CLAUDE‑AUTOMATA
DOC LANDING LICENSE APACHE-2.0 SOURCE GITHUB ↗ EN · KO

AN AGENT ENVIRONMENT FOR CLAUDE CODE, MODELED ON HUMAN MEMORY

24/7 full self‑driving.
Delegate everything. Rest.

FIG. 1: THE MEMORY CIRCUIT · WORK IS LOSSY, MEMORY IS VERIFIED

Claude Code runs on conversation, and conversation runs on your attention. claude‑automata drives itself: hand it months of work and it finishes in days. All the loop asks for is your intent.

Get started View source ↗

01"DONE" GETS AUDITED

The moment the agent declares itself done, a hook blocks the stop and demands the audit — by the advisor, an independent metacognition with access to the whole story.

This is what ploop provides. The authority to end the loop rests with the advisor.

Saying "done" doesn't end it. Being done does.

02OPERATING PRINCIPLES

The loop never wanders

ploop defines the intent you hand it as the anchor, plants it outside the transcript, and the advisor judges against it. Injected into context right after each auto‑compaction, the anchor remains the single source of truth.

The loop calls you like a tool

Once launched, the loop does not stop, and it treats you as a tool in service of the anchor. You can drop in instructions mid‑flight or ask a separate docent session for an explanation. You are one component of the loop.

Forgetting matters

Memory that fails the verified transaction circuit is forgotten along with the loop. Forgetting is a core component of intelligence.

03THE MEMORY SYSTEM

The human memory system, modularized into three plugins. Working memory consolidates into long‑term memory, and long‑term memory is rebuilt on a cycle.

  1. WORKING MEMORY

    Working memory forms inside ploop. The anchor sets the criteria, and the advisor provides the metacognition.

  2. CONSOLIDATION

    tx is the screening gate where working memory consolidates into long‑term memory. It checks the implementation against the intent, passes CI, and writes long‑term memory as one squash merge.

  3. LONG‑TERM MEMORY

    All non‑executable, git‑tracked text is long‑term memory, organized with precision: specs as semantic memory, archived changes as episodic, the glossary as lexical, skills as procedural.

  4. RE‑GROUNDING

    Stagnant memory does not survive. The refine workflows clear out dead memory and converge the whole repository toward its optimal state.

04MODULES

ploop

WORKING MEMORY

Lets a single session sail autonomously for days. Your intent becomes the anchor that holds the loop steady against drift.

tx

LONG-TERM MEMORY · WRITE

A Git workflow that treats change as a transaction (an integrity boundary). It guards the repository's integrity. Install it and the agents drive it on their own.

refine

LONG-TERM MEMORY · UPKEEP

Large‑scale workflows that eliminate technical debt: /refine:code optimizes the code architecture, and /refine:docs aligns documentation with the code. They touch only the representation layer — never behavior — and sweep the whole repository, so a run can take ten hours or more.

05GETTING STARTED

Enter the following instruction in Claude Code.

REQUIRES · Claude Code · uv · POSIX (macOS / Linux / WSL)

Read https://raw.githubusercontent.com/clomia/claude-automata/refs/heads/main/INSTALL.md with curl -sSL and install claude-automata.

Your agent reads INSTALL.md and installs claude-automata.

06OPERATING THE LOOP

This is the whole operating surface. Write an anchor, launch it, and step in only when you want to.

1 · WRITE THE ANCHOR

# an agent interviews you, interprets your intent, and writes the anchor
/ploop:define-mission   # a mission with an end
/ploop:define-purpose   # an open-ended purpose

2 · LAUNCH

# in a fresh session: hand the anchor to the loop
/ploop:launch [anchor text]

3 · OPERATE

/ploop:off      # pause the loop
/ploop:on       # resume / restore the loop
/ploop:docent   # reports the loop's progress - run in a separate session, same directory

4 · KEEP THE REPOSITORY LEAN

# between missions: hours-long maintenance passes
/refine:code       # optimizes the code architecture
/refine:docs       # aligns documentation with the code

APPENDIX · WHY AGENTS BRANCH

To guard repository integrity, tx blocks writes to the base branch. Agents work on a tx-* branch cut by /tx:open, and /tx:close lands it on base as one verified, CI‑green squash merge. An agent branching off instead of editing the base branch is tx working as intended.