tannishmango

Invariants

Rough notes, first entry. Later notes will reference, revise, and probably contradict this.

The churn problem

The software environment right now is defined by churn. Frameworks, “loops”, harnesses, swarms, orchestrators. The jargon multiplies faster than the standards. Every serious team building with agents is grappling with some version of the same questions: where in the stack does the agentic layer actually belong? Which abstractions are safe to build on? How much do you invest in orchestration tooling when the next frontier model might invalidate it? Each model generation blows a swath of frameworks and would-be standards out of the water, and teams that bet on the wrong abstraction eat the rewrite.

So the question I keep coming back to: what are the invariants? What survives the model upgrades?

The frameworks won’t tell you. The frameworks are the churn. You have to go a level down.

Three heuristics

Everything in this note unfolds from three ideas, none of them mine, all of them old enough to have gray hair:

  1. Compression is intelligence. Kolmogorov1 defined the complexity of a dataset as the length of the shortest program that reproduces it. A system that compresses gigabytes into a tiny set of rules has found the hidden structure. A system that can’t has memorized. Shannon2 set the floor, Hutter3 turned it into a cash prize, Sutskever4 turned it into a lecture.
  2. Planning is entropy compression. A goal, freshly conceived, is a high-entropy object: a huge space of possible implementations, most of them wrong, weighted by intent that only exists in your head. A spec is a compressed encoding of that intent. Short message, collapsed possibility space, cheap to decode.
  3. Some entropy can’t be compressed up front. You don’t know what you don’t know, and finding out is itself work that has to be scheduled. Exploration precedes compression, and the plan has to keep replanning as reality reports back.

Now the mapping I actually care about. Treat the finished artifact as the dataset. Treat the entire orchestration that produced it (every agent, every token, every reasoning pass) as the program. Token spend is program length. Then “build the thing intelligently” means “find the shortest program that reproduces it,” and allocating the right level of model to the right task stops being a devops preference and becomes the Kolmogorov problem restated with a billing meter attached.

Is any of this news? To the people I argue with, no. This is catechism. Everyone in AI has nodded along to “compression is intelligence” the way everyone in finance has nodded along to “past performance is no guarantee.” What’s overlooked isn’t the slogan, it’s the operationalization. Watch how teams actually route work and you’ll see intelligence allocated by vibes, deadline panic, and whichever model was already selected in the dropdown. The heuristics are known as trivia and unused as tooling. That gap is the whole note.

The tree unfolds

Take the heuristics seriously and a structure falls out: the recursive planner-implementer tree. A planning agent breaks a goal into pieces and delegates each piece to an implementer. Any piece still too ambiguous becomes a subplan, recursively, until the leaves are tasks explicit enough to just execute. Specs flow down, results flow up. Each node holds only the context it needs.

Why this shape and not another? Because every node is a compression event. The planner takes high uncertainty in and emits a description that leaves very little ambiguity behind, which is precisely the expensive frontier capability, so that’s where you spend it. Executing an explicit instruction is a low-entropy stream, so you hand it to a cheap decoder. Pointing a max-reasoning model at an already-compressed task is running your best compressor on a stream that’s already near its Shannon limit. You pay frontier prices to recover bits that were never there.

Cursor just published research on agent swarms5 that lands here with receipts:

  • Hierarchical swarms (frontier planners delegating to cheaper, faster workers) hit similar quality across every model mix they tried, 73-85% on their SQLite benchmark, while cost varied 8x ($1,339 to $10,565) depending on where the intelligence went.
  • Workers burned 69-90% of the tokens, but the frontier planner ate roughly two-thirds of the cost. The expensive model does a small fraction of the tokens and most of the important work.
  • Their line: few moments in a large task genuinely require frontier intelligence. Once a frontier planner has collapsed the ambiguity into a detailed, explicit instruction, cheaper models just follow it.
  • Context efficiency, not raw parallelism, drove scalability. Agents with focused scopes don’t drift.

Notice they talk economics, not information theory, and land in the same clearing anyway. Different roads converging on the same spot is what an invariant looks like from the outside. And the recursion explains why it survives model generations: each new frontier model changes how much ambiguity a single node can collapse, which changes the tree’s depth and branching factor, but not the tree.

The cheap-inference objection

The standard counter: inference costs are collapsing, between AI ASICs and cheap open-weight reasoning models, so just set everything to max reasoning, skip the planning apparatus, and let the agents rip. Why architect for a scarcity that’s about to disappear?

First, cheaper tokens don’t change the optimal allocation. They just lower the cost of ignoring it. If quality is flat across model mixes and only cost varies, near-free inference shrinks the penalty in dollars, but the same Jevons dynamic that makes tokens cheap makes everyone’s ambitions bigger, and the allocation question comes right back at the new scale. And anyone who has watched engineers under deadline pressure reflexively slam the most expensive max-reasoning tier at every problem knows the waste is real today: thousands of dollars in a couple of days, mostly spent decoding streams that were already explicit.

Second, even at zero token cost, context isn’t free. A single agent reasoning at max effort across a whole large task drags its entire history along and drifts. Coordination overhead grows faster than the work itself, which is Coase on firms6, and Cursor rediscovered it in agent form: their early swarms produced 70,000 merge conflicts, the deliberately structured one under 1,000, with 6x less code for the same outcome. The tree isn’t a cost hack. It’s what keeps every context window small and scoped. Contextual isolation is the actual payoff of parallelism.

Now the honest caveat, because the hardware argument deserves better than a strawman. Suppose ASICs get hyper-tuned per model, silicon shaped to one specific high-reasoning model the way a glove is shaped to a hand. I don’t know the AI ASIC scaling laws. I have no principles for projecting what specialized silicon does to the cost of high reasoning, and I’m suspicious of anyone who claims to from the armchair. Maybe the gains are violent enough that “big model for everything” becomes locally correct in some regimes. But notice the comparison isn’t ASIC versus orchestration. It’s ASIC-for-high-reasoning alone versus ASIC-for-high-reasoning plus ASIC-for-low-reasoning plus proper delegation between them. Hardware discounts every node in the tree at once. If specialization wins at the silicon layer, the normalized comparison seems to preserve the orchestration advantage: you’d still route low-entropy work to the cheap specialized decoder and high-entropy work to the expensive specialized compressor, just at lower absolute prices. Efficiency gains compose. They multiply through the allocation rather than replacing it. I hold this one loosely and would genuinely like to see the regime where it breaks.

The loop at the bottom

There’s a real objection hiding inside “let it rip,” and it’s the third heuristic biting back. Anthropic’s field guide on finding your unknowns7 names the actual bottleneck of agentic work: the quality ceiling is set by your ability to surface the gaps between your description of the task and reality. Known unknowns, unknown knowns you’d never think to write down, unknown unknowns entirely off your map.

Here the theory gets pleasantly strange. To compress a task you need to know its entropy. To know its entropy you have to explore it. Exploration is itself a task, which could use a plan, which requires knowing its entropy, which requires exploring it first. Down and down. It never fully grounds out, and in fact it provably can’t: Kolmogorov complexity is uncomputable8, so the perfect allocation of intelligence is uncomputable too. You cannot, even in principle, know the shortest program in advance. This sounds like bad news for the whole thesis until you recognize it as the job description. Engineering is the practice of approximating uncomputable optima with computable heuristics. The tree doesn’t promise the shortest program. It promises a systematically shorter one than “throw the biggest model at the undifferentiated blob.”

So the reconciliation of plan-everything and let-it-rip: exploration is the search phase of compression. When an agent runs ahead loosely, prototyping, probing the codebase, interviewing you about ambiguities, it isn’t skipping the plan. It’s measuring the distribution the plan will compress. Unknown unknowns become known knowns, then the planner compresses them into specs and pushes them down the tree. A plan written before that conversion is compression of the wrong distribution: confidently short, and wrong. And the loop runs continuously, not once. Every unexpected constraint an implementer hits at a leaf is new information that propagates up and triggers recompression above it. The tree is less an org chart than a metabolism.

If I had to compress this whole note into one hypothesis, the first draft of the equation I actually want:

Total cost of a task ≈ the sum over tree nodes of (bits of ambiguity collapsed at the node) × (price per bit of the model you pointed at it), minimized subject to the constraint that a node’s ambiguity is only revealed by spending intelligence to explore it.

The first term says allocate by entropy. The constraint says the entropy isn’t free to know. Everything above is prose orbiting that inequality, and my guess is the eventual real theory of agent orchestration is a proper treatment of it.

The open territory

I think intelligent routing, delegation, and specialization, mediated by reasoning planners that decide where intelligence gets spent, is the most underexplored optimization surface in the field right now. Model capabilities get the headlines and harnesses get the GitHub stars. The allocation layer in between, the part that decides which node of the tree gets frontier compression and which gets a fast decoder, barely exists as a discipline.

The frameworks will keep churning. Intelligence is compression, compression is expensive, and the tree is how you spend it where it counts.

References

  1. Andrey Kolmogorov, “Three Approaches to the Quantitative Definition of Information” (1965). The complexity of an object is the length of the shortest program that produces it. ↩

  2. Claude Shannon, “A Mathematical Theory of Communication” (1948). The paper that made information a measurable quantity. ↩

  3. The Hutter Prize: a standing cash bounty for compressing Wikipedia, on the argument that better compression just is better AI. ↩

  4. Ilya Sutskever, “An Observation on Generalization” (Simons Institute, Berkeley, 2023). The compression-as-generalization argument, from someone with unusual standing to make it. ↩

  5. Cursor, “Agent swarms and model economics” (2026). ↩

  6. Ronald Coase, “The Nature of the Firm” (1937). Firms exist because coordination has costs that grow faster than the work being coordinated. So do planner trees. ↩

  7. Anthropic, “A field guide to Claude Fable: finding your unknowns” (2026). ↩

  8. No algorithm can compute Kolmogorov complexity for arbitrary inputs; it is equivalent in hardness to the halting problem. The optimum provably exists and is provably out of reach, a very Gödelian arrangement. ↩