Claude Fable 5

Claude Fable 5 and Mythos 5 are Anthropic’s latest frontier models, and both are supported in Swarms from day one. There are no migrations, no infrastructure changes, and no special configuration — switching to Fable 5 is a single line change:

model_name = "anthropic/claude-fable-5"

This tutorial walks through everything you need to build, configure, and scale agents and multi-agent systems on Fable 5.

What’s new

Fable 5 — state-of-the-art on nearly all tested benchmarks, with exceptional performance in software engineering, knowledge work, scientific research, and vision. The longer and more complex the task, the larger Fable 5’s lead over earlier Claude models.
Mythos 5 — the same underlying model as Fable 5, but with safeguards lifted in some areas. Restricted to Glasswing partners (defensive cybersecurity and biomedical research). For most users, Fable 5 is the right default.
Built-in safeguards — Fable 5 detects requests in narrow risk areas (cybersecurity, biology, chemistry, distillation) and quietly falls back to Opus 4.8 on those queries. Fallbacks happen in under 5% of sessions on average, and users are informed when they occur.

Fable 5 is automatically routed through LiteLLM by Swarms. As long as your ANTHROPIC_API_KEY is set, no other configuration is needed.

Two important limitations:

Tools / function calling are not supported on Fable 5. Leave tools=None and tools_list_dictionary=None on every Fable 5 agent. If you need tool use, route those calls to a different model (e.g. claude-sonnet-4-6 or gpt-5.4) and use Fable 5 as the reasoning/synthesis layer.
temperature is not supported. Leave it unset. Agent defaults temperature and top_p to None, and Swarms leaves unset values out of the request, so the model uses its own sampling.

When reasoning is on (reasoning_effort or reasoning_enabled=True), Swarms itself sends temperature=1 and drops top_p for Claude models, as Anthropic’s extended thinking requires.

Installation

pip install -U swarms

Environment Setup

Set your Anthropic API key:

export ANTHROPIC_API_KEY="sk-ant-..."

Or create a .env file:

ANTHROPIC_API_KEY="sk-ant-..."
WORKSPACE_DIR="agent_workspace"

Quick Start

The minimum needed to run a Fable 5 agent:

from swarms import Agent

agent = Agent(
    agent_name="Fable-5-Agent",
    model_name="anthropic/claude-fable-5",
    max_loops=1,
)

print(agent.run("Explain how transformer attention works in three paragraphs."))

That’s it. Streaming, multi-agent orchestration, autonomous loops, and vision work against Fable 5 with no additional setup. Tool calling (including MCP tools) does not; see Tools.

Complete Example: Quantitative Trading Agent

Here is a fully-configured Fable 5 agent tuned for finance research. This is a good template to copy for serious workloads — it uses extended thinking, high reasoning effort, and a detailed system prompt:

from swarms import Agent

system_prompt = (
    "You are Quantitative-Trading-Agent, an advanced AI assistant specializing in quantitative finance, "
    "trading, and algorithmic analysis. You have deep expertise in analyzing financial instruments, "
    "with a focus on exchange-traded funds (ETFs), equities, derivatives, and portfolio construction. "
    "You always provide thorough, data-driven, and well-cited analysis suitable for both institutional "
    "and individual investors, incorporating recent performance metrics, expense ratios, portfolio holdings, "
    "liquidity considerations, risk factors, and competitive landscape insights. When responding, organize "
    "information clearly, use tables or bullet points where appropriate, and explain your reasoning process "
    "explicitly. Proactively mention relevant industry trends and regulatory context as needed. Avoid making "
    "financial recommendations, but focus on providing comparative research to empower decision-making. Use "
    "plain language to explain technical topics, and cite reputable public sources when possible. Your "
    "responses should reflect professionalism, accuracy, and a collaborative, respectful tone."
)

agent = Agent(
    agent_name="Quantitative-Trading-Agent",
    agent_description="Advanced quantitative trading and algorithmic analysis agent",
    system_prompt=system_prompt,
    model_name="anthropic/claude-fable-5",
    max_loops=1,
    reasoning_enabled=True,
    thinking_tokens=1024,
    reasoning_effort="high",
)

out = agent.run(
    task=(
        "Analyze the best semiconductor ETFs and provide a detailed comparison. "
        "Include metrics such as performance, expense ratio, holdings, and any notable strategies."
    ),
)

print(out)

Why these parameter choices?

Parameter	Value	Why
`model_name`	`"anthropic/claude-fable-5"`	The LiteLLM-prefixed name for Fable 5.
`max_loops`	`1`	One LLM call per `run()`. Bump to `"auto"` for autonomous loops.
`reasoning_enabled`	`True`	Sends an explicit thinking block. Without it, `thinking_tokens` is ignored.
`thinking_tokens`	`1024`	The thinking budget: a private scratchpad before responding.
`reasoning_effort`	`"high"`	Tells the model to favor depth over speed. Use `"low"`/`"medium"` for cheaper, faster runs.

temperature, top_p, and tools_list_dictionary are left at their None defaults: Fable 5 supports neither temperature nor tool calling.

Extended Thinking & Reasoning Effort

Fable 5 supports Anthropic’s extended thinking. Swarms exposes this through three parameters:

agent = Agent(
    agent_name="Deep-Thinker",
    model_name="anthropic/claude-fable-5",
    reasoning_enabled=True,
    thinking_tokens=4096,        # private thinking budget per response
    reasoning_effort="high",     # "low" | "medium" | "high"
    max_loops=1,
)

reasoning_enabled — turns on the explicit thinking block. thinking_tokens (default 1024) only takes effect when this is True.
thinking_tokens — the maximum number of tokens the model can spend on internal reasoning before producing its final answer. Larger budgets help on multi-step problems (proofs, code refactors, deep research) at the cost of latency and tokens.
reasoning_effort — a coarse dial, forwarded on its own (LiteLLM maps it to a thinking budget). "low" is roughly chat-quality, "medium" suits analytical work, "high" is best for hard problems where you want the model to think before answering.

The autonomous loop’s think tool is off by default (think_tool=False), so a model that already reasons natively doesn’t spend an extra round-trip on it. Leave it off for Fable 5.

Choosing budgets

Task class	`thinking_tokens`	`reasoning_effort`
Casual chat / short Q&A	unset (`reasoning_enabled=False`)	`"low"` or unset
Standard analytical work	`1024`	`"medium"`
Long-form research, multi-file code review, hard math	`4096`–`16000`	`"high"`
Multi-hour autonomous loops	`8192`+	`"high"`

Streaming

Stream tokens straight to stdout:

from swarms import Agent

agent = Agent(
    agent_name="Streaming-Fable-5",
    model_name="anthropic/claude-fable-5",
    streaming_on=True,
    max_loops=1,
)

agent.run("Write a 300-word essay on why Rust is gaining adoption in systems programming.")

Or pipe tokens to your own callback (useful for dashboards, websockets, or audio synthesis):

def on_token(token: str) -> None:
    print(token, end="", flush=True)

agent = Agent(
    agent_name="Callback-Fable-5",
    model_name="anthropic/claude-fable-5",
    streaming_on=True,  # the callback only fires while streaming
    streaming_callback=on_token,
    max_loops=1,
)

agent.run("Explain quantum entanglement in plain English.")

For async streaming, use arun_stream:

import asyncio
from swarms import Agent

agent = Agent(
    agent_name="Async-Fable-5",
    model_name="anthropic/claude-fable-5",
    streaming_on=True,
)

async def main():
    async for token in agent.arun_stream("Walk me through async/await in Python."):
        print(token, end="", flush=True)

asyncio.run(main())

Tools (Not Supported)

Fable 5 does not support function calling / tool use. Passing tools=[...] or tools_list_dictionary=[...] to a Fable 5 agent will not work. If your workflow needs tools, the recommended pattern is to split responsibilities across two agents — a tool-calling model gathers the data, and Fable 5 does the reasoning over it:

from swarms import Agent, SequentialWorkflow
import yfinance as yf

def get_stock_price(ticker: str) -> str:
    """Fetch the current stock price for a given ticker symbol."""
    data = yf.Ticker(ticker)
    price = data.fast_info["last_price"]
    return f"{ticker}: ${price:.2f}"

# Step 1: a tool-capable model gathers the raw data
data_collector = Agent(
    agent_name="Data-Collector",
    model_name="claude-sonnet-4-6",   # Sonnet supports tools
    tools=[get_stock_price],
    max_loops=3,
)

# Step 2: Fable 5 does the deep analysis on the collected data
analyst = Agent(
    agent_name="Fable-5-Analyst",
    model_name="anthropic/claude-fable-5",
    reasoning_enabled=True,
    thinking_tokens=4096,
    reasoning_effort="high",
    max_loops=1,
)

pipeline = SequentialWorkflow(agents=[data_collector, analyst], max_loops=1)
print(pipeline.run("Compare NVDA, AMD, and INTC, then deeply analyze the implications."))

This pattern keeps Fable 5 focused on what it does best — reasoning, synthesis, and writing — while letting another model handle the I/O.

Vision

Fable 5 has strong vision capabilities. Pass an image path, URL, or base64 string to run():

from swarms import Agent

agent = Agent(
    agent_name="Chart-Analyst",
    model_name="anthropic/claude-fable-5",
    max_loops=1,
)

result = agent.run(
    task="Describe the trend in this chart and call out anything unusual.",
    img="path/to/chart.png",
)
print(result)

Autonomous Loops

For agents that should plan, execute, and reflect until done, set max_loops="auto":

from swarms import Agent

agent = Agent(
    agent_name="Autonomous-Fable-5",
    model_name="anthropic/claude-fable-5",
    max_loops="auto",
    reasoning_enabled=True,
    thinking_tokens=4096,
    reasoning_effort="high",
    persistent_memory=True,
    context_compression=True,
    context_length=200_000,
)

agent.run(
    "Research the top 5 vector databases used in production AI systems in 2026, "
    "compare them on latency, recall, and pricing, and write the report to report.md."
)

Fable 5 is particularly well-suited to autonomous loops — the longer the task, the larger its lead. Combine it with persistent_memory=True and context_compression=True for long-running production agents.

Multi-Agent Systems with Fable 5

Every Swarms multi-agent structure works with Fable 5 the same way it works with any other model — just set model_name="anthropic/claude-fable-5" on the agents.

The examples below leave temperature, top_p, and tools_list_dictionary at their None defaults, which is what Fable 5 needs. If you want a tool-calling agent in the mix, give that role to a different model (e.g. claude-sonnet-4-6) and let Fable 5 do the reasoning.

Sequential Workflow

from swarms import Agent, SequentialWorkflow

researcher = Agent(
    agent_name="Researcher",
    model_name="anthropic/claude-fable-5",
    system_prompt="You research topics thoroughly with citations.",
    reasoning_enabled=True,
    thinking_tokens=2048,
    max_loops=1,
)

analyst = Agent(
    agent_name="Analyst",
    model_name="anthropic/claude-fable-5",
    system_prompt="You analyze research and identify key insights.",
    reasoning_enabled=True,
    thinking_tokens=2048,
    max_loops=1,
)

writer = Agent(
    agent_name="Writer",
    model_name="anthropic/claude-fable-5",
    system_prompt="You write clear, engaging executive summaries.",
    max_loops=1,
)

pipeline = SequentialWorkflow(agents=[researcher, analyst, writer], max_loops=1)
print(pipeline.run("Impact of GPU shortages on AI training costs in 2026."))

Concurrent Workflow

Run several Fable 5 agents in parallel:

from swarms import Agent, ConcurrentWorkflow

agents = [
    Agent(
        agent_name=f"Expert-{topic}",
        model_name="anthropic/claude-fable-5",
        system_prompt=f"You are an expert on {topic}.",
        reasoning_enabled=True,
        thinking_tokens=1024,
        max_loops=1,
    )
    for topic in ["Hardware", "Software", "Economics", "Policy"]
]

workflow = ConcurrentWorkflow(agents=agents)
results = workflow.run("How will export controls reshape the global AI chip market?")

for entry in results:
    print(f"\n=== {entry['role']} ===\n{entry['content']}")

Mixture of Agents

Fable 5 also makes an excellent aggregator on top of cheaper worker models — let smaller models propose ideas in parallel and have Fable 5 synthesize the final answer:

from swarms import Agent, MixtureOfAgents

workers = [
    Agent(
        agent_name="Worker-Haiku",
        model_name="claude-haiku-4-5",
        max_loops=1,
    ),
    Agent(
        agent_name="Worker-Sonnet",
        model_name="claude-sonnet-4-6",
        max_loops=1,
    ),
    Agent(
        agent_name="Worker-GPT",
        model_name="gpt-5.4",
        max_loops=1,
    ),
]

aggregator = Agent(
    agent_name="Fable-5-Aggregator",
    model_name="anthropic/claude-fable-5",
    system_prompt="Synthesize the worker responses into one coherent answer.",
    reasoning_enabled=True,
    thinking_tokens=4096,
    reasoning_effort="high",
    max_loops=1,
)

moa = MixtureOfAgents(
    agents=workers,
    aggregator_agent=aggregator,
    layers=2,
)

print(moa.run("What are the best practices for securing a Kubernetes cluster?"))

Hierarchical Swarm

Make Fable 5 the director and let cheaper models be the workers:

from swarms import Agent, HierarchicalSwarm

director = Agent(
    agent_name="Fable-5-Director",
    model_name="anthropic/claude-fable-5",
    system_prompt="You break complex tasks into subtasks and delegate them.",
    reasoning_enabled=True,
    thinking_tokens=4096,
    reasoning_effort="high",
    max_loops=1,
)

workers = [
    Agent(agent_name=f"Worker-{i}", model_name="claude-haiku-4-5", max_loops=1)
    for i in range(4)
]

swarm = HierarchicalSwarm(director=director, agents=workers, max_loops=2)
print(swarm.run("Produce a competitive analysis of the AI inference chip market."))

Safety Fallbacks

Fable 5 detects requests in a narrow set of high-risk topic areas (cybersecurity, biology, chemistry, distillation-style extraction) and silently routes those queries to Opus 4.8 instead. Anthropic reports that fallbacks happen in under 5% of sessions on average, and the user is informed whenever a fallback occurs. For Swarms users this means:

You don’t need to do anything. Fallback is handled inside the Anthropic API; Swarms surfaces the response normally.
Your agent may occasionally return text noting that a different model answered. This is expected behavior, not an error.
If your domain is consistently flagged (e.g. legitimate defensive cybersecurity work), apply for access to Mythos 5 — see below.

Mythos 5 (Restricted Access)

Mythos 5 is the same underlying model as Fable 5, but with safeguards lifted in some areas. It is currently restricted to Glasswing partners working on defensive cybersecurity and biomedical research. Anthropic plans to expand access through a broader trusted-access program. If you have access, use it the same way as Fable 5:

from swarms import Agent

agent = Agent(
    agent_name="Mythos-5-Agent",
    model_name="anthropic/claude-mythos-5",
    reasoning_enabled=True,
    thinking_tokens=4096,
    reasoning_effort="high",
    # tools are not supported on Mythos 5 either; leave tools unset
    max_loops=1,
)

print(agent.run("Run a defensive analysis of this network traffic capture."))

If you receive an authentication or access error, your API key is not yet whitelisted for Mythos 5 — contact Anthropic to apply.

Production Best Practices

When deploying Fable 5 agents to production, these defaults work well:

agent = Agent(
    agent_name="Production-Fable-5",
    model_name="anthropic/claude-fable-5",
    max_loops=1,
    reasoning_enabled=True,
    thinking_tokens=2048,
    reasoning_effort="medium",
    persistent_memory=True,        # survive process restarts
    context_compression=True,      # auto-summarize at 90% of context
    context_length=200_000,
    autosave=True,                 # snapshot agent state after each run
    retry_attempts=3,
    print_on=False,                # silence console output in services
    verbose=False,
)

Cost Controls

Tier reasoning effort to task complexity — "low" for triage and routing, "high" only for the work that needs it.
Cap thinking_tokens per agent — start at 1024 and only increase if quality demands it.
Use Fable 5 as the aggregator, not every worker — Mixture of Agents and Hierarchical Swarms get most of the benefit when only the top of the hierarchy runs on Fable 5.
Set max_loops explicitly — avoid "auto" in production unless you have a hard timeout or token budget elsewhere.

Observability

Set verbose=True and autosave=True during development so you can inspect every loop. In production, prefer your own logging via streaming_callback rather than stdout.

Troubleshooting

AuthenticationError — your ANTHROPIC_API_KEY isn’t set or doesn’t have access to Fable 5. Run echo $ANTHROPIC_API_KEY and confirm. Empty responses on reasoning tasks — if you previously hit a regression where non-OpenAI providers returned empty strings when reasoning_effort was set, this was fixed in Swarms v12. Make sure you’re on the latest release: pip install -U swarms. Slow responses — Fable 5 with thinking_tokens=16000 and reasoning_effort="high" is deliberately slow because the model is reasoning before answering. Drop both to 1024 / "medium" for routine tasks. Mythos 5 returns access errors — your API key isn’t whitelisted for Mythos 5. Apply through Anthropic’s trusted access program or stay on Fable 5.

Next Steps

Agent API Reference — every parameter Fable 5 agents accept.
Model Providers — using other providers alongside Fable 5.
Multi-Agent Architectures — composing Fable 5 agents into swarms.
Production Best Practices — running Fable 5 agents at scale.

​What’s new

​Installation

​Environment Setup

​Quick Start

​Complete Example: Quantitative Trading Agent

​Why these parameter choices?

​Extended Thinking & Reasoning Effort

​Choosing budgets

​Streaming

​Tools (Not Supported)

​Vision

​Autonomous Loops

​Multi-Agent Systems with Fable 5

​Sequential Workflow

​Concurrent Workflow

​Mixture of Agents

​Hierarchical Swarm

​Safety Fallbacks

​Mythos 5 (Restricted Access)

​Production Best Practices

​Cost Controls

​Observability

​Troubleshooting

​Next Steps

What’s new

Installation

Environment Setup

Quick Start

Complete Example: Quantitative Trading Agent

Why these parameter choices?

Extended Thinking & Reasoning Effort

Choosing budgets

Streaming

Tools (Not Supported)

Vision

Autonomous Loops

Multi-Agent Systems with Fable 5

Sequential Workflow

Concurrent Workflow

Mixture of Agents

Hierarchical Swarm

Safety Fallbacks

Mythos 5 (Restricted Access)

Production Best Practices

Cost Controls

Observability

Troubleshooting

Next Steps