The Loop You Own: Run the Self-Improving Agent Loop in Claude Code and Codex with ADD

There’s a feature in Nous Research’s Hermes Agent that makes every developer who sees it a little envious: a built-in learning loop. Hermes finishes a task, then a background process quietly reflects on what just happened and folds the lesson into durable memory and reusable skills. Next session, it’s a little better. The agent compounds.

If you build with Claude Code or Codex, your first reaction is reasonable: I want that, but my agent doesn’t ship it. Here’s the part nobody tells you. You don’t need Hermes’ runtime to get Hermes’ loop. The loop is not magic baked into a binary — it’s a small set of habits and artifacts. And when you express those habits as AI-Driven Development (ADD), the self-improving loop runs on top of Claude Code, on top of Codex, on top of whatever model you switch to next year — because the loop lives in your repo, not in someone else’s product.

This is the pitch, stated once: rent the model, own the loop.

What the self-improving loop actually buys you

Strip away the mechanics and the loop delivers three things a team can feel.

It compounds. The second time the agent touches your codebase, it isn’t starting cold. It already knows the domain language, the decisions you’ve settled, and the conventions that bit you last time. Work that took a full session in month one takes an afternoon in month three — not because the model got smarter, but because the ground it stands on got firmer.

It stops forgetting. The single most expensive failure mode of AI coding is context rot: the agent re-deriving what your project means every session, filling the gaps with confident guesses, and quietly reintroducing a bug someone already fixed. A learning loop ends that. State that mattered last week is still there this week.

It earns trust, not just speed. A loop that only learns faster can also be confidently wrong faster. The version worth having gates the work — proves it before it ships — so the speed is something you can actually rely on in production.

Those are the outcomes. The question is where the loop has to live to deliver them.

The catch: Hermes’ loop is bolted to Hermes

Hermes’ loop is real and impressive — and it is also inside Hermes. Its memory store, its skill manager, its background reviewer are runtime features of that one agent. They learn beautifully, but they learn into a place you don’t control and can’t carry. Adopt a different agent next quarter and the loop doesn’t come with you; it stays behind in the tool you left.

For a personal assistant, that’s fine. For an engineering org betting on a fast-moving model market — where the best coding agent changes every few months — it’s a quiet form of lock-in. You’d be renting not just the model, but the institutional memory of your own codebase.

ADD moves the loop into your repo

ADD’s core move is to take everything Hermes keeps inside its runtime and write it down as plain files in your project — files any agent reads, that survive any model swap, that you own outright.

• The living foundation — PROJECT.md: the domain language, the active spec, the key decisions. The first thing every session reads. This is Hermes’ memory, made portable.
• The conventions ledger — CONVENTIONS.md: every pattern the project learned the hard way, tagged and dated, inherited by name. This is Hermes’ skills, made portable.
• The decision log — append-only, dated: why every settled choice was made, recoverable months later. This is the institutional memory a chat window can’t hold.
• The task record — one TASK.md per feature, moving through eight fixed steps: Ground → Specify → Scenarios → Contract → Tests → Build → Verify → Observe, then folding what production taught back into the foundation.

None of that is a feature of Claude Code or Codex. It’s a feature of your codebase. The agent is the interchangeable part.

The right column is the marketing claim and the engineering claim at once: the same self-improving behavior, running in the tools you already pay for, owned by you, with a safety gate Hermes was never built to have.

How it runs in Claude Code and Codex

Here’s the part for the people who’ll actually wire it up. ADD doesn’t fight your agent — it uses the exact extension points Claude Code and Codex already give you.

Memory → the file your agent reads first. Claude Code reads CLAUDE.md; Codex reads AGENTS.md. ADD points both at the same living foundation. Your PROJECT.md is the memory — and because it’s a real file, the agent re-orients from it on every cold start, in either tool, with zero runtime state.

# CLAUDE.md  (or AGENTS.md for Codex)
Before any task, read .add/PROJECT.md first — domain language, active spec,
key decisions. Treat .add/CONVENTIONS.md as binding: those patterns were
learned from real failures. Never weaken a test or change a FROZEN contract
to make a build pass; stop and ask instead.

Skills → folded conventions, inherited by name. Both agents support reusable commands and skills. ADD’s CONVENTIONS.md is the same idea expressed as content: when a task overcomes a non-obvious failure, the lesson is folded in as a tagged entry, and every later task inherits it without re-deriving it. That’s Hermes’ “skills self-improve during use” — except the skill library is a file you can read, review, and version.

The front gate → Plan Mode, made permanent. Claude Code’s Plan Mode is a great in-session guardrail, but it’s ephemeral — close the session and the plan is gone. ADD persists that same constrain-before-build instinct as a frozen contract and a red test suite that outlive the session. (We drew this out in Method vs. Mode.) The agent gets the pause Hermes never had — and it’s written down.

The reflection → Observe-and-Fold, on your schedule. Hermes runs its review automatically after each turn. In ADD you run the lightweight human version at task and milestone close: capture what production taught as a tagged spec delta, fold the confirmed ones into the foundation, bump the version. Same loop — you keep your hand on the consolidation gate, which is exactly where you want it for code other people depend on.

The advantages, stated plainly

For the skim-readers, here’s what adopting ADD on your existing agent actually gets you.

• You own the loop. The compounding asset — domain model, conventions, decisions — lives in your repo. Swap Claude Code for Codex, or this model for the next, and your project’s memory comes with you. No lock-in.
• It gets faster as it runs. On ai-proxy, a real ADD build, the conventions ledger grew past 600 lines of hard-won patterns and the decision log passed 140 entries across six days. Later work inherited all of it by name. The method measurably sped up as it went.
• It’s safe enough for production. This is the half Hermes doesn’t have. On that same build, running the system for real through its TLS edge caught two production defects a 326-test suite had passed clean. On another ADD project, a disciplined “does this test actually test anything” pass caught two vacuous green tests — one importing nothing, one asserting nothing — before they could wave bad code through.
• It survives cold starts and staff changes. A new teammate, or a session opened weeks later, re-orients from the foundation instead of asking around. The knowledge isn’t in anyone’s head or any vendor’s runtime.
• It’s governed. Every gate resolves to a named outcome — proceed, proceed-with-a-signed-waiver, or hard-stop — with an accountable owner. Speed you can put your name on.

Rent the model, own the loop

The model market will keep moving. The best coding agent today may not be the best one next quarter, and the smart bet is to stay free to switch. What you can’t afford to keep re-buying is your own project’s hard-won knowledge.

Hermes showed the industry that a self-improving loop belongs in the way we build with AI. ADD’s contribution is to put that loop somewhere you can keep it: in your repository, running on Claude Code and Codex today, ready for whatever you adopt next — with a safety gate that makes the speed trustworthy.

Rent the model. Own the loop.

Go deeper: How ADD Fixes the AI-Era SDLC is the full method; Where the Loop Lives maps ADD against Hermes’ runtime loop in detail; Observe and Fold is the self-improving step on its own.