AI / Next Gen Flagship Models Interview questions

Next-gen flagship models are the newest top-of-lineup models from a lab, built for long-running agentic coding, research and knowledge work rather than quick chat replies. In Anthropic's lineup these are Claude Fable 5.1 and Claude Mythos 5.1, released on September 1, 2026, with Claude Opus 5.5 as the cheaper Opus-tier option below them.

What sets them apart from earlier generations is not only benchmark scores. They ship with a 1M-token context window, an effort setting that trades quality against cost, and safeguards tuned for dual-use areas such as cybersecurity and biology.

In interviews, be ready to separate tier from generation. Fable and Mythos are tiers above Opus, while 5.1 and 5.5 are generations. A newer generation of a lower tier, such as Opus 5.5, can be cheaper than an older higher-tier model, so always check current pricing before picking one.

Claude Fable 5.1 is Anthropic's generally available top-tier model, released on September 1, 2026. It is a Mythos-class model aimed at complex, long-running coding and knowledge-work tasks, and it is the version of the Fable/Mythos model that anyone with API access can use.

It supports a 1M-token context window with up to 128K output tokens, and is addressed as claude-fable-5-1 on the Claude API. It runs with Anthropic's production safeguards, which is what separates it from the restricted Mythos 5.1.

Remember the naming logic: Fable is the public, safeguarded face of the Mythos-class model. If an interviewer asks which one to call from a normal application, the answer is Fable 5.1, since Mythos 5.1 requires approval through a trusted-access program.

Claude Mythos 5.1 is the same underlying model as Fable 5.1, offered with more permissive safeguards to vetted users. Access is limited to approved individuals and organizations whose work touches cybersecurity or the life sciences.

It is not a separate, smarter model. The capability is identical; what changes is how readily the safeguards intervene on sensitive requests such as vulnerability research or advanced biology work. Mythos 5.1 also powers Claude Security, Anthropic's product for scanning codebases for vulnerabilities.

A useful way to explain it: Mythos 5.1 is a policy difference, not a capability upgrade. If a team asks why their Fable 5.1 requests were declined on a security task, the fix is to apply for access, not to wait for a smarter model.

Claude Fable 5.1 and Claude Mythos 5.1 were released on September 1, 2026. They arrived roughly three months after Fable 5 and Mythos 5, which first launched on June 9, 2026.

Fable 5.1 was available on the day of release across the Claude apps, Claude Code, the API and the major cloud platforms, while Mythos 5.1 went live only through trusted-access programs.

The gap between releases is a good talking point. Mythos-class models went from a restricted preview in the spring to a public Fable in June, then to the 5.1 refresh in September. That cadence is why teams should keep model IDs configurable and rerun their evaluations on each release.

On the Claude API, Fable 5.1 is called with the model string claude-fable-5-1. The rest of the 5.5 family follows the same pattern: claude-opus-5-5, claude-sonnet-5-5 and claude-haiku-5-5.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model": "claude-fable-5-1", "max_tokens": 1024,
       "messages": [{"role": "user", "content": "Hello"}]}'

Cloud platforms such as Amazon Bedrock, Google Cloud and Microsoft Foundry use their own model identifiers, so check each provider's catalog.

Never hard-code the string in many places. Read it from an environment variable or config file, so moving from claude-opus-5-5 to claude-fable-5-1 for a hard workload is a one-line change that can be tested and rolled back.

Claude Fable 5.1 lists at $10 per million input tokens and $50 per million output tokens, unchanged from Fable 5. The headline change is on caching: cache reads cost 75% less than they did on Fable 5.

Anthropic says this lowers the real cost of typical workloads by about 25% and highly agentic ones by up to 45%, because agent loops re-read the same long context many times.

A quick sanity check on cost: a call with 100K input tokens and 5K output tokens at list price is about $1.00 for input plus $0.25 for output, so $1.25 before caching. Caching and lower effort are what bring that number down in real agent workloads.

Fable 5.1 and Mythos 5.1 both support a 1,000,000-token context window and up to 128,000 tokens of output per response. The Opus 5.5, Sonnet 5.5 and Haiku 5.5 models list the same 1M context and 128K output ceiling.

A large window helps agents keep a whole repository or document set in view, but every token you send is billed, so pair it with prompt caching.

An interviewer may probe the difference between context and output limits. The 1M window is the total the model can read in one request; the 128K cap applies to what it writes back. A task that needs a longer generation has to be split across calls.

Mythos-class is Anthropic's label for the tier of models that sits above Opus. It started with Claude Mythos Preview, which was shared with a small set of trusted organizations, and now covers Fable 5.1 and Mythos 5.1.

The key idea is that these models are strong enough at cybersecurity and science tasks that Anthropic gates some of their behavior behind safeguards. Fable is the version with those safeguards on for general use; Mythos is the version with them relaxed for vetted work.

Do not confuse the label with a benchmark threshold. It is a product tier used by Anthropic, and the interesting part for engineers is the consequence: access is split into a general version and a gated version, which changes how you plan procurement and fallbacks.

Trusted access is the vetting program through which Anthropic lets approved cybersecurity and life-sciences organizations use Mythos 5.1. It replaces open sign-up: you apply, are verified, and get a model whose safeguards are loosened for your legitimate work.

For biology, Anthropic built an access program with the US government. The aim is to let defenders and researchers use the full capability while keeping it away from people who could misuse it.

In practice, a security team would apply, get verified, and then be given Mythos 5.1 access for defined work. Teams without that need should simply design around Fable 5.1's safeguards and handle refusals gracefully instead of trying to work around them.

Fable 5.1 launched as generally available everywhere on day one:

• The Claude apps and Claude Code
• The Claude API
• Amazon Web Services (Bedrock)
• Google Cloud
• Microsoft (Foundry/Azure)

Plan eligibility and usage limits in the consumer apps can vary by subscription tier.

Cloud availability matters for compliance. Many enterprises must buy through their existing cloud agreement, so having Bedrock, Google Cloud and Microsoft access on day one removes a common adoption blocker. Verify the exact model ID and regional availability in each provider's console.

Claude Opus 5.5 is Anthropic's current Opus-tier model, released on September 22, 2026 as the first model of the Claude 5.5 family. It targets long-running agentic coding and knowledge work at a lower price than Fable 5.1.

It lists at $4 / $20 per million input/output tokens with a 1M context window, 128K output limit, always-on adaptive thinking and a default effort of medium. The API ID is claude-opus-5-5.

Know where it fits. Opus 5.5 is the review and planning tier and the practical default for multi-hour agentic coding. Its list price is 2.5x lower than Fable 5.1, so most teams start there and escalate only when a task needs more capability.

Claude Sonnet 5.5 is the mid-tier model of the 5.5 family, released on September 28, 2026. It replaces Sonnet 5 at the same $2 / $10 price, with a 1M context window and 128K max output.

It is the fast, everyday builder: code generation, data analysis and tool use. Its default effort is high, one notch above Opus 5.5's medium default, which is easy to overlook when comparing the two.

Sonnet 5.5 is the model many production features run on because of its price and speed. A common interview point: it replaced Sonnet 5 at the same price, so upgrading costs nothing extra on list rates, though you should still retest prompts for behavior changes.

Claude Haiku 5.5 is the fastest and cheapest model in the family, released on October 7, 2026. It starts at $0.10 input / $0.50 output per million tokens for prompts up to 100K tokens, and rises to $0.50 / $2.50 above that.

It is the first Haiku with an effort setting, and suits routing, classification, real-time workloads and sub-agent tasks. Anthropic notes its cyber safeguards are stricter than Haiku 4.5's.

Haiku 5.5 is cheap enough to put in front of everything. A typical design uses it as the first pass that decides whether a request needs a bigger model, which keeps expensive tiers focused on tasks that actually need them.

The 5.5 generation sits below Fable 5.1 and covers three tiers:

Above them sits Fable 5.1 at $10 / $50 (claude-fable-5-1). Together the four give you a price ladder from roughly $0.10 to $10 per million input tokens, which is what makes tiered routing worthwhile.

Opus 5.5 costs $4 per million input tokens and $20 per million output tokens. Cache reads are $0.20 per million, a 5-minute cache write is $5, a 1-hour write is $8, and the Batch API takes 50% off input and output.

Against Opus 5 this is roughly a 20% cut on base rates and a 60% cut on cache reads. Fast mode, when you need speed, is billed at $8 / $40.

Compare batch and standard cleanly: batch input and output are $2 and $10, half of standard. It suits offline jobs such as nightly document processing, while interactive features stay on standard or Fast mode.

Fast mode is a premium option that returns Opus 5.5 output noticeably faster, reported as up to 2.5x, in exchange for 2x standard pricing, so $8 / $40 per million tokens. It is meant for latency-sensitive, interactive use.

It is not available through the Batch API, since batch work is already asynchronous and cost-optimized. Treat the speedup figure as a ceiling, and measure it on your own prompts.

Use it sparingly. A sensible pattern is to enable Fast mode only on user-facing steps where waiting is visible, and leave background agent steps on standard speed. Always benchmark the actual speed gain, since it will vary by prompt and output length.

The effort parameter tells the model how much work to put into a task. Lower effort means fewer reasoning and tool-use tokens and faster answers; higher effort means more thorough work at higher cost.

Anthropic claims Fable 5.1 can match or beat Fable 5 results at lower effort levels for much less money, so effort is a primary cost dial. Defaults differ: medium on Opus 5.5 and Haiku 5.5, high on Sonnet 5.5.

A tip for interviews: say that effort is tuned per workload with an evaluation set. A support classifier might work at low effort, while a refactoring agent may need high. There is no single best value across tasks.

Adaptive thinking means the model decides for itself how long to reason before answering, instead of you setting a fixed thinking budget. On Opus 5.5 it is always on, so there is no switch to turn reasoning off.

You steer depth indirectly with the effort parameter. Easy requests get little reasoning and hard ones get more, which usually spends tokens better than a flat budget.

The practical result is fewer knobs to misconfigure. You no longer pick a reasoning budget per request; you choose an effort level, and the model scales its thinking to the difficulty, so easy questions stay fast and cheap.

Prompt caching stores the processed form of a repeated prompt prefix, so later requests that start with the same content read it back at a small fraction of the normal input price instead of reprocessing it.

Writing to the cache costs slightly more than normal input (for Opus 5.5, $5 for 5 minutes or $8 for 1 hour per million tokens), but reads cost just $0.20. Agent loops and long system prompts benefit the most.

A quick example: a 50K-token system prompt reused over 200 agent steps costs full input price only once for the write, then 199 cheap reads. That is why stable prefixes are the first thing to design in an agent.

Project Glasswing is Anthropic's program for putting Mythos-class cybersecurity capability in the hands of a limited set of trusted organizations. Claude Mythos Preview was first used this way before any public release.

The idea is to let defenders find and fix vulnerabilities with the strongest models while broader access waits for safeguards. Mythos 5 shipped through it as a preview, and Mythos 5.1 continues under trusted-access programs.

The name comes up in interviews about AI security because it shows the staged-access model: strongest capability goes first to defenders, and wider release follows once safeguards are ready.

Fable 5.1 is the successor to Fable 5 and keeps the same $10 / $50 list price, but it changes three things that matter in practice.

1. Performance: Anthropic reports much higher scores, including more than double Fable 5 on Terminal-Bench-Science 0.1.
2. Cost: cache reads are 75% cheaper, lowering typical bills by about 25%.
3. Safeguards: retuned so they fire far less often on benign requests, which cuts false refusals.

Lower effort levels on 5.1 can also match Fable 5 results for less money.

Interview tip: separate what is confirmed from what you should measure yourself. The price, cache-read cut and release date are published facts. Whether Fable 5.1 beats Fable 5 for your tasks, and at which effort level, depends on your own evaluation set.

Nothing in the model itself. Anthropic describes them as the same model with different levels of safeguards. Benchmarks, context window, output limit and pricing are identical.

The gap shows up only on tasks where the safeguards would otherwise intervene.

So if someone proposes 'testing Mythos for better answers', the correct reply is that on ordinary tasks you should see no difference. The behavior diverges only when a safeguard would have intervened, for instance in vulnerability analysis or advanced biology.

Because the risk sits in use, not in the weights. The same capability that helps a defender find a vulnerability can help an attacker exploit it, so Anthropic keeps one model and varies the policy layer around it.

This avoids training and serving two separate models, and it keeps results consistent. A verified security team gets the full behavior, while general users get a version that declines the riskiest requests.

The tradeoff is that safeguards must be precise. Over-blocking frustrates legitimate users, which is why 5.1 retunes them to fire less on benign work.

There is also an operational benefit: one set of weights means a single evaluation story. A fix or improvement lands in both versions together, and teams moving from Fable to Mythos do not need to re-tune prompts for different base behavior.

Agent loops resend the same long context on every step, so a large part of the bill is cache reads. Cutting that line by 75% shrinks the whole bill by an amount that depends on how big the line was.

Let the old cache-read share of cost be s. The new cost is (1 - s) + s x 0.25.

These shares are an inference that reproduces Anthropic's stated 25% typical and 45% highly agentic figures. Measure your own cache-read share before forecasting.

To use this in planning, pull your usage report, add up cache-read tokens and multiply by the old and new rates. If cache reads are a small share of your spend, expect a smaller saving than the headline numbers.

Opus 5.5 is cheaper and designed to finish tasks in fewer tokens. Anthropic positioned it as the new leading Opus model.

Because it also uses fewer tokens per task, Anthropic estimates typical workloads run about 40% cheaper. Opus 5 remains available as the prior generation.

Do not just read the price table. Run your own tasks, because a model that finishes in fewer tokens can reduce output cost further. Also remember that Opus 5.5 defaults to medium effort, which may differ from the setting you used before.

Fable 5.1 costs 2.5x as much as Opus 5.5 on both input ($10 vs $4) and output ($50 vs $20). In return it is the stronger model for the hardest long-horizon work and scientific research tasks.

Opus 5.5 is the practical default for review, planning and multi-hour agentic coding. Reach for Fable 5.1 when a task fails or stalls on Opus, and the extra capability is worth the premium.

Frame it as insurance: run most traffic on Opus 5.5 and keep Fable 5.1 as the escalation tier. That way the 2.5x premium is only paid on the fraction of tasks that really need it.

Choose Sonnet 5.5 when you want fast, everyday building at half the price: features, tests, tool calls, data analysis. It costs $2 / $10 against Opus's $4 / $20, and responds faster.

Move to Opus 5.5 when work is long-running, spans many files or needs careful review. A common pattern is Sonnet for the build step and Opus for the review step.

One detail interviewers like: Sonnet 5.5 defaults to high effort while Opus 5.5 defaults to medium. If you compare them with defaults, you are not comparing the same effort, so set effort explicitly in your evaluation. Treat the choice as reversible: log which model handled each task, so if Sonnet's quality slips on a task type you can move that type up a tier without redesigning the system.

Pick Haiku 5.5 for high-volume, latency-sensitive work: triage, classification, routing and sub-agent tasks. At $0.10 / $0.50 per million tokens it is 40x cheaper than Opus 5.5 on input.

Avoid it for deep reasoning or hard coding. Also watch the 100K-token threshold: above it the rate jumps to $0.50 / $2.50.

Haiku also works well as a sub-agent. A planner running on Opus can hand many small lookups or extractions to Haiku in parallel, which keeps latency and cost low without lowering the quality of the final plan. Check accuracy on your own data first. A cheap model that misroutes or misclassifies often creates rework that quietly erases its price advantage, so sample and audit its decisions regularly.

Choose Fable 5.1 when the task is hard enough that a cheaper model fails or needs repeated retries. Typical cases are long-horizon agentic coding, deep research and complex multi-step analysis.

Compare cost per accepted task, not price per token. If Fable finishes in one run what Opus needs three runs to do, the 2.5x token price can still be the cheaper path. Test with your own data before committing.

It also helps to define the escalation trigger in code: for example, a failed test run or a low confidence flag sends the task up a tier. That makes the choice repeatable instead of a gut call.

Anthropic says Fable 5.1 can reach similar or better results than Fable 5 at lower effort levels, at much lower cost. Lower effort means fewer reasoning and tool tokens, and output tokens are the expensive part at $50 per million.

A practical method:

1. Run your evaluation set at the default effort.
2. Drop one level and rerun.
3. Keep the lowest level whose acceptance rate stays within your tolerance.

Hard tasks may still need a higher level, so tune per workload rather than globally.

Keep an eye on the failure modes too. Too little effort can cause shallow answers or skipped verification, so pair any reduction with checks such as automated tests, schema validation or a reviewer step.

A thinking budget is a hard cap you set on reasoning tokens. Effort is a softer signal about overall diligence that affects reasoning, tool calls and response length together.

On Opus 5.5 thinking is adaptive and always on, so effort is the lever you tune.

When migrating, search your code for thinking-budget parameters and replace the cost logic with effort-level choices, then compare token usage before and after on a representative sample of your traffic. Also document the change for your team. Engineers used to setting explicit thinking token limits need to know that effort is the new cost control, and that its effect is on overall behavior rather than a strict ceiling.

The model is built to judge how hard a request is and spend reasoning accordingly, so a switch that turns thinking fully off works against how it was designed. The docs list its thinking as adaptive (always on).

This affects migration. Code written for older models that sets a fixed thinking budget or disables thinking may need to change, and you should test for errors. Control cost through the effort parameter and max output limits instead.

In an interview, state the design philosophy: let the model allocate its own reasoning, and give developers a coarse, understandable control. This reduces both under-thinking on hard problems and wasted tokens on easy ones.

Match each role to the cheapest model that passes your evaluation for that role.

• Router / triage: Haiku 5.5
• Workers (build, tests, tool use): Sonnet 5.5
• Planner / reviewer: Opus 5.5
• Hardest escalations: Fable 5.1

Keep prompts prefix-stable so caching works across steps, and log which tier solved each task so you can adjust the routing rules from real data.

Also decide what the orchestrator needs to see. Passing full worker transcripts upward inflates cost, so have workers return concise structured results and keep shared reference material in a cached prefix. Finally, set a per-task budget in tokens or dollars for the whole agent tree, so a misbehaving sub-agent cannot consume an unexpected amount of spend before anyone notices.

It lets an agent hold a large codebase, logs and tool results without constant summarizing. That reduces information loss, but it does not make context free.

Every input token is billed, and a long, noisy context can distract the model. Good practice is to cache the stable prefix, drop stale tool output, and compact history when the task phase changes.

Output is capped at 128K tokens per response, so very long generations still need to be split.

Another point: very long contexts raise latency as well as cost. If a task only needs a few files, retrieving those is usually better than loading everything, even when the window could technically hold it.

Treat it as a model change, not a drop-in swap.

1. Change the model string to claude-opus-5-5.
2. Read Anthropic's migration notes for changed defaults, such as effort and thinking behavior.
3. Rerun your evaluation set and compare accuracy, tokens and latency.
4. Recheck prompt caching, since cache-read price fell from $0.50 to $0.20.
5. Roll out gradually behind a flag and keep a rollback path.

Expect lower cost per token, then confirm it with your own traffic.

Do not forget the non-obvious parts, such as rate limits, SDK versions and logging. If you track cost by model name, add the new ID to your dashboards before cutover, or you will miss the change in spend.

The model gets more capable but also 2x pricier on input and output than Opus 5, so migrate selectively. Some teams moved Opus 5 traffic to Fable 5.1 on launch day, but only where results justified it.

1. Shadow-run a sample of real requests on Fable 5.1.
2. Score outputs on your acceptance criteria.
3. Test lower effort levels to offset cost.
4. Move the high-value workloads first and canary the rest.

Keep Opus 5.5 as the fallback tier for easy traffic.

Record the reason for every escalation. After a few weeks you will know which request types truly benefit, and you can encode that as routing rules rather than sending everything to the most expensive tier.

The model declines or stops the sensitive part of the request, and your application receives a response that signals a refusal rather than a normal completion. The most common triggers sit in cybersecurity and biology.

Your code should handle this explicitly:

1. Detect the refusal rather than treating it as an empty answer.
2. Do not blindly retry the same prompt.
3. Rephrase only if the request is legitimate, or escalate to a human.
4. If your work legitimately needs it, apply for trusted access to Mythos 5.1.

Log refusals with enough context to review them, but avoid storing sensitive prompt content longer than needed. A rising refusal rate after a prompt change is a useful signal that your wording is triggering safeguards for benign work.

Anthropic suspended access to both models on June 12, 2026 to comply with U.S. Department of Commerce export controls. The Department lifted those controls on June 30, and Anthropic restored access on July 1, 2026.

The lesson for builders is operational: a flagship model can become unavailable for non-technical reasons. Design a fallback to another tier or model so your product degrades gracefully. Anthropic's own statement has the authoritative details.

For interviews, tie this to resilience patterns: health checks, multi-model fallback, and clear user messaging. A graceful downgrade to Opus 5.5 is far better than an outage, even if quality dips on the hardest tasks.

Public benchmarks tell you where a model stands, but they will not tell you whether it fits your product. Build your own test.

1. Collect 50-200 real tasks with known good outcomes.
2. Run each candidate at several effort levels.
3. Record acceptance rate, input and output tokens, latency and refusals.
4. Compute cost per accepted task.
5. Review failures by hand, since averages hide the cases that matter.

Rerun this set on every new release.

Include safety checks in the test. Add a handful of borderline benign prompts to measure false refusals, because a model that refuses too often can hurt your product even when its raw accuracy is excellent.

Cost per accepted task is total spend divided by the number of outputs that pass your acceptance check. It captures retries, long outputs and failures that a per-token price hides.

In this example the pricier model costs the same per accepted task and wastes less time. The numbers are illustrative.

Add latency and human review time to the calculation when they matter. A model that needs fewer manual corrections can be cheaper in total even when its token bill looks higher.

Work from the biggest cost drivers down.

1. Cache hit rate: a changed system prompt or reordered prefix can silently break caching.
2. Effort level: a default or config change may have raised effort.
3. Output tokens: look for longer answers or runaway loops.
4. Context growth: unpruned tool output inflates every call.
5. Retries: errors and refusals retried automatically multiply spend.
6. Model routing: check that traffic did not shift to a pricier tier.

Start by comparing a recent day against a baseline day, split by model, effort and endpoint. Most surprises come from one change: a prompt edit that broke caching, an agent stuck in a loop, or a default effort that was raised. Add alerts on cost per request so the next spike is caught within hours, not at month end.

Caching only helps when the beginning of your prompt is byte-for-byte identical across calls.

• Put stable content first: system prompt, tool definitions, reference documents.
• Put changing content last: the latest user turn and tool results.
• Never insert timestamps or request IDs into the cached prefix.
• Choose the TTL deliberately (5 minutes or 1 hour).
• Monitor cache read versus write tokens in usage data.

With cheaper reads on Fable 5.1 and Opus 5.5, a well-built prefix is one of the largest savings available.

Verify the result in the usage fields. If cache-write tokens keep appearing where you expected reads, your prefix is changing between calls. Fix the ordering first, then consider whether the TTL matches your call spacing, since an expired cache means paying for the write again.

Compare the write premium with the saving per read. On Opus 5.5 base input is $4, a read is $0.20, a 5-minute write is $5 and a 1-hour write is $8 per million tokens.

Use 5 minutes when calls come in quick bursts. Use 1 hour when the same prefix is reused over longer, irregular gaps.

Two cautions: the break-even numbers assume the entire prefix is reused, and a partly changing prefix lowers the benefit. Also track the real gap between calls, since a 5-minute cache that expires between steps costs you the write every time and saves nothing.

They sit at opposite ends of the speed-versus-cost scale.

Choose by when the user needs the answer, not by habit.

They can be mixed across a product. An interactive assistant might use Fast mode for the live response, while its background indexing and evaluation jobs run on the Batch API. Always confirm current limits and availability in the documentation before relying on either.

A router sends each request to the cheapest tier likely to succeed and escalates only on failure.

flowchart TD
  A["Incoming request"] --> B{Haiku 5.5 triage}
  B -->|Simple| C["Haiku answers"]
  B -->|Standard task| D["Sonnet 5.5 builds"]
  B -->|Complex or long-running| E["Opus 5.5 plans and reviews"]
  D --> F{Passes checks?}
  E --> F
  F -->|Yes| G["Return result"]
  F -->|No| H["Escalate to Fable 5.1"]
  H --> G

1. Haiku classifies difficulty cheaply.
2. Sonnet or Opus performs the work.
3. An automated check validates the output.
4. Only failures reach Fable 5.1, keeping the premium tier for hard cases.

The router itself must be cheap and measurable. Log the tier chosen, whether the check passed, and the final cost, then review misrouted cases. If Haiku sends too many hard tasks to Sonnet, adjust its instructions or add a few examples of what counts as complex. Keep the escalation check automated, such as tests passing or a schema validating, so it does not depend on a person.

A long task is a loop of planning, acting and checking, with context growing each turn.

sequenceDiagram
  participant U as User
  participant A as Agent app
  participant M as Flagship model
  participant T as Tools
  U->>A: Goal
  A->>M: Prompt (cached prefix + goal)
  loop Until done
    M->>A: Plan or tool call
    A->>T: Run tool
    T-->>A: Result
    A->>M: Result appended to context
  end
  M->>A: Final answer
  A->>U: Deliver result

Cost behaves in a typical way: the cached prefix is re-read on every loop turn, which is why cache-read pricing matters so much, and the context should be pruned or compacted as stages change.

Three practical points follow from the flow. First, keep tool results short, because they are appended to context on every turn. Second, add a stop condition and a turn limit so a confused agent cannot loop indefinitely. Third, checkpoint progress, so a failed run resumes from the last good step instead of starting over, which saves both time and tokens.

These models are strong enough that the same answer can protect or harm. A model that finds a software flaw helps a defender patch it, and also helps an attacker exploit it. A model that designs a protein binder helps medicine, and in other hands could assist misuse.

Anthropic's response is layered: production safeguards for everyone, and vetted trusted access for those with legitimate need. The model itself is the same. Anthropic says its 5.1 safeguards are more precise than earlier ones, so benign requests are blocked less often.

The safeguards also have a cost, so they must be calibrated. If they are too broad, researchers and defenders are blocked from legitimate work; too narrow, and misuse becomes easier. That calibration problem is why Anthropic reports retuning them for 5.1 and why trusted access exists as a second path.

Claude Security uses Mythos 5.1 to scan codebases for vulnerabilities and suggest patches. Because it runs on the more permissive model, it can reason about exploitability in ways the generally available model may decline.

The workflow keeps a human in the loop: the product proposes fixes, and people review them before anything is merged. That matches the broader approach of giving defenders strong tools with oversight.

For teams, the takeaway is the pattern: pair a strong model with a narrow, auditable workflow. The model finds and explains issues, a human reviewer decides what ships, and the output is a proposed change rather than an automatic deployment. That is a sound design for any high-stakes agent.

Combine several levers instead of relying on one.

1. Route: send easy work to Haiku or Sonnet, keep Fable for hard cases.
2. Tune effort: find the lowest level that holds quality.
3. Cache: design a stable prefix and use the 75% cheaper reads.
4. Trim output: ask for concise formats, since output costs $50 per million.
5. Prune context: remove stale tool output.
6. Measure: track cost per accepted task, not just spend.

Fable 5.1 customers have reported using fewer tokens on finance tasks at equal accuracy, so token efficiency is worth testing for your own workload too.

Sequence matters. Fix caching and routing first because they usually give the largest savings with no quality risk, then tune effort with an evaluation set, then trim output formats. Re-measure after each step so you know which change produced which saving, and set a budget alert so a regression is caught early.

Releases are close together: Fable 5 in June and Fable 5.1 in September, Opus 5 in July and Opus 5.5 in September. Assume your model will change within months.

• Keep model IDs in configuration, not scattered in code.
• Wrap the API behind a thin interface so providers and tiers can be swapped.
• Maintain a regression set and rerun it on each release.
• Pin versions in production and promote through canary traffic.
• Track deprecation notices for legacy models like Sonnet 5 and Haiku 4.5.

One more safeguard is a canary: send a small slice of traffic to the new model for a few days and compare results before switching everything. Pair that with a documented rollback and with a calendar reminder to check for deprecation notices, because older models are eventually retired and unready teams are forced into rushed migrations.