Fable 5.2: what long-running agent experiments show

Fable 5.2 is Anthropic's language model for complex technical work. It can perform long chains of actions involving code, tools, and multiple agents. In the published experiments, the model was not used as a chat interface for individual code fragments, but as the coordinator of a large process: agents wrote programs, ran checks, analyzed errors, and continued working after intermediate failures.

The results are impressive, but they cannot be considered proof of universal autonomy. Anthropic describes controlled test scenarios, not independent verification in production use. The main question is different: which tasks can Fable 5.2 already carry through to completion without constant human instructions, and where is engineering verification still required?

These are experimental scenarios.

How Fable 5.2's long-running execution was organized

In the experimental setup, Fable 5.2 acted as the coordinator, while more than 1 000 subordinate agents worked around it. Each agent could receive a separate part of the work, modify files, run tools, and pass results to other participants. The coordinator connected individual actions into a sequence, returned tasks for further work, and used the project's saved state.

This approach differs from an ordinary dialogue with a model. The user submits a request and receives an answer in one or several turns. In a multi-agent run, the result emerges after a large number of operations, including failed builds, incorrect assumptions, repeated tests, and fixes. Quality is determined not only by the ability to write code, but also by whether the system can detect its own error, localize it, and continue working with the current version of the project.

The mechanism for preserving progress is also important. A long task should not depend on a single uninterrupted session, because a context or tool failure can destroy the results of several hours of work. In the experiment involving the formalization of a mathematical proof, participants continued working after a checkpoint, making it possible to compare the pace of progress over 30 hours.

Creating an operating system from an empty folder

The most illustrative example concerns an operating system prototype. According to Anthropic's description, an engineer gave Fable 5.2 an empty folder and the task of designing a system. More than 1 000 agents worked for about eight days, writing code, checking it, and fixing errors. The resulting system ran on a laptop.

The project included its own kernel, disk, keyboard, and network drivers, persistent file storage, a graphical interface, a login screen, an installer, and built-in Claude functionality. This list shows that the agents were not solving a single isolated task, but connecting several subsystems with different interfaces and constraints.

Running on a laptop is not equivalent to creating a full-fledged industrial-grade operating system. The public description does not provide all the information about hardware compatibility, test coverage, resilience to failures, performance, and security. It is also unknown how easy it would be to reproduce the result with the same settings and infrastructure. The experiment demonstrates the ability to assemble a working prototype in a given environment, but it does not replace an audit of the kernel, drivers, and threat model.

This is a working prototype, not an industrial system.

Rewriting a service and the claimed speed increase

Anthropic reports that a team of agents ported a critical production service from Python to Rust. The description states that after the migration, the service became more efficient and reliable, while startup became approximately 26 times faster. The statement applies to a specific service and a specific experiment. It cannot be turned into a promise of the same acceleration for every Python project.

Switching between languages requires checking program behavior, library compatibility, error handling, memory consumption, build time, and operation. Faster startup does not automatically mean that all characteristics have improved. For a production migration, the team should compare the old and new versions on identical data, check regression scenarios, and confirm the result with measurements in the production infrastructure.

Another Anthropic metric concerns its own development. The company stated that Claude creates more than 90% of the changes accepted into its main codebase under developer supervision. This statement describes Anthropic's internal process, not the share of high-quality code across the entire industry. An important part of the wording comes after the number: developers retain direction, review, and the decision to accept changes.

Formalizing Fermat's Last Theorem

Formalizing a mathematical proof translates it into a language that a computer checks step by step. In the Fable 5.2 experiment, about 1 000 agents worked on formalizing Fermat's Last Theorem in Lean. According to Anthropic, the team completed the task in approximately 30 hours with minimal human intervention and began with very brief instructions.

The system developed coordination methods on its own, used approximately three times fewer action tokens than the previous experiment with a research version of the model, and created a proof that turned out to be seven times shorter. The previous formalization took 11 days and was conducted in a specially prepared environment with the help of a researcher. These figures concern two different experimental configurations, so they cannot be interpreted as a pure measurement of the performance increase of a single model.

The comparison with Opus 5.5 demonstrates the role of coordination. With a setup involving approximately 1 000 agents, Fable 5.2 completed about 86% of the work after 18 hours, while Opus 5.5 reached approximately 26%. After 30 hours, Fable had completed the formalization, whereas in the comparative Opus run, progress had nearly stopped. Anthropic attributes this to the Opus agents' inability to coordinate how to continue working.

Formal verification in Lean gives this experiment a strong point: the final text can be checked using the proof system's tools. However, the process of preparing the environment, selecting libraries, dividing up the task, and interpreting the result still requires an independent audit. The computer checks the formal object, but the researcher must ensure that the intended theorem was formalized and that the initial conditions have not changed.

Why agent coordination matters more than simply increasing their number

A thousand agents do not guarantee a thousand useful results. If participants cannot see the current state of the project, duplicate work, or argue about file formats, parallelism increases costs and the number of conflicts. Fable 5.2 demonstrated an advantage not only through the number of workers, but also through its ability to organize their interaction.

According to Anthropic, specialists at Jump Trading observed error accumulation in earlier systems after several dozen calls to tools. Accumulating error occurs when an agent begins relying on an outdated assumption, an incorrect file, or an erroneous result from a previous step. The longer the chain, the greater the likelihood that a local inaccuracy will turn into a systemic problem.

In the new configuration, according to Jump Trading's assessment, the model remained functional for longer in tasks involving tools. This observation belongs to the testers and is not a universal guarantee. For a specific project, it is necessary to measure separately the number of successful steps, rollback frequency, the cost of reruns, and the proportion of actions that a person must correct.

Typical failure points for Fable 5.2

A working demonstration result does not yet mean a reliable system. Long-running agent tasks are vulnerable to several classes of errors:

• Loss of state. An agent continues working with an outdated description of the files or forgets the reason for a previous decision.
• Incorrect local objective. An executor improves an individual module but violates the contract with a neighboring subsystem.
• Faulty verification. A test confirms that the system starts, but does not check security, performance, or rare scenarios.
• Accumulation of technical debt. Quick fixes conceal an architectural problem and complicate subsequent iterations.
• Coordination failure. Agents do not understand who is responsible for continuing the task after a stoppage or conflict.

What happens if an agent claims that the work is ready but does not show a reproducible result? An independent verification layer is needed: a clean build, tests on fixed data, change analysis, review of tool logs, and manual confirmation of critical decisions. For an operating system, this means checking boot, memory, the file system, drivers, and network behavior. For a service migration, performance comparison and validation of result correctness are required.

What Fable 5.2's experiments mean for software development

Fable 5.2 already appears useful for tasks that have an executable result and the ability to automatically verify intermediate steps. Such scenarios include service migration, finding the causes of regressions, preparing prototypes, generating tests, formalizing proofs, and research pipelines involving code. The more precise the success criterion, the easier it is for the system to understand what counts as completing the work.

Things are more difficult with tasks whose requirements are informal, whose cost of error is high, and whose correctness cannot be checked quickly. Architectural decisions, changes to financial systems, work with personal data, or releasing code into critical infrastructure require human accountability, access control, and staged deployment. Here, autonomy should mean extended work in a constrained environment, not an unrestricted right to change everything.

The practical conclusion for a technical leader is simple: Fable 5.2 should be evaluated not by one flashy demo, but on your own task. Record the initial state, outcome criteria, permitted tools, time limit, and budget, then conduct several independent runs. Compare not only final success, but also the cost of fixes, the number of manual interventions, resilience after pauses, and the ability to reproduce the result.

FAQ about Fable 5.2 and autonomous development

Did Fable 5.2 create a full-fledged operating system?

Anthropic reports a working prototype that booted on a laptop and included a kernel, drivers, storage, an interface, and an installer. The public description does not prove industrial maturity, broad compatibility, or the system's security.

Does Fable 5.2 port Python services to Rust 26 times faster?

In one described experiment, the service started approximately 26 times faster after migration. This is the result for a specific service, not a universal forecast for all migrations from Python to Rust.

Can Fable 5.2 be entrusted with development completely without a human?

The experiments demonstrate extended work with minimal intervention, but they do not eliminate human task definition, environment setup, result verification, or the decision to release. For critical software, this oversight remains a mandatory part of the engineering process.

What should be measured when evaluating an autonomous agent?

Measure the proportion of completed tasks, the number of manual fixes, the cost of tokens and tools, duration of work, rollback frequency, reproducibility of the result, and the quality of independent tests. A single metric, such as startup speed, does not describe the reliability of the entire system.