Skills earn autonomy through demonstrated reliability — they start .proposed, prove themselves to become .verified, build a track record to reach .trusted, and finally graduate to .autonomous. No daemon. No cloud. No re-explaining.
Install · How it works · Manifesto · Philosophy · Docs · Compare
Claude Code's AutoMemory writes notes. AutoDream cleans them. compounded verifies them — and lets them earn the right to act.
When your agent saves a skill from a successful task, compounded holds it in .proposed/. The next time a similar task comes up, a verifier subagent replays the procedure. Pass → .verified. Three clean uses → .trusted. Ten uses with no recent corrections → .autonomous. One correction sends it back a step.
It's how you train a junior. It's how you should train your agent.
# In Claude Code:
/plugin marketplace add ankitkr3/compounded-marketplace
/plugin install compounded@compounded-marketplaceRestart Claude Code. That's it.
First-time approval prompts: hooks fire silently, but the first time you run any
/compounded:*slash command you'll see a Claude Code permission prompt. Either click "always allow" in the prompt (per-command, easiest) or pre-allowlist everything by adding"Bash(python3 ~/.claude/plugins/cache/compounded-marketplace/compounded/**:*)"topermissions.allowin~/.claude/settings.json. See INSTALL.md for details.
| ✅ No daemon to run | ✅ No cloud account | ✅ No telemetry | ✅ 100% local |
| ✅ Python stdlib only | ✅ SQLite + flat files | ✅ Portable archive | ✅ MIT licensed |
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ .proposed │───▶│ .verified │───▶│ .trusted │───▶│ .autonomous │
│ │ │ │ │ │ │ │
│ awaiting │ │ 1 verifier │ │ 3 clean │ │ 10+ uses, │
│ verification │ │ PASS │ │ uses │ │ 5+ clean │
└──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘
▲ ▲ ▲ │
│ │ │ │
└────────── correction = one tier down ───┴────────────────────┘
| Tier | Behavior | Activation |
|---|---|---|
.proposed |
Authored by the agent, awaiting verification | Never auto-loads |
.verified |
Replayed once successfully on a real task | Loads only when invoked by name |
.trusted |
3+ clean uses on real follow-ups | Auto-loads, asks before applying |
.autonomous |
10+ uses, last 5 clean, no recent corrections | Runs without asking |
Demotions happen automatically: one correction = one tier down. Three corrections in 30 days = back to .proposed. Pin a skill with /compounded:pin <skill> to lock it at its current tier.
Run /compounded:trust-status to see where every skill sits and what's about to promote or demote.
Three things. That's the whole pitch.
|
A user-global AutoMemory writes per-project notes — compounded writes the preferences and facts that follow you across all of them. Hard-bounded at 1500 characters by design, so it stays readable and useful. |
When the agent proposes a skill, it's a hypothesis until proven. The verifier subagent replays the procedure against a real follow-up task and decides PASS or FAIL with a logged reason. Skills that pass start at |
|
You don't have to remember to save things. After every turn, the Stop hook scores what just happened — tool calls, distinct files edited, shell commands, recovery from failure, planned execution. When the score crosses the threshold, the agent gets a nudge to consider authoring a skill. The agent still decides whether to propose (one-off chores get ignored), but the prompt to consider is automatic.
Quiet by design: routine turns produce zero output. You only see anything when there's real signal. Edit ~/.claude/compounded/logs/auto_propose.jsonl to see what fired and what didn't — useful for tuning if you want to.
Run the included lifecycle demo to see propose → verify → use × 3 → trust → use × 7 → autonomous → correction → demote in 30 seconds:
bash docs/demo.sh[1/8] proposing skill 'typo-fixer' ......................... .proposed/
[2/8] running verifier subagent (claude-haiku-4-5) ......... PASS
[3/8] moved to .verified/, ready for use
[4/8] used 3× on real follow-ups ........................... promoted → .trusted
[5/8] used 7× more, last 5 clean ........................... promoted → .autonomous
[6/8] one correction on use #11 ............................ demoted → .trusted
[7/8] exported archive ..................................... compounded.tar.gz (12KB)
[8/8] imported on a fresh install .......................... ✓ same state
compounded does not replace anything. It is the verification + portability layer of a stack:
| Tool | What it does | What compounded adds |
|---|---|---|
| AutoMemory (native) | Per-project notes, MEMORY.md | Cross-project USER.md |
| AutoDream (native) | Consolidates project memory between sessions | Verifies skills, not notes |
| skill-creator (native) | Eval-based testing of hand-authored skills | Replay-based verification of agent-authored skills |
| superpowers | TDD / brainstorm / plan methodology | Memory + earned trust gradient |
| claude-mem | Daemon-based observation capture | No daemon, different model |
| Karpathy CLAUDE.md | Behavioral principles | Composable — drop both into your project |
Each layer does one thing well. None of them does what compounded does.
| Command | What it does |
|---|---|
/compounded:status |
USER.md size, skill counts by tier, recent transitions |
/compounded:trust-status |
The full trust ladder, with promotion/demotion candidates highlighted |
/compounded:export <path> |
Bundle USER.md + verified skills into a portable archive |
/compounded:import <path> |
Merge an archive on this machine |
/compounded:verify <skill> |
Manually run the verifier on a .proposed/ skill |
/compounded:trust <skill> --to <tier> |
Manual promotion (skip the gradient) |
/compounded:demote <skill> |
Drop a skill one tier |
/compounded:pin <skill> |
Lock a skill at its current tier (no auto-demotion) |
/compounded:unpin <skill> |
Remove a pin |
~/.claude/compounded/
├── USER.md ← user-global preferences (loaded every session)
├── trust.db ← SQLite: skill state, events, sessions
├── config.json ← per-user config
├── skills/
│ ├── .proposed/<name>/ ← awaiting verification
│ ├── .verified/<name>/ ← passed verification
│ ├── .trusted/<name>/ ← 3+ clean uses
│ ├── .autonomous/<name>/ ← 10+ uses, recent run clean
│ ├── .rejected/<name>/ ← failed verification (recoverable)
│ └── .pinned ← list of pinned skill names
└── logs/
└── verifier_dispatches.jsonl
All local. All inspectable. All editable if something goes wrong.
| Won't do | Why |
|---|---|
| ❌ No daemon | Zero install friction. Hooks fire when Claude Code fires them. |
| ❌ No cloud / telemetry / account | Your skills are yours. |
| ❌ No vector index / embeddings / GPU | Keyword overlap + replay is enough. |
| ❌ No transcript capture | claude-mem does that — use both if you want both. |
| ❌ No project memory cleanup | AutoDream does that. |
| ❌ No eval framework | skill-creator does that. |
Every "no" is deliberate. compounded does three things and stops.
The verifier subagent runs on Claude Haiku 4.5 by default. Each verification is roughly 1500 input tokens + a small JSON response.
Expected cost at typical usage: under $0.20/month.
The verifier only runs when a .proposed/ skill matches the just-finished task, which for most users is a handful of times per week.
To switch to Sonnet for higher-accuracy verification (~5× the cost), edit ~/.claude/compounded/config.json:
{
"skills": {
"verifier_model": "claude-sonnet-4-6"
}
}22 unit tests covering memory injection, skill proposal, security scanning, trust-ladder transitions in all directions, pin behavior, archive roundtrip, and verdict finalization.
git clone https://github.com/ankitkr3/compounded
cd compounded
python3 -m unittest discover tests/ -vCI runs the suite on Linux + macOS across Python 3.9–3.12 on every PR.
Read the manifesto. Four principles, one page, copy-pasteable.
- Bounded over Unbounded — memory should be small enough to read in one breath.
- Verified over Recalled — a skill that replayed successfully is a fact; one that was merely saved is a hypothesis.
- Earned over Granted — authority is earned, not assumed.
- Composable over Comprehensive — small tool, sharp wedge, plays well with everything else.
PRs welcome. New built-in skills, bug fixes, doc improvements.
python3 -m unittest discover tests/ -vFor new built-in skills (skills that ship with compounded itself, not user-authored skills), follow the format of skills/compounded-typo-fixer/SKILL.md and include the criteria the skill is meant to demonstrate.
See CLAUDE.md for codebase conventions.
MIT. Fork, ship, sell. Just include the notice.
Capability that compounds is the whole point. Every verified skill compounds the agent's toolkit. Every clean use compounds the trust in that skill. Every correction compounds back — trust isn't given once, it's earned and re-earned. The trust ladder is compound interest applied to demonstrated reliability: small reliable acts that, over time, become the foundation for larger autonomous ones.
"The most powerful force in the universe is compound interest." — Albert Einstein (apocryphal)
The product is named for what it does to your agent.
Manifesto · Philosophy · Install Guide · Architecture · Memory Guide · Skill Authoring · Privacy
Built for Claude Code · Made with discipline by @ankitkr3