Claude Fable 5: A Practical Guide to Long-Running AI Work
How to use autonomous AI for complex projects without losing control of cost, quality, security, or scope
Introduction: From Chatbot to Long-Running Agent
Most AI assistants are used one prompt at a time. You ask a question, receive an answer, review it, and then decide what to do next. Claude Fable 5 is designed for a different style of work: large assignments that may continue across many steps with less supervision.
Anthropic positions Fable 5 as its most capable widely available model for long-running agents, complex coding projects, multi-stage knowledge work, vision-heavy analysis, and tasks that need repeated testing. In an agent environment such as Claude Code, it can plan a project, use tools, delegate parts of the work, inspect the result, and continue until a defined condition is reached.
That extra independence is useful, but it changes the user’s responsibility. A normal chatbot can be corrected after every response. A long-running agent may continue in the wrong direction for hours if the assignment is vague. The most important skill is therefore not writing a clever prompt. It is defining the result, the limits, and the evidence of completion so clearly that the system can check them.
What Is Claude Fable 5?
Claude Fable 5 is a Mythos-level model built for demanding, long-duration work. Anthropic says it can operate for days inside an agent harness, plan across multiple stages, delegate work to sub-agents, and test its own output. It is available through Claude products and the Claude API, while Claude Mythos 5 is a more restricted configuration offered only to approved organizations.
Fable 5 is especially suited to work where quality depends on maintaining context across many actions. Examples include migrating a large application, analysing a collection of business documents, implementing a complete product feature, reviewing a complex architecture, or creating a deliverable that requires several rounds of research and validation.
It should not be treated as the automatic choice for every request. Quick emails, ordinary summaries, simple code changes, brainstorming, and routine questions usually do not need the most expensive model. Fable 5 makes the most sense when the task is difficult, long, interconnected, and valuable enough to justify the additional cost.
Where Fable 5 Adds the Most Value
The clearest advantage appears in long-horizon work. A difficult project often fails with smaller models not because they cannot write an individual function or paragraph, but because they lose the overall plan, stop too early, fail to verify changes, or need constant human direction. Fable 5 is designed to remain engaged across a much longer sequence of decisions.
Good use cases include large codebase migrations, cross-system impact analysis, multi-document research, complex financial or operational analysis, interface implementation from visual designs, and end-to-end preparation of professional deliverables. In each case, the work contains many connected steps and benefits from a model that can revisit its assumptions and test the final result.
A useful decision test is simple: would the assignment normally require an experienced person to work through several stages, consult multiple sources, and perform quality checks before calling it complete? When the answer is yes, Fable 5 may be appropriate. When the work can be completed reliably in one or two short responses, a faster and cheaper model is normally the better choice.
Cost Matters: Use the Strongest Model Only Where It Helps
Fable 5 is priced at $10 per million input tokens and $50 per million output tokens. Anthropic’s current model comparison lists Claude Opus 5 at $5 and $25, and Claude Sonnet 5 at $3 and $15. Sonnet 5 has introductory pricing of $2 and $10 through August 31, 2026.
These differences become significant during an unattended run that repeatedly reads files, calls tools, generates code, and verifies its own work. The practical approach is to route tasks according to difficulty instead of using the most powerful model everywhere.
Use Fable 5 for the moments where judgment is most valuable: understanding the problem, designing the strategy, identifying risks, resolving difficult blockers, and performing the final review. Use a cheaper model for predictable middle-stage execution such as repetitive file updates, standard transformations, routine documentation, and simple test fixes. This model mix can preserve quality while reducing unnecessary token spend.
A Simple Model-Routing Strategy
Consider a legacy application migration. Fable 5 can first inspect the architecture, map dependencies, define the migration sequence, and create acceptance criteria. Sonnet can then perform repetitive conversions across many files. Fable 5 can return at the end to examine the complete change, run broader checks, and look for architectural or behavioural problems.
The same idea applies outside software. For a market analysis, Fable can establish the research framework and identify the questions that matter. A cheaper model can collect and organise straightforward information. Fable can then review the evidence, challenge weak assumptions, and produce the final interpretation.
The principle is not that cheaper models are unimportant. It is that expensive reasoning should be concentrated where it changes the outcome.
The Most Important Instruction: Define “Done”
Long-running agents perform best when completion is objective. An instruction such as “improve the application” or “research this thoroughly” sounds reasonable to a person, but it does not provide a machine-checkable finish line.
A strong completion condition normally contains four parts:
· A measurable end state: what must be true when the work is complete.
· A verification method: the test, command, report, comparison, or review that proves it.
· Constraints: files, interfaces, systems, behaviours, or data that must not be changed.
· A stopping limit: the maximum number of attempts, turns, elapsed time, or cost.
For example, replace “refactor the authentication module” with a condition such as: refactor the module without changing its public API; all unit and integration tests must pass; the application must build successfully; no new high-severity security findings may be introduced; and the run must stop after 20 unsuccessful repair attempts.
This instruction gives the agent a destination, a way to prove arrival, boundaries for the journey, and a rule for stopping when progress has stalled.
Use /goal for Completion and /loop for Repeated Checks
Claude Code includes different mechanisms for keeping work active. The /goal command is intended for a bounded assignment with a verifiable end state. After each turn, a smaller evaluator checks whether the stated condition has been satisfied. If it has not, Claude continues working.
This is suitable for tasks such as completing a migration until tests pass, implementing every acceptance criterion in a design document, reducing a backlog to zero, or updating a repository until all required files meet a standard.
The /loop capability serves a different purpose. It repeats a prompt at an interval while the current session remains active. It is useful for polling or watching: checking a deployment, reviewing new alerts, or looking for a change at regular intervals. It is not the same as a project completion mechanism.
Permissions also matter. A goal can continue across turns, but it does not automatically approve every tool action. For unattended execution, the permission mode and allowed tools must be configured carefully. Grant only the access required for the assignment, especially when commands can modify production systems, delete files, send messages, or change infrastructure.
Make the Evidence Visible
A completion evaluator can only judge the evidence it receives. The agent should therefore run the required checks and place their outputs in the session. Statements such as “the tests should pass” or “the design looks correct” are not evidence.
For software work, useful proof may include test results, build output, static-analysis results, a clean version-control status, a migration dry run, or screenshots of the completed interface. For research, proof may include a checklist showing that every required question was answered, citations for major claims, a section on conflicting evidence, and a final validation against the original brief.
The strongest workflows produce artefacts that can be independently inspected. Confidence is helpful, but verifiable output is better.
Turn Repeated Procedures into Agent Skills
Agent Skills are reusable, file-based packages containing instructions, metadata, and optional resources such as scripts or templates. They allow Claude to load a specialised procedure when it is relevant instead of requiring you to repeat the same guidance in every conversation.
A skill can describe how your team writes design documents, reviews pull requests, prepares weekly reports, investigates incidents, validates data pipelines, produces client presentations, or follows an internal release process. It can include examples, checklists, commands, reference files, templates, and quality rules.
A practical way to create a skill is to begin with a successful piece of work. Identify the steps, standards, decisions, and examples that made the result good. Save them as a structured procedure. Then test the skill on new work. Whenever the output misses an expectation, correct the result and update the skill so the lesson becomes reusable.
Skills create an organisational asset that is more durable than a single chat. Because the instructions live in files, they can be reviewed, version-controlled, improved by a team, and reused across future projects.
Use Vision as Both an Input and a Quality Check
Fable 5 can understand charts, diagrams, tables, screenshots, interfaces, and visual elements inside files and PDFs. This is useful when important information is difficult to represent as plain text.
Instead of manually retyping numbers from a chart, you can provide the image and ask the model to extract the values, explain the trend, and identify uncertainty. You can submit an architecture diagram and ask for a component map, integration risks, and missing controls. You can share a dashboard screenshot and request a usability or data-quality review.
The more powerful pattern is visual self-checking. Suppose the task is to build a webpage from a design. The model can inspect the reference image, implement the page, capture the rendered result, compare the two, and correct visible differences. In this workflow, the screenshot becomes part of the acceptance test rather than merely an example.
The same technique can be used for presentations, reports, forms, dashboards, and spreadsheet layouts. A visual output should be reviewed visually, not only through source code or extracted text.
Security, Safeguards, and Data Retention
Fable 5 includes stronger safeguards in sensitive areas such as cybersecurity and biology. Anthropic may route flagged requests to a less capable Claude model, and the user is not charged Fable pricing for those rerouted requests. Applications built around Fable should therefore handle refusals, model fallback, and partial completion instead of assuming every request will always be processed by the same model.
The model also requires 30-day data retention for safety monitoring. Anthropic says this retained information is not used to train new Claude models, but the requirement still matters for confidential or regulated workloads.
Before using Fable 5, organisations should classify the data involved. Avoid sending passwords, private keys, production secrets, unrestricted customer records, medical information, confidential legal files, or any material that policy or contract does not permit to be retained. Where sensitive data is necessary, use approved controls such as redaction, tokenisation, access restriction, logging, and formal security review.
Availability is another operational risk. Fable 5 was released on June 9, 2026, temporarily suspended on June 12 following US export-control restrictions, and restored globally from July 1. The incident is a reminder not to place critical business knowledge only inside one provider’s platform. Store prompts, skills, project context, tests, and procedures in portable systems that your team controls.
A Reliable Workflow for Long-Running AI Projects
· Choose the model deliberately. Confirm that the work is difficult and valuable enough to justify Fable 5.
· Prepare the environment. Provide only the files, tools, repositories, and permissions needed for the assignment.
· Remove sensitive information. Redact secrets and confirm that the 30-day retention requirement is acceptable.
· Ask for a plan first. Have the model describe stages, assumptions, risks, dependencies, and proposed checks before execution.
· Write a measurable completion condition. Include the end state, evidence, constraints, and a stopping limit.
· Use cheaper models for routine execution. Reserve Fable for difficult reasoning, blockers, and final validation.
· Require proof. Make tests, screenshots, reports, diffs, and validation results visible.
· Review before release. Human approval remains important for production changes, regulated decisions, external publication, and high-impact actions.
· Capture what worked. Convert successful instructions and corrections into a reusable Skill or project file.
· Track cost and quality. Review token usage, failed attempts, rework, and the value delivered before expanding the workflow.
Reusable Prompt Template
The following structure can be adapted for coding, research, analysis, documentation, or operational work:
ROLE
Act as a senior [role] responsible for completing and verifying this assignment.
OBJECTIVE
[Describe the final business or technical outcome in one or two sentences.]
INPUTS
Use only the following repositories, files, tools, data sources, and environments: [list them].
REQUIRED OUTPUTS
Produce: [list the exact deliverables].
DEFINITION OF DONE
The assignment is complete only when: [list measurable conditions].
VERIFICATION
Run or perform the following checks and include the results: [tests, comparisons, screenshots, citations, review checklist, build output, and so on].
CONSTRAINTS
Do not change, access, delete, publish, or send: [list boundaries]. Ask before any irreversible action.
STOPPING RULE
Stop and report the blocker after [number] unsuccessful attempts, after [time limit], or before estimated usage exceeds [budget].
FINAL RESPONSE
Summarise the work completed, files changed, evidence collected, unresolved risks, assumptions, and recommended next actions.
Final Thoughts
Claude Fable 5 represents a move from short AI interactions toward delegated projects. Its value comes from endurance, planning, tool use, verification, and the ability to maintain direction across a large amount of work.
But greater autonomy does not remove the need for management. It increases it. The user must choose the right assignment, define success, control permissions, protect data, set a stopping point, and demand evidence.
The best results will not come from asking the model to “do everything.” They will come from designing a clear operating system around it: strong goals, reusable procedures, visible checks, sensible model routing, and human review where the consequences matter.
Sources and further reading
· Claude models overview and pricing
· Claude Code /goal documentation