Search is not discovery: a typed account of self-revising AI
A new MIT paper separates retrieval, search, and discovery with category theory, defining discovery as a verified change of representational regime rather than subjective novelty. Here is why that typed, gated boundary is exactly what production agent systems are missing.
Most of the agentic systems I run in production are very good at one thing: recombining what they already know. They retrieve a paper, search a design space, fit a coefficient, rewrite a function. What they almost never do — and what I cannot currently make them do in an auditable way — is change the vocabulary they reason in. A new paper from MIT, Self-Revising Discovery Systems for Science by Fiona Y. Wang and Markus J. Buehler, takes that gap seriously and gives it a precise shape. It argues that scientific discovery is not answer generation but revision of the representational regime in which evidence, artifacts, operations, and verifiers are typed — and it makes that claim operational with category theory.
I want to walk through why I think that framing is the right one for anyone building agents, even if you never write down a single functor.
Three operations that look the same and aren't
The paper's most useful move is to separate three things that current "AI scientist" demos tend to blur:
- Retrieval adds an artifact the system could already represent — pull an existing structure, cite an existing result.
- Search finds a new path or object inside a fixed schema — a new composition of operations you already have, a better point in a space whose axes are fixed.
- Discovery changes the regime in which artifacts and operations are typed — a new effective variable, a new admissible operation, a new verifier, a new tool, a new artifact type.
Stated plainly, this sounds obvious. In practice it is the distinction most agent evaluations get wrong. A model that "proposes a novel hypothesis" is, almost always, searching: recombining inside a fixed vocabulary. That is useful, but it is not the move that reorganizes a field. Knowing which one your system just made determines how you should verify it, how you audit its provenance, and whether scaling the same model will ever produce the other behavior. The authors are blunt that it will not — optimizing inside a representation is qualitatively different from constructing a new one.
The machinery, without the jargon tax
Here is the categorical core in engineering terms. A schema is a category S_b: its objects are artifact types (sequence, structure, contact graph, normal mode, symbolic model, score, report) and its morphisms are the allowed operations between them (build a contact graph, diagonalize a Kirchhoff matrix, fit a symbolic expression). The system's current state is a copresheaf I_t: S_b → Set — which actual artifacts inhabit each type right now. The realized provenance is the category of elements ∫ I_t: the typed graph of what was built from what.
A fixed-regime update is an endofunctor on those states — but only legitimately so when it preserves provenance. Discovery is something else: a regime transition u: S_b → S_b′. Old artifacts are carried into the new schema by transport (a left Kan extension, Lan_u I_t), then compared against the post-transition state. Whatever is left over — content that could not have arrived by transport alone — is the discovery.
That last step is the part I keep returning to. It gives "novelty" an objective definition: residual content beyond functorial transport, not a judge model's vibe. If everything in the new state is the old state relabeled, nothing was discovered. If something genuinely new survives the comparison, you can point to exactly what it is.
The verifier is the load-bearing part
A regime change is only credible if it passes a gate, and the paper instantiates this twice. In Builder/Breaker, a protein-mechanics world model is revised under a Minimum Description Length gate; the accepted law expresses within-chain flexibility as all-mode elastic compliance conditioned by slow collective-mode participation — "mode-conditioned compliance." The point is not the law itself but the discipline: a new variable is admitted only because it pays for itself in description length. In CategoryScienceClaw, typed skills, artifacts, open needs, gates, stress tests, and even public discourse become one proof-carrying knowledge–computation graph; a fiber-network example records the candidate models, the rejected alternatives, an AIC gate, the perturbation tests, and the accepted anisotropic-stiffness surrogate that supersedes an isotropic fiber-count descriptor.
What I value here is that the rejected paths are first-class. In most agent transcripts, the alternatives a model considered and discarded are lost. Here they are typed records in the same graph as the accepted result, which is the only way a regime change stays auditable later.
Why I care, building this for real
Three things carry over directly to production work.
First, measure novelty structurally. "Residual content beyond transport" is something you can compute against a schema; "the model said it was novel" is not. Any honest evaluation of an agentic discovery loop should be able to say which of retrieval, search, or discovery just happened.
Second, provenance has to be typed, not logged. A chat history is not a provenance graph. If you cannot say what type each artifact has and which operation produced it, you cannot tell a refit from a genuine extension — and the dangerous failure mode in production is an agent quietly enlarging its own schema with no gate in front of it.
Third, the paper reverses a habit worth dropping. We usually bolt AI onto a domain as an external optimizer. Wang and Buehler let mechanics define the system instead: tracking boundary conditions, preserving invariants, testing failure modes, distinguishing a new constitutive structure from a refit of old variables. Those are exactly the habits a self-revising agent needs, and they are older and better understood than any agent framework.
What it is and isn't
This is a specification, not a shipped product, and the formalism asks more of the reader than most engineering teams will want to pay up front. But it names the thing my systems are missing: a typed, gated boundary between optimizing inside a representation and changing it. I would rather build toward that boundary deliberately than keep shipping agents that search confidently and call it discovery. The full paper is worth the effort.