Skip to main content
Draftify offers a tier-based model system designed to give you the perfect balance of speed, reasoning capability, and cost-\
efficiency. Instead of worrying about underlying provider names, you target semantic tiers, and our intelligent router ensures\
the best results.

​
Available Models

​
Sonnet 4.6-level

The fastest and most cost-effective model, perfect for general-purpose tasks, frontend code generation, and rapid text processing.
  • Model ID: sonnet-4.6-level
  • Pricing: €0.20 per 1M input tokens / €0.74 per 1M output tokens
  • Best for: Chatbots, quick content generation, and simple logic.

​
Opus Tier (4.6, 4.7, 4.8)

A highly capable, balanced reasoning tier that excels at complex backend logic, algorithmic problem-solving, and architectural\
design. You can select different version levels based on your exact precision and budget needs.
  • Opus 4.8-level (Highest capability)
    • Model ID: opus-4.8-level
    • Pricing: €2.00 per 1M input tokens / €5.00 per 1M output tokens
  • Opus 4.7-level (Balanced)
    • Model ID: opus-4.7-level
    • Pricing: €1.00 per 1M input tokens / €3.00 per 1M output tokens
  • Opus 4.6-level (Efficient)
    • Model ID: opus-4.6-level
    • Pricing: €1.00 per 1M input tokens / €2.00 per 1M output tokens
  • Best for: Complex reasoning, backend development, and deep logical analysis.

​
Fable 5-level

Our most advanced reasoning engine, designed for agentic, long-running, and complex multi-step tasks.
  • Model ID: fable-5-level
  • Pricing: €2.00 per 1M input tokens / €6.00 per 1M output tokens
  • Best for: Agent workflows, long and complex tasks, deep architectural reasoning, and extreme edge-case handling.

​
reasoning_effort parameter

Fable 5-level accepts an optional reasoning_effort tag that controls how much “thinking budget” the model spends before producing the final answer:
Supported values:
  • high — Recommended for most demanding workloads: agent loops, long-context synthesis, multi-file refactors, and tasks where the model needs to keep track of many moving parts. Strong reasoning at a predictable latency.
  • xhigh — Reserved for the hardest problems where high plateaus. The model runs an extended reasoning pass, exploring multiple solution branches, self-verifying intermediate steps, and backtracking when needed.
When xhigh actually shines (and high falls short): Imagine you hand the model a 40,000-line legacy monorepo with a subtle, intermittent race condition that only triggers under a specific combination of three async event handlers, a stale cache entry, and a misconfigured retry policy spread across 7 files. You ask it to: find the root cause, prove why it happens, write a minimal failing test, propose three architecturally different fixes with trade-offs, and refactor the affected modules without breaking the 1,200 existing tests.
  • With high, the model will usually identify one plausible cause and ship a working patch — but it may miss the interaction with the retry policy and pick the first viable fix.
  • With xhigh, the model traces the full causal chain across all 7 files, explicitly rules out two red-herring hypotheses, produces the failing test on the first try, and presents the three fixes ranked by blast radius — with the trade-offs you’d expect from a senior engineer who actually read the whole codebase.
Use xhigh when correctness, completeness, and depth matter more than latency or cost. Stick with high for everything else.