tannishmango

Invariants

Working notes.

Framework churn

Every few weeks there is another agent framework, loop, harness, swarm, router, supervisor, or other name for models calling models while carrying various amounts of state. Some of these systems solve real problems. I have no useful taxonomy for them yet, and I doubt a taxonomy written around the current models would survive very long.

The question I care about is narrower. As models get better, context windows grow, and inference prices move around, is there any orchestration pattern that remains useful enough to build around?

Right now I think there is at least one. A capable model handles decisions that affect large portions of the work, turns the result into narrower specifications, and gives those specifications to cheaper or more specialized models. Any child task that still contains important unresolved decisions can go through the same process again. This produces the recursive planner and implementer tree that Cursor used in its recent swarm experiments.1

Information theory

This is where I need to clean up the information theory intuition rather than turn it into fake mathematics.

Shannon entropy describes expected information under a probability distribution.2 Kolmogorov complexity describes the length of the shortest program that produces one particular object, relative to a fixed universal machine.3 They are related under particular assumptions, but neither is a generic measurement of how hard a task feels.4 A software task has no canonical entropy unless somebody supplies a distribution over requirements, implementations, failures, or whatever random variable is supposed to matter. A model or team can maintain subjective beliefs over those things, although the resulting entropy belongs to that model of the task rather than to the task by itself.

The phrase “compression is intelligence” is also too strong if read as an identity. When the cost of the compressor is counted, good compression is evidence that a system has found regularity in the data. This is the intuition behind minimum description length, the Hutter Prize, and Sutskever’s discussion of the correspondence between prediction and compression.567 It does not follow that every good compressor is generally intelligent, or that a system which fails to compress must be memorizing. The data may contain irreducible noise, the compressor may have the wrong inductive bias, or the evaluation may reward a trick that does not generalize.

My first impulse was to treat the finished artifact as the object, the orchestration as the program, and token spend as program length. The last step is wrong. Token spend is closer to runtime or computational cost than description length, and even that is only a proxy because equal token counts can have very different hardware, latency, and dollar costs. A search might consume a billion tokens to discover a ten-line specification, while a ten-line prompt can invoke an absurd amount of computation.

The part I still find useful is to think of a specification as a description that a worker decodes with the codebase, tools, and its own weights as side information. The output is allowed to differ from any particular artifact as long as it satisfies the intent, which makes this vaguely rate-distortion shaped: the specification should preserve the distinctions that alter the result and omit the ones that do not.8 This is an analogy, not a direct application of classical rate-distortion theory, since we do not have a defined source distribution or a complete distortion function. Tests are at best a sparse and rather gameable proxy for distortion.

The length of the plan is therefore much less interesting than the combined cost of producing it, carrying it out, and repairing the places where it failed to preserve intent. If a short plan leaves the wrong decisions implicit, the missing description reappears as worker search, inconsistent implementations, or rework. That downstream residue is the quantity I want an allocator to notice.

Cursor’s experiment

Cursor asked several model configurations to implement SQLite in Rust from its 835-page manual. The new system used planner agents for decomposition and worker agents for implementation. At the four-hour cutoff, its configurations had reached between 73 and 85 percent of a held-out sqllogictest suite, and each later reached 100 percent of that suite. This does not mean they reproduced every SQLite behavior or performance characteristic. It does give the runs a common external score.

The reported cost ranged from $1,339 for Opus 4.8 planning with Composer 2.5 workers to $10,565 for GPT-5.5 handling both roles.1 Workers consumed at least 69 percent of the tokens and more than 90 percent in most runs. In the all-GPT configuration, worker inference cost $9,373; in the Opus and Composer configuration it cost $411.

The Opus and Fable hybrids are the part I keep circling. Both used Composer workers, and Fable spent fewer planning tokens, but its workers used several times more tokens and made the whole run substantially more expensive. It is tempting to attribute the difference to the plans, which would fit the idea that omitted structure reappears downstream. These were not repeated, role-swapped experiments with uncertainty estimates, however, so the comparison is suggestive rather than a causal estimate of planner quality. The useful measurement idea survives the caveat: planner cost should be evaluated together with the worker search and correction that follows it.

Cursor’s old Grok run accumulated more than 70,000 merge conflicts before being stopped during its second hour. The new Grok run logged fewer than 1,000 over four hours. In the Fable comparison, the old system eventually passed the same test suite with 64,305 lines of engine code while the new one used 9,908. Cursor suspects the ability to keep planning context separate from implementation detail matters more than parallelism itself, and these numbers are consistent with that explanation, although the harness changed in several ways at once.

I keep calling the recursive control structure a tree, but repository work acquires cross-links almost immediately. Separate tasks touch the same file, depend on the same design decision, and return information that affects siblings. Cursor had to add shared design documents, reconcilers, neutral conflict resolution, and a mechanism for splitting files that became sites of contention. The planner and worker hierarchy may be a tree while the dependency and invalidation structure is a graph, and replanning has to follow the latter.

New models change where decomposition should stop. A stronger worker can take a wider assignment with fewer instructions, and a planner may decide that a small task is cheaper to complete directly than to route. An explicit multi-agent system can stop paying long before context becomes infinite or inference becomes free. What seems stable to me is the availability of recursive decomposition and the need to decide when it is worth using, rather than a claim that every problem wants a large swarm.

Exploration and replanning

The annoying problem with planning is that some facts become available only after work begins. Anthropic’s field guide describes ways to expose them through codebase inspection, prototypes, questions, references, and implementation notes.9 A plan made before this work may be perfectly clear about the wrong picture of the problem.

I do not think every missing fact should be described as entropy. Two equally surprising observations can have completely different consequences if one changes an architectural decision and the other changes nothing. Decision theory’s value of information is closer to what an agent needs: acquire information when its expected effect on later decisions is worth more than the cost of acquiring it.10 This depends on beliefs, consequences, and the actions available afterward, rather than surprise alone.

Exploration should therefore be one of the actions available to the planner, alongside further reasoning, implementation, clarification, and delegation. An exploratory worker may produce no code and still save the run by changing the next decomposition. Once implementation starts, workers need to return discovered constraints as well as patches, and those constraints should invalidate every dependent part of the task graph rather than merely travel to a convenient parent in the control tree.

This has the recursive oddity that interested me in the first place. The planner has to spend intelligence deciding how much intelligence to spend, including whether to delegate that decision to another planner, which receives a smaller version of the same problem. There is no clean point outside the recursion from which the correct tree is visible in advance. Kolmogorov complexity is also uncomputable in general, although that fact should not be stretched into a proof that every finite decomposition problem is uncomputable. It is enough to prevent Kolmogorov complexity from becoming the metric in an actual router.

The objective I currently have in mind is closer to:

π* = arg minπ E[C_inference + C_latency + C_coordination + C_rework + L_failure | I_t]

Here π is an adaptive policy over future observations and actions, not a one-time model selection. I_t is whatever is known at the current point. The terms have to be converted into common units that reflect the actual objective, and quality can instead be imposed as a constraint if failure loss is too artificial. This is not yet measurable enough to be a theory. It is a list of costs that a useful router should eventually learn to predict.

Cheap inference

The generic hardware objection is that inference prices will collapse through specialized silicon and efficient open models, at which point everyone can use maximum reasoning everywhere and stop caring about routing. I do not know enough about ASIC scaling or future model architectures to project the relative cost curves with confidence.

Absolute cost declines do not settle the question because routing depends on relative costs, capability differences, task heterogeneity, and its own overhead. If specialized hardware makes frontier reasoning disproportionately cheap, the frontier model should take more of the tree. If the workload is small or homogeneous, routing may already lose. If frontier and worker models remain different enough, a system can use specialized hardware for both and still benefit from assigning work according to those differences. None of these outcomes is guaranteed by the mere existence of an ASIC.

Token prices are only one term anyway. Hardware can make extra search, verification, and larger contexts affordable, so it may indirectly reduce mistakes as well as inference cost, but it does not automatically reconcile conflicting design decisions or determine which context is relevant. The present Cursor result says that model allocation and context separation matter in the configurations they tested. I would like to know how quickly that result weakens as the frontier-worker price ratio falls and worker capability rises.

Open questions

  • How can a planner estimate whether a task is specified well enough for a cheaper worker without first doing most of the task?
  • Can planner quality be measured by downstream worker search and rework while controlling for the stochasticity of the run?
  • How should new information propagate through the dependency graph without forcing the entire plan to be rebuilt?
  • When does another round of exploration have positive expected value, and can a model estimate that without spending the same inference the estimate is supposed to save?
  • How do the stopping rules move as hardware changes the relative prices of planning, execution, memory, and verification?
  • Does the recursive planner and implementer pattern remain externally visible, or do sufficiently capable models internalize it within one inference?

References

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

  2. Claude Shannon, “A Mathematical Theory of Communication” (1948). ↩

  3. Andrey Kolmogorov, “Three Approaches to the Quantitative Definition of Information” (1965). ↩

  4. Peter Grünwald and Paul Vitányi, “Shannon Information and Kolmogorov Complexity” (2008), a careful treatment of where the two theories meet and where they do not. ↩

  5. Peter Grünwald, The Minimum Description Length Principle (MIT Press, 2007). ↩

  6. The Hutter Prize, a continuing prize for improvements in lossless compression of a fixed Wikipedia corpus, motivated by the connection between compression and modeling. ↩

  7. Ilya Sutskever, “An Observation on Generalization” (Simons Institute, 2023). ↩

  8. Claude Shannon, “Coding Theorems for a Discrete Source with a Fidelity Criterion” (1959), the origin of rate-distortion theory. ↩

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

  10. Ronald Howard, “Information Value Theory” (1966), on valuing information by its effect on decisions rather than its probability alone. ↩