Built by one agent. Checked by another. Merged when green.

Agentry is the harness around Claude Code. It sizes the process to the task, runs your own board as verified lanes, remembers what it learned, and every move it makes is a command you can script.

/plugin marketplace add silentthreadstudio/agentry#v0.4.2
01 · THE RIGHT-SIZED HARNESS

The least process that wins.

/agentry:go reads the task and picks its shape. A hidden decision vetoes a one-shot; coupled parts earn a plan. You approve at every fork.

Most tasks never meet most of the agents. That's the point.

02 · YOUR BOARD, AS LANES

Pre-planned work runs on rails.

When the contract is already written, /agentry:exec T-14 skips the planning: its own worktree, a builder, an independent verifier, your gate, then /agentry:merge. Several lanes at once; gates queue; a guard stops any lane whose base moved.

  • T-14
    1. build
    2. verify
    3. gate
    4. merged
    Invoices
  • T-16
    1. build
    2. verify · 2 notes
    3. fix N2
    4. recheck…
    Refunds
  • T-17
    1. build
    2. stopped: main moved under it
    Tax rules
03 · THE AGENTS

One job each. Called only when earned.

Nine roles cover the whole path a change takes: what and why, the shape, the build, the check, and what's worth keeping, plus two read-only helpers for unfamiliar code and outside facts. Nothing forces all nine: a one-line fix meets an implementer and a verifier.

conductor

Routes the work. Dispatches the team. Asks you at the forks.

Owns: the shape of the work, who gets dispatched, and every approval gate.

Never: grades work it dispatched, or builds big work itself.

Called when: always. It is the session you talk to.

implementer

Clean code and tests inside the contract.

Owns the files its contract names and their tests. Hands back commits and a report: done, done with concerns, or needs context. Repro-first on bugs.

Called when: there is code to write.

verifier

Never the author. Tries to prove it wrong.

Owns the verdict on the exact tip: pass, pass with notes, or fail, with evidence and a security lens.

Never fixes what it finds. Notes go back to the builder.

Called when: anything is built.

product-owner

"Make it better" becomes a spec you can check.

Called when: "done" isn't clear yet.

architect

Boundaries, decisions on record, task contracts.

Called when: the work spans parts or hides a design choice.

designer

UI that fits your system, checked on the rendered screen.

Called when: the change has a screen.

librarian

Keeps memory clean. Proposes skills, never installs them.

Called when: a run ends with something worth keeping.

explorerresearcher

Read-only scouts for what nobody knows yet.

The explorer maps an unfamiliar codebase and edits nothing. The researcher answers an outside unknown with cited sources and says what it changes in the plan.

your own agents

Bring the agents you already use.

A lane's brief is a plain prompt. The script suggests an agent; the conductor can hand it to yours: a mobile specialist, your security reviewer, a team-standard implementer. The rules still hold: the builder never checks its own work, and the gate decides.

04 · EXTENSIBLE

It learns your process. It doesn't replace it.

One small file maps Agentry onto how your repo already works. /agentry:init drafts it from what it finds; you confirm each part.

  • Any kinds. Tasks, sprints, epics, questions, decisions, or your own.
  • Any shape. Markdown tables, headings or frontmatter files.
  • 17 rules to switch on, mirroring the checks you already run.
  • Your gate, in tiers picked by what changed, with a list of known-flaky tests.
  • Your skills as merge checks, your own conductor prompt, your own agents.
.agentry/process.json drafted by /agentry:init 
{
  "kinds": {
    "task": { "at": { "table": "BOARD.md", "heading": "Tasks" } },
    "decision": { "at": { "table": "DECISIONS.md" } }
  },
  "rules": [
    { "rule": "deps-done", "kind": "task" },
    { "rule": "ready-has-contract", "kind": "task" }
  ],
  "gate": {
    "tiers": [
      { "name": "docs", "command": ["pnpm", "lint"], "when": { "only": ["docs/**"] } },
      { "name": "full", "command": ["pnpm", "test"] }
    ],
    "roles": { "verify": "none", "merge": "pick" },
    "flaky": ["render budget"]
  },
  "extensions": { "merge": { "checks": ["release-notes"] } },
  "conductor": { "prompt": "docs/CONDUCTOR.md" },
  "guard": { "allow": ["docs/STATUS.md"] }
}
✓ agentry board check · OK · 2 rules 57 tasks found
05 · SCRIPTABLE

Every move is a command.

The slash commands are thin. Underneath is one dependency-free CLI the agents call, and so can you, your scripts, or another agent host.

  • Writes preview until --apply
  • --json on every command
  • Exit 0 ok · 1 stopped · 2 refused
  • Errors name the next command
board lane mem draft ~/billing
agentry board status --ready S3T-19 Refund exportcontract ✓deps ✓
agentry board add task --fields '{"sprint":"S3","what":"Audit log"}' previewwould add T-20 to BOARD.md › Tasks and sprints/S3.md add --apply to write it
agentry lane exec start T-19 --json | jq -r .next dispatch builder
agentry lane merge T-19 --preflight exit 2the gate has not run on this tip → agentry lane exec gate T-19
06 · THE DAY, SAME EVERY TIME

Open. Build. Land. Close.

  1. /agentry:start Where things stand in five lines, what's on you, one recommendation.
  2. /agentry:exec One lane per task, as many as your writer cap allows.
  3. /agentry:merge Lands commits, board row, SHA and handoff in one go. Pushes by your policy.
  4. /agentry:close Your calls from the day drafted for OK, worktrees swept, a handoff for tomorrow.
07 · YOUR BOARD, MADE VISIBLE

No dashboard. Your board, read for you.

The board stays plain markdown in your repo. Agentry derives the view: what's moving, what's on you, what's blocked and why, what's next. A new repo gets a ready-made board: milestones, sprints, tasks, questions, decisions.

NOW
S3 · Invoices 6/9
ON YOU T-12 lookQ4 answer
BLOCKED T-21, T-22 behind T-14
AHEAD S4 0/7 · S5 0/5 · 3 parked agentry board status
08 · MEMORY

The next run knows what this one decided.

Decisions, gotchas and repo facts are written as plain files with where they came from, recalled few and ranked when a task needs them, and distilled from each run. Local, plain files, yours.

  1. FIRST RUN spec-first No prior decision: shape it, gate it, write the decision down.
  2. NEXT RUN one-shot The decision is recalled. Nothing to re-derive.
09 · GUARDRAILS

What it never does.

  • Lets an agent grade its own work.
  • Pushes without your policy saying so.
  • Merges on a base that moved, or a gate that didn't run.
  • Installs a skill or writes your settings without asking.
10 · FIELD LOG

Proven on a real game, bugs and all.

A week of night runs on a game board. Every bug it found in itself is logged and fixed in the open.

  • Found: the builder's brief listed symbols as files to own. Now: paths only, parsed once, amendable.
  • Found: parallel gates failed timing tests under load. Now: gates queue; known-flaky tests rerun alone.
  • Found: the guard froze the conductor's own night notes. Now: board writes are recorded; listed files may change.

Three lines. Then your board.

  1. /plugin marketplace add silentthreadstudio/agentry#v0.4.2
  2. /plugin install agentry@agentry-dev
  3. /agentry:init

Needs Claude Code and Node 24 or newer. MIT. OpenCode is supported in 0.4.0; see the install docs.