The rise of the foundation model

I've spent the last few posts raining fire and brimstone down upon Large Language Models. A few readers took that as a declaration of war against the LLM, but nah, it wasn't. It was actually an intervention. I admire the darn thing too much for that. The simplest reason being the fact that prior to GPT3.5, I always had to explain what Machine Learning (can't stop writing this in capitals) was to execs, who couldn't reproduce anything I said beyond "oh, wow, it can predict the future" and when engaging in projects we always started with running inspiration workshops.

But these days I have the opposite problem.

I run de-motivation workshops.

Somewhere between ChatGPT writing our emails and generating suspiciously competent code, half the corporate world concluded that artificial intelligence had finally become Harry Potter's wand. The only thing you had to do was to wave it over a business process and mumble something Latin like "agenticus autonomicus resultans non-hallucinatus", sprinkle in some Retrieval-Augmented Whatever, and then watch decades of organizational dysfunction go away in a poooooff of probabilistic smoke. My Dunning Kruger friends are particularly susceptible to this condition. They have developed the remarkable ability to see an LLM and immediately imagine a sentient digital employee with the chutzpah to modernize SAP over a long weekend.

B_uuuu_t reality, as it stubbornly tends to do, always refuses to cooperate.

We have started asking a language model to turn into a physics engine or a process simulator, a compliance officer and, on a particularly optimistic Tuesday, the entire enterprise operating system.

Man, that's like when you hire Shakespeare to design you a jet engine. He would certainly produce the most beautiful maintenance manual ever written but I still wouldn't get on the plane.

An LLM is one of the most remarkable pieces of engineering this industry has produced during my career, but I'm not sure if it dragged humanity forward or just handed every marketing department a flamethrower. But no one would seriously defend that it didn't bend the trajectory of computing. I think that history will file the arrival of ChatGPT next to the arrival of the web.

There was a world before it, and there is a different one now.

But there's a problem. We have started abusing language as a universal interface to reality.

The industry built the first successful major neural network on language and then convinced itself that it had built the final form of artificial intelligence. But it has not, and that confusion is becoming increasingly expensive.

A frontier language model eats a genuinely staggering amount of text. No one outside the handful of labs training these things publishes the exact figure, but the cleaned corpora behind today's largest models run into the tens of terabytes before tokenization even happens. That is the same amount as tens of millions of books across every discipline our species got obsessive enough to write down.

And something happens to the machine when it has swallowed that much text.

The model builds an internal picture of how it sees the world, and in the model's minds eye, everything is made up of language. Physics, chemistry is language, economics, war, love, grief, all of it, language. Even a coffee mug turns into language eventually, described down to width, diameter, curvature, handle geometry, and color, thoroughly enough that another human could picture it with real accuracy.

And even though we have created a rich vocabulary, language still doesn't represent reality.

Pick up that same mug and rotate it slowly in your hand. Now watch the handle vanish behind the ceramic, reappear at a different angle, warp with the perspective, catch the light differently every fraction of a second, throw shadows that move across the surface as you turn it.

Do you find it hard to picture this?

That is because none of this lives inside language. Language points a finger at the experience, but it never becomes the experience itself, no matter how many adjectives you throw at it.

Large language models are, in an unusually literal sense, Platonic. Plato spent an entire story about a cave talking about the fact that behind our dirty physical world is a realm of perfect Forms, that he called the Eidos, where the true and unchanging version of every object exists untouched by mess or decay. He said that every chair you've ever sat on is a flawed copy of the perfect Chair — with a capital C — and every circle you've ever drawn is a wobbly imitation of the perfect Circle. Our world is a noisy and dirty thing and it's constantly falling apart.

But the world of Forms is clean and timeless.

That description should sound familiar to you by now. . .

The internal world of a language model is built entirely from statistical relationships between symbols that are averaged across millions of examples until every concept feels almost coherent. The result we are experiencing feels believable because it mirrors what people usually say most often and it converges toward whatever most people already agree with, and that convergence feels like safety.

Almost perfect, by design.

But not reality, by construction.

The model has never felt gravity pull anything toward a floor and for that matter never watched a ceramic mug accelerate toward concrete or felt the vibration traveling through porcelain milliseconds before it fractures. But it can describe every one of those events beautifully, because millions of humans already described them first.

Describing why something happens and understanding why it happens are not the same operation, and the language model only ever performs the first one.

That is the difference.

Drop the mug. The model tells you it probably breaks, because the words drop and mug, fall, floor, break, and shards show up together constantly across its training data. That association is close to statistically flawless. But underneath it, though, the causal mechanism is completely outside of the model's universe. Nothing in there simulates force vectors or the propagation of stress or how fracture mechanics work. Something in there only predicts the next symbol, and predicts it extremely well (give or take a few percent).

A diffusion model — the stuff I use to create the comics for this blog — doesn't fix any of this either. It has memorized visual regularities at scale and learned that mugs appear under an almost infinite range of lighting and camera angles, then learned how rotation changes in appearance because it has seen billions of examples of a particular rotation. And when you ask it for another picture l, it will oblige instantly, but when you want to simulate what happens structurally when that mug hits the floor under a different gravitational constant, well, then it starts looking suspiciously like the rest of us after two glasses of Absinth and a pop quiz on the workings of a quantum computer.

And again, none of it holds any criticism.

It's all about domain specificity, plain and simple. A language model is extraordinary at modeling language because that is the only thing it has ever done, and humanity happens to put a humongous amount of its accumulated knowledge inside language. That's exactly what makes the model look nearly omniscient.

Well, almost.

The cracks show up when a problem depends on something that language merely describes instead of what it actually is in reality. When you ask it to predict what that mug does under twelve newtons of force applied at a forty-five degree angle then language runs straight into its ceiling. In that instance, what you need instead is a model that is trained on physics itself, and not descriptions of physics written by people who watched it happen. That is the little distinction that changes everything downstream.

In an AI, there's nothing that states the training data should be made of words. You could train a model on weather systems or protein sequences, or telemetry from your manufacturing operations, or even the operational heartbeat of an enterprise itself for that matter. The only real requirement is that you have a domain with enough volume, and recurring patterns for a model to extract something meaningful from it.

The transformer, for all its fame, is just one of many ways to extract structure from data. Self-attention compares every token with every other token in a sequence and by doing so, it is gradually learning which relationships matter and then it is stacking those discoveries into increasingly abstract representations, layer by layer. Now, when you replace the tokens with something other than words, or replace the transformer itself with an architecture better suited to graphs or state spaces or what have you, and then you'll see that the underlying idea will survive perfectly well. The language disappears and the entire transformer might disappear too, but the Foundation Model doesn't.

Yeah, strip away the transformer, the attention heads, the tokenizers, the embeddings and the billion-dollar GPU cluster and the flashy demos… and you're left with something that organizations other than Anthropic or OpenAI have been building for decades.

Yeah, a foundational neural network.

We have become remarkably good at inventing increasingly sophisticated ways of saying exactly that.

And that's the real subject here. I suspect we're closing in on the point where language is now more of a bottleneck instead of an advantage, and biology got there years before enterprise AI did.

Google DeepMind's AlphaFold did not, contrary to a myth that refuses to die, crawl out of the wreckage of a failed language model. A protein is simply a very long chain of amino acids, just as a sentence is a long chain of words. That meant they could, in fact, borrow ideas from language models to learn useful patterns in protein sequences.

Then they hit a wall.

Biology was far more than a sequences of words.

The problem they faced was predicting how that long chain twists and bends and then eventually settles into a stable three-dimensional shape. That shape determines if a protein actually works or not.

So they built AlphaFold 2 specifically to solve that problem.

Given this entire chain, what three-dimensional shape is nature most likely to produce?

To answer that question it combines three things. It compares the protein with millions of similar proteins found throughout evolution. It also learns which parts of the chain stay together in three-dimensional space. Then it adjusts its prediction until it arrives at the most physically stable shape — the one with the lowest energy.

What I am trying to say is that AlphaFold didn't treat proteins as language, but instead treated them as objects that obey the laws of chemistry and physics. That result earned Demis Hassabis and John Jumper half of the 2024 Nobel Prize in Chemistry and David Baker took the other half for the complementary trick of designing proteins that had never existed before. AI didn't get any acknowledgement by the way.

So, in short, language didn't fail here, but biology demanded a richer representation, and language alone just couldn't hack it. Now, Google appears to have absorbed that exact lesson and turned it into a Foundation Model factory. Across half a dozen unrelated domains at once, they are shipping Foundation Models for time series forecasting (TimeFM), wearable sensor data (SensorFM), tabular enterprise data (TabFM), weather prediction (WeatherNext), and a handful of others. And the cool thing is that each one speaks a completely different native tongue and none of that is language.

And enterprise operations are no exception to the rule because somewhere inside ERP systems and event logs, the workflow graphs, and the books full of governance rules is another domain with its own grammar and a recurring structure, and possibly its own Foundation Model waiting to be built.

That model doesn't exist yet.

But I'm building one anyway, but more on that later.

More rants after the messages

Visit the ATLAS website. It's free. I built it for myself. And now you can use it too.

• Connect with me on Linkedin 🙏
• Subscribe to TechTonic Shifts to get your daily dose of tech 📰
• Please comment, like or clap the article. Whatever you fancy.

Intelligence depends on what you feed it

One of the strangest things the AI revolution has done is convince smart people that intelligence somehow lives inside the model itself. And between ChatGPT writing our emails and explaining quantum mechanics and hallucinating whole reports (hi PWC!), we all forgot to ask the most obvious question of them all.

What exactly did we feed the bloody thing?

That question matters far more than you would realize, because intelligence is not some magical sauce that oozes out your model after connecting enough NVIDIA GPUs together. A neural network, no matter how sophisticated, begins life as nothing more than a friggin' expensive pile of random numbers, and when you leave it, it has roughly the same amount of intelligence as my dishwasher.

Everything the model eventually turns into is determined by the world you expose it to.

Say, you raise a boy in the most ethically questionable experiment ever proposed. We lock the poor sod inside a gigantic library immediately after birth. There are millions upon millions of books inside, with, like, every book ever written and, oh yeah, the whole of the internet's content as well, with Reddit discussions between people who have somehow mistaken confidence for evidence and all the tweets by Donald Trump. Well now, that boy would spend twenty years reading without interruption because he has nothing better to do. And when you, after twenty years, finally open the doors, that boy may very well know more about thermodynamics than your local physicist and more about molecular biology than an undergraduate student, and he could probably explain why porcelain fractures under stress or how coffee beans are roasted, and why gravity causes objects to accelerate towards the Earth.

But then you hand him a coffee mug.

Not a book of a mug, but a real one.

Ask him to close their eyes, rotate it between his fingers and tell you what it feels like when the handle slowly disappears behind the cup as it turns. Ask him how the ceramic resonates if you tap it with a spoon and how slippery it becomes after condensation forms on the outside or how it behaves when you accidentally let it slip from your hand.

All those books don't mean a thing at that moment, because descriptions are not experiences.

Language points towards reality but it never turns into reality.

That observation is actually far more profound than it first appears, because a Large Language Model suffers from exactly the same limitation. It has consumed an unimaginable amount of human writing with almost every other subject humanity has ever thought would be important enough to write down, and from that staggering volume of text, the model has constructed an extraordinarily rich internal representation of our written world.

Notice the last three words.

Our written world. Not the physical one. That distinction may seem almost pedantic, but I suspect it is one of the most important questions we can ask about artificial intelligence. If everything a model has ever experienced consists of descriptions written by humans, then has it learned the world itself, or merely our collective description of the world?

Those are not obviously the same thing.

In fact, cognitive science has wrestled with exactly this question for decades. The theory of embodied cognition says that intelligence is not simply the manipulation of abstract symbols, but that it emerges from continuous interaction with the physical world.

We learn because we move, touch, smell, manipulate objects and experience the consequences of our actions. Our concepts are grounded in perception and action and not only in language.

And a Language Model, no matter how large, has done none of those things.

It has never touched a coffee mug or felt its weight shift as the handle rotates between its fingers. The LLM only knows that millions of humans have described those events. And that raises the question if that is what we consider intelligence? Being able to capture events in symbols and then recalling them statistically?

Or is it something slightly different?

I think that what we are observing with an LLM is that it has an extraordinary ability to model the statistical structure of human language, but it has no clue about reality itself, but Big Tech has framed linguistic competence as though it were a universal proxy for intelligence.

Even though Sam Altman is talking as if we are already in "ze singularity" (pronounce in French, dunno why, just try), that we are well into Artificial General Intelligence, but the scientific community is far less certain than what these guys suggest. Researchers continue to debate if intelligence can emerge purely from symbolic representations or if it requires embodiment and that causality must be learned through interaction. There is no consensus. But it is telling that some of the most influential researchers in AI, including Yann LeCun, Fei-Fei Li and, to a somewhat more nuanced extent, Demis Hassabis, have repeatedly said that language alone is unlikely to get us all the way there and that further scaling is a dead end.

Personally, I think we have accidentally stumbled into a much bigger question than "How smart is GPT?"

I think the real question is this.

Can a system that has only ever learned one representation of reality ever become generally intelligent, or have we simply built the world's greatest expert on language?

Because if the answer turns out to be the latter, then language was never the destination, it is merely the first domain that contained enough data for another Foundation Model to emerge.

The accidental discovery of the Foundation Model

Alexander Fleming was not trying to revolutionize medicine when he left a petri dish uncleaned in his lab before going on a holiday. He forgot to tidy up and then a spore of some mould drifted in through an open window. Long story short, this is how we ended up with penicillin, and it was born out of bad housekeeping, not some grand hypothesis or anything like that.

The microwave oven exists because an engineer stood too close to a live radar with a chocolate bar that melted in his pocket and he had the common sense to ask why that happened. And the internet was built to help computer networks in the 60s survive a nuclear war and now mostly survives arguments about which chocolate bar melts fastest. GPS was built to guide a missile onto a target, not to reroute a UPS driver around traffic. Viagra started life as a heart medication that apparently produced a side effect that no one knew about until the trial volunteers reported it themselves.

Yeah, we humans have an oddly consistent talent for finding the revolutionary thing while we are hunting for something else entirely. And artificial intelligence has now joined that tradition, formally and without much ceremony.

When you would walk into OpenAI sometime around 2018 and you'd ask a researcher what they were building, than none of them would say that they were about to discover a universal recipe for learning representations of arbitrary domains. These guys set out to build a better language model.

What they actually found, more or less by accident, was that when you expose a large enough neural network to enough examples from one domain and force it to keep predicting the missing piece instead of spoon-feeding it a hand-labeled answer every single time, then something strange would begin happening inside it. At first, the network memorizes countless examples, much like when I was a student, cramming facts the night before an exam. But eventually, that strategy stopped working for me, because there was simply too many dense matter to remember.

I recall reaching exactly that point in secondary school. Memorizing endless lists of facts was exhausting and, frankly, a terrible long-term strategy. So I switched to physics and chemistry. They were harder during the first year because I actually had to understand what was going on, but once those fundamental principles clicked into place, then everything else became easier. Every new concept could be built on top of the old ones instead of being stored as again another isolated fact.

That is remarkably similar to what happens inside a model. Instead that it is trying to remember millions of individual examples, the network gradually learns the underlying patterns that generated those examples in the first place. It stops memorizing and turns to learning the rules behind them. In other words, it is compressing the structure of an entire domain into mathematics.

That distinction deserves to sit for a moment, because I think it is one of the most misunderstood ideas in the entire field.

A Foundation Model would be less interesting because it stores an enormous amount of information. You know, a NAS could do that, and Wikipedia too, or a search engine for that matter. And none of these things understand a single word of what they are holding. But a model discovers the hidden structure that generated the data in the first place. Language carries grammar and hierarchy with rhythm, and context, layered on top of rules, exceptions to those rules, and exceptions to the exceptions, and to be honest, Dutch, in particular is carrying an almost ideological commitment to making life difficult for anyone who did not grow up speaking it.

The model uncovers that structure by guessing what comes next, and getting nudged back into line every time it guesses wrong. And out of that the structure surfaces entirely on its own, because the underlying data already contained that structure, and the model kept getting rewarded every time it found a little more of it.

By the way, none of that observation has much to do with language specifically, whatever the marketing implies. Language simply happened to be the first domain where our species had already spent several thousand of years accumulating enough raw examples to run the trick at scale.

And nothing in that recipe actually required words.

For language, yes, it does.

But swap words for amino acids and the same trick predicts how a protein folds into its lowest-energy shape. Swap language itself for almost any domain that has a rich enough structure to contain a recurring pattern worth learning, and that recipe keeps working exactly as well as it did before, with language, and only the domain changes, but the mathematics stays precisely where it was standing the whole time.

That, more than any single chatbot release, was the actual invention worth naming.

Not the Language Model.

The Foundation Model sitting underneath it — with language as the first test case and not the ceiling everyone mistook it for.

The enterprise is simply another domain

One of the things that has always amused me about enterprise software is that we insist on treating companies as though they somehow operate outside the laws of nature. We happily accept that our planet obeys gravity or that rivers carve remarkably predictable paths through landscapes over thousands of years, but when someone says that organizations also exhibit recurring patterns and hidden structure, otherwise sensible people suddenly become deeply philosophical.

"No," they will insist, usually while standing in front of a PowerPoint slide containing enough colored fonts to scare an LHBT parade.

"Businesses are different. People are involved."

Yeah, right, as if chemistry would take the afternoon off every time Karen from Procurement joins a steering committee*

Of course people are involved. Yet none of those suddenly become immune to analysis simply because humans participate in them. Quite the opposite. Freakish human behavior creates even richer structures, because people have an astonishing tendency to repeat themselves. We invent organizational rituals with recurring approval chains and governance structures, and then spend decades pretending that each of them is a unique masterpiece of corporate creativity.

When we describe an enterprise, we usually talk about people and departments with applications and policies on top of business processes. That description is technically correct. Yeah, in much the same way that describing a human being as "roughly seventy percent water" is technically correct that is. It isn't wrong if anything but it simply doesn't explain anything particularly interesting.

Now, from the perspective of a machine, an enterprise looks nothing like an organization chart or a collection of PowerPoint slides. For the machine it is an enormous dynamical system that is in constant motion. Every invoice that is passed around is an event, and approvals are nothing more than state transition (state: invoice not paid → state: invoice paid). And then, purchase orders are points along a trajectory, and every employee interaction forms another connection inside an enormous graph, and there's policies that try to bends those trajectories without anyone objecting to it (that much).

The enterprise continuously evolves through millions of tiny state changes that together define how the organization actually behaves.

Most organizations never experience themselves that way because we humans do not perceive companies as streams of state transitions. We experience lengthy meetings and horrible deadlines and more emails from Karen asking if we've completed the mandatory export-compliance awareness training for the fourth time this year.

But the enterprise experiences something entirely different. . . It experiences flow.

Every time that a customer places an order, the inventory changes and then a planner reacts and manufacturing adjusts its schedule, finance updates a forecast and treasury reallocates cash, tax receives yet another headache and someone, somewhere down the line, approves something they probably shouldn't have approved because it happened to be five o'clock on a Friday afternoon and everyone involved simply wanted to go home.

I've completely forgotten the point I was trying to make, but you know what I mean, that kind of flow I mean.

When you view it from up close, those events feel messy and almost random, but when you step back far enough, something rather remarkable begins to emerge. You notice that certain approvals almost always precede particular delays and that some organizational structures consistently produce bottlenecks and that a particular type of policy change ripples across dozens of apparently unrelated business processes and that some managers are invisible hubs through which an absurd percentage of important decisions somehow flow. You may call that bureaucracy if you like. But mathematics is blissfully indifferent to corporate terminology. It only notices that the same structures keep reappearing.

This is precisely what process mining has been showing for well over a decade. It is a truly powerful technology and when you feed enough event logs into the algorithms, the elegant process diagram 'the consultancy firm™' presented during the BPR program, suddenly mutates into something that looks pretty much like Will Smith eating a plate of spaghetti in Februari 2022.

What is interesting, however, is not the spaghetti itself but that this spaghetti is reproducible.

Because when you run exactly the same analysis next month, you'll see the same loops appear and the bottlenecks return. The same detours snake through the organization as though they have become part of the company's DNA. That observation alone tells me that an organization possesses structure. Hidden structure, undoubtedly. But structure nevertheless.

And whenever a structured flow of activities exists, there is something to learn.

That thought kept bothering me because we already train Foundation Models to understand weather precisely because weather exhibits recurring patterns. We train them to understand proteins because evolution leaves statistical regularities behind, and we train them on language since language itself follows an intricate grammar that has been evolving for thousands of years.

So why do we continue to pretend that enterprises somehow fall outside that same principle.

Every organization continuously generates event logs, process traces, workflow histories and other coordination behavior. The data is already there, my friend. In fact, most enterprises are drowning in it, but they simply don't think of it as training data. It's just that stuff SAP keeps producing.

Perhaps that is the greatest irony in enterprise AI.

For years we have been feeding language models millions of beautifully written pages that describe how our organizations are supposed to work, and all the while we've been ignoring the billions of observations that tell us exactly how our organizations actually work.

If someone gave me the choice between a beautifully crafted process manual and ten years of execution traces, I wouldn't hesitate for a single second. The manual tells me what management hoped that would happen, but the execution traces reveal what is actually happening. Nature has always preferred observations over intentions.

I suspect Foundation Models do too, in a way . . .

So yeah, perhaps the next great Foundation Model will not emerge from yet another trillion words scraped from the internet, but from something far less glamorous like the purchase orders, and process mining logs and the invisible mathematics of coordination itself.

Because if language has a grammar, proteins have a grammar and weather has a grammar, then certainly an enterprise big enough to produce a repeatable pattern would have one as well.

We've simply been too busy attending meetings to notice.

• Note to self: check if there's a procurement officer named Karen before publishing.

Can coordination be learned?

Somewhere during the past eight months, after staring at more process mining diagrams than I care to admit and having spent an unhealthy amount of time wondering why enterprise AI never quite seemed to deliver on its promises, I asked myself a difficult question.

Can coordination itself be learned?

At first glance, that sounds like one of those wonderfully vague research questions academics invent so they/we can spend three years discussing it over coffee without ever agreeing on a definition (take AGI). But the more I looked at enterprise data, I became convinced that the question was anything but philosophical but of a deeply practical nature instead.

Think about what actually happens inside a large organization.

A purchase order is one person coordinating with another. An approval is a decision about who may act next. An invoice follows a path through dozens of systems and departments before it eventually disappears into somebody's quarterly report. And policies attempts to influence future behavior, by keeping thousands of independent decisions pointing in roughly the same direction. And in that line of thought, every escalation is simply coordination recovering after it failed the first time.

Now, when you strip away the SAP screens and the org charts and the endless collection of PowerPoint slides about how things are supposed to work, and you'll start to notice that an enterprise is a coordination machine.

Nothing more and nothing less.

That observation completely changed the way I looked at enterprise AI.

For years we have treated enterprises primarily as collections of documents. We index policies, retrieve procedures, search knowledge bases, vectorize manuals and build increasingly sophisticated Retrieval-Augmented Generation systems that are good at telling us what the organization once decided. Those systems are genuinely useful, but they are fundamentally describing the enterprise instead of modelling its behaviour.

And that is because behavior lives somewhere else altogether.

It is inside execution.

Millions of decisions ripple through an organisation every day. Work is handed from one department to another and then exceptions appear and resources become unavailable, with shifting priorities and new regulations trying to alter behavior across hundreds of interconnected processes without anyone fully understanding the downstream consequences.

From close up, all of that is messy, but when you lean back, patterns start to emerge, and none of those patterns exist because someone designed them, they simply emerge.

That should sound familiar by now.

Language contains recurring structure, proteins contain recurring structure, etcetera. Entire scientific disciplines exist because reality keeps repeating itself in ways that mathematics can capture. Why should enterprises be any different?

I think it isn't.

What we call "enterprise complexity" is simply the visible expression of an underlying coordination grammar that we have never attempted to learn directly.

And I know that this grammar exists. And to me, process mining diagrams are no longer just visualizations and event logs aren't just operational exhaust, with ERP transactions being mere r accounting records. They are, in fact, observations of an underlying dynamical system whose rules we only partially understand.

And when I started looking at enterprise data through that lens, another question immediately presents itself.

If language contains enough statistical regularity to justify a Foundation Model…then why shouldn't enterprise coordination? If coordination possesses its own statistical regularities, its own latent representations and its own hidden geometry, then we have been asking the wrong question all along.

I think that what Big Tech is trying to do, inflating a model to make it smarter, and bolting on ever more complicated harness-components to the language model to fix its inherent flaws because we're trying to make it do something it was never intended to, is simply the wrong direction. The objective was never to build a better chatbot that happens to work inside an enterprise. The real objective is that we need to build a model that learns the enterprise itself, not through its language — the documents — but through its own behavior: coordination.

And when coordination turns out to have a grammar, then it can be learned, and then it deserves its own Foundation Model. That possibility has occupied an unhealthy amount of my spare time over the past year and a half.

It even has a name now.

The Coordination Foundation Model.

The Coordination Foundation Model

My dear smart friend. Because you made it this far, you are the 1% of the 1% of people that truly want to understand where things are going, and now you can probably already guess where this blog has been heading all along.

The easiest way to misunderstand the CFM is to think of it as another chatbot for the enterprise, with a RAG attached and a few agents buzzing around. Neither is it another workflow engine with an LLM bolted onto the side, nor is it another version of an LLM-Wiki system that retrieves yesterday's policy before helping you make tomorrow's mistake. Those technologies all have their place, and they solve genuinely useful problems, but they all begin with the assumption that understanding the enterprise starts with understanding its documents.

The Coordination Foundation Model begins with behavior.

This model learns the hidden structure that governs how work actually flows through an organization. Most enterprise software today reasons about what organizations say they do. A CFM learns what organizations actually do. Those are rarely the same thing.

Every day, your company generates an astonishing amount of behavioral evidence without even noticing it, and thousands of people continuously coordinate with one another without ever thinking of themselves as participants in a gigantic dynamical system.

Yet that is precisely what they are.

Those events seem almost meaningless when you consider them individually, but together they reveal the behavioral fingerprint of an enterprise.

Perhaps an analogy makes this easier to visualize.

Say you are looking down on a large city from orbit. At first, all you see below is chaos. Millions of cars are moving independently through an impossibly complicated road network, and individual drivers are making their own decisions for their own reasons. Nothing appears coordinated because, from that distance, the countless local interactions blur into one stream of movement. But only when you observe the city over time do the larger patterns begin to reveal themselves.

Morning rush hour emerges almost like clockwork. Congestion appears in remarkably predictable locations. A single bridge closure quietly changes traffic patterns across half the city. Roadworks in one neighborhood unexpectedly influence travel times twenty kilometers away. None of the drivers understands the behavior of the entire city, yet the city itself exhibits remarkably stable dynamics.

An enterprise behaves in much the same way.

Not a single employee understands everything that happens inside a multinational organization and nor should they. People simply go about their business, answer emails and attend meetings that should have been replaced by an email, and collectively they all create repeatable behavior.

The more I studied enterprise behavior, I became convinced that the entire industry has wasted decades modeling the wrong artifact.

Enterprise software has been built around documents for as long as anyone can remember. But knowing why something exists and understanding how it actually behaves turn out to be two completely different problems.

The thing is that these enterprise all generate evidence. From purchase orders, to approvals, escalations and so on. The documents describe the enterprise management intended to build, but the evidence it generates reveal the enterprise that actually showed up, and when you turn behavior into the primary source of truth, the enterprise trades its identity as a stack of documents for something closer to a living dynamical system

After more evenings than I care to admit, I landed on five building blocks that show up underneath every coordination decision I have ever looked at closely.

Every act of coordination opens with a signal. Something changes out in the world, a customer submits an order or a machine reports a fault, etc. A signal is nothing more than an observation that something happened and that the organization might need to respond to it.

Then there is an actor who interprets that signal. Sometimes that actor is a person, but it can also be a software system, and increasingly (though paired with a lot of difficulty), it is an AI agent standing in for either one. Actors never operate alone regardless of which of the three they happen to be, they sit inside organizational structures, carry different authorities, have different objectives, and answer to different policies depending on where in the org chart they live.

And when an actor receives the signal, a decision has to be made. This could be approving the invoice or reschedule production, you name it. But enterprises like to present these moments as simple business rules on a flowchart describing a process, when in reality each one is the exact point where uncertainty, competing objectives, governance, and whatever information happens to be available all collide at once.

Every decision therefore produces an action. This could be a workflow advancing to the next step, or a manager escalates an exception up the chain. Actions are coordination made visible, the thing that everyone in the building can actually see happening.

And the result of an action is an outcome, last of all. Sometimes the outcome is exactly what everyone intended, or it creates a delay three departments away and in the end, every outcome turns into a new signal when it lands, and then the entire cycle begins again.

That closed feedback loop is what actually fascinates me, because it makes an enterprise look remarkably similar to every other complex adaptive system that science has ever bothered studying. Coordination is a continuous feedback system where signals generate decisions, decisions generate actions, and actions keep reshaping whatever signals show up next.

And when you view coordination through that lens, the architecture of a Coordination Foundation Model nearly designs itself.

It starts with the representation layer, which is the foundation. Its purpose is to convert the overwhelming variety of enterprise evidence into one shared behavioral language. You create a corpus of event logs, ERP transactions, organizational graphs, process mining traces, policies, resource allocations, and communication patterns (yes, like emails), because they are all different projections of the same underlying coordination process. The goal is to get to one shared latent representation that describes how coordination actually behaves.

The Coordination Foundation Model itself is positioned on top of that normalized evidence pile. Its purpose is to discover the latent structure behind enterprise coordination, in exactly the same way that TimesFM discovers the dynamics governing a time series. The model learns trajectories instead of documents and actual behavior instead of descriptions of and interactions rather than isolated transactions in a table somewhere.

A Foundation Model on its own is only one piece of the architecture. Around it is an entire reasoning environment that is carrying the actual weight of simulation, governance, and execution. Simulation lets alternative coordination strategies get explored before anyone risks them on the real organization. Governance continuously narrows the solution space by applying policy and whatever objectives the enterprise happens to care about that quarter. And then execution connects the learned behavioral model back to the operational systems where a recommendation or a prediction, or an autonomous action finally reaches out and touches the enterprise itself.

And when you put those three pieces together, you do get something structurally different from today's increasingly elaborate stack of prompts and RAG pipelines with their orchestration frameworks, and agent chains held together by optimism, YAML, and ductape.

If this particular architecture turns out to be the right one, I think is an open question until it is implemented, and rightly so. Science has an irritating habit of refusing to care how attached anyone gets to their own framework. Every assumption here deserves to be challenged and that is exactly why most of this has been published as research instead of product marketing.

If you want to know more about the CFM, visit eigenvector/papers. It's somewhere at the top, right above or below the FGM. This paper introduces the concepts, and the reasoning behind it, the mathematical formalization, the representation learning strategy, the architectural decomposition, the simulation framework, and the theoretical foundations underneath all of it.

If your curiosity just got triggered you should head there directly, that is precisely where the rabbit hole begins. I've recently written a book/manual about it, and when you're interested in it, then send me a message directly on LinkedIn. There is always room for one more traveler willing to disappear into the unsexy frontier of AI, enterprise systems, and mathematics.

Signing off,

Marco

For my daytime job, I'm a researcher and factory builder at Eigenvector, a commercial research lab operating at the frontier of unsexy AI. In the evenings, I write about why building this stuff is a lot harder than the vendors would have you believe.