claude-automata 0.1.8

Your agent stops when it thinks it's done. This one stops when it's actually done.

An autonomous agent environment for Claude Code, modeled on human memory.
An advisor audits every stop; one verified gate decides what gets remembered.

▶ Watch the memory circuit run

English | 한국어

Claude Code ends its turn the moment it believes it's finished, and forgets everything at the next compaction. claude-automata rebuilds it around the way memory actually works:

Long-term memory isn't a database. It's the repository's own git-tracked text — recall is grep. Whatever never passes the gate dies with the loop, on purpose.

Install

Needs Claude Code and uv, on POSIX (macOS / Linux / WSL). One command, from your project root:

uvx claude-automata init

Re-running is safe (idempotent). uvx claude-automata@latest init forces the newest release.

What init actually writes — this environment assumes unattended operation. Review the diff before you commit it:

• permissions.defaultMode: "bypassPermissions" — no approval prompts. The agent runs shell commands on your machine without asking first; the trust is host-level, not repo-level.
• model: "opus[1m]" — pinned model, 1M context
• alwaysThinkingEnabled: true · autoCompactEnabled: true · autoMemoryEnabled: false
• registers the clomia/claude-automata marketplace and enables its plugins
• installs missing gh, Node.js ≥ 20, repomix into your user area — no sudo, present tools skipped, gh auth login stays yours

Run a loop

/ploop:define-mission          # write the anchor — your intent, interviewed out of you
/ploop:launch [anchor text]    # hand it to the loop in a fresh session

The loop rides the Stop hook: whenever the agent stops, an independent advisor with a clean context inspects the round and surfaces what was missed. It ends only when the advisor has nothing left to say — not when the agent feels finished.

agent   › Mission accomplished. Stopping.
hook    › Stop blocked — summoning the advisor.
advisor › Not yet. The mobile layout was never measured. Two claims cite no source.
agent   › …resuming.
        ⟲ six rounds later
advisor › I have no further advice. Ending the turn.

An illustrative exchange — the mechanics are real. The anchor survives every auto-compaction. Safe on subscription plans — safe in mechanism, not in price: the loop shares your plan's quota, and multi-day runs spend it accordingly.

Change as transactions

/tx:open  [description]   # cut a tx-* branch off base
...work...                # tx:plan → tx:apply → tx:verify
/tx:close                 # verify, docs gate, CI, then squash-merge

A transaction is an integrity boundary — it can only close once the implementation and its recorded intent are both verified. Guard hooks keep the base branch protected in between. This is the gate everything above flows through.

Keep memory true

/refine:code [focus] · /refine:docs [focus] · /refine:integrity [focus]

Heavyweight multi-agent workflows (hours per run, 3–12h) that eliminate accumulated debt: code architecture, documentation truth, integrity boundaries. Findings settle through cross-examination into consensus; only the highest-ROI plans execute. The docs pass never modifies code — defects are reported. Empty focus targets the whole codebase; watch with /workflows.

▶ Watch the memory circuit run

Apache-2.0 · claude-automata is developed by claude-automata — every contribution in this repository was authored by a Claude Code agent running this very environment. Recursive self-improvement, in production.