LLMers Are BSing You

If you follow AI news even casually, you are constantly bombarded with headlines about how close we supposedly are to AGI, usually announced by AI CEOs competing to sound one step ahead of everyone else.

OpenAI’s Sam Altman says we are now confident we know how to build AGI. Google DeepMind’s Demis Hassabis puts it a few years out. And Anthropic’s Dario Amodei, the most aggressive of the lot, has pushed the scaling bet into outright overclaiming, arguing that powerful AI could be just one or two years away.

From Silicon Valley to Shenzhen, LLMers seem to be in a competition over who can make the wildest claim first. Bigger models will become AGI. AGI will become superintelligence. Superintelligence may wipe us out.

As a side note, the genuinely dangerous part has very little to do with some godlike machine intelligence suddenly deciding to destroy humanity, and much more to do with something far more ordinary.

Behind all this futuristic drama, though, most LLMers are making essentially the same bet: that getting from today’s AI to increasingly powerful machine intelligence, and eventually to AGI, is mainly a matter of scaling.

You know the fancy tale by now: more compute, more data, larger models, longer inference, denser GPUs and… voilà: AGI at the end of the assembly line.

There is just one problem, though…

The mathematics does not show that this assembly line leads to AGI.

Why Math Doesn’t Back Them Up

You know something is rotten in the kingdom of AI when brilliant people start waving scaling curves around as if extrapolation had suddenly become a theory of intelligence.

Sam Altman claims that model intelligence scales roughly with the logarithm of the resources used to train and run it. Well, a scaling law can tell you how the curve rises. It cannot tell you when the curve turns into a mind.

Dario Amodei’s argument is even simpler. Skip the formula, add more compute, watch LLMs acquire a broad range of cognitive capabilities, keep scaling and, somewhere up the graph, voilà: extraordinarily powerful, beyond-human systems.

At that point, the mathematics has left the room. What remains is a story about where AI might go, not a prediction of where the mathematics says it will go.

Strip away the glittering façade of GPUs, trillion-dollar infrastructure plans, benchmark curves, and promises of approaching machine intelligence, and what remains is brutally simple: the mathematics underneath does not lead to the destination they are selling, as the animation below conveniently shows.

Now let’s translate the LLMers’ grand claim into plain mathematics and see what is actually hiding underneath all the LLM hype. The recipe goes something like this: take C, the computational resources we keep pouring into the machine, and…

As C grows, the measured loss L(C) falls:

Don’t panic. In plain English:

That just means: throw more compute at your AI, and the measured error goes down.

So far, no miracle. This is the boring part, and an empirically important one.

But now comes the second half of the trick.

As we keep piling on computational resources, measured cognitive capabilities can improve too. Let’s call some aggregate measure of those capabilities K(C)

Again, in plain English: More compute. More measured capability. More cognitive abilities for your AI, apparently.

Put the two together and you get the seductive little engine underneath the whole scaling dream:

And that is the basic idea: keep increasing C, and the LLM is supposed to keep moving toward AGI. Add in gains from better hardware, training, data, inference-time computation, and optimization, and you get the full package: errors go down, capabilities go up.

Repeat the recipe enough times, and you have pushed C toward the heavens, supposedly unlocking a whole new stack of mind-blowing cognitive power

And now you can see the dream of the AI CEOs in all its splendor. Run the same loop long enough, they suggest, and the machine keeps climbing: planning, abstraction, causal reasoning, persistent memory, agency, scientific discovery, general intelligence and, finally, superintelligence.

Not because anyone derived those structures from a theory of intelligence. Nobody proved they had to emerge. And the underlying architecture did not suddenly wake up one morning as a different piece of mathematics.

No. According to the LLMers, the magic ingredient is the compounding effect of scale.

Translated brutally, the proposed alchemy looks something like this

And there they are. Those two tiny question marks.

Those two question marks hide one of the biggest sleights of hand in recent technological history.

Because, as you can see in the equation below, scaling mathematics can describe the improvement on the left. What it does not give us is the missing theorem on the right:

That last transformation, from improvements in the measurable capabilities we already observe to the necessary emergence of qualitatively new cognitive machinery, is not contained in the scaling law.

That part is an extrapolation. And a massive one at that

To Build the Right Technology, Use the Right Mathematics

OK, enough beating up on the LLMers.

If throwing another mountain of GPUs at today’s mathematics is not magically going to turn an LLM into AGI, then sooner or later we have to face the annoying question:

All right, smartass. What mathematics would you use instead?

Now we’re getting somewhere. This is where the real problem begins, because the answer is not one new equation or one miraculous architecture. Nope.

We need to climb through several different mathematical worlds.

Not because mathematics is some decorative intellectual frosting you sprinkle over the engineering afterward, but because every mathematical framework determines what your machine can naturally represent, relate, transform, and reason about in the first place.

Choose the wrong abstraction and engineering can still perform miracles. It will just perform them inside the wrong mathematical universe.

So instead of asking how many more GPUs stand between us and AGI, let’s try a different question: How many mathematical revolutions might stand between us and AGI?

The two plots below give us a map for the climb.

The first shows the proposed cumulative capability stack: each mathematical revolution would preserve what came before while adding something fundamentally new, first represent, then transport, then compose, then act, and finally reflect.

The five steps toward AGI, summed up as an ascending ladder of verbs: Represent, Transport, Compose, Act, Reflect.

The second shows the same idea as a mathematical staircase: from today’s predominantly linear-algebraic AI, through geometry, category theory, geometric dynamics, and finally self-reference.

And notice the annoying little question mark sitting above the final stair.

It is there on purpose.

We should not replace the LLMers’ scaling fairy tale with our own mathematical fairy tale and pretend that five sufficiently fancy branches of mathematics automatically add up to AGI.

This is a research hypothesis based on what these mathematical frameworks might let us build, and it leaves us with a much sharper question than How big should the next model be?

We can ask instead: What mathematical structure is missing from the machine we already have?

One honest note before we climb. Researchers have already visited each of these floors on its own. Some teams add geometry to neural networks. Some use category theory, mostly to describe networks that already exist. Some build agents that act and keep a model of themselves. All real work. But each of them stays on one floor. Nobody has built a single machine that climbs the whole staircase. That is the claim of this article, and it is, as you will see, a much harder one.

So, shoes on. Buckle up.

We’re going upstairs, step by solid mathematical step, toward the final goal: a credible path to AGI.

#1 — Welcome to Flatland
#2 — Bend the Machine
#3 — Everything Is a Relationship
#4 — Get Out of Your Head and Act
#5 — The Machine Enters Its Own Equation
#? — And Then, Maybe, AGI

The mathematical way upstairs to a possible AGI.

#1 — Welcome to Flatland

Today’s AI lives largely in a magnificent mathematical Flatland.

Words become vectors. Concepts become points in high-dimensional spaces. Learning becomes the transformation of those vectors through matrices, tensors and nonlinear maps.

Quick precision: the maps are nonlinear, the space isn’t. Every hidden state sits in a flat vector space with no geometry of its own. That flatness is the Flatland, not the algebra.

OK, granted: this machinery is powerful enough to explain a lot of what we see in our AI chats.

But its native language is still fundamentally one of coordinates and transformations.

That is where the geometry starts to wobble: meaning does not sit at a fixed coordinate independent of context. Its position shifts as the surrounding context changes.

The same token can mean one thing here, something subtly different one paragraph later, and something radically different when buried inside several nested contexts, references, exceptions and dependencies.

LLMs can absolutely represent context. Their hidden states and attention mechanisms do precisely that.

The deeper problem is that they do not possess an explicit intrinsic mathematical law saying: Here is how this meaning must be transported when the context changes.

So contextual consistency has to be continually reconstructed through the model’s learned transformations.

As contexts become longer, nested, conflicting or increasingly dependent on earlier distinctions, keeping the same semantic object coherent can become harder.

And eventually the machine can do something wonderfully LLM-like: Remain locally fluent while becoming globally wrong.

That is one route to what we call hallucination: not simply bad vectors, but a failure to preserve the relevant constraints and meaning across the evolving context.

Summing up, our current AI, still living in Flatland, is extraordinarily good at telling us where a representation is and how to transform it. What it does not naturally make explicit is how meaning should remain coherent as it moves through changing contexts.

Its foundational verb is:

REPRESENT.

And that missing verb gives us the reason to climb to the next floor:

TRANSPORT.

#2 — Bend the Machine

Now bend Flatland.

Instead of assuming representations merely inhabit some enormous ambient vector space, give their world intrinsic geometry: manifolds, metrics, fibers, connections, curvature and holonomy.

Suddenly the interesting question is no longer merely, Where is the state?

It becomes: How should the state change when context changes?

A connection supplies the rule for transporting information along a contextual path γ .

Curvature measures the incompatibility between different transports. Holonomy records what happens after traveling around a loop.

Now the path can matter.

That opens the door to something Flatland does not naturally make explicit: context-dependent transport and path-dependent memory.

The new verb we add at this step on our way upstairs is… TRANSPORT.

#3 — Everything Is a Relationship

Geometry gives us structured spaces. Now we step into category theory, which lets us make an even more radical move: stop treating the things themselves as the whole story.

Study how they relate and compose. Objects become connected by morphisms:

And compositions of those morphisms become mathematical objects in their own right:

Functors relate entire systems of relationships. Natural transformations relate those functorial mappings.

Sheaf-like structures can formalize how locally compatible information becomes, or fails to become, a coherent global picture. The machine is no longer merely carrying representations around.

It acquires a mathematics for asking: What can be connected to what, and what survives when those connections are composed?

Example

Imagine an AI has learned three completely different problems:

Virus → receptor → cell

Hacker → exposed service → network

Invasive species → transport route → ecosystem

To us, these look like different subjects.

Category theory gives us a language for asking whether they instantiate the same abstract pattern of relationships and composition:

OUTSIDE → GATEWAY → INSIDE

Now give the AI a problem it has never seen before.

Instead of asking only: Have I seen something similar?

it can also ask: Does this new problem have a structure I already know?

That is the potential cognitive leap: transfer knowledge by relational structure, not merely by similarity.

Current LLMs can already discover analogies like this, but often only after enormous amounts of training, and even then they may generalize them unreliably.

A category-theoretic framework could make those relationships explicit, composable, and mathematically constrained, rather than leaving them buried inside learned representations.

The machine gains a new way to reason: Don’t just recognize the pieces. Recognize how the pieces fit together… and what remains unchanged when the pieces change.

The new verb for this step is: COMPOSE.

#4 — Get Out of Your Head and Act

A sufficiently rich intelligence cannot spend eternity contemplating its representations. At some point, something has to happen.

That takes us into Lie groups, Lie algebras, geometric mechanics, dynamical systems, control, and phase space.

A note for the roboticists rolling their eyes right now:

yes, you’ve had rigid-body groups and geometric control since the 1980s. True. But that math lives in the controller, bolted on under a perception model that still thinks in Flatland. The step isn’t inventing the tools. It IS moving them into the reasoning core, so the machine’s representations flow on the same geometry its body obeys.

That probably sounds like mathematical soup, so let’s give it arms and legs.

Imagine two robots standing in a kitchen (see the animation above). You tell both: Grab that glass without spilling the water and put it on the moving tray.

A current-generation robot might perceive the glass, estimate its coordinates, calculate a grasp, generate a trajectory for its joints, execute it, measure the error, correct, and repeat.

Very impressive. But now somebody bumps the table…

The glass begins sliding.

The water starts oscillating.

The tray keeps moving.

The robot’s shoulder approaches its mechanical limit. Its fingers are already applying force to the glass.

And all of these things are changing at the same time.

Now the problem is no longer:

Where is the glass?

It is:

What actions can I physically perform from this exact state, while the world itself is evolving, without violating the constraints of my body, the glass, the water, and the task?

That is a radically more geometric question.

The robot’s orientation is naturally described by rotations such as:

while its position and orientation together can be represented through rigid-body transformations such as:

The small moves it can make right now, from that exact pose, form what mathematicians call the Lie algebra: the list of nudges currently available to the robot. And the robot is not alone in this dance:

Its body has velocities and momenta.

The glass has its own dynamics.

The moving tray has another trajectory.

The sloshing water introduces still more dynamical constraints.

The state therefore does not merely sit somewhere waiting for the next command. It flows.

And every action changes which futures remain physically possible.

A geometrically richer robot could reason directly over this evolving structure: continuously transform its frame of reference, predict families of possible trajectories, exploit symmetries, respect physical constraints, and continuously adapt its actions as the world changes.

The table gets bumped? It does not simply say: Oops. Recalculate coordinates.

It asks something closer to: Given the new state of this entire coupled system, which physically admissible trajectory still gets the glass onto that tray without spilling the water?

That is the conceptual jump.

Not: SEE → CALCULATE → MOVE

But:

There you go. The new verb: ACT.

#5 — The Machine Enters Its Own Equation

So far, the machine has been modeling something else: language, contexts, relationships, worlds, actions.

But an intelligent system is itself part of the world it is trying to understand.

So eventually the arrow turns around:

The system begins representing aspects of itself: its beliefs, uncertainty, previous reasoning, actions, limitations, and perhaps even models of its own models.

Now we enter the territory of reflection, self-reference, recursive structures, type theory, belief revision and metamathematics.

This does not mean the machine suddenly becomes conscious.

Mathematics gives us no such free miracle.

The more defensible claim is stranger and more precise: The reasoner becomes one of the objects being reasoned about.

One warning comes with this floor. Mathematics proved long ago that no system can fully check its own reasoning from the inside (Gödel and Löb). A machine that thinks about itself inherits that limit. So the goal is not a machine that knows itself completely; that door is locked. The goal is a machine that knows how sure it is, can change its mind about itself, and knows where its self-knowledge ends. That much is within reach

The new verb is: REFLECT.

SUMMING UP: LLMs Are Step Zero

LLMs are not the end of the road to intelligence. They are step zero. And the good news is that we are not mathematically empty-handed.

Geometry, category theory, dynamics and self-reference already give us candidate tools for building machines that can do more than represent: transport, compose, act, and reflect.

Will that get us to AGI? We don’t know.

That question mark is still there.

But at least now we have something more interesting to investigate than how many GPUs we can pile onto Flatland.

The next revolution in AI will begin when we stop asking how much bigger we can make today’s machine and start asking what mathematics tomorrow’s machine is still missing.

Don’t just scale Flatland. Get out of it. The next revolution is upstairs.

Not All Programming Languages Are Created Equal

The key to using AI productively in coding is knowing exactly where the contextual minefields are hidden before your AI coder blows up the entire project.

Of all the myths around AI and coding automation, this may be the most damaging:

AI will soon make developers unnecessary.

The logic sounds obvious. All programming languages collapse into one common abstraction, the LLM learns it, and humans get pushed out of the loop.

AI is already very good at writing the visible code, but it still sucks when it has to deal with what actually makes a real-world project work: the hidden structure of the programming language.

If you thought programming languages were just different syntaxes for the same thing, sorry, but you are wrong. Not all programming languages are created equal. Some hide layers of context, ownership, state, order and semantic rules that all have to remain correct at once.

Or, in plain words: the different contexts that even one simple line of code can carry with it make the myth completely false and the developer in the loop more necessary than ever… depending on the programming language. And once you see it, you will know exactly which group you are in.

Case in point: The C++ Nemesis

That AI can write C++ does not mean that it can build a reliable C++ project.

It can generate templates, write RAII, produce concepts, iterators, lambdas, move constructors, forwarding wrappers, allocators and concurrency code that looks frighteningly competent. Fine.

Yeah, we agree with the fearmongers here. Much of that visible code production is already being automated.

But don’t pop the AI champagne yet.

Because C++ has a nasty property that languages such as Go expose much less aggressively: the meaning of a line can depend on several interacting semantic contexts that are not visible in the line itself.

A piece of C++ can compile cleanly, pass superficial tests and still be wrong because correctness depends on something living several semantic layers away: name lookup, ADL, template dependence, overload resolution, concepts, value categories, object lifetime, ownership, concurrency, you name it.

And this is exactly where AI can screw up your entire project.

The problem is not that it cannot produce the syntax. The problem is that C++ can require something closer to

(code, nested contexts) → meaning

rather than simply

code → meaning.

Now you know where current AI sucks most: nested contexts, whether in C++ or in any other programming language that relies heavily on them.

And if you have read my articles before, this is another smoking gun for why we need a completely different kind of AI, built on a different mathematical foundation from the one we use today.

So the important point is simple:

The line of code is only the visible surface. The real semantics live underneath. And that is exactly where current AI sucks.

Why AI cannot understand what an average developer does without effort

This is the question that really matters to any developer, not just C++ developers, who feels threatened by automation.

An average developer, let alone a senior one, can look at a line of code and immediately recover much of the context surrounding it.

So what is so difficult for an AI about something you do almost routinely?

The animation below will look as familiar to you as the ABC of C++, but the same idea applies to any language with several nested contexts hiding behind even a single line of code.

This simple fact kills any AI coder. This is not a matter of more or less human supervision. The problem is that AI is blind to many of those nested contexts, as you will see in the examples coming next.

Read more

Whether you are an AI newbie or a senior AI engineer, you may be risking your future by using the wrong AI mindset.

Let me explain.

Most of us have been taught two fatal fallacies about AI.

The first is that today’s transformative generative AI is somehow the only possible form of machine intelligence — and that the road to AGI is simply to give it more speed, more memory, more data, and more compute.

The second follows directly from the first: that the mathematics and programming you need to learn are basically linear algebra and GPU programming. Forget geometry, topology and category theory. Forget Bayesian reasoning and probability distributions. Just multiply bigger matrices on bigger clusters and wait for intelligence to emerge.

But there is a problem, one the AI industry rarely puts center stage.

While the public is being sold an endlessly optimistic future of faster GPUs and ever-larger LLMs, the numbers are beginning to tell an uncomfortable story.

Today’s AI may already be approaching the end of its reign as the uncontested paradigm. You do not believe me?

Then look at the relationship between performance, computational cost, and marginal returns.

As computation, memory, parameter counts, and training resources increase, marginal returns do not rise proportionally. They begin to flatten. You spend vastly more to extract increasingly smaller improvements.

That means every new generation of frontier LLMs risks becoming dramatically more expensive — not merely in money, but in energy, chips, infrastructure, and computational complexity — while the gains become harder and harder to extract.

So the numbers leave us facing an inescapable conclusion.

Either a new breed of machine intelligence, built on new mathematics and new technology, takes over and resets this insane trajectory of escalating energy and computational cost…

or we may be heading toward a third AI winter.

And that new machine may look very little like the AI you know today.

Okay, I can already hear you saying: Sure, current AI has its flaws, but isn’t it still better to keep improving LLMs and building new frameworks around them than to bet on a completely different kind of AI that does not even exist yet and sounds like science fiction?

Not so fast, dear reader.

This new AI is not merely mathematics confined to books or technology still waiting for a blueprint. Startups and established companies are already building the technology, testing prototypes, and turning parts of it into real products.

Most of these systems are not mainstream yet. Some are still early. But the results suggest that they could move from the lab into wider use — and begin taking serious market share — over the next few years.

The New Frankenstein Factories Are Already Here

The next thinking machine is not emerging from a single laboratory.

It will emerge from an ecosystem.

And the right mindset now begins with understanding how that ecosystem actually works.

One company builds the nervous system.

Another develops the body.

Another specializes in memory.

Another teaches the machine to interact with the physical world.

Another models biology itself.

Even Google DeepMind, the company that currently comes closest to integrating many of these ideas under one roof, is better understood as the center of a much larger Alphabet ecosystem than as a completely self-contained AI factory.

Around it, Alphabet has built specialized organizations such as Isomorphic Labs, dedicated to AI-first biology and drug discovery, and Intrinsic, focused on intelligent robotics and physical AI. These companies operate independently, but collaborate with Google DeepMind wherever their technologies overlap.

That is the first sign that the future of AI is already changing before our eyes.

Until now, the standard model was simple: a startup grows around one star product — usually an LLM chatbot built on generative transformer AI.

Those days may be coming to an end.

Instead of one promising rookie startup, or one already consolidated giant laboratory trying to solve everything, we are beginning to see an AI industry organized around networks of specialized suppliers and cognitive supply chains.

And yes, Frankenstein is the perfect metaphor for what is happening.

Different companies are developing different parts of the same emerging system: better neurons, more capable bodies, richer world models, biological reasoning, and machines that improve through experience.

No single company has assembled the complete monster.

But the factory chain producing its organs is already running.

And here are the companies currently running the show — some old, some rookies, but all converging toward a new mode of AI production.

The consequence may be enormous: the LLM-based AI we have seen so far could end up looking like a mere cognitive toy beside what is coming over the next few years

The Organs

Victor Frankenstein would feel strangely at home in the current evolution of AI.

The difference is that, instead of collecting a few dead organs, stitching them together, adding electricity and — well, you already know the rest — he would become an AI engineer and assemble something far more abstract.

Not biological organs. Mathematical organs disguised as technology.

Read more

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

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.

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.

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.

Look at the animation below and the trick becomes obvious.

Read more