All the Letters of AGI

Everyone in this field is racing for all three letters at once. The bet underneath the race is simple: Artificial General Intelligence is one artifact. One model, one checkpoint, one system that plans and codes and sees and acts. Train it big enough and the generality shows up on its own, like a bonus.

The framing sells because it’s clean. One thing to build, one thing to benchmark, one thing to put on a slide. And “general” is doing a lot of the selling in that acronym. Strip capabilities out and you’re shipping a product. Keep everything in and you’re shipping the future.

I think that reading has it backwards. We’re building these systems in a world that hands out partial information and finite budgets. You never see the whole board, and every move costs compute you don’t get back. In that world, generality isn’t the destination. It’s a greedy play. Looks great up close. Gets expensive fast.

What generality costs

A general system has to carry every capability everywhere it goes. It can’t cache anything. There’s no shortcut table, no “we already solved this one, reuse it.” Every task gets re-derived from scratch through the same giant pile of machinery, whether or not that machinery is the right shape for the job.

You can see this in the actual mechanics of serving a dense transformer. Every parameter participates in every forward pass, so the model burns roughly the same FLOPs whether the next token is a hard reasoning step or a comma. The KV cache grows linearly with context length, which is why long-context requests get measured in gigabytes of keys and values shuffled per sequence. Decode is mostly memory-bandwidth bound, not FLOP-bound. Ask anyone running an inference fleet: the entire business is batched scheduling, prompt caching, and prefix reuse. Workarounds for generality’s refusal to remember anything cheaply.

This is textbook greedy behavior, by the way. Grab the choice that pays off right now, never look back. Pure generality makes that same choice on repeat: keep everything, commit to nothing, pay full price forever. It feels great short term because you never have to answer the uncomfortable question, “what is this thing actually for?”

But optionality sitting around unused isn’t free. It’s usually the biggest cost in the budget. Worse, it fails ugly. When resources tighten, a generalist degrades everywhere at once, because everything shares everything. A network of specialists just drops the parts it doesn’t need today and keeps the rest running. Ask any cloud bill how that story goes.

The thermodynamics of it

Intelligence runs on electricity and dumps waste heat, same as any other physical process. Physics doesn’t care how clever your architecture looks in a diagram. So the number I care about isn’t raw compute. It’s useful work per unit of energy burned. There are hard floors down in the physics, Landauer limits and such, and nobody is anywhere near them. At room temperature the floor is around 3×10⁻²¹ joules per bit erased, and real chips pay trillions of times that. Which means the efficiency gains are sitting on the table for whoever organizes computation better, not for whoever buys more chips.

There’s a second-law-flavored point hiding in where the energy actually goes. On modern hardware, moving a bit costs far more than transforming one. Reading a number from DRAM can cost hundreds of times the energy of multiplying two numbers that are already sitting in registers. Data movement is the tax; arithmetic is nearly a rounding error next to it. So the whole game is locality. Keep the data next to the compute that needs it. Move less, transform more. Specialization is exactly that idea applied to capability instead of bytes: keep each skill small enough to live close to where it’s used.

A generalist spends a huge chunk of its budget keeping options warm for futures that mostly never show up. That’s heat with no work attached. Biology settled this ages ago. Cells specialize. Organs specialize. Nothing grows a kidney that can also see. Economies ran the same experiment and got the same result: nobody builds a car factory that brews coffee on the side. Wherever energy is scarce and the timeline is long, specialization shows up first. Every time.

Specialization network flows

Here’s the part people miss. The unit of competence isn’t the specialist. It’s the flow between specialists. Cells form tissues, tissues form organs, organs form organisms that do things no single cell could dream of. Companies form supply chains. Libraries become programs. The specialists matter, sure. The wiring matters more.

Most of what looks like “general intelligence” from the outside is exactly this: a well-routed network of narrow skills with fast, cheap handoffs. Call a big company and watch your problem move through reception, then support tier one, then an engineer, then billing. Somehow the whole machine behaves like one smart entity. It isn’t. It’s routing.

And here’s the fun part: the field already confessed, quietly, inside the very checkpoints marketed as monoliths. Open a modern frontier model and there’s a decent chance it’s a mixture-of-experts. Dozens of specialist blocks, plus a trained router that fires only a couple of them per token. Mixtral 8x7B runs 8 experts and activates 2, about 13B parameters of its ~47B per token. DeepSeek-V3 activates roughly 37B of 671B. On the model card it reads as one giant generalist. Under the hood it’s a specialization network with learned flows, because paying full price on every token stopped being affordable.

Zoom out past a single checkpoint and the same trick shows up at every altitude. Speculative decoding: a small draft model guesses the next few tokens, the big model verifies them in one pass. Cheap specialist proposes, expensive generalist checks. Distillation: compress a giant’s behavior on one domain into a small model that serves at a fraction of the cost. Tool use: stop burning transformer FLOPs on arithmetic a CPU does deterministically for free, just call the calculator. Retrieval: stop trying to cram the corpus into weights, keep it in a database and fetch what’s relevant at run time. Prompt caching: stop recomputing the prefix that didn’t change. All one move, repeated: find what’s reusable, cache it, route around it.

So name the layer that ties these together: specialization network flows. How problems come in, get decomposed, get sent to the right specialist, and get recombined into something useful. Flow quality matters as much as node quality, and honestly probably more. A mediocre expert behind great triage beats a genius stuck behind a bad router. Every org chart and every nervous system agrees on this point.

I build multi-agent systems for a living, so take this from someone with receipts. Almost every failure I’ve seen was a routing failure. The right capability existed somewhere in the system. The answer was one hop away. But it sat in the wrong agent’s context, or reached the specialist after the deadline, or never got recomposed into anything the user could use. Nobody shouts “the model wasn’t smart enough.” Somebody mutters “why did that go there?”

Okay, but partial observability

Fair objection incoming. If you can’t see the future, you don’t know which specialist you’ll need. Generality is your hedge against a world you can’t fully observe. Build the thing that can sort of do everything, and you’re covered no matter what shows up.

True! And it tells you exactly where generality belongs. Not smeared evenly across the system like butter. Concentrated at the exploration boundary, where the system meets stuff it hasn’t seen yet. The general faculty is the search process. It wanders, it tries things, it pokes weird problems with a general-purpose stick. Whatever it keeps running into should crystallize into a specialist, and the network should re-route around that new organ.

Explore wide, exploit narrow. A system that never specializes is exploring forever and never banking a single win. A system that only exploits is efficient right up until the world shifts, and then it’s extinct. See also: most incumbents. Adaptation lives in the loop between the two, and the thermodynamic math says the crystallizing side of that loop is where the efficiency comes from. Search pays the discovery cost once. Specialization amortizes it forever after.

Specialization is a signal

All of this gives you a heuristic you can run on real systems. When a system starts growing dedicated components and clean interfaces, it’s telling you something: it can convert experience into structure. It learns in the only sense that compounds. That’s the kind of system that adapts well over long time horizons, so when you’re picking what to bet on, bet on those trajectories.

Run the other way from the opposite pattern. A monolith that stays “general” by refusing to commit is paying for optionality it never touches. Staying general is easy. Nothing gets decided, nothing gets built, nothing can be blamed. Deciding what you’re for, then building the structure to do it cheap, is the hard move. It’s also the informative one, which is exactly what makes it a signal.

A quick word on computational philosophy

People hear “philosophy” and picture a seminar arguing about universals. But engineers already do a kind of philosophy whether they admit it or not. Take the old questions: what is intelligence, what does it mean to understand something, where does a mind begin and end. Answer them with the tools of computation instead of intuition pumps. Information, search, complexity, thermodynamics, budgets. That’s computational philosophy: philosophy that takes finiteness seriously. Intelligence stops being a glow inside a machine and becomes something you can state precisely: what a bounded process does when it keeps producing useful work under partial observability.

What changes first under that lens is where you look for the smart. The classical picture treats intelligence as a substance a container holds, so a more general container must hold more of it. The computational picture treats it as an organization: a way of routing problems so scarce compute lands on the decisions that matter. Same math as a scheduler, a supply chain, a market. Hayek saw it in 1945 in “The Use of Knowledge in Society”: the world’s knowledge is scattered across specialists, and the coordination signals between them carry more of the outcome than any single head. That essay is basically a design doc for multi-agent systems, eighty years early.

Second change: tired old binaries dissolve. General versus specialized stops being a ranking and becomes a division of labor along a time axis. Exploration crystallizes into exploitation; the general is just the frontier of the specialized. Understanding becomes compression you can act on, which makes a specialist nothing more exotic than cached experience. Even the Ship of Theseus gets boring: an intelligent system’s identity lives in its flows and interfaces, not in any particular part. Components churn. The routing table persists.

And that reframes what we should actually be building. The interesting questions stop being “how do we make one model smarter” and become: what are the interfaces, what signals pass between specialists, what gets cached versus recomputed, who attends to what, and when does experience get promoted into structure. Philosophy of mind turns back into systems design. Good news, honestly. Systems design has debuggers.

Where this leaves the letters

So where does the current race stand? It bets that one model can spell all three letters alone. Greedy, given the incentives. Grab every market with one checkpoint before somebody else does, keep the optionality, defer the specialization question indefinitely. If you’re optimizing for the next funding cycle, it’s almost rational.

The money, though, already votes differently. Look at where value actually piles up: routers, small models trained for one job, tool use, retrieval, orchestration layers gluing it all together. Composition ships useful things daily while the frontier chases the one artifact. Efficiency already won this argument in every other industry. It’s winning here too, just quieter.

Between the multi-agent systems I work on day to day and everything above, the lesson repeats until it gets boring. Wins come from decomposition and routing, not from any single agent being universal. The interesting engineering lives in the flows: who talks to whom, when, with what context, and how the pieces get reassembled at the end.

My prediction is unglamorous: composition spells the letters. The G lands last, and it lands as a property of the network, of the flows between specializations, not of any single checkpoint. Go get all the letters. Just don’t try holding them all in one hand.