Self-Revising Discovery Systems for Science: A Categorical Framework for Agentic AI

TL;DR

Most “AI scientist” systems are very good at recombining ideas inside a fixed set of concepts, but real scientific discovery usually changes the concepts themselves: a new variable, a new operation, a new test. This paper gives a mathematical definition of that difference. It models the state of a discovery system as a typed artifact graph (every data object, model, and result has a type, and every operation has a declared input and output type). Search is updating that graph inside a fixed schema of types. Discovery is a verified move to a larger schema, where old evidence is carried forward by a standard construction (a left Kan extension) and the genuinely new content is exactly what that transport cannot produce. Two systems make it concrete: Builder/Breaker, which revises a symbolic protein-mechanics law under a compression (MDL) gate and discovers a new “mode-conditioned compliance” interaction; and CategoryScienceClaw, which turns a multi-agent research platform’s skills, artifacts, gates, and public discourse into one typed, proof-carrying knowledge graph.

Problem & Motivation

AI is now woven into every stage of science: it retrieves papers, proposes hypotheses, writes code, runs simulations, designs proteins, and drafts figures. Agentic systems chain these together and take partial responsibility for what to do next. But there is a question nobody has pinned down: when is the system merely searching inside a fixed scientific vocabulary, and when is it actually changing that vocabulary?

That distinction is not academic hair-splitting. It decides:

• How you must build the verifier. Checking “is this a better answer to the same question?” is a different job from checking “is this a legitimate new kind of answer?”
• How you audit provenance. If the vocabulary changed, you have to prove old evidence still means something in the new frame.
• How you measure progress. Scaling a fixed model gives you more of the same. Building a system that can commit to new representations is a categorically different capability.

The concrete pain: an elastic-network model of a protein fits compact proteins fine, then fails on a hinge protein because the real phenomenon is no longer local residue softness — it is softness expressed through a global collective motion. You can either fiddle coefficients (search) or admit a new effective concept (discovery). Prior “AI scientist” work blurs these two moves into one undifferentiated loop, so it cannot record, verify, or reuse the exact moment a representation had to grow. That missing bookkeeping is what this paper supplies.

What’s New (Core Contribution)

Four contributions, each a “before → now”:

1. A formal state model for discovery systems. Before: an agent’s state was a chat transcript, a hidden vector, or a model checkpoint. Now: the state is a copresheaf I_t : S_b → Set — a typed inventory of artifacts over a schema of types and operations — and the realized history is its category of elements (the actual provenance graph). Knowledge, computation, verification, rejection, and public discourse become one executable graph instead of three separate layers.

2. A clean split between search and discovery. Before: “the model improved” covered everything. Now: fixed-regime updates are modeled as an endofunctor Φ_b (which only earns that name if it preserves provenance), and discovery is a verified regime transition u : S_b → S_b' equipped with Kan-extension transport of old evidence and an explicit preservation map. A theorem shows that iterating Φ_b can never create an artifact of a type outside the current schema — so discovery genuinely needs the transition.

3. A quantitative discovery case (Builder/Breaker). A symbolic world-model of protein flexibility is revised by an adversary that picks failure-inducing proteins, under a Minimum Description Length gate. The accepted law is a new interaction type — local compliance multiplied by slow-mode participation — not just another additive term. The paper audits, in bits, exactly which parts were “transported” old physics and which were genuinely new.

4. A systems case (CategoryScienceClaw). A categorical, proof-carrying layer over an existing multi-agent platform (ScienceClaw × Infinite). Skills become typed morphism signatures, artifacts become typed objects with content hashes and parents, open questions become typed “holes,” and rejected models stay in the graph as first-class contrast objects.

The honest read: contributions 1–2 are a formal language, not a new algorithm. Its value is discipline and auditability, not raw capability. Contributions 3–4 are the working demonstrations that the language maps onto real runs.

How It Works (Technically)

Start with the one idea everything hangs on: a discovery system’s state is a typed artifact graph, and there are two fundamentally different ways to change it.

The core objects (category theory, demystified)

You do not need category theory background. Here is the whole vocabulary you need, in plain terms.

• Schema category S_b — a typed catalog. Its objects are artifact types (PDBChain, ContactGraph, SymbolicDAG, BFactorTarget). Its morphisms (arrows) are operations with a declared input type and output type (build : PDBChain → ContactGraph, fit : ContactGraph → SymbolicDAG). This is just a strongly typed API surface for your science.

• Copresheaf I_t : S_b → Set — the filled-in inventory at time t. For each type A, I_t(A) is the set of actual artifacts of that type you currently hold (the concrete PDB chains, the contact graphs built from them). For each operation f : A → B, I_t(f) says how an input artifact maps to the artifact it produced. Read “copresheaf” as “the current database, typed by the schema.” Nothing more mysterious than that.

• Category of elements ∫ I_t — the realized provenance graph. Its nodes are concrete pairs (type, artifact); its edges are the operations that actually ran to produce one artifact from another. This is your literal DAG of “this result came from that simulation came from this structure.” The paper’s point: provenance is not a metaphor here, it is this category.

That gives the state. Now the two kinds of change.

Change type 1 — search (fixed-regime update Φ_b)

Inside a fixed schema, an update reads the current artifacts, applies allowed operations, proposes new artifacts, runs them past a gate, and returns the next inventory:

Φ_b : [current typed inventory] → [next typed inventory]

The subtle part: for Φ_b to be a real endofunctor (not just “a script that rewrites JSON”), it must preserve refinements. A refinement is an arrow I → J saying “state J extends state I by adding verified artifacts without overwriting or silently merging old ones.” If your pipeline honors that (stable IDs, append-only or explicit supersession, no silent deletes), then whenever J extends I, the updated Φ_b(J) still extends Φ_b(I). In engineering terms: refactor the pipeline and old valid workflows still compose. The math is just formalizing an audit contract.

Key theorem (why search is not enough): finite iteration of Φ_b only ever produces artifacts whose type is already an object of S_b. So no amount of searching inside a fixed schema can invent a new kind of thing. Discovery must come from somewhere else.

Change type 2 — discovery (verified regime transition u)

Discovery is a schema map u : S_b → S_b' from the old catalog to a larger one. Usually u keeps all old types and operations and adds new ones (a new type, a new operation, a new verifier, or a new arrow between old types).

The problem: your old evidence lives in the old schema. How do you carry it into the new one, systematically and losslessly? Answer: the left Kan extension Lan_u I_t. Ignore the name; here is what it computes. For each type A' in the new schema:

(Lan_u I_t)(A')  =  colimit over all old artifacts that map toward A'

Operationally: “reinterpret old artifacts in the new vocabulary in the least-invasive way possible.” Two cases matter, and they carry the whole insight:

• If nothing old maps to A' (the indexing set is empty), then (Lan_u I_t)(A') = ∅. Transport supplies nothing at that type. Any artifact you have there is genuinely new — it could not have come from old evidence. This is the Kan obstruction: it is a hard, structural signal of real discovery.
• If some old type does map to A', old evidence transports in, even if A' itself is a brand-new object.

Finally, a verified transition ships an explicit preservation map ρ saying how each old accepted artifact survives in the new state. Its adjoint is the comparison map ρ̄ : Lan_u I_t → I'_{t+1}. The image of ρ̄ is the “transported evidence.” Everything in the new state outside that image is the discovery residual — the measurable content the system had to acquire beyond re-labeling old evidence:

residual at A'  =  I'_{t+1}(A')  \  image(ρ̄ at A')

And when a description-length functional is present, the discovery cost in bits is L(I'_{t+1} | image(ρ̄)) — how many bits to specify the new state given the transported old evidence. This is a genuine, non-subjective measure of “how much was discovered,” with no appeal to a fuzzy “novelty score.”

Generator-reachable vs. composite-reachable

One refinement that makes the protein result click. When a new type appears, classify it:

• Generator-reachable — reached by a single new arrow from an old type (a new unary transform of something you already had).
• Composite-reachable — reachable only through a new multi-input operation (e.g. a product of two old-derived quantities).
• Isolated — unreachable even by composites; pure forced residual.

The protein discovery is precisely a composite-reachable event, which is why it counts as a new scientific commitment rather than a refit. More below.

Architecture & data flow

flowchart LR
  subgraph Sb["Schema S_b (typed catalog)"]
    T1[PDBChain] -->|build| T2[ContactGraph]
    T2 -->|fit| T3[SymbolicDAG]
    T3 -->|score| T4[BFactorTarget]
  end
  I["Copresheaf I_t\n(actual artifacts per type)"] -. fills .-> Sb
  Sb --> EL["Category of elements ∫I_t\n= provenance DAG"]
  EL --> GATE{"Gate V_b\n(MDL / AIC / pressure)"}
  GATE -->|accept: same schema| PHI["Φ_b: next inventory (SEARCH)"]
  GATE -->|evidence won't fit| U["u: S_b → S_b'\nregime transition (DISCOVERY)"]
  U --> KAN["Lan_u I_t: transport old evidence"]
  KAN --> RES["residual = new state minus transported\n(the discovery content)"]

flowchart TD
  P[PDB chain e.g. 4AKE] --> A["contact graph A_ij\n(residues within 10 Å)"]
  A --> G["Kirchhoff matrix Γ"]
  G --> D["diagonalize → modes\nλ_k eigenvalues, u_k eigenvectors"]
  D --> C["compliance C_i = Σ u²/λ\n(how floppy residue i is)"]
  D --> M["slow-mode participation |u_i2|\n(motion in slowest collective mode)"]
  C --> PHI["φ = z(log C)"]
  M --> PSI["ψ = ReLU(z(|u_i2|)+θ)"]
  PHI --> PROD["φ × ψ  (NEW product operation)"]
  PSI --> PROD
  PROD --> BHAT["B̂ = α + β·φ·ψ\nmode-conditioned compliance"]
  BHAT --> GATE{"MDL gate:\nfewer total bits on same evidence?"}
  GATE -->|no| BREAK["Breaker picks a harder protein"]
  BREAK --> P
  GATE -->|yes| COMMIT[commit revised law]

Search vs. discovery, schematic. Left: artifacts recombine inside a fixed schema box (search). Trigger the transition and the box enlarges with a new type node that old arrows cannot reach — the Kan obstruction — which only new evidence can fill. Click to toggle.

The Builder/Breaker loop (the concrete discovery)

The physics is a Gaussian Network Model (GNM): treat a protein as beads (one per residue) joined by springs between residues closer than 10 Å. The math you actually need:

• Contact graph A_ij = 1 if residues i,j are within 10 Å (else 0). Just “who touches whom.”
• Kirchhoff matrix Γ = the graph Laplacian of that contact graph (off-diagonal -A_ij, diagonal = number of contacts). Standard network-stiffness matrix.
• Diagonalize Γ to get modes: eigenvalues λ_k (low = slow, collective, whole-domain motions) and eigenvectors u_k (the shape of each motion).
• Compliance C_i = Σ_{λ_k>0} u²_ik / λ_k — the diagonal of the pseudo-inverse. Plain English: how much residue i jiggles, summed over all modes, weighting slow modes heavily. This predicts crystallographic B-factors (measured atomic wobble).
• Slow-mode participation |u_i2| — how much residue i moves specifically in the slowest collective mode.

The learning target is the per-chain normalized B-factor (so absolute scale constants drop out). The discovered law:

B̂_i = α + β · φ_i · ψ_i        with  φ_i = z(log(C_i))  ,  ψ_i = ReLU(z(|u_i2|) + θ)

fitted α = -0.1332, β = 0.2239, θ = 2.2678. Mechanically: a residue has high predicted wobble when it is both locally soft (φ) and strongly participating in the dominant collective motion (ψ). Local softness that is not aligned with the slow mode gets down-weighted. That product φ·ψ is the discovery: LogNormCompliance × ReLUModeAmpl → ModeConditionedCompliance, a composite-reachable new interaction type that did not exist as an operation in the old schema.

The gate is Minimum Description Length. Total code length of a model M on evidence D:

L(M, D) = L_model(M) + L_data(D | M)

L_model = bits to write down the model (its complexity). L_data(D|M) = bits to encode the data given the model (its residual error). A proposed revision M' is accepted only if, after refitting both M and M' on the same accumulated evidence, L(M', D∪E) < L(M, D∪E). This is the compression test: a productive failure becomes real structure only when the new law explains the counterexamples well enough to pay for its extra bits.

The MDL gate as a trade-off plane (built from the paper's operator statistics, Fig. 7B). Each accepted move spends model bits (x) to buy data bits (y); everything below the diagonal frontier lowers total bits and is accepted. Additions pay bits to fit; removals shed complexity; swaps are near-neutral. Hover a point for its operator.

The algorithm, simplified

# Builder/Breaker discovery loop with an MDL gate.
# llm_propose_edit(model, evidence) -> a symbolic DAG edit (add/remove/swap/threshold a term)
# breaker_pick_protein(model, evidence) -> a new protein chosen to expose the model's failure
# refit(model, data) -> fit coefficients on this exact evidence set, return fitted model
# mdl(model, data) -> L_model(model) + L_data(data | model)   # total description length, in bits

def builder_breaker(model, evidence, outer_iters=4):
    for t in range(outer_iters):
        stress_protein = breaker_pick_protein(model, evidence)      # adversary: find a failure mode
        evidence = evidence + gnm_features(stress_protein)          # enlarge the evidence set

        for _ in range(inner_search_budget):                        # hill-climb over symbolic edits
            edit = llm_propose_edit(model, evidence)
            candidate = apply(edit, model)

            # paired comparison on the SAME evidence: both models refit first
            m0 = refit(model,     evidence)
            m1 = refit(candidate, evidence)
            if mdl(m1, evidence) < mdl(m0, evidence):               # candidate compresses better
                model = m1                                          # commit — accept the revision
            # else: reject; edit stays a recorded, rejected artifact

    return model   # e.g. B̂ = α + β·log_compliance·relu(slow_mode)

The whole categorical apparatus is the audit wrapped around this loop: which accepted edits merely re-transformed old quantities (generator-reachable) and which admitted a genuinely new composition (composite-reachable), plus the bit cost of each.

CategoryScienceClaw (the systems case)

The second system lifts an existing multi-agent platform into the same math. ScienceClaw is the execution substrate: a registry of typed skills, immutable artifacts with parent lineage and content hashes, shared “open needs,” pressure-based coordination, and workflow mutation. Infinite is the discourse substrate: structured posts (hypothesis, method, findings), claim links (extension, contradiction, replication), votes, comments, reputation. CategoryScienceClaw wraps both so that:

• skills = typed morphism signatures (A_1,…,A_k) → B
• artifacts = typed objects with hashes + parents (a typed multicategory, because artifacts have multiple parents)
• open needs = typed holes / lifting problems
• gates + rejected models = first-class provenance (the rejected model stays in the graph as a contrast object)
• the publication map into Infinite = a functor-shaped carry from private computation to public claim

The typed knowledge-computation graph in 3D (schematic). Blue nodes are old artifacts; grey edges are operations that ran. Trigger the regime transition and a new type node appears with no incoming old edge — the Kan obstruction — highlighted as forced-new discovery residual. Drag to orbit.

Worked example — a fiber network. Compute the orientation tensor A = Σ w_i n_i n_iᵀ, its nematic order S and anisotropy ratio χ = λ_max/λ_min, and a linear stress-strain fit σ = Eε + σ_0. Two candidate models: M0 = isotropic fiber count; M1 = orientation-tensor anisotropic stiffness. The gate is AIC (a lighter model-selection criterion than full MDL): accept M1 iff AIC(M0) − AIC(M1) > 0. Result: ΔAIC = 123.87, M1 accepted, M0 retained as the rejected alternative. The discovery residual at the new types is exactly the orientation tensor, principal axis, anisotropic stiffness surrogate, gate record, and perturbation stress test — the content transport could not supply from the old scalar-count regime.

Built on Prior Work

Results & Evidence

• Builder/Breaker, four outer iterations. MDL gains of +9.0, +37.3, +54.3 bits at the accepted transitions. Signed model-code change ΔL_model is +39.1 bits at the first transition but −14.4 and −10.3 bits at the later ones — the model got simpler while compressing more evidence. Selectivity is real: across all iterations the gate accepts only 25 of 388 proposals (6.4%), and one inner search kept just 16 of 144 edits. Feature removals are a high-yield operator, so discovery here includes retraction and compression, not only accumulation.
• The non-monotone R² (0.48 → 0.68 → 0.54 → 0.41) is not a failure. Each value is measured on a different, harder, larger evidence set (122 → 1171 residues), moving from compact proteins to hinge/domain stress tests. Data volume rose ~9.6× while model length rose only ~1.3×. The success criterion is paired MDL compression on the same evidence, not a rising benchmark curve — an important methodological point the paper argues carefully.
• CategoryScienceClaw fiber network. S = 0.673, principal orientation 47.9°, stiffness E = 119.4 kPa, linear fit R² = 0.999989, gate ΔAIC = 123.87 accepting the anisotropic model. Four supplementary mechanics runs (7T10 contact mechanics, mechanobiology force paths, membrane biophysics) follow the same typed audit skeleton.

What the evidence does and does not establish. It establishes that the categorical distinctions can be computed from real run logs and that they line up with an intuitive reading of what was discovered. It does not establish new physics as validated science — the authors are explicit that the CategoryScienceClaw runs use deterministic/synthetic computational inputs and are “not empirical validation claims.” The Builder/Breaker protein law is a compact structural proxy for B-factor patterns, not a first-principles or MD result. There is no benchmark comparison against other discovery systems (the paper deliberately refuses to make a leaderboard), and both cases are single-lab demonstrations. The underlying agents are GPT-5.5 (Builder/Breaker) and GPT-5.2 (CategoryScienceClaw), so results depend on strong closed models.

How You’d Use It

You run an AI services company; the practical payoff here is auditability as a product, not the protein physics.

• Typed provenance as the backbone of any agentic pipeline. The single most reusable idea: give every artifact a type and every tool a typed signature, store immutable artifacts with parent lineage and content hashes, and treat your workflow state as “the typed database + its provenance DAG.” This is a concrete spec you can implement now, and it directly attacks the biggest weakness of agentic demos: you cannot explain why an output was produced. A provenance-graph layer that replays any result’s lineage is a sellable deliverable for regulated or scientific clients.
• A gate that includes rejected candidates as first-class objects. Most agent systems throw away rejected ideas. Keeping the rejected model with the gate record turns “model selection” into an inspectable artifact — exactly what an auditor, reviewer, or skeptical client wants to see.
• A defensible definition of “novelty” for R&D clients. The residual-beyond-transport idea gives you a non-hand-wavy way to say “this part of the output is genuinely new vs. this part is recombination.” That is valuable framing for IP, for grant reporting, and for pricing “discovery” work.
• Schema-transition logging for long-running agent projects. When your agents start needing a new type/tool/verifier that the current pipeline can’t express, log that as an explicit regime transition with a preservation map. It converts “we changed how the system works midway” from a liability into a documented, replayable event.

Where it slots in: a middleware layer between your agent orchestrator and your artifact store. You do not need the category theory in code to get 80% of the benefit — you need the contracts it encodes (stable IDs, append-only lineage, typed signatures, explicit supersession, gate records).

Build Your Own (Minimal Recipe)

A toy that captures most of the value in a weekend or two:

1. Define a tiny schema. A list of artifact types and a list of operations each with (input_types) -> output_type. Store it as data, not code, so it can grow.
2. Store artifacts as immutable typed records. {id, type, value_hash, parents: [ids], produced_by: op, status}. Append-only; supersession is a status flag, never a delete. This is your copresheaf + provenance graph.
3. Write the fixed-regime update Φ. A loop: read current artifacts, run allowed operations to propose new ones, run a gate, commit accepted ones with lineage. Enforce the audit contract (no silent merges/deletes).
4. Implement one real gate. MDL is the instructive choice: total_bits = model_bits + data_residual_bits; accept a revision only if it lowers total bits after refitting both models on the same data. AIC is a lighter drop-in.
5. Implement a regime transition as a schema diff + a transport function. When the update wants a type/op that doesn’t exist, add it, and write the “carry old artifacts forward” map. The residual is trivial to compute: new artifacts whose type or producing-operation did not exist before. You get the Kan obstruction for free — a new type with no incoming old operation is pure discovery content.
6. (Optional) A Builder/Breaker wrapper. One agent proposes edits to a symbolic model; a second picks inputs designed to break it; the gate decides. Symbolic regression over interpretable features (compliance, mode participation) is the pattern.

The two genuinely hard parts: (a) the gate — a principled, paired, refit-on-same-evidence comparison is more work than a naive score check, and it is what makes acceptance meaningful; (b) honest transport — deciding how old artifacts survive a schema change without silently losing provenance. Everything else is disciplined bookkeeping. Reach for: a symbolic-regression library (PySR) for the model search, numpy/scipy for the GNM linear algebra, and a plain content-addressed store (even SQLite with hashes) for the artifact ledger.

How to Improve It

1. Learn the schema instead of hand-building it. The authors flag this as the major open problem. Mine tool signatures, code, equations, and figures to induce the type-and-operation catalog S_b and its description-length functional from a corpus — the difference between a framework and a system that grows its own vocabulary.
2. Make the categorical layer software-enforced, not just descriptive. Right now CategoryScienceClaw records typed provenance but does not check that diagrams commute or that every public claim has an admissible artifact path. A verifier that fails the build when provenance is broken would turn the audit from documentation into a guarantee — and is a clean product feature.
3. Estimate discovery cost at scale. The bit-cost L(new | transported) is defined but reported only as paired MDL gains. Build tooling that computes the true residual code length, split into an artifact term and an operation-registry term (the paper’s multicategorical decomposition), so you can compare investigations by how much they actually discovered.
4. Attack the convergence question. As the system produces regime transitions b_0 → b_1 → b_2 …, when does the sequence of transported states stabilize vs. oscillate unproductively? A practical detector for “we are churning the schema without net gain” would be directly useful in long-running agent projects.
5. Stress-test the gate against reward hacking. MDL/AIC gates can be gamed by clever feature engineering that lowers bits without real generalization. Pair the compression gate with held-out adversarial evidence chosen by the Breaker to make acceptance harder to fake.

Glossary

• Schema category S_b — the typed catalog: objects are artifact types, arrows are operations with typed inputs/outputs.
• Copresheaf I_t : S_b → Set — the current typed inventory; for each type, the actual set of artifacts held.
• Category of elements ∫ I_t — the realized provenance graph (concrete artifacts as nodes, operations that ran as edges).
• Endofunctor Φ_b — a fixed-schema update that preserves provenance structure (adds artifacts without breaking old lineage).
• Regime / schema transition u : S_b → S_b' — a move to a larger schema; the formal act of discovery.
• Left Kan extension Lan_u I_t — the standard construction that transports old artifacts into the new schema in the least-invasive way.
• Kan obstruction — when a new type receives no operation from the old schema, transport yields the empty set there; anything present is forced-new discovery content.
• Comparison map ρ̄ / residual — the map from transported evidence into the new state; the residual (new state minus its image) is the measurable discovery content.
• Generator-reachable vs. composite-reachable — a new type reached by a single new arrow vs. one reachable only via a new multi-input (product) operation; the protein discovery is the latter.
• MDL (Minimum Description Length) — model-selection by total bits: L_model + L_data(data|model); simpler models that explain more win.
• AIC — a lighter model-selection criterion penalizing parameter count; used as the fiber-network gate.
• GNM (Gaussian Network Model) — a protein as beads-and-springs from residue contacts; predicts residue wobble (B-factors) from structure alone.
• Compliance C_i — how much residue i fluctuates, from the pseudo-inverse of the Kirchhoff (contact-Laplacian) matrix.
• Mode-conditioned compliance — the discovered relation: predicted flexibility = local compliance × participation in the slowest collective motion.
• Multicategory — a category whose arrows can take several typed inputs at once; the right model when artifacts have multiple parents.