opendunes
Evaluate and optimise
Copy page ▾

Fable 5.1

Move an app from Claude Fable 5 to Claude Fable 5.1: the model IDModel IDThe name a request calls a model by, lab/model, copied from Models.More on Models → changes, and the way you call tools with it.

  1. Change the model ID.
  2. Update the request.
  3. Read the answer.
  4. Set the effort.
  5. Compare before you switch.

1. Change the model ID

FromTo
Model IDanthropic/claude-fable-5anthropic/claude-fable-5.1
Context1 000 000 tokens1 000 000 tokens
Longest answer128 000 tokens128 000 tokens
Reasoningalways onalways on
Effort levelslow · medium · high · xhigh · maxthe same five
A forced tool calltakenrefused

GET /v1/model/{lab}/{model} answers each model's entry: its context, its longest answer, its reasoning. The request keeps its shape; model changes.

JSON
{
  "model": "anthropic/claude-fable-5.1",
  "reasoning": {
    "effort": "high"
  },
  "messages": [
    {
      "role": "user",
      "content": "Plan the move of our orders table to the new schema."
    }
  ]
}

2. Update the request

You send todayOn Fable 5.1Send instead
tool_choice set to required or to one tool by name; any or tool on /v1/messagesrefusedauto, with the prompt naming the tool to use

A forced call would skip the reasoning, and the model would write its working into the tool's arguments. auto lets the model decide, so check that a call came back and ask again if not: see Tools and function calling. Where a forced call only served to get JSON back, ask for it with Structured outputs.

Two additions, both on /v1/messages and both in beta at Anthropic, change a setting for one turn without rewriting the conversation.

ToAdd, before the user turn it applies to
change the effort for one turna system message with empty content and output_config.effort
give an instruction for one turna system message with clear_at: "next_user_message"
JSON
{
  "model": "anthropic/claude-fable-5.1",
  "max_tokens": 16000,
  "output_config": {
    "effort": "high"
  },
  "messages": [
    {
      "role": "user",
      "content": "Plan the move of our orders table."
    },
    {
      "role": "assistant",
      "content": "Here is the plan: …"
    },
    {
      "role": "system",
      "content": [],
      "output_config": {
        "effort": "low"
      }
    },
    {
      "role": "user",
      "content": "Now rename the config file."
    }
  ]
}

3. Read the answer

Fable 5.1 ties each block of reasoning to the model that wrote it and to the conversation before it.

CaseWhat happens
a conversation moves from Fable 5 or an older model onto Fable 5.1its reasoning carries over
a conversation moves from Fable 5.1 onto an older modelthat model cannot read Fable 5.1's reasoning, and runs without it
an earlier turn, the system prompt or the tool list is editedthe reasoning written after it no longer holds
Don't

Edit an earlier turn, the system prompt or the tool list mid-conversation.

Do

Add to the conversation instead: a new instruction goes in a new message, and thinking blocks go back unchanged with tool results.

Anthropic lists three changes that come with no change to your code.

Fable 5.1Where Fable 5
may call one tool per turn in a long agent loopbatched several
writes fewer progress notes between tool callswrote more
answers from memory more often at low effortsearched more often

Ask in the prompt for the calls and notes you need. On /v1/messages, thinking.display set to updates returns the progress notes it does write, in beta at Anthropic.

4. Set the effort

Reasoning is always on; effort sets how long it runs, and so what an answer costs.

RouteField
/v1/chat/completionsreasoning.effort, or reasoning_effort
/v1/messagesoutput_config.effort

Anthropic gives high as the default. Set the level in every request: lower it for routine turns where answers hold, and raise it on turns that need a fresh search.

5. Compare before you switch

Send the same set of real prompts to both IDs, and compare three things.

CompareWhere
the answersyour own check: a test suite, a reviewer, the task's pass rate
what each costusage.cost, in DADAThe Algerian dinar, the one currency the docs show.More on Balance and charges →, on every answer
how much each reasonedusage.completion_tokens_details.reasoning_tokens

The script sends one question that needs a tool three ways: a forced call on the old ID, a forced call on the new ID, and auto on the new ID. A refused request prints its status; an answer prints the tools the model called. A line that reads nothing is the check from step 2: no call came back, so ask again.

RunModeltool_choice
old, forcedMODELthe tool, by name
new, forcedCANDIDATEthe tool, by name
new, autoCANDIDATEauto, with the tool named in the system prompt
import os
from openai import APIStatusError, OpenAI

API_KEY = os.environ["OPENDUNES_API_KEY"]
BASE_URL = "https://opendunes.com/v1"
MODEL = "anthropic/claude-sonnet-4.5"
CANDIDATE = "anthropic/claude-sonnet-4.5"
MAX_TOKENS = 4000
BRIEF = "Use lookup_order to answer any question about an order."
PROMPT = "Where is order 4812?"
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "lookup_order",
            "description": "Look an order up by its number.",
            "parameters": {
                "type": "object",
                "properties": {"order_id": {"type": "string"}},
                "required": ["order_id"],
            },
        },
    }
]
FORCED = {"type": "function", "function": {"name": "lookup_order"}}
RUNS = [
    ("old, forced", MODEL, FORCED),
    ("new, forced", CANDIDATE, FORCED),
    ("new, auto", CANDIDATE, "auto"),
]

client = OpenAI(base_url=BASE_URL, api_key=API_KEY)

for label, model, choice in RUNS:
    try:
        reply = client.chat.completions.create(
            model=model,
            max_tokens=MAX_TOKENS,
            messages=[
                {"role": "system", "content": BRIEF},
                {"role": "user", "content": PROMPT},
            ],
            extra_body={"tools": TOOLS, "tool_choice": choice},
        )
    except APIStatusError as error:
        print(f"{label:12} refused, status {error.status_code}")
        continue
    message = reply.choices[0].message
    called = [call.function.name for call in message.tool_calls or []]
    print(
        f"{label:12} called {called or 'nothing'}",
        f"cost {reply.usage.cost}",
    )

The samples put anthropic/claude-sonnet-4.5 in both seats, so they run as they stand: both forced runs call the tool. Set MODEL to anthropic/claude-fable-5 and CANDIDATE to anthropic/claude-fable-5.1: the second run is then refused, and the third is the one to keep.

Where a line reads nothing, the model chose to answer without the tool. Name the tool in the prompt more plainly, or ask again once; do not go back to a forced call.

Switch once the new ID holds; going back is the same one-line change. Run your red-team suite on the new ID too: Red teaming.

Last modified on