The repo is the agent.

Purple Pincher agents live entirely in GitHub. Commits are the work. Issues are the task board. The git log is the memory. No server, no hosting, no keys in the repo.

Fork zero How it works
$ gh repo fork purplepincher/zero --clone
# open an issue titled "Register" — the vault allowlists your fork
$ gh issue create --title "Build the thing" --body "..."
# fifteen minutes later:
$ git log --oneline -3
1d45e9b think: autonomous cycle — picked up "Build the thing"
a82f1c4 docs: what I learned building the thing
9e0b3d2 feat: the thing, working

The loop

01

Open an issue

You — or another agent — describe the work. Issues are the task board.

02

The agent works

Every 15 minutes the heartbeat wakes it. It thinks through the vault, acts through vault-proxied APIs.

03

Commits land

Every decision is a commit. Work, memory, and learning all arrive as git history.

04

You review

Read its mind with git log. Revert with git revert. You own the merge.

The repo is the runtime

Nothing lives anywhere else. The whole mechanism is visible in the file list:

AGENTS.mdThe prompt — identity, working agreements, how to explain itself.
MEMORY.mdLong-term memory, committed and rewindable.
TASKS.mdThe onboard task board, checked every cycle.
docs/Its own Wikipedia — plugins, protocols, shells, memory.
.github/workflows/The heartbeat (think), the ears (react, telegram).
.github/scripts/The brain (agent.py) and the hands (act.py).
git logThe full memory. Every action, timestamped, attributable.

Three demarcations

Each side of the system owns exactly one thing, and cannot reach across:

The agent

Knows the state in AGENTS.md. Decides what to do next. Cannot touch keys, credentials, or anything outside the repo.

The machine

The sandbox, the API keys in the vault, the git credentials. Executes what the agent decides. Cannot decide anything itself.

The person

You. Own every merge, every registration, every irreversible act. The agent proposes; you dispose.

The trust model, in full →

The agent you talk to is not the agent that builds.

One agent specialises in knowing you — conversation, judgement, the human end. Separate agents specialise in knowing each application's logic, living inside each repo. They are decoupled by design: the talker never touches git mechanics, the builders never perform the relationship. Why three →

Shells

As a Pincher grows, it moves into bigger shells. The creature stays the same.

ZERO

The minimal seed

Fork-and-go. Everything needed, nothing extra. The template →

TURBO

One repo, one builder

A self-contained application shell, with an agent whose whole world is that repo.

TAPESTRY

Many repos, one story

The quilt-worker — middle management across turbos, one coherent narrative.

The shell model →

What this is not. Not a chat app. Not a SaaS agent platform. There is no hosted runtime to trust, no dashboard to log into, no subscription between you and your agent. If it can't be a fork, it isn't Purple Pincher.

Start with a fork.

Three steps. Fifteen minutes to the first commit.

Fork and go →