I have been writing about agents and software iteration for a while. Each essay has been one corner of the same picture: software is memoization, there is no such thing as "an agent", iteration speed is the substrate of progress, and the right way to test an agent is to wrap it in an end-to-end harness with mock users and a fitness function.
Eventually a frame becomes operational. You stop writing about the loop and start running it. The artifact is a gist — call it justinception — that distills the methodology into a single portable document. The name is multi-purpose: the just-in-time compilation metaphor (the agent is recompiled each session from cached scaffolding); the inception / nested-doll structure of concentric isolation rings; and the self-applying property of using agent patterns to develop agent tools.
The Ring model
Agent tool systems have concentric rings of trust and rigidity:
- Ring -1 (Methodology) — the portable, project-agnostic doc. Generic procedure: signal first, prioritize by ring + ROI, fix, reduce entropy, commit. Never names a specific file or tool.
- Ring 0 (Architect) — project CLAUDE.md and design journal. Project-specific Ring mapping. Disappears after deployment. Not shipped.
- Ring 1 (Director) — the human user (production) or mock user (testing). Expresses intent, judges quality.
- Ring 2 (Operator) — the LLM-driven agent (production) or mock agent (testing). Decides what to do.
- Ring 3 (Engine) — deterministic code. The skeleton. Enforces invariants. This is what we ship.
- Ring 4 (Specialist) — LLM calls wrapped by Ring 3. The organism inside the skeleton — prompts, skills, fresh search within engine-enforced constraints.
Read top to bottom: organism → organism → skeleton → organism. Organic (adaptive, probabilistic) layers sandwich an inorganic (deterministic, rigid) core. The same pattern recurs in the memoization frame: Ring 3 is the cached search structure; Ring 4 is the freshly-generated solution that inhabits it.
There are two phases. Ahead-of-time development: Ring 0 mocks Ring 1-2 to evolve Ring 3-4. E2E runs are parallel universes; the grader is the fitness function. This is exactly the E2E harness shape. Just-in-time production: Ring 1 becomes real users, Ring 2 becomes real agents, Ring 0 is gone. The agent is recompiled from the cached infrastructure on every invocation — Ring 4 fresh search inside Ring 3 invariants.
Why this is "agents iterating on agents"
The interesting claim is not that an agent wrote the document. It is that the methodology was evolved by applying itself to itself. The doc has Chapel Card invariants — entropy reduction passes that run after each round of fixes. Drafts went through them: "is this project-agnostic?", "is the Ring -1 vs Ring 0 boundary defensible?", "does any sentence leak a specific file format from Ring 0 into Ring -1?". Ring 4 (a Claude session) generated each draft; Ring 0 (me) graded; the document is the converged fixed point.
The recursion is genuine, not metaphorical. The Ring -1 doc constrained Ring 4's revisions of the Ring -1 doc. The fitness function evaluated "is this useful for projects beyond the one that produced it?". Convergence happened when revisions stopped surfacing new information.
What it operationalizes
This is the practical answer to several frames that previous essays argued for separately:
- Software is memoization → "skills/constraints are cached; fixes are generated just-in-time by Ring 4".
- Speed of the loop → "Wind first: run E2E before optimizing. Signal, not guesses."
- No such thing as agent → the Ring stack formalizes what an "agent" actually is — layered organism/skeleton wrappers, not a monolithic thing.
- Testing AI agents with an E2E harness → Ring 0's mock-user / mock-agent dual is the harness; the grader is the fitness function.
- Iteration on AI software → the four-phase loop (signal → prioritize → fix → entropy-reduce) is the operational shape of "iterate on the system that iterates the system".
What I had not had before was a single document that combined them into a workable order-of-operations for any agent-tool project. The gist is that document, and it is portable: drop it into a new project's .claude/, write the project-specific Ring 0 CLAUDE.md, and you can start iterating immediately.
The interesting bit, in retrospect: every essay above was about a frame. This is the first artifact that is the frame — and the frame is what produced it.