Argument chains: holding the agent’s explanation to the requirements
Breaking the code checks the code. A chain checks the agent’s explanation of the code. When an agent finishes a change, it writes down, step by step, why the change does what the requirements ask: each step is one claim in plain words, plus what that claim stands on. The loop then checks every step against the requirements, the code and the graph.
A chain is a written argument the agent produces on purpose, like showing your work. It is not a recording of the model’s private thinking, and the tool does not try to extract that.
What a chain looks like
A real one, run on a copy of the kit’s example, a store’s wallet. It names the question it set out to answer, then its steps; each step says one thing and cites what it stands on: a requirement’s id, a question put to the owner, or a method in the code.
chain:
id: CH-EXAMPLE
question: "Does a purchase stop when the stock is gone?"
steps:
- says: "A limited line sells its quantity and is then sold out"
cites: [W-3, Store.Buy]
The four checks
- Grounded. Every cite must exist: a requirement in the model, a question the owner was asked, or a method the code really has. A step that cites nothing, or cites something that is not there, fails the run.
- Same words. The step’s words should share at least one word with what it cites. If they share none, the step is flagged for a person (“a new finding, or a mistake”). This is a hint, not a failure.
- Joined in the graph. For every pair of things one step cites, the graph must already connect them within four links. The shortcuts that would make everything look connected are not counted: the chain’s own links, the shared “space” node, and the records of breaks and tests. A pair the graph does not join is either a link the model is missing or a mistake in the argument, and a person decides which.
- Blind spots. Every inferred requirement (an owner’s open question) that no step cites is listed: the chain never looked there.
The chain also becomes part of the graph: a node for the chain, a node for each step, and a link from each step to everything it cites. A later agent can see which explanations rest on which requirements.
How a chain meets the code
The chain does not sit beside the graph: it goes in. Take that step, “A limited line sells its quantity and is then sold out”, citing W-3 and Store.Buy. The step becomes a node with an edge to each of those, and both were already nodes. Then the graph walks from one to the other. Here a branch of that method maps to W-3, so the two are 2 links apart, and the report says so: “grounded; the graph joins every pair it cites”. The picture on the slide is this step’s walk through the example’s graph, on down through the code, a branch, a break of that branch and the test that caught it.
Run end to end on 30 October, on a copy of the kit's example
Measured A chain with real cites: exit 0, and the chain and its step are in the graph with their cites. The same step citing a requirement that does not exist: exit 1. Citing a method the code does not have: exit 1. Citing nothing: exit 1.
Run on the kit’s example, 30 October
Measured CH-EXAMPLE: 1 step, grounded, and the pair it cites already joined in the graph, 2 links apart. The owner’s one open question, W-4 (what a refused purchase does to the stock), is a blind spot: the chain never looked at it. The whole loop on that copy held.
What it does not check yet
Open Whether a claim is true of the code. A real step, in one of our own runs, said “or” where the code needs both, and passed. A fresh reviewer found it. The fix being built: a step can carry a precise claim in the same form a requirement’s effect uses (for example, which two values a method branches on), and the code check tests it the way it tests an effect.
Open Whether the code a step stands on is tested. Next: a chain is accepted only if no break that got past the tests sits in code one of its steps stands on.
On the slides: slide 11.
Made by RJ’s TNT Tools. TNT Tools’ own work, not a Heavy Iron product.