$ proposal
~$605 redirectable
252 model-less dispatches on expensive models matched mechanical routing classes.
FIX → NEW HOOK: route mechanical subagent dispatches to cheaper models
REVIEW →copy brief
$ how it works
What happens to your sessions,
and what you get back.
ax watches every run your coding agents make, turns the history into a typed local graph, mines the mistakes you keep repeating, and hands them back as small fixes you review one at a time — then measures whether they worked.
- 01watch
- 02graph
- 03mine
- 04propose
- 05measure
$ 01 · watch
Five harnesses. One local graph.
ax reads the transcripts your coding agents already write to disk — nothing to instrument, nothing to send anywhere. A parser per harness folds every run into the same typed graph on your own machine.
- jsonl transcripts
- jsonl sessions
- jsonl sessions
- sqlite store
- sqlite store
LIVEtyped local graphsurrealdb · 127.0.0.1:8521a background watcher ingests new runs the moment they land
The watcher tails your session dirs and ingests in the background — the loop is pull-based, never a per-turn hook that blocks your agent.
$ 02 · graph
Not a vector index. A graph of what actually happened.
Every run becomes nodes and typed edges. The interesting questions are relational — which tool call preceded that correction, which skill fires in the sessions that ship — so the edges are the load-bearing primitive, queryable as first-class facts.
skill ← invoked ← turn → edited → fileThe line at the top of the schema. That is the model — a RELATE edge between a session and a commit is a queryable fact, not a join across two tables.$ 03 · mine
The same mistake, counted.
Once the graph holds enough runs, the patterns stop being anecdotes. ax measures verification churn — where a change lands, breaks, and gets repaired — and surfaces the family that keeps costing you the same way.
$ ax sessions churn --herelast 30 days
26×recurring
Feature work closes without re-verifying the file it just changed. Same family, again and again.
- episodes opened
- 26
- repair LOC vs landed
- 1.4×
- median time-to-repair
- 2 turns later
- evidence
- cites_evidence → friction_event
every number traces back to the turns and commits that produced it
$ 04 · propose
One small fix at a time. You decide.
Each pattern becomes a ranked proposal — a concrete, repo-specific change with the receipt attached. Nothing is applied for you. You review the brief, accept the ones worth trying, and skip the rest.
$ what's next
20 actions waiting
Mined from your sessions — savings to route, fixes that recur, verdicts due.
$ proposal
26× recurring
Feature closure needs stronger same-file follow-up verification.
FIX → NEW SKILL: post-feature verification checklist
REVIEW →copy brief
+18 more in the registry below
Accept a proposal and ax writes a brief into .ax/tasks/ — you act on it like any other task, then reconcile. The fix is yours; the graph just found it.
$ 05 · measure
Did it actually work? ax keeps score.
A fix you can't measure is a guess. Every accepted proposal becomes a bet, and ax checks the same churn signal at +3, +10 and +30 sessions after you apply it. A trace bar that shrinks to zero is a confirmed win — receipts over vibes.
$ experiments Past bets, measured
$ why this shape
Two convictions, one design.
Local-first by construction.
The graph runs on your machine. Nothing is transmitted, no key is required to read your own history, and you can inspect or delete any of it. The subject matter — what you tried, what failed, what to try next — only belongs in one place.
RELATEA graph, not a vector index.
The questions worth asking are relational: which tool calls preceded this correction, does this skill show up in the sessions that ship. A similarity search loses that connective tissue. An edge between a session and a commit keeps it as a fact.
For the curious: the table inventory, the @rationale extractor, and the rest of the ingest internals live in the architecture reference →