- Guides
- Claude Fable 5.1 to Fable 5.2: 4 Breaks and 6 Silent Changes to Re-Test
Claude Fable 5.1 to Fable 5.2: 4 Breaks and 6 Silent Changes to Re-Test
What to re-test before you move Messages API code from Claude Fable 5.1 to 5.2: the three changes that return a 400, the one that drops reasoning silently, the six behavior shifts that pass your tests, and how to measure cost per task.
Anthropic's guide for moving from Fable 5.1 to 5.2 starts with one line: update your model ID. The very next step asks whether your code edits conversation history [1].
That second step is where teams get caught. Three changes in Fable 5.2 return a 400 error. One drops the model's reasoning without any error at all. Six more pass every test you already have, then change your output, your bill or what your UI shows.
Model upgrades shifting under you isn't new. When researchers at Stanford and Berkeley tested two versions of GPT-4 three months apart, accuracy on one math task fell from 84% to 51% [12]. Yet LangChain's survey of 1,340 teams found only 52% run offline evals on a test set before they ship [13].
If you're migrating from Fable 5.1 to 5.2, start with the quick check for whether any of this applies to you. Then work through the 10 changes, the 5-step re-test you can run today, and what one task actually costs on each model.
Fable 5.1 vs 5.2: What Changed and What Didn't
Anthropic released Claude Fable 5.2 (claude-fable-5-2) on November 9, 2026 [10]. Most of the API surface matches 5.1. The changes sit in four places: how strictly the API checks your history, which models can read 5.2's reasoning, two tool versions, and price.
What changed
| Area | Fable 5.1 | Fable 5.2 | Re-test? |
|---|---|---|---|
| Prefix check on edited history | 400 only on accounts created on or after Aug 31, 2026 | 400 on every account | Yes, if you build messages |
| Who can read its thinking blocks | Fable 5.2 can read 5.1's blocks | Only Fable 5.2 and Mythos 5.2 | Yes, if you route or fall back |
| MCP tool list changes | Not treated as an edit | Treated as an edit | Yes, test on 5.2 |
| Computer use | computer_20251124 or the toolset | Toolset only; computer_20251124 is a 400 except on Bedrock | Yes |
| Advisor tool | Any supported advisor | Only claude-fable-5-2 or claude-mythos-5-2; advice is encrypted | Yes |
| Price per MTok (input / output) | $10 / $50 | $8 / $40 | Re-baseline cost per task |
| Cache reads per MTok | $0.25 | $0.20 | No |
| Fast mode | Not in Anthropic's fast-mode model list | $16 / $80, up to 2.5× output speed | Optional |
| Rate limits | Shared pool with Fable 5 | Its own pool | Yes, before cutover |
| Effort calibration | Baseline | At low, 5.2 scored close to 5.1 at higher effort on Anthropic's coding evals | Yes, re-run the sweep |
What stayed the same
1M token context, 128K max output, the same tokenizer, always-on adaptive thinking, five effort levels with high as the API default, no assistant prefill, no temperature / top_p / top_k, tool_choice limited to auto and none, refusal handling through stop_reason: "refusal", and the 30-day data retention requirement [2].
Two claims worth checking before you rely on them
low to medium, and that the tool_choice default changed. Neither matches Anthropic's migration guide [2]. The API default is high on both models, and forced tool_choice (any or tool) was already a 400 on 5.1. Also, medium is the default in Claude Code and the Claude apps, not the API [11], so effort results from Claude Code aren't comparable to API calls that leave effort unset.Most of these rows won't touch your code. The next section shows which ones will.
Do You Need to Re-Test?
It depends on who builds the request your app sends.
If Claude Code, claude.ai or the Agent SDK runs your loop
They manage the conversation history, so the prefix check changes nothing for you [1]. One condition from Anthropic's prefix-check docs: with the Agent SDK, the system prompt you pass in must stay the same across the conversation [4]. You still need to re-check cost, rate limits and the six behavior changes. Claude Managed Agents users only change the model name, plus the advisor model if they use one [2].
If your code builds the messages array
Everything on this page applies. Start with the prefix check in the next section. It is the change most likely to return a 400 on day one.
If you route between models, fall back or replay stored conversations
This is the group most exposed to the silent break. A router that sends a 5.2 conversation to 5.1 or Opus 5.5, or a replay through a different account, drops 5.2's reasoning without an error.

Find your setup
| Your setup | What breaks or drifts on 5.2 | Where to look |
|---|---|---|
| A support bot that summarizes old turns to save context | Prefix-check 400 on the next turn | Break 1 |
| A system prompt that includes today's date | 400 on the first request after midnight | Break 1 |
| A router with 5.2 primary and a 5.1 or Opus 5.5 fallback | Reasoning dropped silently; the next turn costs more and runs slower | Break 2 |
| An eval pipeline replaying production conversations from another account | Thinking blocks dropped with no error | Break 2 |
| A computer-use agent on the Claude API or Google Cloud | 400 on computer_20251124 | Break 3 |
| A long-running coding agent with a chat UI that renders only text | Ends turns early; UI looks frozen between tool calls | Silent changes 3 and 6 |
A planner at xhigh or max that can spawn subagents | More subagents, higher cost | Silent change 5 |
If a row matched, here's what fails first.
The 4 Breaking Changes (3 Return a 400, 1 Fails Silently)
Three of these show up in your error logs. The fourth doesn't, which makes it the one to check first if you route between models.
1. The prefix check now applies to every account (400)
On 5.1, the API enforced this check by default only for accounts created on or after August 31, 2026. On older accounts, an edited history reached the model with no error [10]. On 5.2 it's enforced for everyone. So code that edits history can pass on 5.1 and fail on 5.2 with no other change. Anthropic ties the change to its anti-distillation work: it stops callers from editing Claude's earlier context to pull out its reasoning [11].
What “The block is bound to a different conversation” means
A thinking block is valid only against the exact system prompt, tools and messages that came before it when Claude wrote it. Anthropic calls that content the block's prefix [4]. Change the prefix, send the old block back, and you get:
messages.5.content.0: Invalid `signature` in `thinking` block. The block is bound to a
different conversation. Remove the block, or set
`thinking.block_binding.prefix_mismatch_behavior` to "drop_block". That setting requires
the `thinking-binding-controls-2026-08-01` value in the `anthropic-beta` header.The error has no error_code. Match only the substring The block is bound to a different conversation, because Anthropic says the rest of the text can change. Retrying the same request body fails the same way [2].
Which history edits trigger it
| Edit | Triggers the 400? | Append-only alternative |
|---|---|---|
| Changing one word of a tool description | Yes | Build tools once per conversation |
| Today's date in the system prompt | Yes, after midnight | Put the date in a new user message |
| Summarizing or trimming turns in place | Yes | Use the API's threshold compaction or context editing, which don't count |
| Deleting, moving or editing an earlier message | Yes | Append a correction as a new message |
| Dropping a thinking block from the middle | Yes | Drop only the oldest, the newest or all of them |
| Stripping thinking blocks with empty text | Yes | Send each assistant turn back exactly as returned |
| Changed content at the same file URL | Yes | Use a new URL for new content |
Changing model, effort, max_tokens, metadata or cache_control | No | Not needed |
| Appending a new turn | No | Not needed |
Anthropic's rule for staying safe has three parts: send each assistant turn back exactly as the API returned it, build system and tools once per conversation, and put every update in a new message at the end [4]. If your harness compacts context today, our guide to context engineering for production agents covers the append-only patterns in more depth.

MCP tool lists: test this on 5.2, not 5.1
With the MCP connector, a server whose tool list changes between requests counts as an edit for Fable 5.2 blocks only. Fable 5.1 and Opus 5.5 don't flag it [2]. A pre-switch test on 5.1 passes, and production on 5.2 fails. Run the test against claude-fable-5-2, or pin the server's tool list.
2. Older models can't read 5.2 thinking blocks (silent)
Fable 5.2 reads thinking blocks from 5.1, Opus 5.5 and other earlier models, so a conversation moving up to 5.2 keeps its reasoning. The reverse doesn't work. No model except Fable 5.2 and Mythos 5.2 can read 5.2's blocks. That includes Fable 5.1, Opus 5.5, and Fable 5.2's own refusal fallbacks, Opus 4.8 and Opus 5 [1].
When a request carries a block the model can't read, the API drops it and the request succeeds. The dropped block isn't billed, but the migration guide warns the next turn “can raise cost and latency” because the model works without that reasoning [2].

The same thing happens across accounts. Fable 5.2 blocks work only in the account that produced them, or one linked to it. On the Claude API the account is the organization; on Bedrock, the AWS account; on Google Cloud (Google managed), the project. Replay a conversation through a different one and the blocks drop with no error [6].
Anthropic's advice: keep sending the whole conversation. Don't strip blocks yourself, and don't keep a separate history per model. Blocks become readable again when the conversation returns to a model that can read them [6].
3. computer_20251124 returns a 400 (except on Bedrock)
5.1 accepted both the old tool and the new toolset. 5.2 accepts only computer_toolset_20260801, except on Amazon Bedrock. The upgrade is more than a rename [9]. You remove the beta header, drop the display fields, dispatch on name + toolset_name, add "toolset_name": "computer" to every tool_result, stop at the first failed action in a turn, and resize screenshots yourself. Zoom is now on by default. The toolset adds about 4,520 input tokens per request, and turning zoom off saves about 410 of them.
Changing tools is an edit (break 1), so roll this out in new conversations only.
4. The advisor must be claude-fable-5-2 or claude-mythos-5-2 (400)
A Fable 5.2 executor accepts only a 5.2 advisor. claude-fable-5-1 as advisor returns a 400. A 5.2 advisor also returns its advice encrypted, so any code that logs or parses the advice text has to change [1]. Changing the advisor model is an edit to tools, so switch it in new conversations.
Those four show up in logs, or in the test later on this page. The next six don't.
The 6 Silent Changes That Pass Your Tests
These come from Anthropic's own testing, reported in its Fable 5.2 prompting guide [3]. We haven't found an independent replication yet, which is one more reason to run them on your workload.
1. Effort levels are recalibrated
- What you'll see: different quality and token use at the same
effortvalue. - Why: the levels rank the same way, but the amount of thinking at each level differs. At
low, 5.2 scored close to what 5.1 did at higher effort on Anthropic's coding evals.xhighraised scores slightly and used many more tokens [7]. - Test: set
effort: "high"explicitly and run your evals atmediumandxhightoo. Don't carry 5.1 settings over.
2. “Think less” lines are ignored at medium and above
- What you'll see: responses with
stop_reason: "max_tokens"that contain athinkingblock and no text. - Why: 5.1 usually followed a line like “answer directly without deliberating”. 5.2 keeps thinking at
mediumand above, and athighit thinks before almost every reply, greetings included. Thinking counts towardmax_tokens[3]. - Fix: remove the line, lower effort, or raise
max_tokens.
3. It stops early on long tasks
- What you'll see: a turn that ends with a list of what's left, an offer to continue, or a stop at an ordinary obstacle. It happens more at
lowandmedium. - Fix: add Anthropic's “Finishing work” system-prompt text. In Anthropic's replay of coding sessions at
medium, about half as many sessions ended with work left undone. Output tokens rose about 30%, so measure the cost [3].
4. Approval rules are read literally, and caution piles up
- What you'll see: an agent that asks permission for routine work, or refuses to retry.
- Why: in one of Anthropic's simulated tasks, a rule saying “sending messages to people outside this conversation” needs approval made the model hold back about half of its routine messages to colleagues. Old notes like “never retry” in memory files get followed closely too, mostly in multi-agent setups [3].
- Fix: name the exact actions that need approval, name the steps that don't, and write exceptions into “never” rules. Approve with specifics, not “continue”.
5. More subagent delegation at xhigh and max
- What you'll see: more subagent calls and a higher bill on the same task.
- Why: at
xhighandmax, 5.2 used subagents to review its own work. 5.1 didn't on the same tasks [3]. - Fix: review your delegation instructions. In Anthropic's test, a longer, cost-focused subagent tool description roughly halved the number of subagents at
high. Subagents normally start their own conversations, so they don't inherit 5.2's thinking blocks.
6. Progress updates arrive as thinking blocks
- What you'll see: a UI that looks frozen during long turns.
- Why: 5.2 sends updates between tool calls as progress-update
thinkingblocks. Under the defaultdisplay: "omitted"those blocks are empty, so a client that renders onlytextshows nothing [3]. - Fix: set
thinking.displayto"updates"(betathinking-display-updates-2026-08-18) or"summarized", and render the non-emptythinkingblocks.thinking.displayisn't part of the prefix, so changing it doesn't trigger the 400.
Now the test that catches all ten.
How to Re-Test: A 5-Step Framework
Run these in order. Step 1 catches the 400s, Steps 3 and 4 catch the drift, and Step 5 covers the paths a normal test run never reaches.
Step 1. Run the prefix-check test on claude-fable-5-2
The beta header thinking-binding-controls-2026-08-01 plus prefix_mismatch_behavior: "drop_block" turns each failure into a logged entry instead of a 400. Every response then includes a top-level input_transformations array: [] when nothing was dropped, one entry per dropped block otherwise [6].
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: thinking-binding-controls-2026-08-01" \
-H "content-type: application/json" \
-d @request.json | jq '.input_transformations'{
"model": "claude-fable-5-2",
"max_tokens": 16000,
"thinking": {
"type": "adaptive",
"block_binding": { "prefix_mismatch_behavior": "drop_block" }
},
"system": "...the exact system prompt your app sends...",
"messages": [ "...the exact history your app sends on this turn..." ]
}Send the request bodies your app really builds, not hand-written ones. Capture them at the point where your code calls the API.
Prove the test can fail first
A clean result proves nothing if a proxy stripped the header or the session had no thinking blocks [5]. So break one conversation on purpose: replay a real turn with the first user message edited. You should get an entry like this:
[{ "type": "thinking_dropped", "path": "messages.2.content.0", "reason": "prefix_binding_mismatch" }]If it comes back [], the check isn't running on your path. Fix that before you trust any other result.
Reading the result
| reason | Meaning | Action |
|---|---|---|
prefix_binding_mismatch | Your code changed the history | Find the edit (see the table in break 1) and make it append-only |
model_binding_mismatch | The conversation moved to a model that can't read the block | Expected after a switch away from 5.2; decide if the cost is acceptable |
organization_binding_mismatch | The block came from another account | Replay through the account that produced it |
path indexes the messages array as you sent it, so messages.7.content.0 points at the block right after the edit. Cover the sessions that compact, add tools late, change instructions, switch models or resume from storage. Plain back-and-forth turns don't reach that code.
Step 2. Fix each edit, then go back to "error"
"drop_block" is a stopgap. Dropped blocks aren't billed, but the model can spend more output tokens working out again the reasoning it lost, and the drop invalidates the prompt cache from that point on. Anthropic gives no figure for the extra cost and says to run your own evals before relying on it [5].
Once Step 1 comes back clean, set production to "error" (the default) and alert on the 400 substring. Don't retry prefix errors: the same body fails the same way every time.
Message Batches drop blocks silently
"error" explicitly if you want batch items to fail [4].Step 3. Remove 5.1-era prompt lines
Prompts tuned for 5.1 or Opus 5.5 carry lines that now cost you tokens or quality. Three to look for:
The code-ownership sentence. With “You are the owner and long-term maintainer of this codebase, and its design is up to you.”, Anthropic saw 5.2 merge repeated code in about three quarters of tries (under a tenth without), use 1.7 to 1.8 times the output tokens, and change an existing feature's behavior in one of every six to ten tries [3]. Keep it only where the agent should own the design, and review the diff, not the summary.
- You are the owner and long-term maintainer of this codebase, and its design is up to you.
+ Make the requested change with the smallest diff. Report nearby problems; don't fix them.Token budgets written into the prompt. Removing a large budget shown in the prompt lowered cost at equal performance in Anthropic's coding tests [3].
- You have a budget of 200,000 tokens for this task. Track your usage.
+ (line removed: let effort control depth)“Treat that answer as done” lines from the Opus 5.5 prompting guide. They cut follow-up thinking, but made the model “far less likely to point out mistakes in its earlier answers” [3].
- Once you have answered, treat that answer as done and move on.
+ If you find a mistake in an earlier answer, say so and correct it.Also check for “think less” lines (silent change 2), hard style rules like “one instruction per sentence, 20 words max”, and stale “never” notes in memory files. Make all prompt and tool changes in new conversations or as an appended system message. Editing system mid-conversation is itself a prefix edit.
Step 4. Re-run the effort sweep on your own evals
Set effort: "high" explicitly, then run the same task set at medium and xhigh [7]. A minimum regression suite for this migration records, per run:
| Metric | Why it matters here | Example threshold |
|---|---|---|
| Pass rate on your task set | Quality at each effort level | No drop vs the 5.1 baseline |
| Output tokens per task | Thinking and the prompt fixes add tokens | Within your cost budget (next section) |
| Latency per task | 5.2 claims up to 30% faster output; more thinking can offset it | No slower than 5.1 at p95 |
| Unfinished-task rate | Silent change 3 | Lower than or equal to 5.1 |
max_tokens stops with no text | Silent change 2 | Zero |
| Subagent calls per task | Silent change 5 | Within budget |
Add Anthropic's fixes one at a time and measure each one's token cost. Several of them raise output by 20% to 80%. For the wider method, see our guide on benchmarking a candidate model against your own workload.
Step 5. Check the UI and routing paths
- Progress display: set
thinking.displayto"updates"or"summarized"and confirm the UI renders the non-emptythinkingblocks. - Fallbacks and routers: confirm that every route from 5.2 to 5.1, Opus 5.5, Opus 4.8 or Opus 5 is acceptable without the earlier reasoning, and check first-turn cost after a switch.
- Stored conversations: resume a few stored conversations after your prompt or tool changes. If
systemortoolschanged, they'll hit the 400. - MCP: run Step 1 against 5.2 with a changing tool list, or pin the list.
- Refusals: keep handling
stop_reason: "refusal". With an explicitfallbackslist, 5.2 permits onlyclaude-opus-4-8andclaude-opus-5[2].
Tools for the re-test
| Tool | Use it for in this migration |
|---|---|
thinking-binding-controls beta + input_transformations | Finding every history edit that trips the prefix check (Step 1) |
/v1/messages/count_tokens | A free first pass: it runs the same prefix check and returns the same 400 in "error" mode |
response.usage logs or Anthropic's Usage and Cost API | Cost-per-task baseline, 5.1 vs 5.2 |
| Promptfoo | Running the same test set against both model IDs from a config file, in CI |
| DeepEval | pytest-style pass/fail assertions on outputs |
| Braintrust | Comparing experiment runs side by side to spot regressions |
| Langfuse or LangSmith | Tracing long agent runs to find early stops and subagent fan-out |
The full checklist

Returns a 400 or drops reasoning (4)
- Prefix-check test passes on
claude-fable-5-2, including MCP tool lists, after proving it can fail. - Every route away from 5.2, and every cross-account replay, is checked and accepted.
computer_20251124replaced withcomputer_toolset_20260801(off Bedrock), in new conversations.- Advisor set to a 5.2 model, and no code reads the advice text.
Passes and drifts (6)
- Effort sweep at
medium/high/xhighre-baselined. - “Think less” lines removed; no
max_tokensstops without text. - Early stops checked on the longest tasks.
- Approval rules name exact actions; stale “never” notes removed.
- Subagent count and cost checked at
xhigh/max. - Progress updates render in the UI.
Step 4 gives you token counts. Here's what they cost.
Fable 5.2 Costs Less per Token. Re-Test Cost per Task First
Fable 5.2 is 20% cheaper per token: $8 / $40 per million input and output tokens against 5.1's $10 / $50 [1]. That doesn't make each task 20% cheaper.
The break-even point is 25% more tokens
Because both prices fall by the same 20%, the math is simple: if a task uses 25% more tokens on 5.2 than on 5.1, it costs the same. Above 25% more, 5.2 costs more.
Several of Anthropic's own recommended fixes cross that line on output tokens alone [3]. The “Finishing work” text adds about 30%. The code-ownership sentence adds 70% to 80%. The opening and recap text for progress updates adds about 20%. "drop_block" adds an unmeasured amount on every turn it fires.

| Example task (illustrative) | Input tokens | Output tokens | Cost |
|---|---|---|---|
| Fable 5.1 | 40,000 | 12,000 | $1.00 |
| Fable 5.2, same tokens | 40,000 | 12,000 | $0.80 |
| Fable 5.2 + “Finishing work” text (+30% output) | 40,000 | 15,600 | $0.94 |
| Fable 5.2 + code-ownership sentence (+75% output) | 40,000 | 21,000 | $1.16 |
Where the extra tokens come from
- Thinking on more turns. At
highand above, 5.2 thinks before almost every reply. - Dropped blocks. After a fallback or a
"drop_block"drop, the model works the reasoning out again. - Prompt fixes. The +20% to +80% figures above.
- Subagents. More of them at
xhighandmax. - Computer use. About 4,520 extra input tokens per request with the default toolset.
For context, Anthropic's launch post claims 5.2 at High effort roughly matched Opus 5.5 at Max on its FrontierCode benchmark “for roughly half the cost per task” [11]. That's a vendor benchmark, not your workload. Your Step 4 numbers decide this.
If the numbers pass, ship it without losing reasoning mid-conversation.
Rolling Out: Rate Limits, Canary and Rollback
Anthropic's migration guide doesn't cover rollout, so this section is our practice, not Anthropic guidance.
Check the separate rate-limit pool first
Fable 5.2 has its own rate limit, separate from the pool Fable 5.1 and Fable 5 share. The listed standard values match 5.1's: 4,000 RPM at the Start tier, 10,000 at Build, 13,000 at Scale [8]. Check your actual limits on the Console's Rate limits page. Ramp limits can also cap how fast usage on a model grows, returning a 429 with ramp_limit_exceeded. With a brand-new pool, moving all traffic at once is the easiest way to meet one.
Canary by new conversation, not by request
Move a share of new conversations to 5.2 and keep existing ones on 5.1 until they end. Splitting by request moves live conversations between models. A move up to 5.2 is fine, but a move back down drops 5.2's reasoning.
Rollback has a cost
You can switch back to 5.1 at any time. Conversations that started on 5.2 continue on 5.1 without 5.2's reasoning, so expect higher cost and latency on their next turn. Roll back new conversations first, and let in-flight 5.2 conversations finish where you can.
Eight ways teams get this wrong:
Mistakes to Avoid
Running the pre-switch test on 5.1
It won't catch MCP tool-list changes, which only Fable 5.2 treats as an edit.
Swapping the model ID and running only a smoke test
Plain turns don't reach compaction, resume or model-switch code.
Trusting a clean test you never proved can fail
A header stripped by a proxy looks exactly like a clean result.
Comparing cost per token instead of cost per task
Past 25% more tokens, Fable 5.2 costs more than 5.1.
Leaving drop_block on in production
It hides the bug and raises output tokens on every turn it fires.
Retrying prefix errors
The same request body fails the same way every time.
Stripping empty thinking blocks, or replaying through another account
Both drop reasoning. The first returns a 400, the second fails silently.
Cutting over before checking the rate-limit pool
Fable 5.2 has its own pool, and ramp limits cap how fast usage on it can grow.
So, switch or not?
Switch Now, Wait, or Choose Opus 5.5?
Anthropic's benchmarks show large gains on agentic coding, such as 49.1% vs 32.4% on FrontierCode 2.0 at xhigh [11], but we found no independent 5.1-vs-5.2 comparison yet. Let your own re-test decide.
Switch now
Your harness is already append-only, the prefix-check test comes back clean, and the effort sweep shows equal or better quality at a cost per task you accept.
Wait a sprint
The test found history edits, or you route between models or replay stored conversations. Fix those first, or you trade a working 5.1 setup for 400s and silent reasoning loss.
Choose Opus 5.5
Your cost-per-task test fails your budget on Fable 5.2 at every effort level that passes your quality bar. Opus 5.5 can't read 5.2's thinking blocks, so pick per new conversation, not per request.
If you'd rather have someone else run this re-test on your harness, our AI model migration service does exactly this.
Want the Fable 5.2 Re-Test Run on Your Harness?
Crescent AI runs the prefix-check test, the effort sweep and the cost-per-task comparison on your own traffic, then tells you whether to switch, wait or route.
Sources
- [1] What's new in Claude Fable 5.2 — Anthropic Platform Docs
- [2] Claude Fable 5.2 and Claude Mythos 5.2 migration guide — Anthropic Platform Docs
- [3] Prompting Claude Fable 5.2 — Anthropic Platform Docs
- [4] Prefix checks on thinking blocks — Anthropic Platform Docs
- [5] Fix a thinking block bound to a different conversation — Anthropic Platform Docs
- [6] Preserved thinking — Anthropic Platform Docs
- [7] Effort — Anthropic Platform Docs
- [8] Rate limits — Anthropic Platform Docs
- [9] Computer use tool: migrate from computer_20251124 — Anthropic Platform Docs
- [10] Claude Platform release notes — Anthropic, 2026
- [11] Introducing Claude Fable 5.2 and Claude Mythos 5.2 — Anthropic, November 2026
- [12] How is ChatGPT's behavior changing over time? — Chen, Zaharia & Zou, Stanford / UC Berkeley, arXiv 2023
- [13] State of Agent Engineering — LangChain, survey of 1,340 respondents, 2025