Claude Fable 5.1 is Anthropic's Mythos-class model — a capability tier above the Opus class — made safe for broad use, and the successor to Claude Fable 5. It improves on Fable 5 across the board, with the biggest gains in agentic coding, long-running agentic workflows, and knowledge work: long code refactors, front-end and visual engineering, and multi-step tasks where sustained coherence and judgment matter most. It accepts text, image, and file inputs with text output, serves a 1M-token context window with up to 128K output tokens, and supports adaptive reasoning and structured outputs. Fable 5.1 keeps the autonomous, long-horizon posture of the Fable line: it stays coherent across millions of tokens, improves its own outputs using file-based memory, and completes complex multi-step work with far less scaffolding than prior models. It is a strong default for AI coding assistants, deep research and analysis pipelines, and long-running autonomous agents.
Claude Fable 5.1 is an Anthropic model available on OrcaRouter with the model ID anthropic/claude-fable-5.1. It accepts text, image, and file inputs, supports a 1,000,000-token context window, and…
The main documented capability of Claude Fable 5.1 is to hold up to 1,000,000 tokens in context while generating up to 128,000 tokens. This makes it possible to place the full source material before the instruction and ask the model to answer without building a separate retrieval step. Because it accepts text, images, and files, one message can include diagrams, scanned pages, spreadsheets, and other material alongside ordinary text. Review tasks can then operate on whole collections rather than page-sized slices. The model also has a general intelligence score of 66.0 on the Artificial Analysis Intelligence Index, but the catalog does not define domain-level behavior. Reasoning, coding, and instruction following should be verified with custom evals. There is no claim in the supplied facts about latency, caching, or agentic tool execution. Use the model where context memory and long-form output are the center of the job, and measure everything else against your own test suite.
The strongest use cases follow directly from the specification. A 1,000,000-token context makes Claude Fable 5.1 suitable for full-repository code analysis, long legal or scientific document review, corpus-wide summarization, and question answering over a multi-hundred-page source in one call. The 128,000-token maximum output supports long reports, detailed summaries, or content generation that would otherwise require multiple model calls and manual stitching. Mixed inputs mean images and files can be analyzed together with text. Because context is costly at $10 per million input tokens, the model fits best when the entire input is genuinely needed for the answer. It also fits best when expensive engineering time would otherwise be spent building a chunking and merging pipeline. If the task only needs a few paragraphs from one document, or if the application cannot wait for a long prefill, a smaller model will probably serve traffic better. Test on representative payloads to see which workload segment receives tangible improvement.
Use a cheaper model when its output is good enough for the task. Simple classification, metadata extraction, short summarization, chat assistants, and code completion rarely need 1,000,000 tokens of context or 128,000 tokens of output. Claude Fable 5.1 is priced at $10.00 per million input tokens and $50.00 per million output tokens. At high request volume, those rates turn ordinary prompts into a noticeable line item when compared with low-cost alternatives. A cheaper model also tends to be faster for small payloads, and it avoids paying for context you do not occupy. Nothing in the catalog suggests that Claude Fable 5.1 outperforms all cheaper models on every short task. Build a routing rule in OrcaRouter so that long, high-value jobs go to this model while routine requests stay on a more economical path. Revisit the split after production logs show how often long context actually changes answer quality.
The only benchmark listed for Claude Fable 5.1 is 66.0 on the Artificial Analysis Intelligence Index. That index is a third-party composite used to compare the general capability of language models across different providers. Because it aggregates many tasks into one number, it is useful as a broad reference, but it cannot tell you whether the model will handle your specific long-context, image, or file-based workflow correctly. The catalog does not provide a confidence interval, a task-level breakdown, or the exact index version used. Treat the score as one data point rather than a certification. If you want comparability, compare Claude Fable 5.1 with another model measured on the same index version. For internal decisions, always pair the number with domain-specific evals on your own data. A composite index will not detect subtle failures in legal reasoning, vision accuracy, or citation behavior.
No speed or latency figures are provided for Claude Fable 5.1. Do not confuse a 66.0 index score or a high token limit with response speed. In proportionate terms, a request that sends a very long input will spend time processing the entire input before the first output token is produced, and a request that generates many output tokens will also need more wall-clock time. Longer context and high output budgets therefore suggest variable latency. If your product needs fast turnarounds, benchmark time-to-first-token and tokens-per-second on realistic prompts through OrcaRouter's OpenAI-compatible API. Quantify behavior with the exact file sizes and output limits you plan to set. Avoid assuming performance from another model's behavior. If only a slice of traffic is latency-tolerant and context-heavy, Claude Fable 5.1 can handle that segment while faster models answer interactive requests. Without measured numbers in this entry, latency remains an open question.
The strengths in the fact sheet are capacity and modality. Claude Fable 5.1 has a context window of 1,000,000 tokens and a maximum output of 128,000 tokens. It accepts text, image, and file inputs. These combine to make especially long, mixed-material tasks possible in one call. The 66.0 Artificial Analysis Intelligence Index score also provides a general signal of model competence. The main strength is range: the amount of source material and generated text the model can handle in a single request. The limitations are equally clear from what is missing. No latency figure, caching rate, or domain-specific benchmark is provided. No guarantee is made about perfect recall at the far end of the context, accurate parsing of every image or file type, or behavior under adversarial instructions. The model is also expensive, so careless use can inflate spend. Production teams should verify grounding, output quality, and failure modes before treating it as a default for every scenario.
OrcaRouter bills Claude Fable 5.1 at the Anthropic provider rate with zero markup. The stated price is $10.00 per 1,000,000 input tokens and $50.00 per 1,000,000 output tokens. There is no per-request fee or gateway surcharge described in the supplied facts. You pay for what the model consumes in tokens, and the usage data in API responses can tell you how many input and output tokens were billed. Text, image, and file content all become part of the model input and will be converted into tokens, although exact conversion rules are not supplied. Setting a lower max_tokens value is a practical way to control output spend. A short question with a short answer will cost very little at these rates; a full 1,000,000-token input followed by a long output will cost much more. Because these are provider rates, they may change if Anthropic changes its own price sheet.
At $10 per million input tokens and $50 per million output tokens, Claude Fable 5.1 is expensive enough that cost per successful task matters. Filling the entire 1,000,000-token input costs $10 before generation; emitting a very large output adds generation cost on top. That means the best financial fit is a task that produces a materially better answer because it consumes the model's whole context. If a cheaper model can use a small passage and return an answer of similar quality, no long-context premium is justified. The trade-off is not simply token price. You may save engineering time by removing chunking, summarization loops, and vector search. Those savings can outweigh a higher per-token rate. The comparison should be total cost of ownership, including development time and error rates, not just API spend. Run a pilot on representative documents through OrcaRouter, log usage, and compare success rates against lower-priced alternatives.
The supplied facts do not include a cache price, a cache-control parameter, or any discount rate for Claude Fable 5.1. Because no caching discount is documented in this catalog entry, plan your budget using the full input and output rates. If Anthropic or OrcaRouter returns separate cached input token fields in the usage data, those fields would appear in the API response and could show lower actual billing. Do not assume they are present. To reduce cost without relying on a cache, keep the rest of your system efficient: reuse prompts where possible, exclude irrelevant file content, and set output limits. If repeated identical prefixes are common in your workload, test a day of traffic and inspect usage metadata to see whether any cache line items appear. In the absence of a documented rate, the model is billed at the standard provider rate with zero markup on OrcaRouter. For the latest cache availability, consult OrcaRouter's billing documentation.
Calls go to OrcaRouter's OpenAI-compatible API at https://api.orcarouter.ai/v1. Use the model ID anthropic/claude-fable-5.1 in the chat completions body. The messages payload follows the OpenAI convention: role and content fields for system and user turns, with assistant turns used when continuing a conversation. Code written for OpenAI SDKs can point to this base URL and model name without switching to an Anthropic SDK. Images and files are supplied in the content structure expected by the chat API. OrcaRouter credentials authenticate requests. The response object contains model, choices, and usage, and usage counts the input and output tokens subject to the prices shown in this catalog. Start with a minimal request, inspect the response, then increase the context length in stages. Your first calls should set max_tokens to a modest number until you confirm output length and formatting.
The OpenAI-compatible endpoint on OrcaRouter supports standard chat completion parameters used by OpenAI clients. These include messages, model, temperature, max_tokens, stop, and related generation controls. The catalog does not enumerate every accepted field for anthropic/claude-fable-5.1, so check OrcaRouter's reference documentation or inspect error messages for unsupported parameters. Some fields, especially those used for structured output or tool calling, may only work if the model implements the underlying schema. Given the 1,000,000-token context and 128,000-token output budget, you should deliberately set max_tokens on every production request. If messages exceed the context window, the API should reject them or signal truncation. It is good practice to compute token usage from the usage object and compare it with your cost estimate. Responses may use the same text content format across the OpenAI-compatible API, and streaming behavior should be validated separately if you plan to use it.
If you currently call the Anthropic Messages API directly, migration is mostly a request-format change. The Anthropic API uses a model name, system field, and messages body; OrcaRouter's endpoint uses OpenAI-compatible chat messages. Set your base URL to https://api.orcarouter.ai/v1, put the full model ID anthropic/claude-fable-5.1 in the model field, and reformat system prompts as a system message. Tool schemas, if any, must use the conventions documented by OrcaRouter. If you are moving from another OpenAI-compatible gateway, switch the base URL and credentials while keeping the same message structure. The model ID retains the anthropic prefix, so logging stays identifiable. No per-token gateway markup is listed for this route, so the unit prices are the provider rates. Run one smoke test with a short prompt, then a long-context job, before redirecting production traffic.
Smaller and cheaper models normally offer lower cost per token, less context capacity, and shorter maximum output. Claude Fable 5.1's comparative advantage is range: a 1,000,000-token context and 128,000-token output allow it to accept whole libraries of text and write much longer answers. A small model may still beat it on speed and cost for a request that only needs a few thousand tokens, and it may perform better on a narrow, specialized domain. On a general benchmark, Claude Fable 5.1 scores 66.0 on the Artificial Analysis Intelligence Index, but no comparable score is provided for alternative models on this page. Compare models directly on your own prompts through OrcaRouter. Measure quality, latency, and cost per accepted answer. If a cheaper model returns the same quality for a typical request, the rational default is the cheaper model. Reserve the large model for cases where its size changes the outcome.
Against other long-context models, the direct comparison points are the facts in this catalog: text, image, and file input, 1,000,000-token context, 128,000 maximum output, $10.00 per million input tokens, $50.00 per million output tokens, and 66.0 on the Artificial Analysis Intelligence Index. Some alternatives may provide a smaller output limit or charge differently. Others may offer lower prices but score differently on the same index. A catalog cannot establish an unmeasured winner. The responsible comparison holds the evaluation task constant. Use the same documents and instructions for each candidate model. Run each through OrcaRouter's OpenAI-compatible API, record token usage, and score outputs for accuracy. This avoids comparing context sizes or index scores without knowing how they relate to your workload. If one model can accept your full context and another cannot, that is a meaningful advantage. Otherwise, judge quality rather than headline numbers.
Choose Claude Fable 5.1 when the task depends on the whole context window, needs a large generated response, or combines text, image, and file inputs in one operation. The $10 and $50 per-million token rates should be affordable relative to the value of the task. Choose another model when prompts are short, when a smaller approach is measurably accurate, or when your latency budget cannot absorb a long-context request. There is no reason to pay high output rates for a two-sentence reply. The best decision process is empirical. Spin up a test task in OrcaRouter, set the model ID to anthropic/claude-fable-5.1, and run the same task on one or two alternatives. Compare correctness, response length, and total spend over a realistic sample. Because OrcaRouter exposes models through one OpenAI-compatible API, switching models is inexpensive to test. Make Claude Fable 5.1 a default only if it wins on user-visible quality and cost per completed job.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1https://api.orcarouter.aiimport os
from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key=os.environ["ORCAROUTER_API_KEY"],
)
response = client.chat.completions.create(
model="anthropic/claude-fable-5.1",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)include_reasoningmax_completion_tokensmax_tokensreasoningreasoning_effortresponse_formatstopstructured_outputstoolsverbosity| Input / 1M tokens | $10.00 |
|---|---|
| Output / 1M tokens | $50.00 |
| Cache read / 1M | $0.250 |
| Cache write / 1M | $12.50 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
What developers are saying this week
GET /api/public/models/anthropic/claude-fable-5.1Open @misc{orcarouter_claude_fable_5_1,
title = {Claude Fable 5.1 API},
author = {Anthropic},
year = {2026},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/anthropic/claude-fable-5.1}
}Anthropic. (2026). Claude Fable 5.1 API. OrcaRouter. https://www.orcarouter.ai/models/anthropic/claude-fable-5.1