Compounded
ankitkr3/compounded
Skills ganham autonomia através de confiabilidade demonstrada, totalmente local
Ver no GitHubFramework que implementa um sistema de confiança progressivo para skills do Claude Code. Skills evoluem de .proposed → .verified → .trusted → .autonomous conforme demonstram confiabilidade, sem exigir daemon ou infraestrutura em nuvem. Localizado, com persistência em SQLite e arquivos simples.
Instalação
npx convez-ai ankitkr3/compounded1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Treinar agentes IA para executar tarefas repetitivas com segurança crescente
- Criar workflows automatizados que ganham permissões conforme provam competência
- Gerenciar biblioteca pessoal de skills verificados e confiáveis para Claude Code
Veredito

Solução sofisticada para governança de skills com abordagem única de trust-gradient. Ideal para usuários que querem automação confiável sem sacrificar controle — mas requer familiaridade com Claude Code e paciência durante o treinamento inicial.
README
A tradução para o português deste README ainda está na fila.
compounded
Your AI agent gets better at you the longer you use it.
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
Why compounded?
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.
Install
# In Claude Code:
/plugin marketplace add ankitkr3/compounded-marketplace
/plugin install compounded@compounded-marketplace
Restart 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.
The trust ladder
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ .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.
What compounded actually does
Three things. That's the whole pitch.
🧠 Cross-project memory
A user-global USER.md (~/.claude/compounded/USER.md) gets injected into every session, on every project, on every machine.
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.
✓ Verified skills
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 .verified and graduate by demonstrating reliability over real use. Skills that fail go to .rejected/ (recoverable, not deleted) with the reason on disk.
📦 Portable archive
/compounded:export ~/Desktop/compounded.tar.gz produces a single archive: USER.md + every active skill + the trust state.
/compounded:import merges it on a new machine. Your earned skills aren't trapped on the laptop you're typing on right now.
Auto-propose (v1.1)
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.
Demo
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
How compounded composes
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.
Commands
| 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 |
What's stored where
~/.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.
What it doesn't do
| 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.
Cost
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"
}
}
Tested
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/ -v
CI runs the suite on Linux + macOS across Python 3.9–3.12 on every PR.
The four principles
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.
Contributing
PRs welcome. New built-in skills, bug fixes, doc improvements.
python3 -m unittest discover tests/ -v
For 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.
License
MIT. Fork, ship, sell. Just include the notice.
Why "compounded"
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