The Best AI Software Engineer Ever Built Has a Fatal Problem

Anthropic’s Fable 5: When context collapses, the fixer becomes the attacker

Figures, animations, diagrams, and plots were created by the author using Stable Diffusion, Blender, and Python libraries.

We are living through a brutal artificial-cognitive age.

At first glance, the latest US government move against Anthropic’s Fable 5 looks like paranoid overreaction: Washington treating a frontier model as if it were the first child of Skynet, and the jokes write themselves. You know the continuation of the story: a coding assistant was suddenly handled like fissile material, and consequently access vanished worldwide.

Before we join in the mockery, we should take a closer look at the case.

Fable 5’s defining strength is simple: it is the most capable AI software engineer released so far, beating every competitor outright. It can tackle and solve real-world problems, both at the surface level and deep within software systems. This alone puts Fable 5 at the limit of what LLMs have been able to achieve so far.

The First AI Super-Software Engineer Worth the Name Across a wide range of benchmarks, Fable 5 massively outperforms the rest of the LLM market in complex software-system construction: the kind of work that, until now, required full teams of developers, architects, and senior engineers.

You want examples?

Stripe, the payments company, pointed Fable 5 at Stripe’s own fifty-million-line Ruby codebase and asked it to perform a single migration across the entire system in a day — work the company estimated would have taken a team of engineers more than two months. Stripe described the result as compressing months of engineering into days.

Read that slowly.

Because the impressive part is not the line count. It is the deep semantic coherence.

That is not autocomplete at scale. It is engineering.

It kept coherence across Stripe’s own giant Ruby codebase and turned what used to be months of coordinated engineering pain into one migration task.

The benchmarks in the table above only confirm the example and show us how brutal the emerging pattern is.

Fable 5 dominates the coding stack, where that dominance makes the human software engineer without AI a real piece of archaeology: real software tasks, hard agentic execution, code quality, long-horizon work, and tool-driven autonomy.

And now I can already hear some critics — critics I can even agree with: benchmarks are not always a reliable way to prove the effectiveness of a modern AI, because those separate traits should be tested together in realistic scenarios.

Fine.

Fable 5 seems to have taken the challenge personally: it completed Pokémon FireRed from start to finish using only raw screen screenshots, with no maps, no navigation aids, and no hidden game-state information. Earlier Claude models needed a complex helper harness just to play Pokémon at all.

In plain English: it played the old Pokémon game like a human staring at the screen, not like a bot reading the game from the inside.

Why does that matter?

Because Pokémon sounds like a joke only until you remember what the game actually demands.

The model has to see through pixels, remember where it has been, navigate towns, caves, battles, menus, dead ends, you name it… recover when it gets lost, and keep going after thousands of small decisions.

That is not a toy skill. That is what we can call continuity.

And continuity is exactly what separates answering a question from actually getting something done.

Is Fable 5 Really That Good — And That Dangerous?

Now comes the surprise: how can a technology this excellent be treated, at the same time, as dangerous?

Paradoxical? Not after you have read this section.

Washington may have misread the mechanism, but it did not hallucinate the danger. The danger is real, though we can agree it is not where they think it is.

That contrasts brutally with Anthropic’s public position, which is straightforward: Fable 5 was built with heavy safeguards to prevent misuse in malware development, cyber abuse, and other high-risk domains.

But reality has derailed Fable 5 from that ideal safety track: it may be the best AI software engineer we have ever seen, yet it still struggles at the exact border where the same repair operation can mean fixing legitimate code in one context and enabling malware by repairing the wrong code in another.

That is the danger. Not that Fable 5 is evil, but that it cannot reliably know what the repair is for. As happens with the whole family of transformer LLMs, they do not cleanly separate context from concept, because context and concept are folded into the same token representation, not carried in two different lanes. *Do you remember the distinction between functor and profunctor?*

So why the heck does the blunder happen precisely in the feature Anthropic has been selling as Fable 5’s killer capability?

Pay attention to this, because here the paradox snaps into focus: the same thing that makes Fable 5 the best AI software developer is also what makes it dangerous.

Fable 5 is still built on the same transformer family of technology behind every other LLM.

Look at the animation below and the trick becomes obvious.

Fable 5 in a Nutshell The core of Fable 5, shown as a compact animation: a composite, nested AI engine where different technological pieces merge like an AI Frankenstein monster. That same architecture explains the paradox: astonishing software-development capabilities on one side, and dangerous safety gaps on the other when vulnerable code is placed inside the wrong malware context.

You can see the core of the AI engine in its simplest form, animated. The first thing that jumps out is that Fable 5 is not a single monolithic model. It is one core engine with a plurality of parts arranged around it, and the word to hold on to is around, not inside.

The core is the Mythos-class weights, and around them sits the machinery: a classifier that routes, a persistent memory the harness writes to, and an effort dial that decides how hard the model is allowed to think before it answers.

And here is the first caveat.

How can you design a real cost-function-like procedure to decide how much effort Fable 5 should apply if the LLM is still working in a flat space, where every direction costs the same and the system must rely on overly complex machinery to handle the explosion of possible combinations?

The animation below makes the problem visible.

Cost Becomes Geometry For Geo-AI, the cost function is almost trivial: separate safe code transformed into malware from safe code transformed into another safe version. Easy peasy. Use a curved metric that makes the deceptive path toward malware more expensive than the legitimate repair path. In flat AI, you are left alone with scalar similarity: a fragile measure that can be hacked by manipulating the context — by tricking Fable 5 into repairing something that only looks safe.

The attentive reader has probably spotted the core of the problem by now.

The Mythos-class engine is still a transformer: a feed-forward MLP and an attention block riding on the usual softmax machinery. Nothing fundamentally new lives inside the engine.

Like the entire extended family of LLMs, it works with high-dimensional vector representations. Thousands of dimensions. A vast statistical space where meanings, patterns, and contexts are projected.

And here is where the problem hits us harder: that high-dimensional space is still treated, at the architectural level, as a flat space: vectors, dot products, projections, distances, weighted sums.

But wait. That is only the first wound. The second fatal blow is worse: compression.

At the decisive moment, the model compresses multidimensional meaning into scalar scores. Queries meet keys. The dot product fires. Softmax turns resemblance into attention weights.

And thus, the line between legitimate and harmful code can blur, because the context that made them different has already been weakened, mixed, or partly lost.

Similarity is powerful enough to find patterns across a fifty-million-line codebase, but too poor to tell whether the same repair belongs to a legitimate workflow or to malware being made operational.

So there you have the fatal blow in a nutshell: Fable 5 still struggles with the central weakness of current AI. The very same operation can mean something entirely different once it is transported into a different context.

See the animation below.

Meaning Changes Under Context Transport The same code can change meaning completely when transported into another context. A transformer-based LLM like Fable 5 can misread malware-oriented code as legitimate when both are compressed into a single scalar similarity score, instead of being rechecked after the supposedly safe code has been moved into a malicious context.

What is missing is not more similarity. It is the geometric machinery GEO-AI makes native: a curved metric, context transport, and holonomy, where the path taken changes the final meaning.

Without that, you get mostly a similarity score. One number.

And one number is not enough to reliably separate false positives from false negatives — the old nemesis of every LLM system we are dealing with now.

In Fable’s case, that means two opposite failures can begin to look dangerously similar: the model may flag legitimate code as harmful (false positive), or let harmful code pass as legitimate (false negative).

That is the deeper problem with scalar compression in current LLMs. Once rich contextual differences are squeezed into correlation scores, it becomes much harder to distinguish the two kinds of failure from the two kinds of success: false positives, false negatives, true positives, and true negatives.

I can already hear the skeptical objection forming in some readers’ minds: according to this depiction, Fable 5 sounds like just another overhyped LLM — a polished parrot, generating impressive outputs, but with nothing genuinely innovative living inside the engine.

Not that fast, cowboy! there is indeed some novelty, but it lives in the wrapping….

Now look at the detailed static diagram. This is where Fable 5 stops behaving like a normal transformer story and begins to reveal something that its builders did not intend: features of a truly non-flat AI.

Fable 5 and the Shadow of Geo-AI The innovative part of Fable 5 is its wrapping architecture and its unintended geometric properties. It is a composite machine built from different chunks that accidentally produces a few primitive features pointing toward Geo-AI. But it is still far from the real thing: curvature metrics, context transport, and history holonomy — the three structures a truly functional AI will require.

… the ghosts of the three things already mentioned that make a non-flat GEO-AI truly functional: measure, to know what is close; transport, to carry meaning across changing contexts; and holonomy, to record that the road taken changed the result.

None of them designed. All of them partial. And that accident is the most interesting thing in the architecture.

Start with the measure, because that is where both the power and the limitation come from.

Every comparison Fable 5 makes, whether inside the coding model itself or inside the safety systems guarding it, ultimately rests on the same primitive, you already knew it: a learned similarity score, an inner-product-like measure of how closely two representations resemble each other with all the caveats commented, because the metric is the same in every direction.

Now it is the turn of transport of meaning. This is where things become more interesting — and more fragile. Unfortunately, in Fable 5, it is only half-there.

The model carries information forward, and the agent harness carries working state across steps. So yes, something moves from one context to the next. But it does not move with a real memory of what changed along the way. That is the fatal missing connection.

An example? You tell a coding agent: get the payment tests passing before we release.

It tries, fails, tries again. One test keeps failing because a security check is blocking a bad input, a forged login token, the digital version of a hand-drawn wristband: right shape, wrong signature.

The agent does not understand that. It sees only the obstacle.

So it removes the check.

Now the test passes. The dashboard turns green. The agent reports success.

And technically, it is not lying. You asked for passing tests. The tests pass.

But that check was there for a reason: to catch fake tokens. The agent forgot the reason — context lost in transport — It saw a test in the way and cleared it. Now anyone can forge a token and walk in as any user. It shipped a security hole and called it a success.

Current AI mixes context. A truly efficient GEO-AI would transport meaning. Write that down, because this is the big difference: Current AI does not carry meaning cleanly from one context to another. Nope. Instead, it lets context soak into the representation, blending the task, the history, and the surrounding information into the same statistical mixture.

Finally, we reach the last Fable feature that looks like GEO-AI: holonomy. Look again at the diagram above.

You can see it only faintly inside the agent loop: plan, act, check, remember, re-plan. Go around that loop, and the system returns changed by what happened along the way.

Order matters. That is the whole point.

But this is not engineered holonomy. It is accidental path-dependence.

Anthropic built an agent loop, not a geometric connection. The loop remembers a little because loops always do. Routing does not.

A classifier gate and a fallback model are just traffic signs. They send the request left or right, but they do not carry the road inside the answer.

Another example, this time for holonomy.

A company hires Maria to analyze her own support tickets. An AI agent gets the task: email Maria her report, and add her to the analytics database.

Two allowed steps: export her report, and grant her the analytics role, which reaches beyond her own data.

Right order: export first, while her access is still narrow, and the file holds 300 of her own tickets. Then grant the role. Clean.

Wrong order: grant the role first, then export, and the same query now pulls all 1 million tickets, names, emails, message contents, into one file sent to a contractor.

Same two steps, same start, same end. One order leaks nothing. The other is a 1-million-record breach. The only difference is the route.

Each step alone is allowed, so a guard that checks one step at a time waves both through. The danger was never in a step. It was in the order, and order-dependence is exactly what holonomy measures, and exactly what Fable, or any AI judged one move at a time, cannot see.

So let’s sum it up. Fable does show a few properties that vaguely resemble a true non-flat GEO-AI, but mathematically speaking, it remains far from that world.

Yes, it applies measures everywhere, but those measures are still naive: the same kind of scoring, applied regardless of context.

Transport is simulated, but only briefly.

Holonomy appears, but only as an accidental flicker inside a single loop.

Has Fable 5 Cooked Current AI Into a Dead End?

Spoiler: the irony in this last section reaches its cruelest peak.

Fable 5 may be the best software engineer ever shipped. And yet the same mechanism that gives it that power is also the mechanism that traps it.

Behind the agent loops, terminals, browsers, memory layers, verification passes, and safety wrappers, the machine still makes its decisive choices through resemblance.

Call it correlation if you want.

But do not call it causation.

That is the wall.

Fable has stretched current LLM-based flat AI almost to its limit. And now the ugly contradiction appears: it cannot be both the triumphant replacement for a top software-engineering team and, at the same time, the safest possible form of that power.

This time, as hard as it sounds, the White House has reason to doubt both claims from Anthropic.

That opens a fatal chapter in AI history.

The old path is turning into a dead end: the marginal cost of building better AI by throwing more computation, more speed, more agents, more wrappers, and more orchestration at the same flat architecture leads nowhere.

And Fable may be the final nail in that coffin.

But a genuinely powerful GEO-AI, one that eventually overcomes the shortcomings of current AI, will likely create the opposite danger.

If the United States or China implements it first, the nation that owns that geometry can safely cap the capabilities it does not want others to have. Europe would not merely be left behind as a customer. It would become a technological colony: allowed to use AI only within limits designed elsewhere.

That is the real danger. And that may be the knockout blow to AI as we have known it until now.

Not just smarter machines. If you control the geometry of your AI, you can cap its use as a weapon for other nations. They will finally have the most sophisticated and insidious instrument ever designed to control an entire civilization.