← Blog
#Claude#LLM#cost optimization#multi-model strategy#developer productivity

Claude Fable 5 — Anthropic's Frontier Coding Model

webhani·

Maximum capability, maximum price

Claude Fable 5 achieves approximately 95% on SWE-bench Verified, the current gold standard for coding model evaluation. That's real. The trade-off is pricing: $10 per million input tokens and $50 per million output tokens—significantly higher than previous tiers. These numbers matter when you're running multiple inference calls per day across a team.

After working with clients at webhani to understand the operational reality of Fable 5, we've learned this: it's not a model you use everywhere. It's a model where the decision of when to invoke it becomes the critical business judgment.

Tiered routing by task difficulty

The practical path forward is routing based on task complexity.

Lightweight tasks — boilerplate generation, straightforward code extensions, format transformations. Claude Haiku or the earlier Opus handles these well. Quick execution, low cost per token.

Medium tasks — initial bug investigations, design validation, adding test cases. Claude Opus or Sonnet strikes a reasonable balance between reasoning power and cost.

Complex tasks — multi-step optimization problems, deep debugging of legacy systems, novel architecture design. This is where Fable 5 earns its margin. The model's superior reasoning justifies the price tag when the problem is genuinely hard.

By adopting this hierarchy, organizations typically handle 70-80% of daily tasks on lower-cost models and reserve Fable 5 for the remaining 20-30% of genuinely difficult work. Token consumption stays controlled, and team velocity doesn't depend on a single expensive model.

Building a routing system

To make this strategy work at scale, you need a router that evaluates task difficulty and selects the appropriate model. Here's a TypeScript implementation.

interface CodeTask {
  description: string;
  codeContext?: string;
  estimatedComplexity?: number;
}
 
interface ModelConfig {
  model: string;
  maxInputTokens: number;
  costPerMInputTokens: number;
  costPerMOutputTokens: number;
}
 
const modelTiers: Record<string, ModelConfig> = {
  haiku: {
    model: "claude-3-5-haiku-20241022",
    maxInputTokens: 8000,
    costPerMInputTokens: 0.8,
    costPerMOutputTokens: 4,
  },
  sonnet: {
    model: "claude-3-5-sonnet-20241022",
    maxInputTokens: 200000,
    costPerMInputTokens: 3,
    costPerMOutputTokens: 15,
  },
  opus: {
    model: "claude-3-opus-20250219",
    maxInputTokens: 200000,
    costPerMInputTokens: 15,
    costPerMOutputTokens: 75,
  },
  fable: {
    model: "claude-fable-5",
    maxInputTokens: 300000,
    costPerMInputTokens: 10,
    costPerMOutputTokens: 50,
  },
};
 
function assessTaskComplexity(task: CodeTask): number {
  let score = 0;
 
  // Evaluate code volume
  if (task.codeContext) {
    const lineCount = task.codeContext.split("\n").length;
    score += Math.min(lineCount / 100, 20); // Max 20 points
  }
 
  // Keyword-based signal
  const hardKeywords = [
    "memory leak",
    "concurrency",
    "optimization",
    "race condition",
    "performance bottleneck",
    "architecture",
    "multi-tenant",
  ];
  const keywordCount = hardKeywords.filter((kw) =>
    task.description.toLowerCase().includes(kw)
  ).length;
  score += keywordCount * 15; // 15 points per keyword
 
  // Explicit override
  if (task.estimatedComplexity) {
    score += task.estimatedComplexity;
  }
 
  return Math.min(score, 100);
}
 
function routeTask(task: CodeTask): string {
  const complexity = assessTaskComplexity(task);
 
  if (complexity < 30) {
    return "haiku";
  } else if (complexity < 60) {
    return "sonnet";
  } else if (complexity < 85) {
    return "opus";
  } else {
    return "fable";
  }
}
 
async function solveTask(task: CodeTask): Promise<string> {
  const modelKey = routeTask(task);
  const config = modelTiers[modelKey];
 
  console.log(`Task complexity: ${assessTaskComplexity(task)}/100`);
  console.log(`Selected model: ${config.model}`);
 
  // API call (implementation omitted)
  // const response = await client.messages.create({
  //   model: config.model,
  //   max_tokens: 2000,
  //   messages: [{ role: "user", content: task.description }],
  // });
 
  return `Using ${config.model}`;
}
 
// Example usage
const debugTask: CodeTask = {
  description:
    "Identify memory leak in legacy Node.js app. Suspect race condition in multi-tenant request handling.",
  codeContext: "// hundreds of lines...",
  estimatedComplexity: 30,
};
 
routeTask(debugTask); // → "fable"

This router evaluates difficulty across three dimensions:

  1. Code size — Larger context requires more powerful reasoning to navigate effectively.
  2. Problem keywords — Concurrency, optimization, and performance issues signal higher complexity.
  3. Explicit override — Teams accumulate experience; allow engineers to signal known-hard problems upfront.

Cost control patterns

Prompt caching — When you reference the same document or code block repeatedly, enable Prompt Caching to reduce costs by 90% on repeated invocations. Especially valuable for multi-pass analysis of large codebases.

Context scoping — Don't send the entire log file; extract the relevant 50 lines. Fable 5's context window is generous, but every token is a line item. Be precise about what you include.

Batch processing — If you have multiple independent tasks, use the batch API to process them together. Batch pricing is typically 50% lower per token than synchronous calls.

Staged escalation — Try the problem with Opus first. Only escalate to Fable 5 if Opus reaches its limits. This "escalate on failure" pattern costs less overall than "start at maximum power."

When Fable 5 actually pays for itself

At webhani, we've established clear criteria for when Fable 5 deployment is justified:

  • Existing models have already attempted the task and failed.
  • The problem is consuming 8+ hours of engineer time or blocking production.
  • The impact extends to the production environment.

Reviewing monthly model utilization across client projects, Fable 5 rarely exceeds 5-15% of total API calls. The remaining 85-95% completes successfully on Opus and Sonnet, which is the ratio most teams should aim for.

Conclusion

Fable 5 is powerful. Power has a price. The decision to use it should be driven by concrete business logic: Does the cost of this token outlay save more than its value in engineering time?

By implementing tiered routing and escalation logic, you maximize Fable 5's value while keeping total spending predictable and controlled. For consulting teams like webhani, we now propose this model-selection framework to clients as part of their LLM cost strategy. The real win isn't access to the frontier model—it's knowing exactly when to use it.

← Back to Blog