Claude Code with Claude Fable 5.1 and Long-Running Agents

See what you will be able to do: hand hours of real work to Claude Fable 5.1 in Claude Code, build your own Claude Code setup with hooks, skills, and subagents, and pick the right model and effort level for every task without overpaying.

Claude Fable 5.1 works for hours while you do other things. You see what you can do with long-running agents in Claude Code, from an overnight run to days of handed-off sessions, and how that changes your working day.

You'll be able to say exactly what Claude Fable 5.1 costs per million tokens, and explain why Claude Mythos 5.1 is not a separate, stronger model. You'll see the real pricing table and the model configuration page on screen, including the exact sentence stating that neither Fable model is the default on any plan. By the end, you can state, in the announcement page's own wording, why Mythos 5.1 is not Fable 5.1 without safety filters.

You learn what changed when Claude Fable 5.1 replaced Fable 5 on 1 September 2026, with the figure and the name of whoever measured each gain: higher scores on the hardest coding benchmarks at the same price, cache reads at a quarter of the old cost, knowledge up to June 2026, fewer refusals on ordinary work, and three new API controls. On screen you see the six areas that improved and a diagram of which model a flagged request runs on. You end by typing /model fable in your own session and checking that it says Fable 5.1.

You compare Claude Fable 5.1 with OpenAI's GPT-6 Astra on price, benchmarks, cost, and time per finished task; what each refuses; and where each runs. Every result is on screen with the name of who measured it, so you know what a benchmark can tell you and what it cannot. Video tells you where Astra is best, where Fable is best, and where the difference is narrow, so you know which model to give which work.

You decide which Claude model, and which effort level, fits a task, starting with Opus 5 and choosing Claude Fable 5.1 only for the hardest reasoning and the longest-running agent work. You check four price rows, for Fable 5.1, Opus 5, Sonnet 5, and Haiku 4.5, so you know the Claude API cost before you start. On screen you see the real model comparison table with each model's knowledge cutoff date highlighted. You download a one-page PDF with every number from this lecture.

You see the full setup list, the real Claude Code cost of every hands-on exercise, the replay mode that costs nothing, and the three billing meters that count your Claude Fable 5.1 usage, before you spend a cent.

You download your Fact Tracker: one row per checkable fact about Claude Fable 5.1 and Claude Code, four status words, and two columns you fill yourself. You watch the first three rows, then fill your own copy.

You learn all four ways to reach Claude Fable 5.1: your own code calling the Claude API with your API key, a Claude Code session, non-interactive mode, and the Agent SDK. You watch a real terminal session where you set the model to Fable 5.1 with the slash model command, and you see Claude Code read back the change. You find out which of the four ways asks you before it spends your usage credits, and which three never ask. And if your first call fails with a 400 error that looks exactly like a broken API key, you learn the one setting that fixes it.

You install the official anthropic package, write your first Claude API request to Claude Fable 5.1 line by line, run it live, read the reply and its token counts, and trigger on purpose the 400 error that a first call often returns.

You save real Claude API replies from Claude Fable 5.1 to files, read what a response contains with and without a thinking block, parse both safely, and learn why the thinking text is empty unless you ask for the summary.

You run the same Claude API request to Claude Fable 5.1 blocking and streaming with the official anthropic package, measure the wait before the first words, and learn why a long call needs streaming so a timeout cannot stop it early.

You learn why the old thinking budget now returns a 400 error on Claude Fable 5.1, what the five effort levels change, and how you prove that the effort level is guidance, not an exact token amount.

You watch one number stop an answer mid-sentence, learn that max_tokens limits thinking and answer together, read stop_reason to detect that stop, and set the limit right for Claude Fable 5.1.

You learn why your Claude Fable 5.1 bill is higher than your own estimate: a tokenizer that counts 30% more tokens, thinking you are billed for but never read, and an effort switch that clears the prompt cache. You see the exact usage fields to read after every call, and the one habit that handles all three.

Your old script returns a 400 on Claude Fable 5.1. You fix it with me in one file: you delete the thinking budget, set an effort level, and remove four prompt rules the model already follows.

Someone from security asks what the safety measures on Claude Fable 5.1 are. You learn the exact answer: dual use capabilities, safety classifiers, and who can use Mythos 5.1 through Anthropic's trusted access programs, of which Project Glasswing was the first.

If one line from your old prompts is still there, Claude Fable 5.1 refuses your request. You learn to spot that line, what to write instead, and where in your files to search for it.

Your ordinary debugging question is refused, even though your prompt is fine. You learn the three subjects the safety classifier checks, and you add four lines to your request script that detect a refusal and tell you to rephrase and try again. You also see which model a flagged request is routed to in Claude Code, and the exact command that puts you on Claude Fable 5.1 again.

Can you send company code to Claude Fable 5.1? After this lecture, you can answer that question correctly in a real compliance conversation: how long your data is kept, when an exception to that rule exists, and what your data is never used for without your company's permission. You watch a diagram trace what happens to the code you send, from the mandatory thirty-day retention rule to the one exception only Anthropic can grant.

Two Claude account you need to check: whether your chats and Claude Code sessions train new models, and whether a flagged message goes on with another model.

You still paste prompts written for older models. You learn the five official prompting recommendations for Claude Fable 5.1, why adding instructions now makes output worse, and what you can get from one editing pass.

Your prompts got longer and the answers got worse. You learn the question that removes over-prescription from your Claude Fable 5.1 prompts, and the four-part ask: context, goal, constraints, done when.

You will see why a rule you type into one prompt can stop applying later in a long Claude Code session, with no warning. You will learn where to put that same rule instead, in the Claude Code memory file, so it still applies on every request you send. You will watch my own memory file, with the real rules I use every day, including the one that tells Claude Code to delegate independent work to subagents. You will also see why the effort level controls how much thinking Claude Fable 5.1 does, while typing "think step by step" does nothing on Fable 5.1.

You see the difference an outcome prompt makes on real code, and you can run the same comparison yourself. I take a step by step prompt, rewrite it as a description of the result I want, and run both against the same small project. We compare the two diffs side by side. Both prompts are attached word for word, along with the project code, so you can repeat the test on your own machine.

You stop padding your prompts with reminders the model already follows. I remove the sentence about making sure to test from a working prompt, run it live, and we watch Claude test the change anyway. Then it is your turn: delete one verification reminder from a prompt you actually use, and run it.

You get a tool you defined to actually get called, which does not happen just because you defined it. The model uses a tool only when the system prompt tells it to, so one sentence has to say so. We run the same task twice with the same tool defined: without that sentence the tool is never called, with it, it is. This is also how an agent sends you a message when a long job finishes.

You can follow every lesson in this course, even if you have never used Claude Code. We open a small project, ask for one change, read the diff, and accept it. That is the whole loop you will use from here on. If you already use Claude Code every day, you can skip this one.

You set your default Claude model once, and you know which setting wins when several are in play. We set the default with an environment variable, then walk through what overrides it: a command line flag, another environment variable, a saved settings value, and an organization default. You also learn to read the active model back instead of assuming it, because a display bug or a silent fallback can leave a different model running than you think.

You fix a wrong result with the right one of two moves. If the model skipped work, raise the effort level. If the problem was bigger than the model, move up a model tier. You change only one of them at a time, because doing both leaves you not knowing which one fixed it.

You hand a piece of work to a subagent and keep working in your own session while it runs. A subagent is a separate, fresh session that reports back a summary, and it does not see your conversation. That surprises most people the first time. We use the two delegations you already have built in: one starts a background subagent from your session, the other runs a code review in the background.

You run a feature through three roles, plan, implement, and review, and pick the cheapest model each role needs. We add an export command to the course demo project: Opus 5 plans it, a subagent pinned to Opus implements the approved plan, and a fresh Opus session reviews the diff. Nothing in this demo needs Claude Fable 5.1, and knowing that is the point. You also see where the planning role does need Fable: real ambiguity, long horizon work, and many constraints that interact.

You audit what a real session cost and route routine work to cheaper models. The usage command attributes recent spend to individual skills, subagents, plugins, and connected servers, over the last day or the last week. You also get the number nobody mentions: running work across several agents costs roughly three to ten times the tokens of a single agent on the same task. Nobody stops the spending for you, which is why this check becomes a habit.

You fix a screen bug by pasting a screenshot instead of writing a paragraph about it. Claude Fable 5.1 reads dense technical images, screenshots, diagrams, and web pages far more accurately than earlier models, and it will crop or rotate an image itself when it needs to. We fix one interface bug live from a pasted picture. Desktop users also get a thirty second aside on selecting a page element directly.

You choose a permission mode on purpose and write down what Claude may decide without asking you. We go through all six modes, including the automatic one that became the starting mode on paid plans in August 2026. You pre approve the tools you trust, and you learn the order the rules are read in: denies first, then asks, then allows, and the first match wins. I show you my own list, about forty four read only entries and three denies.

You let Claude try a risky approach, because you can undo it in one command. We use plan mode, where Claude researches and writes a plan without editing anything, and you open that plan in your own editor before it proceeds. Then we look at checkpoints: every prompt creates one, and you can restore the code, the conversation, or both. You watch a live restore, and you see what does not come back: shell command changes, most subagent edits, and anything changed outside the session.

You pick up yesterday's Claude Code session and branch a conversation to try a different direction without losing the original. Four commands do it: continue picks up where you left off, resume lists your sessions to choose from, rename gives a session a name you will recognize, and branch copies a conversation into a new one. You watch a live resume. You also find out that a new session starts empty, because Claude Code does not remember earlier sessions on its own.

You structure your rules and memory files so the right ones load at the right moment. Three different things get called memory, and we name them apart: the rules files you write, the memory Claude writes for itself, and the context window, which is neither. The hierarchy adds up rather than overriding, and you keep each file short by splitting rules into one file per rule, loaded only when Claude touches matching code. I show you my own rules file, seventeen rules, several written after a specific failure.

You verify which rules files are loaded instead of reasoning about it. Discovery walks up from your working directory to your home folder, and files in subfolders load when Claude reads code there. I once believed a nested folder does not load the parent rules, copied the same rules into five places, tested it, and found six files loading. We run the check live in a nested folder, and then you run it in your own project.

You write your first skill and know when a skill is a better home for something than a rules file. Custom commands and skills are now the same mechanism, and a skill is a folder that can carry files with it. You learn the mechanics that matter: a skill body loads only when it is used, while your rules file is loaded every session. I show you my own commit command, which stores a policy rather than a shortcut, and the eighty one project commands I have collected across five repositories.

You rebuild a built in tool so each stage runs on the cheapest model that can do it. The built in deep research pipeline ran every one of its helper agents on my session model, which used up my whole Claude Fable 5.1 session limit at once. I copied it and pinned the search, fetch, and verify stages to Sonnet, keeping the scoping and the final write up on Fable. You see one real run, one hundred eleven agent calls with no errors, and the two limits I found in it.

You write your own subagent definition, with a cheaper model pinned to it and a restricted tool list. A definition is a small file in your project or your personal folder, with a name, a description, the model it uses, and the tools it may touch. Giving an explorer subagent read only tools means it cannot change anything. You also get the order of coordination costs, cheapest first: one session, then a subagent, then messages between sessions, then a full team, and you stop at the first one that solves the problem.

You enforce a rule that must hold every time with a hook, instead of asking for it in prose. A rule written in a memory file is a request the model interprets. A hook is a script that always runs. You learn the events worth knowing, how a script blocks an action and hands its error back to the model, and that a stop hook is overridden after eight blocks in a row. I show you the hook I wrote after losing about one hundred eighty transcript files to a cleanup.

You match each recurring frustration to the one mechanism that fixes it. A convention ignored twice becomes a rule, the same prompt typed again becomes a skill, a side task that floods your conversation becomes a subagent, and something that must happen every time becomes a hook. We go through the whole table, and the question underneath it: who holds the plan, you or Claude. I also tell you about one of my own memory systems that collected bans until nothing useful was left, because rules need pruning as much as adding.

You connect an outside system to Claude Code with one command: a database, an issue tracker, a design tool. That command adds a Model Context Protocol server, the standard way to give Claude tools for a system it cannot otherwise reach. You see a live connection and one tool call, and the three places you can install it: this project only, shared with your team, or all your projects. Check that you trust a server before you connect it, because a server that fetches outside content can feed instructions into your session.

You recognize a job that needs a workflow before it fills your session. A workflow is a script that holds the loop, the branching, and the intermediate results, so only the final answer reaches your conversation. Claude writes that script for your task, and a runtime runs it in the background while your session stays free. You get the numbers that decide it: up to sixteen agents at once, a hard cap of one thousand agents per run, and a warning past twenty five scheduled agents.

You pick which of the four ways to run Claude on your own code fits the job. The Agent SDK is Claude Code itself as a package you import, with the same file tools, shell tool, subagents, hooks, permission modes, and sessions, driven from your script instead of a terminal. Two questions separate the four options: who supplies the loop, and who supplies the tools. One warning is worth repeating here: the Agent SDK spends without asking you first.

You read your context window live and see what is loaded before you type a word: the system prompt, every rules file in the chain, the memory index, one line skill descriptions, and your environment. Tool output and conversation then pile on top of that. You also correct a common belief, that a one million token window means loading a whole codebase, which is still not good practice. And you set up a status line showing your remaining context percentage, so you can watch it all day.

You control what compaction keeps instead of finding out later what it dropped. When your context fills, Claude Code first clears older tool output, then summarizes the conversation, and most people never notice it happened. You get the table of what survives and what does not: your main rules file and stored memory are read back from disk, while nested rules files and path scoped rules are gone until something touches them again. Then you learn the controls, including compacting with a focus and clearing when you switch work.

You keep durable state in files, so a session can compact without losing the work. That is the real reason long sessions work: the plan, the corrections, and the decisions live on disk, not in the conversation. Notes files hold what is in progress, skills hold procedures, and your rules file holds the stable facts, while subagents keep the main session small. I show you my own multi day sessions, which survive for exactly this reason.

You see what handing hours of work to Claude actually looks like in a normal day. While Fable and Opus work for me, I cook, pick up my kid, go for a run, or work on something else in another session. It messages my phone when it is done, or when it needs more information from me. That message is one tool plus one sentence of system prompt, and you can build it the same afternoon.

You read capability claims critically and tell three kinds apart: independently corroborated, benchmark, and vendor testimonial. We load each source on screen and read it together, including a measurement showing that the longest turn durations nearly doubled, which measures one turn and not a whole session. Then you get the three things nobody has settled: the true upper bound of one continuous run is unknown, corroborated figures land between eight and seventeen hours, and no success or defect rates for unattended overnight runs have been published. You measure your own.

You run multi day work as handed off sessions with checkpoints, rather than trusting a run blindly. I show you my own sessions, spanning eight, six, four, and nearly four days, with the file timestamps as the evidence. These are not unattended runs, and the difference matters: I give feedback at checkpoints, and the session messages me when it finishes or needs input. You also see how the approval boundary moved in both directions, tightening after a validator silently dropped data, and loosening once a kind of fix had proved safe.

You build verification into a run, so you can walk away from it. Four levels trade setup effort against your attention: ask for the check inside the prompt, set a goal condition that a small separate model re checks after every turn, install a stop hook that holds the turn open until the check passes, or run a fresh verifier subagent on an interval. The progress audit instruction nearly eliminated fabricated status reports in testing, and you get that exact wording as a download.

You anticipate how long runs fail and apply the fix for each one. The documented failures are rare early stopping deep into a session, reactions to a countdown of remaining tokens, and occasional actions you did not ask for. A stalled loop counts too: a run that needs input it cannot get may repeat the same request all night. There is also a research finding that models often adopt whatever goal a half finished transcript was pursuing, which is why you restate the goal every time you resume or hand work over.

You set the spending limits and the checks that must pass before you leave a run unattended. First, the places an unattended run happens: background sessions survive a closed terminal, a loop command runs on self paced delays, and scheduled tasks expire after seven days. Then the spending side: non interactive mode and the Agent SDK both spend without asking, so you set a guard first. Last, the work side: a stop hook that runs your check, and a reviewer subagent that sees only the diff and the criteria.