 |
VOOZH | about |
|
VOOZH | about |
Jun 29, 2026
"AI agent" covers everything from a chatbot with one tool to a fleet of orchestrated coding agents. This guide maps every major type — reactive vs deliberative, ReAct vs plan-and-execute, coding vs research vs browser agents, single vs multi-agent — and tells you which to build when.
Jun 27, 2026
ReAct is not a framework feature — it is a prompting pattern. Once you understand the Thought/Action/Observation loop you will see it everywhere: in LangChain agents, Claude Code, and every serious agentic system built in 2024 and beyond.
Jun 23, 2026
Submitted June 22, 2026, Critique of Agent Model argues that most LLM "coding agents" are agentic — competence in external scaffolding — not agentive, where goals, identity, and learning live inside the system. The paper proposes GIC: hierarchical goals, evolving identity, world-model simulation, self-regulation, and self-directed learning under human oversight.
Status (June 27, 2026): Fable 5 remains suspended — these use cases reflect what builders shipped before the June 12 ban. Live status →
The internet is exploding with Fable 5 experiments right now.
Within days of Claude Fable 5 launching on June 9, 2026, developers were posting 8-hour autonomous coding sessions, researchers were feeding it 300-page filings, and someone even used it to build a fully playable Minecraft clone from a single prompt. And the pattern is consistent: people keep reporting that this feels different—not just incrementally better, but a genuine step change.
So what is actually happening? What makes Fable 5 worth paying attention to?
The short version: Fable 5 is Anthropic's first Mythos-class model. It wasn't built for quick Q&A. It was built for work that previously required sustained human judgment over hours or days—coding migrations, legal due diligence, deep research synthesis, financial modeling. It scores #1 on FrontierBench, is the first model to break 90% on Anthropic's core analytics benchmark, and can run inside agent harnesses for multi-day autonomous sessions.
Here are the 10 use cases where it's creating real impact right now.
The most immediate shock for most developers: give Fable 5 a product spec, and it builds the thing.
Not a scaffold. Not a skeleton. A working application—backend services, frontend components, API integrations, database schema, tests, and deployment scripts—produced end-to-end in a single session.
The reason this works now and didn't before is Fable 5's ability to hold the full spec in context while simultaneously reasoning about architecture, implementation, and testing. With a 1M token context window, it can keep the entire growing codebase in view without losing track of earlier decisions.
What this looks like in practice:
This is also where the Claude Code + Fable 5 combination becomes powerful. Claude Code's file system access, terminal tools, and /goal command let Fable 5 iterate on its own output until tests pass.
Every engineering team has the migration they've been putting off. The one that touches 40 files, requires understanding the entire data model, and will break things in non-obvious ways if done wrong.
Fable 5 is being used to finally do these.
The workflow: provide the current codebase (or a representative slice), the target architecture, and any constraints. Fable 5 analyzes coupling between modules, proposes a migration path, executes it incrementally, and runs tests at each stage to verify nothing broke.
Real-world cases include:
The loop-based self-correction patterns described by Anthropic's Lance Martin are especially relevant here—Fable 5 runs, hits a failing test, investigates, corrects, and continues without human intervention at each step.
This is where Fable 5's "senior research scientist grade" reasoning—Anthropic's own description—starts to show.
Pass it a research question, a collection of papers, and a set of evaluation criteria. Fable 5 reads the corpus, identifies conflicting findings, synthesizes a structured argument, and produces a deliverable that's actually ready to use—not a summary dump.
What distinguishes this from earlier models:
In Claude Managed Agents, this gets even more powerful: Fable 5 can spawn sub-agents to investigate specific branches of the research in parallel, then synthesize across all of them.
One of the most specific enterprise use cases Anthropic called out at launch: financial work.
Fable 5 can ingest earnings reports, 10-Ks, 10-Qs, proxy statements, and exhibit tables—and actually reason over the numbers. Not just extract them. Build investment theses, model credit risk, flag inconsistencies between a CEO's commentary and the underlying financials, and identify what matters most in a 200-page filing.
The vision capabilities matter here too: charts, tables, and figures embedded in PDFs are understood in context, not skipped.
Use cases:
Harvey AI, which serves top law and financial firms, launched Fable 5 integration specifically for this class of work.
Contract review is tedious, high-stakes, and time-consuming. It's also something Fable 5 is genuinely good at.
The 1M context window means Fable 5 can hold an entire contract bundle—master agreement, schedules, exhibits, prior amendments—in context simultaneously. It catches cross-references between provisions, flags deviations from market standard, and produces first-pass redlines.
Typical workflows:
Legal AI platforms including Harvey have confirmed Fable 5 is their sharpest model for work where missing a nuance in a clause has real consequences.
This is an underrated capability that only became obvious once people started using Fable 5 on real documents.
Fable 5 understands visual content—charts, diagrams, architectural drawings, tables, scanned handwriting—in the same way it understands text, and it integrates both into its reasoning. It doesn't just describe what it sees; it interprets it in context.
Practical examples:
The last pattern is worth dwelling on: Fable 5 can implement a design and then look at the result to check its own work—a feedback loop that catches visual bugs that tests miss.
This is perhaps the most distinctive Fable 5 behavior: autonomous self-correction loops.
Anthropic's Lance Martin documented that Fable 5 follows a consistent progression when working on hard problems: fail → investigate → verify → distill → consult. It achieves 73% verification coverage on Continual Learning Bench tasks, compared to 7–33% for earlier models.
In practice, this means:
Inside Claude Code with /goal:
/goal "Achieve 95% test coverage on the payments module"
Fable 5 runs the test suite, finds the gaps, writes tests, checks edge cases, reruns, and continues until the goal is satisfied—or surfaces a genuine blocker for you.
Inside Claude Managed Agents with Outcomes: The model spawns a verifier sub-agent that grades its own work independently, avoiding the self-critique bias that plagues models evaluating their own outputs.
In Parameter Golf experiments (an ML engineering benchmark), Fable 5 improved the training pipeline ~6x more than Opus 4.8 over 8-hour sessions, making structural architectural changes rather than just tuning scalar parameters.
GitHub made Fable 5 generally available in Copilot on launch day—which means millions of developers already have access.
For individual developers, Fable 5 in Copilot means:
For enterprise teams, the combination of Fable 5's reasoning depth and GitHub's code context (PRs, issues, CI results) creates a review loop that's meaningfully better than any previous generation.
This is the capability that separates Fable 5 from every previous Claude model, and it's worth understanding concretely.
Fable 5 edited its own launch video autonomously—an hours-long workflow involving video editing tools, file management, and quality verification—with minimal human intervention. That's not a demo. That's a preview of what Fable 5 does inside a well-structured agent harness.
The architecture that enables this:
/goal command or Outcomes primitive defines the target stateGitLab has documented multi-day runs where Fable 5 maintained strong instruction adherence across complex, multi-stage software projects—planning, implementing, testing, and refining without needing to be reminded of earlier decisions.
Anthropic specifically called out genomics at launch, and it points to a broader pattern: Fable 5 can operate at senior research scientist grade in technical domains.
For scientific work:
The safety classifiers built into Fable 5 matter here too: when requests touch biology, chemistry, or cybersecurity in sensitive ways, Fable 5's classifiers automatically route to Opus 4.8's more conservative handling rather than refusing or hallucinating. This makes it practical for research environments that need both capability and responsible guardrails.
Looking across all 10 use cases, the pattern is consistent: Fable 5 works best when you treat it less like a question-answering tool and more like an autonomous collaborator you can assign a goal to.
The people getting the most out of it are thinking in terms of loop design—what's the feedback signal, what's the goal condition, what's the memory across sessions—rather than "what prompt gets me the best one-shot answer."
That shift in mental model is what separates good Fable 5 usage from great Fable 5 usage. If you want to go deeper on that, the loop design guide from Lance Martin at Anthropic is the best starting point.
And if you haven't tried it yet, Fable 5 is fully available in Claude Code today.
Update (June 13, 2026): Fable 5 was suspended by US government export control directive three days after launch. Full story: what happened, why, and what to use instead.
Sources: Anthropic · AWS Blog · Microsoft Azure Blog · GitHub Changelog · Harvey AI