claude-automata 0.1.11

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; nothing becomes memory without passing one verified gate.

▶ Watch the memory circuit run

English | 한국어

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

Long-term memory is the repository's own git-tracked text, not a database. 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 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: an agent interviews your intent 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 the agent missed. It ends when the advisor has nothing left to say.

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 closes only after the verifier passes both the implementation and its recorded intent. 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. Agents cross-examine findings into consensus and execute only the highest-ROI plans. The docs pass reports defects and never modifies code. Empty focus targets the whole codebase; watch with /workflows.

▶ Watch the memory circuit run

Apache-2.0 · claude-automata develops claude-automata. A Claude Code agent running this environment authored every contribution in this repository. Recursive self-improvement in production.