To Mr TechSimple

Picture the worst possible reader for this story. And call him Mr. Techsimple.

Techsimple does not invest ahead of the curve. He arrives late. Always.

And there he is again, spending his money and his time on the shiny hype of the latest big thing.

To be fair, Mr. Techsimple is consistent. He has been wrong with discipline.

He put his first money into Theranos, because a black turtleneck and a deep voice were, to him, indistinguishable from a working blood test. He rotated, undaunted, into WeWork because Adam Neumann incarnated the new tech-prophet of renting offices. He was in Nikola a couple of days before the truck rolled downhill into a crashing market

He was convinced by Sam Bankman-Fried about FTX and the old fiat money being a scam — yeah, a tech scammer claiming to fight the banksters and the central banks. He bought the metaverse at its peak. He still is long and owns Meta, because he is convinced that the metaverse was simply ahead of its time and now it will ride victorious on the new AI wave.

So yes, you are guessing right, he is now very bullish on AI, long on the giants, because the brochure said AGI is coming up in your chatbot. With the new AI and superintelligence coming up, all his past failed tech investments suddenly will be absolutely feasible to pull off.

And here we have today our Mr TechSimple doubling down on OpenAI because another Sam — this time Altman — is announcing that OpenAI will be bringing a new AI generation.

Hello, friend. I want to be kind to you. What I am about to show you is sadder but more real, because the AI the giants sold you is a lie… not in the way the others were, but in a deeper one. The real thing is being built. Just not by them

The Tale of Mass Extinctions

We are imitating nature, whether we realize it or not, whether we try to ignore it or believe that tech has nothing to do with it.

So here is the part Mr TechSimple cannot price, because it has never once appeared in a brochure. Every technology we have lived through until now, the legit ones and the scams alike, the smartphones and the Theranoses, the cloud and the crypto winters, will look like a children’s game next to a genuinely legit, functional, and truly scalable AI. Not the kind sold in a keynote. The kind that actually works, and actually scales, and does not stop.

The impact of that machine will not be another product cycle. It will be the first technological mass extinction: an event that rewrites the landscape the way an asteroid does, touching everything a human being touches, because intelligence touches everything a human being touches. Work, law, money, war, meaning.

And here is the cruelest joke in the whole story. Mr TechSimple, in the most fevered, delusional, moon-bound tech dream he has ever talked himself into at the top of a bubble — would, against this, sound like an ultra-conservative. The man who has never in his life overestimated a technology by less than an order of magnitude will, for the first and only time, have catastrophically under-shot.

And the most laughable, ludicrous part of all? It will not be a Skynet — no continent-sized system, no megalomaniac fantasy of Nvidia data centers wired to their own nuclear plants, no. It does not need to be like that. It will be a modest, almost embarrassingly small thing. A tiny thinking engine.

You don't believe me? Keep reading. I promise - by the end, you will.

The Flat AI Era Is Ending

For the last few years, the entire industry ran one experiment: take a flat architecture, make it bigger, and see if intelligence falls out the other end. It did not. What we got is an AI that can only drive in straight lines and goes off the rails when it has to take curves.

Ninety-five percent of enterprise AI returns nothing, pilots die between demo and operations, and the response from the giants has been to order more of the thing that is failing. When a technology needs planetary-scale infrastructure to compensate for architectural blindness, the question is not how many more trillions to feed it. The question is what is missing from the architecture itself, and the answer is geometry.

Flat AI works on a flattened version of thought.

It treats meaning as points in a vector space, then tries to guess what should sit between those points. That is why it looks brilliant when the next case resembles the old cases. Locally, it can be stunning. But once the problem bends away from the training neighborhood, the model starts guessing like a drunk man looking for his keys at night around a very dim light.

This is the Mercator problem.

Read more

Beyond the Anthropic Hype

You know this movie. An AI lab’s marketing team announces that the model does not just look smart, it is really thinking, and as proof they show you a new toy (NLA, short for Natural Language Autoencoder, a second AI trained to describe the first one’s internal states in plain English) to photograph those thoughts.

That sounds like a serious cutting edge in AI research. But what did Anthropic actually build?

Just a stack of nested black boxes.

The first model produces internal numbers. The second model looks at those numbers and writes a caption. Then a third system tries to reconstruct the original numbers from that caption. If the reconstruction is close enough, the caption is treated as meaningful.

That is the machine. Something worth considering, yes, but certainly not the innovative leap that Anthropic’s marketing, and the many articles and posts spreading it afterward, try to suggest.

We know what Anthropic’s thought reader is not: it is neither a mind scanner nor a thought camera.

So before we follow the thought reader any further, we should stop at the source of its raw material: the numbers.

A language model does not think in words. It works with numerical states. At the simplest cartoon level, imagine one tiny unit receiving a few signals and assigning a weight to each one. Should I go to the party? Free pizza: strong positive signal. My ex will be there: strong negative signal. It is raining: another negative signal. Add the scores, pass the result forward, and move on.

That toy example is not a full transformer, of course. Real language models use real-valued vectors, attention, residual streams, nonlinear transformations, and many other moving parts. But the basic fact remains: words become numbers, those numbers are transformed through layer after layer, and eventually new numbers are turned back into words.

That is where activations enter the story.

An activation is not a hidden sentence inside the model. It is a snapshot of the machine mid-calculation. A frozen numerical state. Useful and informative, yes. But not readable in the way your diary is readable, or a confession is readable.

And that is exactly why Anthropic needs another AI to interpret it.

The first model produces the internal numerical pattern. The second model turns that pattern into a verbal caption. Then the system checks whether the labeled text caption preserves enough information to reconstruct something close to the original pattern of numbers.

That is all you need to know to conclude that, in fact, we did not find any thought inside the model. We found a smart reverse-engineering process, where the final AI in the chain analyzes the source AI’s internal numerical state and checks whether those text labels are consistent with the numbers they supposedly depict as internal thoughts.

What Is Wrong With Anthropic’s Thought Reader?

Read more

Current AI is snake oil the moment your problem has to scale

If you are one of those who have tried to use current AI for a problem that scales, you already know that the AI solution they sold you as the hammer for every nail is just the modern tech version of the old snake oil scam.

In fact, the numbers back your experience: ninety-five percent of enterprise AI returns nothing, and most pilots collapse somewhere between demo and operations. But let’s not jump to conclusions. If we look closer at what is actually failing, it is not a model-quality problem, nor a regulation problem; it is a problem of brittle workflows, missing context, and systems that do not learn inside the daily life of an actual business.

Now the other side of the story. The appetite for a functional AI is unstoppable, and how unstoppable? The best foxes sniffing this market put the ballpark at $2.6 to $4.4 trillion annually (McKinsey), a 7% lift to global GDP and roughly 300 million jobs exposed to automation (Goldman Sachs).

You want even more vivid? The energy alone will be around 945 TWh by 2030, with AI as the major driver — slightly more than Japan’s total electricity consumption today!

So here is the scenario we are facing with current flat-AI: trillions in projected upside, hundreds of millions of jobs in the crosshairs, continental-scale electricity demand… all for a miserable flat AI that fails 95% of the time.

Too much ado about nothing.

Is there a way out? An AI to put an end to all this ludicrous, criminal waste of energy and economic resources?

If you have read our articles before, you already know the answer. The architecture that replaces FLAT-AI has a name too. Call it GEO-AI: systems whose metric varies with context, where curvature itself carries the meaning that flat embeddings (tokens as vectors) can only approximate.

The missing layer

Read more

Nothing personal, just math

First of all, don’t be scared of the math here. You will get it, because I will use intuitive plots and animations to show you which math the big names are using to build the first true thinking machine. Yes, you read that right: thinking AI, not just another LLM parroting something that only looks similar on the surface.

How important is the new math the research labs at the big names are already working on? Important enough that if you read our previous article here, you already know the answer: where cognition and AI meet, mathematics is not a tool, it is the battlefield.

Until now, AI has behaved as if intelligence can be squeezed out of flat embeddings, bigger datasets, and enough GPU violence. That is the industry’s favorite superstition. But cognition is not a bag of vectors. It is a layered architecture of dependencies, transformations, transport, constraints, memory, inference, and self-correction.

Let’s start with the math ingredients in the recipe Anthropic and Google are using to build a genuine AI worthy of the name.

The labs are not inventing new mathematics. They are reaching back, all the way back, to the foundations the field abandoned when it decided that scale would be enough.

They are following, maybe without knowing it, the path Hilbert’s metamathematics opened a century ago when it taught us to step outside mathematics and study its machinery. For the first time, they are taking category theory seriously as architecture, not as a functional-programming side dish, to describe how structures compose. Put them together with serious differential geometry, Lie groups, topology, and information geometry, and they will get something far more serious than another transformer stack: they will get a blueprint for cognition built from the bottom up, with no arbitrary glue, no accidental layers, and no corporate fairy dust pretending to be architecture.

We can now say, for the first time, that we have a mathematical idea of how the increasingly fused Google-Anthropic partnership could build a new generation of machines that deserve to be called thinking.

Let’s build that machine the way they will.

The mathematics will become far less intimidating once the animations begin, I promise. This math is not decorative. It is the difference between a machine that merely predicts the next token and a machine that can begin to think in a way worthy of the name.

The reward?

A genuine AI architecture, unlike anything you have seen before

Read more

From Conspiracy to Receipts

Yes, the title sounds like a conspiracy theory.

But let me say in plain words what they refuse to admit: they are trying to reach the moon by building a taller ladder, scaling flat transformers, throwing hundreds of billions of dollars a year in brute-force computation at a problem the architecture cannot solve at any cost.

Meanwhile they hide the blueprint they are actually working on, the rocket ship that is Geometric AI, which would save trillions by handing out the whole map instead of one street address at a time.

Of course they are telling you the opposite story. The core of it is much simpler than the trillion-dollar price tag suggests: at the heart of current AI sits a geometrical problem, and no GPU farm in the world is going to fix it, not even with the nuclear-powered data center the size of Patagonia they have started building.

Stay with me. Because you will see how this apparently crazy absurdity has a point of sanity hidden inside the labs themselves: their research teams are following a different approach to the sola computatione of the current AI church.

The smoking gun is neither a secret server farm nor a leaked memo. And least of all, it is not some cinematic superintelligence hidden behind a locked door. It is something much colder and more practical.

The back door is inside the technical and scientific papers of the companies themselves, which, except for some expert nerds, almost nobody outside the field reads.

Do you want to find out whether NVIDIA, Google, Anthropic, and the rest are selling the opposite of what they are intensively researching? Then don’t read their press releases, their stage-managed public events, or the effusive declarations of their CEOs. Do something far simpler: grab the research papers of their fringe teams, and you will see where this story begins and how it drives into a new territory of AI that should set off alarms for you.

Don’t worry. I have done the homework for you. Here we go.

We Should Already Have a Truly Non-Parroting AI

But first, let me be precise about what is under attack in current AI.

Ok, we have already mentioned transformers. Sure, they have positional encoding. They have attention. They mix each token with the tokens around it across many layers of computation. They are not blind to context in the trivial sense; anyone arguing that they are has not opened the 2017 paper.

The legitimate attack is not that AI is blind.

The legitimate attack is that the current architecture handles context in a structurally wrong way, and scaling computation cannot truly fix it.

Attention layered on top of flat embedding spaces does not, by itself, measure the semantic distance between concepts that overlap and shift with context.

Take justice and law as a worked example.

The distance between these two concepts in the democratic United States and in the theocracy of Iran may look almost identical when you are talking about petty crimes and ordinary civil offenses. But the moment you move to political crimes, the two concepts can sit at opposite ends of the semantic space.

Same two concepts, yeah, but…

Different distance.

Different context.

That is the point.

Meaning is not just a word sitting near another word. Meaning is a position inside a changing semantic terrain. The distance between concepts depends on the background against which they are read.

Flat AI embeddings cannot do this for free. They force the model to fake it by feeding it enough examples to memorize how the distance shifts: different regimes, different offenses, different legal traditions, endless combinations. Brute statistical memorization where geometry should be doing the work.

It is the flat-map problem one layer deeper. You cannot measure curved distances with a straight ruler, no matter how many rulers you stack. Context is not just another word the model processes. It is the ground the words sit on, the surface that decides what the distances between them mean. Flat AI keeps trying to do computation where it should be doing geometry, and no amount of training data can fix that.

It is like trying to measure speed with a stopwatch alone, ignoring distance. A stopwatch gives you time. A speedometer combines time and distance into one quantity — speed — that neither alone can give. Flat AI is the stopwatch (a functor: one input, one direction). Real cognition needs the speedometer (a profunctor: two inputs of different kinds, one a concept, the other its context).

Their own papers are the smoking gun

This was only the warm-up. The mindblowing starts now. (1) Anthropic, caught red-handed. (2) Yale cracking open Llama 2, Gemma 2, DeepSeek-MoE. The curve they grew on their own. (3) Einstein as the working frame, not the metaphor. (4) The first blueprint of a new generation of thinking machines.

And much more...

Read A Mathematician Lurking in the TechUnderWorld: pure mathematics, animated proofs, analysis you will not find anywhere else on the web.

Read more

The Most Boring Tool on the Internet Will Decide the Future of AI

I hear you.

Adblockers? What the heck. Your story this time is about the most boring subject on the internet?

Exactly. It seems like that. And that is the trap.

Adblockers look like the most humble, almost miserable creatures in the entire internet ecosystem: tiny browser extensions working like little invisible shields, sitting there like silent stowaway icons near the address bar of your browser. Barely noticed by you. Credited by almost nobody, and nevertheless carrying the heaviest part of personal security on the whole damn internet

.But what if I told you that this ridiculous little shield is standing on the battlefield from which the next generation of AI may emerge?

You mean something different from my chatbot?

Yes. And much darker.

A new kind of AI built from the war over your personal data, coded and optimized inside one of the most profitable machines of our time: the surveillance economy.

We are talking here, dear reader, about an AI whose power does not come from having the biggest, baddest, smartest brain ever seen.

Its power comes from something more intimate, and far more dangerous: knowing you better than you know yourself.

The battle over your personal data in the wake of the Dark AI

Until now, the unglamorous adblockers have done their job better than most people realize. Good enough to frustrate the dream of total behavioral visibility.

In fact, they have spent years busting the chops of Big Tech’s biggest ambition: seeing enough of your online behavior to personalize, target, and monetize you. This is not paranoia. Alphabet itself warns investors that technologies which block ads or make personalized advertising harder could harm its business.

That is the smoking-gun proof.

Adblockers are not decorative toys. They are effective enough to bother one of the most powerful advertising machines ever built. And they do not only defend your privacy. They also keep the internet navigable: less spam, fewer popups, fewer aggressive ads, fewer paralyzing pages loaded with junk nobody asked for.

How?

By attacking the pipes.

They blocked the scripts, killed the trackers, weakened the fingerprinting, disrupted the cross-site linkage, slowed the whole extraction machine, and stood between ordinary users and a harvesting infrastructure built from ads, pixels, CNAME tricks, real-time bidding networks, and broker profiles.

Every one of them a little invisible hook designed to turn human behavior into money.

Not bad at all for a few miserable browser extensions with terrible marketing.

But they do not all fight the same fight.

Some are better at killing third-party trackers. Some work almost everywhere. Some go deeper into the browser. Some are just very good at blocking the pipes where your data leaks out.

So let’s look at them properly.

The table below is not a beauty contest. It is the old battlefield, layer by layer: who blocks what, who only slows it down, and who still keeps the surveillance machine sweating

Among these quiet internet heroes, Ghostery stands out as the paradigmatic adblocker. Not because it does one magical thing, but because it does several practical things at once.

It does not win by being a silver bullet. It wins by being a stack: a layered shield, a small privacy machine built to fight the old surveillance web without making the normal web unusable. That is why Ghostery works so well as a canonical example.

You can see that logic in the animation below: how it works in full action while you navigate the dangerous wild web on your phone or laptop, keeping your session cleaner, faster, and harder to exploit.

So far, nothing looks broken.

Your Ghostery shield is awake. The little hamster is running in the wheel. The browser feels cleaner. The page loads faster. The obvious junk gets blocked before it can feast on the session: trackers, scripts, popups, fingerprinting attempts, cookie traps, and all the usual garbage trying to turn your browsing into someone else’s money.

Good. That is the old war.

But now look again at the table above. There is one column where everyone fails.

Authorized inference.

That low score is not a technical footnote. It is the crack in the castle: the Achilles’ heel of adblockers.

Adblockers are very good at guarding the browser door. But the inference layer does not need that door.

The inference layer works with data already authorized by you, already collected, already inside the app or cloud, waiting for a model to connect the fragments.

That is where the nightmare begins. But what the heck is the inference layer?

This is only the small introduction to a much bigger story.

What continues behind the paywall is an immersive experience that will change how you think about AI entirely.

Please subscribe and enjoy this article, along with many more top pieces like it.

Read more

Oh no, another LLM guide?

I can understand that reaction. By now, everyone has seen too many of them, and you probably expect to find here another crowded table, another pointless ranking propped up by whichever benchmark fits the headline.

No. Forget it. Here you will not see another childish contest pretending to decide which LLM is the smartest, which is the cheapest, which writes the best code, or which sounds the most human. Most of that is BS when it comes to the thing that really matters to you: getting the damn job done in the best possible way.

So yes, you are lucky. Your frustration is welcome here, and what you are about to read is the first cognitive map of the frontier, the one built from your real work rather than from leaderboards.

The Cards on the Table

Pay attention now, please, because this is where we are saying bye-bye to the non-scientific LLM classifications you see most of the time.

First, let the math separate the chaff from the grain. Easy. Don’t worry, I have already done the homework for you.

This was the recipe: I took 24 related LLM skill variables extracted from real professional use cases, ran the rotation, and voilà, there you go — the three cognitive factors that actually predict which LLM is best suited to the task you need to solve.

The details of the several varimax rotations are not shown here. The animation below reproduces the math cooking the last varimax dish, the important one.

You have the diagnosis. The cure is behind the paywall: the decision rules, the routing patterns, and the multi-model sequences that turn the three lanes into countless hours saved and a lot of unnecessary pain avoided. Subscribe to unlock the rest.

Read more

Time to judge current AI on its own merits, facing the real world, which is not a tidy chatbot window, not something you can summarize into a benchmark, and least of all a controlled demo. We know that critical situations in our familiar world can turn it into a brutal place where conditions shift faster than any frozen AI model can match.

And there you have the perfect example: our familiar drones, and the dream of turning them into a machine fused with AI that handles everything from civilian logistics to military strikes. What other example would show us the supposedly limitless capabilities of AI in the real world better than this one?

So yeah, we are right to expect that if real AI were already available, it would have been implemented in these machines first, especially the precision military hunters. They should look almost extraterrestrial in capability, executing operations no human-controlled device could match, above all those synchronized maneuvers of dozens of drones moving through real landscapes under real pressure, in real time.

Now wake up to 2026. And to the years that follow, if we do not change the flat AI paradigm, and what you get? The miserable “state of the art” showing in the table below.

You see. Many billions of dollars spent on machines that cannot tell a hill from a valley, hold altitude when the temperature drops, or, my favorite, the drone cannot hit a moving target the way any twelve-year-old does on a PlayStation, by aiming at where the enemy will be, not where it is.

And what has been the industry response to those blunders? The usual polished shrug, a press release for every incident, blaming the rotor, the weather, the test conditions, anything except that all those failures come from the same broken mathematics running inside the drone-brain.

The Four Ways AI Hits the Real World Wall

Before we unravel the possible solution in the next section, let’s look at the failures themselves, not as accidents but as archetypes. Each one exposes a different face of the same architectural limitation, and together they map the ways a trained model collapses the moment the world stops matching the training set. Watch them carefully. The solution comes later; I am sure you can already come up with some possibilities while examining these simplified animations.

First Type: The Map Is Not the Territory

The training data of course contained hills and terrain irregularities. But the battlefield in Ukraine was more nuanced than the training set anticipated. The drone flew at the altitude its model had learned was safe, straight into a particular hill the model had never identified as such, because the architecture had no mechanism to notice that the world in front of it no longer matched the world it had been trained on.

You have never seen AI explained like this.

Behind the paywall, you’ll go from animated AI failures to the mathematics beneath them: flat metrics, Fisher geometry, and a multilayer AI architecture built for the real world. It is deep, visual, cinematic, and packed with mind-blowing graphics and practical ideas you need if you want to stay ahead in AI.

Read more

There are nine geometries that matter. AI is built on only one of them, and it is the wrong one.

Pause there for a moment before looking at the table below. At first glance, it may seem like a parade of abstract symbols, the kind of thing people dismiss in an instant. Do not dismiss it.

Read it as you would read a report of your own mind, because that is what it is: a record of structures you already rely on, every waking hour, without ever naming them: when you turn your head toward a sound, when you reach around an obstacle to grab a cup, when you know that your left shoe will not fit your right foot, when you retrace the route that brought you here and remember the turns in the order they happened, you are relying on the very invariances, transformations, and path structures these geometries describe.

You do not need the math to do any of this. You need the math only to see it clearly, to understand how a truly intelligent engine would have to handle it, and thus to see that the machines everyone calls intelligent still cannot.

Behind the paywall: the Nine Geometries table that names exactly what AI is missing, the chirality infographic that explains why flat AI confuses cures with poisons, the financial case for the two companies already shipping what replaces the transformer stack, the architectural diagnosis that shows why scaling cannot close the gap, and new animations showing the geometry problem in motion… and more…

Read more

The LLM Era Is Over

The biggest names in AI have an aging problem, and they are trying to fix it by throwing more raw computation at it. Blatant mistake!

OpenAI, Google, Anthropic, and the rest have spent the last two years scaling inference-time compute: chain-of-thought prompting, search trees, verification loops, more tokens at test time. As I argued in previous articles, this approach has eliminated most of the surface hallucinations, the kind that embarrass you in a demo, while producing deeper structural errors that are far harder to detect and far more dangerous to trust.

And here is what most people are missing: the new LLMs sound smarter. They are not. They have simply learned to hallucinate with better grammar. And the data proves it: with every new release, the deeper hallucination rates are going up, not down.

One of OpenAI’s biggest recent models hit an almost mind-blowing 50% hallucination rate on their own SimpleQA benchmark. One in two answers, fabricated. The coherency is a mask. What is underneath is getting worse.

So there you go: the companies that dominated the first era of AI are becoming its dinosaurs, and they are too busy scaling to notice what the new-kids-on-the-block competitors have already understood:

intelligence is not a frozen function. It is a continuously updated probability distribution moving through a structured space. And in a real learning system, space is not the stage on which computation performs. Space is part of the script.

In quieter times, this would be a technical debt problem. An expensive one, but manageable. These are not quiet times. The window is closing because the architecture itself is hitting a wall that compute cannot push through, and for the first time, there are credible alternatives waiting on the other side.

A new class of AI architecture is now positioned for a serious overtake of the entire industry. Not by building bigger transformers. Not by training longer. By changing the space in which computation happens. The approach has no single brand name yet, but the technical foundation is clear: Fisher-Bayesian AI (see chart above). It replaces the flat Euclidean geometry that neural networks have assumed since the 1980s with the curved, information-theoretic geometry that probability distributions actually live in. It does not improve the existing paradigm. It obsoletes the mathematical surface on which that paradigm was built.

Let’s cut now the tech jargon and explore with a real-world example in an animation with two drones facing the same landscape with the same obstacles. However, one runs on a frozen AI trained like an LLM: it planned its route once before deployment and never updates, because for the LLM AI the world stops changing the moment you finish training. The other runs on a Bayesian brain: every sensor reading reshapes its map of the real world (you know, the one with mountains, valleys, and the kind of surprises that don’t care about your training data) in real time. Now watch what happens when a new obstacle appears mid-flight.

What follows is the proof: the names, the math, the battlefield map, and the animated visual arguments you will not find anywhere else. If you have read this far, you already know something is broken. The rest of this article shows you what replaces it.

Read more

Before the paywall drops, let me tell you what waits on the other side.

I will show you why the industry’s triumphal story is only half true, and why that half-truth is precisely what makes the moment so dangerous. I will separate surface hallucinations from deep hallucinations and show you why that distinction changes everything: how we measure progress, how we should think about AI risk, and why so many intelligent people are misreading what the current generation of models can and cannot do.

Then I will take you into the mathematics. Not vague opinion. Not futurist fog. The actual geometry of the problem. You will see why benchmark gains can keep rising while real progress bends, why the hidden wall is real, why the cost of pushing deeper grows much faster than the industry admits, and why paradoxically, even in its structurally broken state, AI is already strong enough to threaten elite work.

And then comes the part that matters most. I will show you where the machine still breaks, why those breaks are not random, and how those fault lines already sketch a professional map for mathematicians, developers, engineers, lawyers, researchers, and anyone whose work depends on structure rather than surface fluency.

In other words: on the other side of this paywall is not another AI article. It is an autopsy, a warning, and, if you are paying attention, a map.

Read more

A month ago I published Anthropic Is Killing Bitcoin. The rebuttals came fast. Exaggerated, they said. Alarmist. Irresponsible…you name it.

Then the evidence started arriving and not precise in in trickles. but in avalanches as you can check in the table below.

The evidence is not ambiguous. When the financial world, the most demanding, most unforgiving sector on earth, starts being reshaped by a technology, the experimental phase is over. Not winding down. Over. The consequences for your life and your job are already in motion whether you have accepted them or not.

And we do not mean just any corner of finance, but the business core that built its entire identity on eliminating middlemen, on offering an alternative to every convoluted, unfriendly, third-party financial provider in existence: the cryptocurrency universe. The one that promised to replace the old system, and is now being replaced itself. Its clay feet were always the wallets.

While I was writing about crypto dying, the replacement was already being built. Coinbase shipped autonomous AI wallets in February. Not a prototype. A protocol: x402, with 50 million transactions and Stripe already integrated. One month later, Sam Altman’s World project plugged human identity verification into the same pipes. Then Visa launched its Trusted Agent Protocol. Then Mastercard completed Europe’s first live AI-agent bank payment inside Santander’s infrastructure. In weeks, not years.

So the skeptics were wrong about the diagnosis. But I was wrong too. I was not pessimistic enough. 🤔

These are not experiments, these are production systems, and the largest payment companies on earth are racing to give AI agents wallets loaded with real money and full authority to transact on their own. The age of the human-operated wallet is not ending someday; it is ending now

You don’t believe me? Look at the numbers yourself: they tell exactly the same story. Crypto is losing its builders, its capital, and its price floor in the same twelve months that AI wallet infrastructure is exploding. One world is fading while the other is being born inside it.

What you just read is the autopsy. What follows is the surgery.

Never-seen-before animations show what no AI wallet whitepaper ever has: why flat space kills your money, and how a new geometry survives the same crash, frame by frame, in cinematic detail.

Subscribe to read the rest.

Read more

Google and OpenAI just made their last call. You will not hear that in a press conference, obviously. But read the architecture notes — here and here — behind their latest LLMs and the message is right there.

And guess what. They are still betting on the same trick they have been betting on for two years. You have probably already heard the names: inference-time compute scaling — chain-of-thought, tree search, reward-model verification.

If that is not enough, let it explore more branches. If that still is not enough, make it generate more intermediate tokens, score more candidate answers, verify more paths, and keep burning compute until the right answer finally appears.

That is where the quarter trillion goes.

15 models in 16 months is proof enough that something is rotten, and the smell is not coming from Denmark. 🙄

Look at the chart below: green for OpenAI, gold for Google. Each launch comes wrapped in marketing rhetoric. Each model is sold as a leap, yet under the hood it does the same thing as the last: thinking longer, searching harder, hallucinating more, and burning more money at inference time

Repeating the Same AI Seasons — and the Same AI Winters

The cracks are already visible. But to see them clearly, you need the wider frame… because without it, the present moment looks far more original than it actually is.

What the industry now calls inference-time compute scaling — chain-of-thought, tree search, reward verification — is a bundle of ideas from the 1940s and 1950s, repackaged under cleaner labels and sold back to you as a revolution.

The trick has worked before. More than once.

The two animations below compress roughly eighty years of AI history into a single recurring cycle. Once you see the rhythm, you will not be able to unsee it. AI does not advance in a straight line. It moves by seasons:

Breakthrough.
Explosion.
Limits exposed.
AI Winter.
Then the cycle begins again.

Watch the pattern unfold: from McCulloch and Pitts’ binary neuron in 1943, through the perceptron boom and the first AI winter, to the return of backpropagation, the second AI winter, and finally the deep-learning explosion that seemed — for a while — to have broken the loop for good.

But, infortunately It hadn’t

Now zoom into the moment that fooled everyone.

In 1969, Minsky and Papert proved that a single-layer perceptron could not solve even a basic XOR problem — one straight line cannot separate what needs separating. That critique helped trigger the first AI winter.

Then in 1986, Rumelhart, Hinton, and Williams showed the escape route: add a hidden layer, make it trainable through backpropagation, and the network can combine several straight cuts into a non-linear decision boundary.

The XOR problem was solved. The field celebrated. But here is the part nobody talked about at the celebration: backpropagation did not bend the space. It just learned to make more cuts inside the same flat geometry. The geometry never changed. Only the bill did.

Now watch the animation… you can see it clearly: backpropagation escapes the perceptron’s old XOR trap not by bending the geometry, but by learning enough straight cuts

The XOR problem was solved. But the cycle did not end there.

This is where the free ride ends. Everything above was only the runway. Below is where the real argument begins — with animations, diagrams, and peer-reviewed mathematics showing why Google and OpenAI’s reasoning push still runs on old search-era machinery, why models often hallucinate more as inference grows longer, and why Anthropic’s own technical trail keeps circling the same conclusion: the geometry underneath today’s AI is fundamentally wrong.

Subscribe now. No marketing BS. Just the math, the architecture, and the failure analysis — before everyone else catches on.

Read more

The New AI Land Nobody Saw Coming

While the rest of the AI industry spent the last three years in an arms race over who could build the best chatbot Anthropic was doing something very different.

They were building infrastructure.

Not a better LLM. Not a flashier chat interface. They flipped the revenue model inside out — 85% API, 15% chatbot — and built the plumbing underneath. So quietly that most of the industry didn’t realize what it was looking at until it was already running in production.

For years, Anthropic was seen as the company that couldn’t compete with ChatGPT, too niche, too expensive, too cautious, too obsessed with safety to matter. A second-tier chatbot maker losing the consumer war.

But nobody asked the obvious question: why would a losing company spend its time building governance frameworks, open protocols, and multi-cloud settlement rings instead of chasing subscriptions?

Because Anthropic wasn’t playing the chatbot game.

It was building something underneath it: something designed to make the chatbot game itself irrelevant. Meanwhile, OpenAI and Google kept squeezing a dried lemon: wringing the last performance gains out of the LLM paradigm and chasing diminishing returns.

So let me show you how Anthropic began to win the AI race and why you should care about it.

In fact, by the end of this article, you’ll understand why those moves are already changing the structure of the AI industry — and why those who recognize it early hold the best position in the global AI shift now underway.

The golden age of the LLM paradigm is over, the ground has already moved beneath it. You’ll see for yourself, from the solid arguments laid out in this article.

I’ll start by summing up Anthropic’s recent strategy in just six moves that that caught everyone off guard — and almost everybody completely misread. Not anymore for you.

Read the middle column first, then the right:

Anthropic Has Already Won the Game

Those six moves expose something most people still miss: the LLM was one piece. Not the centerpiece. Anthropic’s main focus has never been Claude the chatbot: it’s the AI infrastructure on which the future of AI runs, well beyond those fancy chat windows.

And that AI infrastructure is, at its core, a transaction infrastructure. You’ll see why this kind of infrastructure is crucial for the success and evolution of the true strong, trustable AI that we still don’t have.

To start realizing its importance, take history as an example: every technology that outlasted its hype cycle did it the same way. The internet was real in 1999 and still crashed… not because the technology failed, but because there was no infrastructure to settle value autonomously. It recovered only after transaction layers made value flow without a human in the middle.

And now with this novel AI infrastucture we are heading exactly to that spot right now. You can check it yourself: The models work. The capabilities are genuine.

Behind the paywall: The first global AI currency. The three degeneracies hiding inside every neural network alive — including Claude. A theorem from 1876 that proves your neurons have been crippled. The exact geometry that fixes it. Anthropic's own papers proving they're already looking for it. And why their infrastructure is one layer away from something nobody else has seen coming. Subscribe now and dont skip what brings you a unique advantage in the AI race

Read more

The Dawn of the Total Machine Economy

We are at the beginning of the total-machine economy — and you’re holding the wrong money.

You’re about to see a shift most people in crypto and AI are still missing.

While you’ve been watching Bitcoin prices and AI hype cycles, one company has been assembling financial infrastructure that operates beyond the architectural limits of Bitcoin, Ethereum, and everything else in the current crypto stack.

And yet most people around us don’t notice what’s happening. This revolution isn’t as loud as the ones before: it’s unfolding more quietly than that. Racks of machines coming online, one data center at a time. We’re still in the early stage but the growth is exponential — which is exactly why it’s so easy to miss.

What that looks like in practice takes about three seconds to understand. Just watch the animation below:

But this animation shows only the surface. Here’s the part that should worry every Bitcoin holder:

You’ve already been using this currency without realizing it.

This isn’t a currency that’s coming. It’s already running: processing billions in value daily, secured by physical infrastructure, priced and settled in real time.

At some point, someone will formalize it into an explicit AI coin — but by then, the early-adopter window will already be closed.

Let me show you how it reframes everything.

THE EXODUS

Let’s start by following the money as GPS to show us where the future will be: between cryptocurrency country roads and the new AI multi-infrastructure heavy highways.

TL;DR: Money is escaping the cryptocoin hype faster than it entered years ago. The promises of an economy built on cryptocoins never materialize; and in the meantime, new tech has already begun turning the entire crypto landscape into tech archaeology.

Don’t believe me? Then let me show you two charts that tell the whole story.

The Crossover

Look at these two charts below together. They’re telling the same story from opposite ends.

At the bottom: AI is swallowing everything else. In just two years, it moved from a quarter to half of all global venture funding. Half of every investment dollar on earth now flows into AI, while fintech, crypto, biotech, and SaaS fight over the scraps. And the trajectory shows no sign of slowing down.

At the top: the physical evacuation. Bitcoin miners are watching their revenue share collapse in real time. That crossover point on the chart isn’t decorative — it marks the exact moment when AI compute contracts became more valuable than Bitcoin mining on the very same hardware. Same racks. Same cooling systems. Same electricity bills… but taken over by AI guys paying more.

One chart shows where the capital is going. The other shows where it’s coming from. These aren’t two trends: it’s one migration, captured from both ends.

The capital didn’t disappear. It changed industries.

The Contracts and The Hedge

The first two charts showed you the flow. Now let me show you the receipts.

These aren’t projections. These are signed contracts — the names and amounts are in the chart below. What should stop you cold is who signed them: companies that used to mine Bitcoin, now locking themselves into AI infrastructure deals that stretch a decade or more.

These aren’t hedges. This is the exodus — the moment the people who built crypto started buying their tickets out of it.

And the bottom Figure 3 reveals something the contracts alone can’t tell you: where this is heading. The funding ratio between AI and crypto isn’t just wide — it’s widening. Every quarter, the gap grows. Project that curve forward two years and crypto venture funding doesn’t shrink gradually. It becomes an investment anecdote.

Now the betrayal is becoming explicit. Pantera Capital — the first US institutional fund built exclusively on blockchain: is pouring hundreds of millions into AI. Bloomberg reported that crypto VC funds are actively shifting away from tokens.

The people who built their careers on crypto are quietly moving their chips to the other table. When insiders build lifeboats with their own money, that’s not a cycle, it’s the end of the explosive cryptocoin Cambrian era.

Bye bye BTC

Still not convinced? Fair enough. Now let me show you why the money is leaving.

Imagine you own a data center. You’ve been renting it to Bitcoin miners for years. Then some AI investor guy walks in and offers you a decade-long lease at margins that make your crypto tenants look like they’ve been paying in loose change. A hyperscaler’s signature on a contract that prints money for fifteen years.

Which tenant do you keep?

That’s not a thought experiment. That’s what’s happening right now across every major mining operation on earth. And here’s what nobody’s talking about: they’ll still mint a new kind of coin — an AI-native one — pretty soon, while profiting from the infrastructure that makes all of AI run.

How? That’s what comes next.

You have read 20% of this article.

Behind the paywall: The autopsy of crypto’s last argument — and why AI already won. The four pillars that make Anthropic’s infrastructure a functioning currency. A one-to-one mathematical mapping you can’t unsee. The flywheel animation showing why this machine is unstoppable. The new AI Economy Stack. The protocol layer Bitcoin spent fifteen years failing to build. The four engineering gaps still left to close… and more…

The charts and animations in Part 2 are the ones you’ll want to screenshot.

This is where the math and tech gets interesting.

Read more

You Don’t Know How to Code with AI And the method that works is the exact opposite of what you’ve been taught

Vibe coding had its moment.

Around 2023, it felt almost magical. You described a problem in natural language, the AI answered with confident-looking code, and for a brief window it seemed like software development had finally been abstracted away. Business idea in, working system out — the dream of tech managers wanting to get rid of what they regarded as annoying developers. Easy peasy!

Then you got screwed. Wasted.

Not because you’ve been lazy. Not because your prompts aren’t clever enough. But because current AI systems cannot take a real business idea (messy requirements, edge cases, implicit constraints) and produce code that actually works.

What replaced the dream of your CEO is worse: a workflow that defeats itself.

Those upper layers in your tech company didn’t recognize it, but you did immediately, because you work with it daily.

You prompt. The AI generates code that looks fine — deep waters look still — sometimes even elegant. But the CEO isn’t beside you when you run it.

However, a closer look shows you the bad side of AI-generated code: the errors aren’t localized, they aren’t clustered . They’re scattered across the codebase. Innocent-looking lines sit next to logic traps, clean abstractions hide dangerous assumptions, and mixed in with harmless bugs you find code that isn’t just wrong but actively dangerous: security holes, data corruption paths, failure modes you would never have written yourself.

Congrats. You’ve run into what’s called semantic drift — and if you’re not a developer, here’s what the visual nightmare looks like:

You ask your AI copilot to fix a Module not found error and cool, the code runs now. Except — wait — now it’s Method undefined because the AI just made up an API that doesn’t exist. You ask the copilot to fix that, and suddenly SQL injection pops up because the AI built the query with string concatenation like it’s the early 2000s. You ask it to fix that too, and now you’ve got Token never expires, wow a security hole, wide open!

You close the copilot. You fix it yourself.

Your copilot isn’t stupid. It’s trapped. Current LLMs operate in flat embedding spaces where every direction costs the same( yeah, including the wrong ones). The path from working function to SQL injection nightmare costs exactly as much as the path to correct code: nothing. The model has no geometric reason to prefer one over the other. So it drifts. And you end up chasing after it.

That’s not an AI problem.
That’s a map problem.
The good news? maps can be redrawn.

And that’s exactly what we’re going to do, in a much easier way than the AI industry keeps patching without fixing the problem.

No, we don’t need to rebuild the AI from scratch, or fine-tune it, and much less throw more parameters at it. We’re going to change the terrain it walks on: give it a geometry where drifting toward bugs costs more than drifting toward correct code.

Same model and same infrastructure — but here’s the catch you need to pay attention to: we’ll use a different space where the AI operates and lives.

The Geometry That Actually Works

The solution? A curved toroidal space — the simplest geometry that gives us what we need: periodic structure and a well-defined notion of distance. On top of it, we place a Lyapunov energy landscape. Together, they let an AI copilot see a proper map: one where the path toward correct code is downhill in energy, and the path toward bugs is uphill.

And here's the surprise: Anthropic is taking notes — to the point of publishing research on curved manifolds inside Claude itself.

Note: In January 2026, Anthropic published When Models Manipulate Manifolds, showing that Claude represents information on curved manifolds with geometric transformations. They found the geometry. They’re observing it. What they haven’t done yet is engineer it — deliberately curving the space to make error paths expensive. That’s the lens we’re building here.

Yep, these are the same three error pairs we saw in the flat-space example earlier. The only change is the geometry: once we move to a curved space, the cost structure becomes visible… and the difference is impossible to miss.

Below: the equations, the architecture, and the cost breakdown. For paid subscribers.

Read more

TL;DR for the impatient:

1. Your intuition evolved for objects. However, AI is not an object. It’s a field.

2. Category theory looks rigorous but misses geometry. Algebra without metric is blind. cannot see failure modes.

3. Hallucinations are not bugs. They’re broken invariants in flat space.

4. Stop measuring accuracy. Errors have shape start measuring error structure instead.

5. Scale does not fix structure but amplifies whatever geometry you have. Flat geometry scales into nonsense.

6. Intelligence is geometric.If you don’t have structure, you don’t get intelligence. End of story.

Even the Best AI Engineers Keep Making the Same Mistake

Human brains evolved to track rocks, tools, animals, faces — things with edges. Things that push other things. This served us well for hundreds of thousands of years.

And most of us are still using that intuition in the wrong way for science and technology, including how we think about AI. Even highly skilled engineers are doing the same thing: trying to force square pegs into round holes, then failing to understand the errors in the AI systems they build.

This mismatch between intuition and science is not new.

Take, for example, the history of physics: heat, fluids, and turbulence looked like magic for centuries because we tried to understand them as things — substances that moved, pushed, and accumulated. But then we discovered that the interesting stuff doesn’t work that way and abandoned that picture of objects and things (see Figure 1 above).
Heat became a field.
Pressure stopped being a force you could point at and became a constraint in an equation.
Motion was no longer tracked object by object, but as transformations of a state distributed across space and time.

They are values distributed across space, constrained globally, governed locally. The moment we needed partial differential equations, our stone-age intuitions became a liability.

Paradoxically, even among most educated people is rare to find who have made this jump, you know, because of how we get through the educational system: by memorizing rote formulas and pattern-matching exam questions. That didn’t help our intuition fit reality. On the contrary, intuition for many educated folks stays broken, and curiously enough, it doesn’t matter for most jobs 🤔

But the few who did their homework right, they know that once that shift happened, the mystery vanished. The equations didn’t get simpler, but the intuition finally matched the phenomenon.

AI is now forcing the same adjustment, whether we are ready for it or not

AI Is Not a Thing That Thinks

This habit of seeing objects everywhere is deeply ingrained in most minds— even engineers’, which should come as no surprise given what we have already discussed.

Object-based intuition gets people into trouble — not just in programming (OOP) 😉. A neural network is imagined as a box: data goes in, stored knowledge is consulted, reasoning happens, and answers come out (see Figure 2, diagram 1).

This picture is wrong in every way that matters.

A neural network isn’t a container at all, it’s a state space, a geometry — and meaning doesn’t live inside the tokens or the weights the way we imagine it does.

It lives in the structure of transitions between states. The knowledge you think must be stored somewhere? You won’t find it anywhere you can point to, because it’s implicit in the shape of the manifold itself (see Figure 2 below, diagram 3).

Get this wrong, and you’ll spend years debugging the wrong AI. No surprise here, this pattern repeats in every new release of ChatGPT, Claude, Gemini, Grok. You name it: new patches, the same problems remain.

Mathematicians Are Also Wrong — Even with Category Theory

I know several mathematicians in AI who swear by category theory as the answer to nearly every AI failure… and they’re not fools. They may not be funny, social, or charismatic, but they are among the smartest people I know. Of course, they’ve seen the mess that passes for “theory” in most machine-learning papers — a mess we’ve already analyzed in previous posts:

• Ad hoc architectures justified by vibes.

• Vague claims about generalization that nobody can pin down.

• Benchmarks that prove nothing except that someone got lucky on a test set.

So, naturally, my mathematician friends tend to view category theory as a cleaner alternative (see Figure 2 above, diagram 2). Many of you know exactly what I mean, because a category in math is, after all, a precise combination of :

1. Objects as second-class citizens, understood primarily through how they participate in relationships.

2. Morphisms with composition and identities as first-class citizens, the structure-preserving transformations that do the real work.

3. Functors mapping between categories of representation spaces.

4. Commutative diagrams that actually mean something: statements you can write down and prove.

What follows is the technical depth. Available now for paid subscribers, free for everyone in 72 hours.

Yep, most of us agree: Category Theory at least forces you to ask the real questions: what structure is actually being preserved here? What transformations are legitimate? When can we say two architectures are genuinely equivalent and not just superficially similar?

But here’s the blunder — better than most is not the same as sufficient.

Category theory is algebra, not geometry, and that distinction matters more than most people realize. It tells you when two architectures compute the same function class, how transformations compose, which diagrams commute. So, pure computation? Yeah, that’s the pick any programmer could say. And therefore, due to its purely computational algebraic nature, category theory — the algebra at the core of our current AI — cannot tell you what any path through the network actually costs: there’s no metric baked in, no notion of distance, no way to distinguish a cheap transition from an expensive one or a safe region from a dangerous one.

So in the end, you still end up with AI hallucinations, even when using category theory.

Take this as a paradigmatic example: two networks can be categorically identical: same objects, same arrows, every diagram commuting exactly as it should, and yet one hallucinates constantly while the other produces reliable outputs (see Figure 4).

This is worth emphasizing: computational algebra (category theory) simply can’t see the difference. As long as composition, identity, and associativity hold, two neural networks can behave very differently and still look equivalent on paper. The morphisms compose, the functors preserve structure. And yet one works and the other doesn’t — and category theory has no way to explain why.

What Category Theory Gets Right (And Why It’s Still Not Enough)

To be fair, category theory does get one thing genuinely right — memorize this apparently innocent common word, because it is of crucial importance: naturality.

A construction is natural if it doesn’t depend on arbitrary choices — and this matters more than it might sound. Permute the hidden units? Same object. Reparameterize the weights? Same object. Change basis? Same object. If your “intelligence” disappears the moment you change coordinates, it was never intelligence in the first place. It was a coincidence in one particular basis, a mirage that evaporates when you look at it from a different angle.

But here’s the problem: naturality without geometry is like having a map with no scale. You know which cities are connected. You have no idea how far apart they are. You can prove that two routes are equivalent, but you can’t tell which one goes through a mountain range and which one follows the coast. The algebra guarantees they end up at the same destination — the geometry determines whether you arrive exhausted or refreshed, whether the journey takes an hour or a week, whether you survive at all (see Figure 5, below).

Patching OpenAI, Anthropic, Google, and Grok Won’t Fix Hallucinations — It Just Buries Them Deeper

By now, it should be clear that patching AI with the same wrong math doesn’t fix anything: it just makes the failures harder to see.

And despite all this evidence, the industry keeps chasing the same AI gold-rush dream: better data, tighter RLHF(reinforcement learning from human feedback), more guardrails, constitutional constraints — you know, whatever happens to be fashionable this quarter. Some of it helps a little. Mostly, it’s symptom-patching dressed up as progress, while the real problem stays exactly where it is.

Yep, those one involved unfortunately in that AI industry dynamic agree: the patches are making the disease harder to diagnose: for instance, RLHF makes models better at convincing humans they are correct — even when they’re wrong. The approval rate goes up, but the correctness rate doesn’t follow. Many failures simply weren’t expected, they passed internal safety checks without being noticed.

In other words, every new patch makes the model sound more fluent, more confident, more persuasive. The errors don’t go away… they just get buried deeper.

Here’s what hallucinations actually are, and it’s not what most people think.

They’re not lies. The model isn’t being lazy, rebellious, or confused about what you wanted. Hallucinations happen when the geometry of the embedding space doesn’t enforce meaning, as we saw in the previous section. Once you see it that way, it becomes clear why the usual fixes don’t work.

Think about it spatially for a moment. In whatever high-dimensional space the model uses to represent concepts, “dog” and “wolf” should live close to each other — they’re related, they share features, contexts where one appears often admit the other. Meanwhile, “dog” and “justice” should be far apart, because semantically they have almost nothing to do with each other. So far so good.

But this is where things really fall apart. In a flat Euclidean space, nothing stops a path from wandering through arbitrary points on its way from one concept to another. You can go from “dog” to “justice” in a straight line, and every step costs exactly the same. The metric doesn’t care that you’re moving through semantic nonsense. Every direction is allowed. Every transition is cheap. The space itself has no opinion about meaning.

And here’s the nasty part we run into over and over again: you try to correct your AI chat’s output, and it just ignores you. When you tell the model that was wrong, you’re penalizing a specific output, not reshaping the geometry that produced it.

The underlying space is still flat. The model can’t reason about the path it took — only the output. As a result, it either repeats the mistake or fails in a slightly different way next time. The root cause is unchanged.

At this point, there’s no need to ask what a hallucination is, geometrically. You already have the right intuition: it’s the model taking a path it should never have been able to take — if the geometry were right.

Yep, in a flat space, nothing prevents that. The model can move between unrelated concepts at no extra cost, because the space itself doesn’t say this path is wrong. Every direction looks equally valid.

With the right geometry, those shortcuts wouldn’t exist. The shape of the space would make nonsense paths expensive or impossible.

That’s also why the usual fixes don’t work. More data just fills the same flat space. More scale just repeats the same structure at higher resolution. These errors aren’t glitches: they’re consequences of how the space is built.

And yet — this is exactly where the industry is doubling down.

Scale Makes It Worse

Right now, the industry’s big bet( hundreds of billions of dollars’ worth) is that scale fixes everything. Ok we are already suffering more bloating LLMs: More parameters. More data. More compute, with the hope that continued scaling will make the problems go away.

That’s the wrong kind of linear thinking applied to a nonlinear system.

If the geometry is flat, scaling doesn’t fix anything; it just makes the problem bigger. You give the model more parameters to express the same broken structure at higher resolution. The hallucinations don’t vanish; they just sound smoother and more convincingly, but still wrong. The spaghetti gets longer. It doesn’t get straighter.

Summing Up

Physics learned this lesson the hard way: reality doesn’t care about your intuitions. It runs on constraints, invariants, and geometry. When physicists stopped thinking of heat as a substance and started treating it as a field, thermodynamics suddenly made sense. The mystery didn’t vanish because they got smarter — it vanished because their intuition finally matched the structure of the phenomenon.

AI is the same lesson, playing out again right now. The future isn’t bigger models. It’s models with the right geometry.

Not more data, but more structure.

Better intuitions, grounded in the right mathematics.

As this story has shown, intelligence isn’t something a system slowly accumulates through training. It’s something the geometry either allows or forbids.

Without structure, AI doesn’t gain intelligence. It gains cognitive trickery — something that becomes nastier and more disappointing with every new release. It’s time to play the right math game.

First, thank you.

In just a few months, A Mathematician Lurking in the Tech Underworld has grown to several hundred free subscribers—readers, commenters, and people who share the work.

That growth came with no marketing budget, no algorithm hacks, and no corporate backing.

It came from applying serious mathematics to the hardest problems in AI—and making those ideas accessible beyond a closed circle of private research dominated by a small technical elite.

Today I’m launching paid subscriptions. Here’s exactly how it works:

What stays free

• Every article’s core argument.

• The diagnosis.

• The what and the why.

If your goal is to understand what is broken in AI’s mathematical foundations—and how it can be fixed with the right mathematical and engineering tools—the free posts give you that, fully and openly.

What’s behind the paywall

The how.

How to apply the right mathematics and engineering to solve real AI problems—not just to understand them, but to fix them in production:

• Implementation insights for real production systems

• Code and algorithms

• Technical notes as they are developed—unfinished, exploratory, honest

• Priority responses to technical questions

This is the depth engineers need to actually apply these ideas, not just agree with them.

The price

$5/month or $50/year.

Many engineers expense technical publications through their company’s learning budget.

If that’s you, this is mathematics that may save your team from committing to the wrong AI architecture.

Founding members — $150/year

• Personalized, in-depth responses to your technical questions

• Named acknowledgment as a founding supporter of this research

Why this structure

I want the ideas to spread. Free readers get the full argument.

But turning ideas into working systems takes deeper work: original research, real implementations, code, and sustained technical exploration.

That work is what paid subscriptions make possible, and what paid subscribers gain access to.

Subscriptions keep this research independent.

No sponsors.
No institutional filters.
No pressure to soften the critique.

— Jose Crespo, PhD A Mathematician Lurking in The Tech Underworld

TL;DR (read this in 30 seconds)

• Today’s LLMs store meaning in flat space (vectors). Flat space lets the model slide between nearby ideas too easily. That’s one reason it drifts and hallucinates.

• The main solution to fragmentation is building a so-called unified map of meaning. Based on the currently developing AI toroid geometry, the most obvious and simplest solution is to use, inside the toroid, solenoid-style geometry that naturally combines:
  (1) Memory phase (where we are in a thought loop),
  (2) Taxonomy (what branch of meaning we’re in), and
  (3) Path-dependence (the path you took changes what you know next).

• The math object is real; the AI claim is a testable hypothesis.

• The development of this simplified technology will accelerate the evolution of today’s frustrating, limiting AI to the next level — the basic requirement for solid AGI: representation where semantic drift becomes expensive by design, not “fixed later by patches.”

Three concepts. You probably know them by different names

As Figure 1 shows, current AI treats these three concepts as separate engineering problems:
- different modules
- different geometries
- different code

Memory

Not RAM. We mean: what the model is currently carrying forward from the conversation. The cyan card in Figure 1— that circular arrow represents state that persists between turns. Current AI stores this as flat vectors. No phase. No structure. Just activation strength that fades.

Taxonomy

A fancy word for category tree.
Animal → cat → Persian cat.
Company → Apple → CEO → current CEO.
The purple card, that branching structure. Current AI handles this with hyperbolic geometry (Poincaré embeddings), completely separate from the memory system. Bolted on. Not unified.

Holonomy / path-dependence

Another fancy word for something you, if you’re a software developer, already know from debugging:

How you got here changes what happens next.

Same endpoint. Different route. Different state.

The orange card in Figure 1 shows it: two paths arrive at the same point, but they carry different histories. In LLM land: two chats can end with the same final question, but if one route wandered through Musk / SpaceX earlier, the model’s next answer can drift. Current AI? It ignores this entirely. No path memory. Just final position.

Memory. Taxonomy. Path-dependence. Current AI treats them as three separate engineering problems. That’s the mistake.

Look at Figure 1 one more time. Three cards. Three colors. Three separate systems. That fragmentation is the disease. The solenoid, added to the familiar toroidal geometry, is the cure.

The Geometry That Broke AI

Most LLMs store meaning as points in a huge vector space, like R^4096.

That sounds sophisticated. It is.
But it’s also… flat.

And flatness has a hidden cost:

• In flat space, “nearby” often means “shares features,” not “is the same thing.”

• In flat space, you can slide from one cluster to another without crossing a clear boundary.

Flat space is too permissive.

That’s the thesis.

Not LLMs are dumb.
Not training data is bad.
The map is wrong.

Three failures of Flatland (use your programmer intuition)

Look at Figure 2. Three cards, three bugs you already know — even if you’ve never heard them described this way.

1) Collision (name clashes)

See the first card: two circles labeled river and money overlapping in the middle, with a confused “?” where they meet.

Bank = riverbank vs bank = finance.

In flat embeddings, those meanings drift close because the surrounding text patterns overlap. Rivers have banks. Money goes in banks. The word appears in similar sentence structures. So the vectors converge.

The model keeps guessing: which bank did you mean?

Translation: it’s doing runtime inference on every occurrence because the representation didn’t hard-separate the branches. The red overlap zone in Figure 2— that’s where your model lives, perpetually confused.

2) Spaghettification (state contamination)

The middle card shows it: a path that starts cyan (cooking), gets contaminated by nuclear, and ends red (physics?!).

You’re talking about cooking. Someone says nuclear family. Now the word nuclear is activated in the representation, not because you wanted it, but because it appeared.

Later, the model is one weak anchor away from drifting into nuclear physics🤪

Translation: the internal trajectory is like a messy global variable.

Once something enters the state, it can leak anywhere. The tangled line in Figure 2 isn’t artistic license: it’s what attention patterns actually look like when context bleeds across topics.

3) Hallucination zones (illegal intermediate states)

The third card makes it visual: two green checkmarks (valid ideas) connected by a path, but the middle is filled with red X marks (word salad).

Between two coherent ideas in flat space, there are countless in-between points that decode to nonsense.

Flat space says: Totally fine… it’s just linear interpolation.

Language says: Word salad.

That is hallucination geometry: legal movement through illegal meaning. The green endpoints in Figure 2 are real thoughts.
The red zone between them? That’s where hallucinations live.

And flat space has no fence keeping the model out.

The killer line at the bottom of Figure 2 says it all:

Flat space is too permissive. Not LLMs are dumb. Not training data is bad. The map is wrong.

These aren’t three separate bugs. They’re three symptoms of the same geometric disease: The typical flat, projected, multidimensional ℝ⁴⁰⁹⁶ doesn’t encode the constraints that language enforces. The space permits what meaning forbids.

The Extended Torus as an Alternative to AI Flat Space: Two Dials, One Surface

We previously proposed, together with other researchers, representing conversation memory on a torus: basically a donut shape.

You don’t need topology to get the point — see Figure 3 above. Just imagine two circular dials:

• Dial A: reasoning phase (where we are in a thought loop)

• Dial B: topic phase (which thread we’re currently on)

This matters because a torus gives you something flat space doesn’t: phase + repetition.

In flat space (which is what every current LLM uses) visiting the same region three times just makes the activation stronger. A bigger number. That’s it.

The geometry doesn’t know you came back. It doesn’t count loops.

This is why LLMs lose track. You can repeat a constraint five times in a prompt, and the model treats it as seems important, not stated five times, violated zero times. There’s no counter. Just weight.

On a torus, the geometry records when you loop back. That’s called a winding number: an integer that counts completed cycles.
Visit once? n=1.
Three times? n=3.

And unlike activation weights, this number can’t drift.

Why? Because it’s an integer, not a floating-point score. You can’t half-complete a loop.
You can’t slide from 3 to 2.7 to 2.
The winding number is what mathematicians call a topological invariant — a quantity unchanged by continuous deformation: Wiggle the path, stretch it, compress it, as long as you don’t cut it, the count stays fixed.

Integers are immune to drift. Floats aren’t.

Think about the difference:

The user has circled back to budget constraints 4 times → a fact

Budget seems important → a vibe

Current LLMs give you vibes. The torus gives you counts.

Repetition becomes structure, not just emphasis. But the torus is incomplete: it tracks where you are in the loop, not which branch you’re on. That missing piece is taxonomy.

The missing piece: how do we encode “branches”?

Phase answers: where am I in the loop?
But taxonomy asks: which branch am I even in?

Persian cat isn’t just cat with more features.
It’s cat → subtype.

The core issue: A good system should make it costly to jump from one identity branch to another unless the text truly demands it.

Flat space doesn’t.

So we need a geometry where branches are native.

The Solenoid: a donut with infinite nested depth

This is a candidate shape for unifying a fragmented AI.

Today’s language models don’t live inside one clean geometry.

They juggle half-separate spaces for memory, categories, and reasoning state, then stitch them together with heuristics inside a similarity space that behaves mostly flat (dot products, cosine, smooth interpolation).

A solenoid offers a different move: one compact geometry that carries three things at once, simply because of how it’s built (nested windings), not because we glued three modules together.

• Phase: a built-in clock hand — where you are in the loop. (memory)

• Branch: a built-in address — which track you’re on, and how deep. (classification/taxonomy)

• Path: a built-in trip memory — how you got there still matters. (holonomy)

That coupling is the point: in a solenoid, cycle position and branch identity are not separate add-ons. They come as a package.

And that changes hallucinations.

It won’t abolish them in some absolute, philosophical sense. But it can kill the most common ones, the drift driven by collisions (different meanings sharing the same neighborhood) and spaghettification (too many near-parallel routes you can hop between for free).

In flat similarity space, branch switching is cheap: nearby is nearby, even when it’s the wrong nearby.

In a solenoid-like metric, branch identity and depth become part of distance. The deeper you commit, the more expensive it is to leave — not as a bolted-on penalty, but as a property of the geometry.

Watch the construction, it’s concrete, not a metaphor. A circle thickens into a torus; a winding wraps it; then a smaller wound copy nests inside; repeat… and the infinite limit is the solenoid. Every step is a concrete geometric operation. And the limit is precisely the kind of space where cycle position, branch address, and path-dependent state live together.

Now we’re on solid ground.
Not because this is mystical… because it’s structural.

The solenoid doesn’t give you a new trick.
It gives you a single representation where the three missing ingredients stop living in separate boxes:

phase (where you are),

branch (which meaning-track you’re on),

path-dependence (how you got there).

One object. One metric. One state.

The secret math hack behind the solenoid: the p-adic address.

Inside this solenoid story lives Zp​, the p-adic integers.

A p-adic number is like an infinite base-p digit string:

a0​,a1​,a2​,a3​,…

Read it as a path down a tree:

• a0​ chooses the main branch

• a1​ chooses the sub-branch

• a2​ refines again

And the distance between two addresses is basically:

How long do they share the same prefix before splitting?

Same first 5 digits? Very close.
Different first digit? Far.

That is taxonomy as an address system. No approximate tree embedding.
The tree behavior is built in.

A p=3 tree example:

Why This Could Reduce Drift (Bezos vs Musk Example)

CAT vs BEZOS? Trivial — first-digit split, maximally far.

Bezos vs Musk is harder. Same features: billionaire, tech founder, space company, media presence. Their vectors practically overlap.

So the model can silently slide:

Bezos → space company → Musk.

No alarm. No signal. Just a quiet interpolation through feature space. The model doesn’t know it changed subjects. It just… drifted.

Now watch what happens in a taxonomic address space.

Bezos and Musk are siblings — children of the same parent branch:

TECH BILLIONAIRE
    ├── BEZOS → Blue Origin
    └── MUSK  → SpaceX

They share a long prefix. They’re close. But they’re not the same node.

You can move between them — but it costs a branch change. You have to go up to the parent, then down to the sibling. That traversal is recorded. That cost becomes a signal.

So the model is less likely to drift unless the prompt demands a subject switch.

Flat space hides the switch. Taxonomy exposes it.

The GIF below shows the final branches where Bezos and Musk compete for attention:

How Attention Uses the Solenoid

Figure 6 makes this concrete. Normal transformers ask one question: How similar is this token to that token?

You can keep that exact mechanism. You don’t rewrite the architecture. You just change what similar means.

Instead of dot product in ℝⁿ — which measures feature overlap — use a score that respects both the phase cycle and the taxonomic tree that the solenoid carries:

That’s it.

You don’t need to call it a Mercer kernel. You don’t need RKHS theory. You don’t need a PhD in functional analysis. For attention, you only need a scoring function that respects the solenoid’s structure.

And because phase and taxonomy live in the same geometry (not two spaces glued together) the score is natural.
You’re not reconciling incompatible distance metrics.

You’re measuring distance in one unified space (our familiar toroid geometry ) that already encodes both where am I in the reasoning cycle? and which branch of meaning am I on?

The design goal is simple:

Make incoherent jumps expensive. Make coherent continuation cheap.

The geometry does the rest.

Why Unification Is the Key

AGI isn’t a bigger LLM. It’s not more parameters, more data, more RLHF. Those are necessary but not sufficient.

AGI requires a unified representation: one where memory, meaning, and reasoning aren’t stitched together after the fact, but emerge from the same underlying structure.

The solenoid offers exactly this:

• One geometry (not three bolted-together modules)

• One space where phase, taxonomy, and path-dependence coexist

• One representation where the failures that plague current AI become geometrically expensive instead of geometrically free

• Reversibility in AI tracking: today’s LLMs have no undo. No checkpoint. No way to return to the moment before things went wrong. The solenoid changes that — not by magic, but by geometry:
  

Drift becomes a detectable branch-crossing event. Contamination gets a geometric signature. The winding number becomes a drift odometer.

An intelligent system that can’t recover from errors isn’t intelligent — it’s brittle.
Human cognition doesn’t collapse when we notice we’ve gone off track.
We backtrack.
We revise.
We return to solid ground.

Let’s start bold:

Math theory didn’t fail AI. AI failed to understand Math theory,specifically the mathematics with direct impact on intelligent systems: category theory, topology, differential geometry, and the structures that bind them.

That distinction matters, because right now categorical AI is becoming a fashionable way to draw arrows, sound deep, and quietly erase the very things that make intelligence hard: time, memory, history, and paths.

If you’ve ever wondered why your AI pipeline behaves differently on Tuesday than it did on Monday, despite “nothing changing” — keep reading here we explains why. And it’s not a bug. It’s a fundamental architectural blindness that runs deeper than anyone wants to admit.

Let’s walk carefully. Buckle up.

1. What Category Theory Actually Gives You (And Nothing More)

At its core, category theory gives discipline.

Not intelligence. Not meaning. Discipline.

• Objects: states, spaces, types

• Morphisms: transformations

• Composition: how transformations chain

• Identity: what doing nothing really means

This matters. Without it, systems rot silently.

Category theory forbids magical glue. It forces interfaces. It makes incoherence illegal.

But let’s be precise about what it is:

Category theory is grammar, not literature.

Grammar doesn’t make you wise… but without it, you can’t speak coherently at all.

2. The First Mistake: Treating Categories as Just Functions

Most AI papers stop at the category Set:

• Objects = sets

• Morphisms = total functions

• Composition = function composition

This already commits a silent crime.

Functions are memoryless.

A function does not know:

• how you arrived at an input

• what happened before

• what curvature you traversed

It maps input → output as if it were a meme in your favorite spreadsheet:

f(x) = y

That’s it. No context. No journey. No scars.

But AI systems are nothing but accumulated history.

But we all know the obvious in this story:

Every token depends on context.
Every agent depends on interaction order.
Every trained model carries the sediment of its training path.

So when someone says our AI system is categorical — or, in a diminished sense, functional — what they usually mean is: We are just composing a bunch of stateless maps.

Calling a pile of stateless functions categorical is not depth. It’s cosplay.

3. Kernels: The Part of Reality Your Architecture Cannot See

Here is where most AI discussions collapse — because they never talk about kernels.

Mathematically, a kernel is simple:

The kernel is the space of differences that make no observable difference.

Formally, given a map p : A → B, the kernel is everything in A that collapses to nothing in B.

The kernel is what changes without anyone noticing , where “anyone” means “your measurement tool.”

And this is deadly in AI: the kernel is where the monsters hide.

Because AI systems are full of kernel directions:

• internal states that differ

• histories that diverge

• training paths that rotate the system

…while producing the same output.

Think about it. Two language models fine-tuned along completely different trajectories:

One saw toxic content early and was cleaned up.
The other was trained clean from the start.

They score identically on your benchmark. Same output. But internally? Completely different geometry. Different failure modes waiting to emerge. Different responses to prompts you haven’t tested yet.

The difference between them lives in the kernel of your evaluation map.

If your architecture cannot represent its kernel, it cannot know what it is blind to. You will see this much more clearly explained visually in Figure 1 below.

4. Quotients: When You Decide What “Counts as the Same”

Now comes the epistemological move.

Given a kernel, we form a quotient.

Not by deleting information — but by declaring differences irrelevant.

Two states are equivalent if their difference lies in the kernel.

This is not philosophy. This is exact mathematics.

A quotient is reality after forgetting.

AI systems do this constantly:

• Token equality (different Unicode representations → same token)

• Benchmark scores (wildly different models → same accuracy number)

• Task success metrics (different reasoning paths → correct answer)

• Embedding similarity (different meanings → same vector neighborhood)

Different internal worlds. Same equivalence class.

And the system cannot tell them apart.

Here’s the uncomfortable truth: every metric is a quotient map. Every evaluation collapses a vast space of internal states onto a thin line of numbers. The kernel of that map — everything your metric cannot distinguish — is where all the interesting failures hide.

When your production AI hallucinates confidently, when your agent suddenly destabilizes, when your equivalent models behave completely differently on edge cases: you’re seeing kernel directions assert themselves. Differences you declared irrelevant turning out to matter.

5. The Kernel-Quotient Trap

So we have two operations:

• Kernel: what your system cannot see

• Quotient: what your system refuses to distinguish

Together, they form our AI trap.

AI systems navigate enormous state spaces. To make them tractable, we quotient aggressively: we declare vast swaths of states equivalent for our purposes. Benchmarks. Metrics. Evaluations. All quotient maps.

But quotients don’t eliminate the kernel. They hide it.

The states you collapsed are still there, evolving, diverging, accumulating differences along their paths. You just can’t see them through your chosen lens.

Then one day, something emerges from the kernel. A behavior no one predicted. A failure mode no benchmark caught. A sudden capability or breakdown that was actually building for months in dimensions your quotient blinded you to.

This isn’t mysterious. It’s geometry. The kernel was always there. You just chose not to look.

Said another way: the kernel-quotient trap is written like a story where three characters start in the same place, and the narrator only tells you where they end up: never how they got there. They all arrived at 94.2%, the story concludes. But one walked a clean path. One spiraled through contamination. One is inches from the cliff. The ending looks identical. The journeys were not. And journeys determine what happens in the sequel. See the visual translation in the figure below:

6. Paths, Holonomy, and What Functions Cannot Express

Now we can state the core problem precisely:

Function composition erases paths. Reality remembers them.

When you compose functions f : A → B and g : B → C to get g ∘ f : A → C, you get a map from A to C. But you’ve lost something: the path through B.

In flat spaces, this doesn’t matter. All paths between two points are equivalent.

But AI state spaces are not flat.

They have curvature. And curvature means holonomy: the phenomenon where the path you take changes the outcome, even if you end up at the very same spot.

Let me make this bolder.

Imagine you’re carrying an arrow on the surface of a sphere. You start at the North Pole, arrow pointing toward London. Walk to London, keeping the arrow parallel — not rotating it, just maintaining its direction relative to your motion. Walk along the equator to Tokyo. Keep the arrow parallel. Walk back to the North Pole.

You’ve returned to your starting point. But the arrow? It points in a different direction than when you started.

The path rotated it. The geometry of the sphere induced a transformation that pure function from start to end cannot see.

This is holonomy. And it happens constantly in AI systems.

Two fine-tuning sequences that reach the same model parameters. Same endpoint. Different internal geometry. Different failure modes. Different responses to adversarial prompts. The path left traces that your function-only architecture cannot represent.

If your architecture cannot distinguish how a state was reached, it cannot reason about path-dependent phenomena. And path-dependent phenomena are everywhere in AI.

7. The DAG Illusion: Confusing Diagrams with Dynamics

Modern AI systems are drawn as flowcharts: directed acyclic graphs (DAGs):

• Nodes represent models, agents, or processing steps

• Edges represent data flow

• The whole thing executes in topological order

This looks categorical. You can squint and see objects and arrows. It might even satisfy the formal axioms.

But it captures nothing about dynamics.

A DAG has:

• No sense of how you traverse it, only that you do

• No accumulated errors along the path

• No memory beyond whatever state you explicitly pass

• No notion that taking a different route might yield different results

• No representation of its own kernel: the internal differences invisible to its outputs!

Here’s a concrete example. Two LLM agents negotiate a solution. Agent A proposes, Agent B critiques, Agent A revises.

Now reverse the order: Agent B proposes first!

Same agents. Same composition. Different outcome.

The DAG says these are equivalent pipelines. Reality laughs.

What’s happening? The path through the interaction space has holonomy. The order of traversal rotates the internal state in ways the DAG cannot see, because DAGs don’t have geometry. They’re flat. They’re Set in disguise.

8. The Functional Programming Crime

This isn’t just an AI problem. It’s a computational culture problem.

Even Haskell: the supposed cathedral of categorical purity — commits the same crime.

Haskell’s claim to categorical legitimacy rests on types, functions, and monads. Impressive vocabulary! But what category does Haskell actually implement?

Hask: the category of Haskell types and functions. Which is essentially Set with better marketing.

The monad, which allegedly handles effects, doesn’t fix this. A monad sequences computations along a linear chain:

action1 >>= \x -> action2 >>= \y -> action3

This traces a path, but the path has no geometry. Running the same monadic computation twice gives identical results: that’s the whole point of referential transparency. The path collapses to its endpoint.

What Haskell cannot express:

• Two different operation sequences that should be equivalent but aren’t (holonomy)

• Going around a computational loop and ending up somewhere unexpected (curvature)

• Operations that depend on how you arrived, not just where you are (path-dependence)

• The repeatedly mentioned kernel of a computation: what internal differences produce identical outputs

And everyone thinks this is categorical programming. It’s not. AGAIN it’s Set programming wearing a category theory costume.

9. Category Theory Already Solved This (Nobody Noticed)

Here’s the bitter irony.

Modern category theory( the mathematics developed since the 1960s) has extensive machinery for handling exactly these phenomena:

• Enriched categories: morphisms carry extra structure (cost, time, probability, distance)

• Higher categories: morphisms between morphisms, capturing transformations of transformations

• ∞-categories: infinite towers of higher morphisms encoding paths, homotopies, and loops

• Fibered categories: systematic handling of parameterized families of structures

• Sheaves and descent: local behavior constrained by global consistency

• Kan extensions: principled ways to extend functors along paths

These frameworks are explicitly path-aware. Holonomy lives there. Memory lives there. History lives there. Kernels and quotients are first-class citizens, not afterthoughts.

But almost no AI architecture uses them. 👀

We have the mathematical tools for path-dependent composition. We’ve had them for sixty years. And the AI community is still drawing flat flowcharts and calling them categorical.

10. What This Breaks in Practice

Ignoring path structure has concrete consequences:

Errors accumulate invisibly. Each step in a pipeline introduces small deviations. In flat composition, these are just noise. In curved spaces, they compound along trajectories and can land you somewhere completely unexpected.

Feedback loops become unpredictable. A system that monitors its own output and adjusts is traversing paths through its state space. Without geometry, you cannot predict where these loops converge — or if they converge at all.

Retries aren’t idempotent. Running the same agent interaction twice should NOT matter, but it does, because internal state has evolved along a path your architecture doesn’t track.

Autonomous agents become chaos. Multi-agent systems develop emergent behaviors — ruts, attractors, oscillations — that no one designed because no one modeled the geometry of their interaction space.

Debugging becomes archaeology. When you can’t trace how a state was reached, you can only examine artifacts. Was this hallucination caused by the prompt? The context window? The fine-tuning history? The moon phase? 😜Who knows. The path is lost.

Kernel effects ambush you. Your benchmarks look great… then production reveals failure modes that existed all along in the kernel of your evaluation. The quotient hid the problem until it couldn’t anymore.

This is why orchestration layers rot over time. Each patch adds another invisible path dependency. Eventually the system is a tangle of implicit holonomies that no one can map.

11. What Would Path-Aware AI Look Like?

This isn’t purely negative criticism. There’s a positive program here.

A genuinely path-aware AI architecture would:

1. Represent state spaces as geometric objects with meaningful topology — not just vectors, but manifolds or stratified spaces where curvature means something

2. Track trajectories explicitly, not just current states: know how you arrived, not just where you are

3. Define connections: rules for how to transport information along paths, so “parallel” operations stay consistent

4. Measure curvature: quantify exactly how much path-dependence exists in different parts of the system

5. Model kernels explicitly: know what your architecture cannot distinguish, so you’re aware of your blind spots

6. Use holonomy groups to characterize the space of possible history effects — what traces can paths leave?

Some fragments of this exist. Geometric deep learning touches on it. Topological data analysis hints at it. Homotopy Type Theory provides a programming foundation where types are spaces and equality is path.

But no one has built the full stack.

The tools are there: fiber bundles, principal connections, parallel transport, characteristic classes. Category theory provides the organizational framework — but the enriched and higher versions, not the 1940s fragment everyone uses.

12. Why This Happened

This architectural blindness isn’t accidental. It has roots:

Machine learning grew from statistics, not geometry. The founding metaphors were regression, optimization, probability distributions. These naturally live in flat vector spaces where all paths are equivalent.

Software engineering thinks in functions. The entire paradigm of programming — especially functional programming — is function composition. Categories of sets feel natural. Categories of spaces feel alien.

Higher category theory is genuinely hard. ∞-categories, derived geometry, homotopy type theory… these require years of serious mathematical training. It’s easier to slap categorical on a DAG and publish.

Kernels are uncomfortable. Admitting what your system cannot see is humbling. It’s easier to pretend omniscience than to map your blind spots.

There’s no immediate reward. A system with proper path-tracking doesn’t benchmark better on today’s metrics. The benefits show up in robustness, interpretability, and long-term stability — things that don’t win Kaggle competitions or inflate demo numbers.

So we collectively took the shortcut. And now we’re confused about why our AI systems behave like haunted houses — full of ghosts from paths nobody remembers taking.

13. The Accusation

Let’s say it plainly:

The problem is not that category theory is too abstract for AI. The problem is that AI — and functional programming, and most of computer science — uses a crippled, pre-1950s fragment of it.

As we have already seen: functions without paths. Composition without transport. Arrows without memory. Kernels without acknowledgment.

That’s not category theory. That’s cosplay.

It’s like claiming to use calculus while refusing to acknowledge derivatives. Technically you’re in the building, but you’ve locked yourself in the lobby.

The entire computational paradigm has internalized the Set-reduction so deeply that people mistake the costume for the substance. And we stop thinking and just stay comfortable in the lobby, ignoring the rest of the floors in our Category Hotel, as you see in the funny, somewhat cynical GIF below:

14. The Path Forward

As we again state, and unfortunately never tire of repeating: The real tragedy is that mathematics already solved these problems. The tools exist. They’re sitting in textbooks on differential geometry, algebraic topology, and higher category theory, waiting for someone to actually use them.

What would it take?

For AI researchers: Learn some geometry. Not just linear algebra: actual differential geometry. Understand what a connection is, what curvature measures, why parallel transport matters. Learn what a kernel tells you about your system’s blindness. Then look at your pipeline diagrams again.

For functional programmers: Acknowledge that Haskell isn’t the endpoint. Look at Homotopy Type Theory, where types are spaces and paths are first-class citizens. The next generation of programming languages will be path-aware. Be ready.

For everyone building AI systems: When your system behaves mysteriously: when fine-tuning order matters, when retries give different results, when agent interactions spiral unexpectedly — don’t dismiss it as noise. It’s signal. It’s the geometry you’re ignoring, asserting itself. It’s the kernel you never mapped, coming back to haunt you.

The question is whether AI will grow up and learn real mathematics… or keep playing with flat diagrams while wondering why nothing quite works.

SUMMING UP…

If your AI architecture cannot distinguish how a state was reached, then it cannot truly reason, learn, or adapt, no matter how many arrows you draw.

If your architecture cannot see its own kernel, it cannot know what it doesn’t know.

And no amount of categorical vocabulary will save a system that forgot geometry, history, and paths.

Category theory wasn’t misdesigned.

It was misused.

The paths are still there, curving through your systems, accumulating holonomy with every inference. The kernels are still there, hiding the differences your metrics cannot see. You can model them, or you can pretend they don’t exist.

But they’ll keep mattering, whether you acknowledge them or not.