the retro loop · for AI coding agents

Reflection is the
missing layer.

ax is the reflection step the agent stack lost. A local typed graph of every session, with retros, experiments, and verdicts that close the loop your sub-agents drop on the floor. Runs on your laptop. MIT.

retro at every session-end experiments with t+7 / t+30 / t+90 verdicts 100% local

install in 30 seconds

$ curl -fsSL https://raw.githubusercontent.com/Necmttn/ax/main/install.sh | bash

macOS first · Linux for CLI · runs on your laptop

Read the origin → View on GitHub

what ax does.

It reflects. Then it earns the change.

Every sub-agent you spawn finishes its work and disappears. Whatever it figured out - which command failed three times before the right one, which file actually mattered, which approach to skip - dies with it. ax closes the loop before the session ends, and proves whether the fix earned its place.

retros
Every session ends with a structured note - tried, worked, failed, next. Main sessions and sub-agents alike. JSON by default.
experiments
Accepted proposals become artifacts you can point at. Each one gets a t+7 / t+30 / t+90 checkpoint.
evidence
Verdicts come from retros, tool calls, corrections, and local git outcomes - joined in one graph. No vibes.

the loop closes.

One cycle. Every session.

The retro is iter zero, not the finish line. What one session notices becomes the next session's proposal; what the experiment earns becomes the verdict the graph remembers. The shape below is the shape of the work — not a funnel, a loop.

Run a session, end with a retro, accept the proposal worth trying, and let the experiment ride to its checkpoint. The next session opens with that verdict already on the table. Nothing you wrote yesterday gets thrown out.

Loop retro → proposal → experiment → verdict →

session 4129 · iter 0

failed="ran on main"

next=use-hook

The retro is the start of the next session, not the end of the last one. The token closes the ring once per cycle. Click a node to jump the inspector. Hover to peek without breaking the flow.

read: retro is only the first step →

what you actually use.

Installed isn't used.

You have twenty skills wired into your agent. Eleven of them fired this week. Nine sat there. ax tells you which is which — from your real session log, not from the plugins.json you forgot you edited.

The heatmap below is a synthetic week. Dim tiles are dead weight. Lit tiles are the ones the agent actually reached for. The count on the right is the answer to "what's earning its place in my CLAUDE.md."

Heatmap installed skills · fires this week

fires this week 0 / 20

dead weight 0

Installed isn't used. The graph knows which is which. Hover any tile for last-fire timestamp. Skills that never fired across the week are dead weight — candidates for the chopping block.

read: the origin behind the layer →

install

Install. Ingest. Serve.

$ curl -fsSL https://raw.githubusercontent.com/Necmttn/ax/main/install.sh | bash
$ PATH="$HOME/.local/bin:$PATH" axctl ingest --since=7
$ axctl serve   # live dashboard at http://127.0.0.1:8520

For dev setup, schema, and benchmarks, see docs/development.md.

why retros compound

Every sub-agent dies with what it learned.

Memory is what you remember. Retro is what you reflect on, structure, and turn into the next bet. The stack has compute, tools, and logs. It does not have a reflection loop. ax is that loop.

Verbal self-reflection at the engineering layer. Reflexion for software. Open reference, MIT, runs on your laptop.