Learn from the work
your agent repeats.
Your agent's past work holds useful lessons. Adage learns small, reusable rules called reflexes from those sessions and suggests steps when the same situation returns. Inspect what it learned, try it in your workflow, and help discover what else it can learn.
Claude Code mod prototype · development study
48% fewer model requests.
The mod lets Adage carry out approved steps directly inside Claude Code's agent loop. In this study, it used 3.75 requests per session versus 7.17 for the agent alone, with 12/12 runs passing hidden tests in both arms and 22% lower API-list cost.
A separate prototype, beyond the standard hook integration. 6 sandbox tasks × 2 runs per arm, Claude Sonnet 5.5, development run 4 after fixes on these tasks. A promising direction to test on fresh work.
Explore the mod resultsHelp explore deeper harness integration →
The same repo. The next task.
Past sessions. Future shortcuts.
For example: after changing a schema, regenerate the files before running the checks. A repeated recovery can become advice for the next session.
Session 1 / discovery
edit schema/event.json
$ make check
generated files are out of date
$ make gen
$ make check
checks passThe trace records the recovery. Across sessions, a repeatable edit → regenerate pattern builds evidence.
Illustrative sequence, not a benchmark. Matching runs locally on the CPU; your agent still reasons and executes through its own tools and permissions. Walk the full graph →
What actually moves off the model?
By default: local CPU matching delivers guidance; supported pre-call instincts can correct a command to the repository's verified environment without another model request. The agent still executes its tools.
With separate execution approval: adage-exec can prefetch a read-only result or run a staged action in a sandbox and apply permitted outputs. Choosing and running that invocation needs no model request; the agent may still reason over its result.
A learned command is not automatically approved to run. A delivered directive is not proof of a saved model turn. Each behavior has its own evidence. The experiment is whether this reduces repeated work. We measure model requests, tokens and API cost, and check that the task still passes its tests. GPU use and energy are not measured. How we tested it →
Ready on day oneInstinctsBind known moves to your repository's tools.
Learned from workTracesTurn repeated paths and dead ends into reflexes.
Taught by youSkillsCompile procedural steps. Keep judgment as text.
How it works
Observe. Learn. Review. Use it again.
-
01
Read the traces
Adage reads the session histories your coding agent already writes, including supported subagent histories. Learning runs locally and makes no model requests. Claude Code is the primary integration; Codex and OpenCode are in preview.
-
02
Learn repeatable steps
The learner looks for patterns: which check follows an edit, which command recovers from a familiar failure, and which steps recur together. Each candidate keeps its source evidence. An unknown result stays unknown.
-
03
Review what it learned
Inspect the sessions behind a reflex, where it applies and what it would say. Keep useful guidance and turn off noisy rules. Learning a command never grants permission to run it.
-
04
Use it when it matches
A local rule matches the current situation and delivers guidance through your agent's hooks. The agent normally runs its own tools. Exact actions can be delegated separately, with your approval.
- agent tracestranscripts, instincts, adage train <SKILL.md>
- conditionone learner mines what worked
- reflexestracks and packs
- indexcompiled
- hooksClaude Code, Codex, OpenCode
- responseguidance, rewrites, approved actions
What one learner finds in your traces
| Reflex | Learned from | What the agent sees |
|---|---|---|
| Look the item up | Agents passing a value from the prompt to the same command; the value's type (W-2042, #482) is learned from the values themselves | fireWork item details are looked up with: |
| Read what it lists | Agents reading, one turn at a time, the files a lookup listed | primeThat result lists these files … read them together in one turn |
| Avoid a dead end | A command that fails with the same signature, followed by one that works | inhibitRunning |
| Regenerate after an edit | A regenerate step that follows edits to a path pattern | fireChanges to |
| Steps in order | Commands run one after another after edits to a path pattern | primeChanges to |
| Check the part you edited | A command naming the directory an edit touched, or the tests of the edited file | primeAfter an edit under |
| Sync the environment | A dependency step after a dependency file changes; waits for your approval | primeOnce |
| Start like others did | Prompts that mean the same thing, whose sessions ran the same command first | primeRequests like this one usually start by running: |
| Procedure card | Two or more earlier sessions of a task the repository repeats, one of them passing | primeOnce, at the prompt: the files to edit in order and where each stands in your checkout now, the commands that worked and those that failed, the finishing check |
Every reflex carries its evidence. Advice is weighed by uplift: how much more often agents take the step when told than on their own. A recurring edit-then-command routine can instead become an execution candidate, even when a reminder adds no value. It stays silent until a person approves its exact automatic action.
Built to stay out of the way
Small rules. Clear boundaries. Your agent keeps control.
Your agent keeps control
By default, your agent executes the suggested steps through its own tools and permissions. One change is on by default in Claude Code: a Python test run under the system Python is pointed at the project's verified
.venv, shown to you each time;adage delegate rewrites offturns it off. Delegating a step is opt-in, per reflex, inside an OS sandbox.Fails open
If Adage errors or runs out of time at a hook, the agent carries on as if it were not installed.
Evidence attached
Inspect the supporting sessions, confidence and measured response to guidance. A pattern being frequent is not proof that a reminder helps, or that executing it is safe.
Yours, on disk
Traces stay on your machine. Reflexes live in tracks on disk and travel as signed packs you can review, commit and share.
Keep going
More useful reflexes are waiting in the traces.
We think there is much more to learn from the work agents already do. Our working hypothesis: a specialized repository or workflow gives Adage clearer patterns to learn, and better reflexes to reuse. Help test it with more histories, find valuable patterns the learner misses, and turn useful discoveries into packs.
How it works
Follow one session from transcript to hook, step by step, with the math behind every threshold.
Packs
Share what your agents learned as signed packs, and get Adage's instincts on day one.
Evidence
What worked in our studies, what needs improving, and how to test the next useful reflex.
Get started
Install from npm, try the Claude Code plugin, or explore a local demo first.