Toru Claude Agents

A dev workflow for Claude Code that won't call your work done until your tests, linter and build exit zero — and won't call it mergeable until a security audit passes. Seven specialists run it. Install is two commands.

Built by ToruAI — this is how we work with Claude Code, packaged as we actually use it.

Quick Start

Inside Claude Code:

/plugin marketplace add ToruAI/toru-claude-agents
/plugin install toru-claude-agents@toru-claude-agents

Then restart Claude Code so the new agents and skills load. That's the whole install — memory comes with the plugin, and your own settings.json, agents and skills are untouched.

/scout what does this codebase do?          ← try it first, read-only
/dev-cycle implement user authentication    ← the actual workflow

Three things to know before you install

• It costs ~1.1k tokens of always-on context. Seven agent descriptions plus fourteen skill descriptions. Nothing else loads until you invoke it. Don't take our word for it — claude plugin details toru-claude-agents prints the measured number.
• It blocks git push. Agents commit as much as they like; publishing stays your decision, because it's the one thing an agent can't take back. How to remove it.
• These agents aren't built to agree with you. Sentinel doesn't soften findings — "this is exploitable", not "this could potentially be a concern". Bob says so before building when the spec is contradictory. Scout reports that your premise was wrong rather than answering the question you asked. If you want an assistant that nods, install something else.

Prefer symlinks into ~/.claude/? Use the installer instead.

git clone https://github.com/ToruAI/toru-claude-agents.git
cd toru-claude-agents
./install.sh              # Global install to ~/.claude/
./install.sh --local      # Local install to ./.claude/ (current project only)
./install.sh --dry-run    # Preview exactly what it would change — read this first

For people who want to read and edit the agents in place, or install into one project only. It writes into ~/.claude/ and replaces some of what's there — see What the installer overwrites before running it. Pick one route, not both: the same agents registered twice is just noise.

Why this instead of a bigger collection

Most collections hand you a hundred agents and leave the orchestration to you. This is the opposite bet: a small roster wired into one pipeline with objective exit conditions.

/dev-cycle   →   /dev-qa   →   /dev-security   →   /dev-rc   →   /dev-finish
  plan+build     tests,lint    Sentinel audit     last gate    commit+learnings

Exit conditions are machine-checked, not vibes: tests pass, lint clean, types clean, audit green. If they don't, the loop goes back to work. Session state lives in a file, so closing your terminal doesn't lose the thread.

That's the trade: fewer agents, but they run a process. If you want breadth, the big collections are genuinely better at breadth.

The Team

Four agents do the development work:

Agent	Role	What they do	Model
Garry	Chief of Staff	Plans, delegates, argues with the plan before Bob builds it	opus
Bob	Technical Builder	Writes code and tests; says so when the spec can't work	sonnet
Sentinel	Security Specialist	Audits for vulnerabilities; won't soften a severity	opus
Scout	Codebase Explorer	Read-only reconnaissance; reports when your premise is wrong	haiku

Three more, for work that isn't code: Arlo (data), Luna (design), Maya (client-facing writing)

Agent	Role	What they do	Model
Arlo	Data & Patterns	Finds the pattern, says which parts the numbers support	inherit
Luna	Design	Interfaces that remove decisions instead of adding controls	inherit
Maya	Client-facing	Pitches, proposals and hard emails, pressure-tested	inherit

They cost context whether or not you use them — about 110 tokens for all three. If you want them gone, delete the three files from the plugin's agents/ directory, or use the installer route and don't link them.

Models are aliases, so each agent picks up the current generation of its tier as new ones ship: opus for judgement, sonnet for building, haiku for fast reads, inherit to match your main conversation. Change any of them in the agent's frontmatter.

How to use them:

• Automatic — skills like /dev-cycle delegate to agents internally
• Direct — "have Bob review this code", "let Sentinel audit the auth flow"
• Explicit — the Task tool with subagent_type: "toru-claude-agents:bob" (plugin components are namespaced; on the installer route it's just bob)

The Dev Workflow

/dev-cycle      →  plan and build, interactively — you approve the plan
/dev-full-auto  →  same pipeline, no check-ins: spec in, working software out
/dev-qa         →  tests, lint, types, build
/dev-security   →  Sentinel audit
/dev-rc         →  last gate before merge
/dev-finish     →  commit, capture what was learned

The loop: build → check → pass? → done. If not, fix and repeat. /dev-cycle asks before it plans; /dev-full-auto doesn't ask at all and stops only at a real blocker.

Honest limit: the gates are instructions to Claude, enforced by Claude running your actual test and lint commands and reading the exit codes — not by CI. It will tell you a suite failed; it can't stop you overruling it. The one gate enforced mechanically is the push guard below.

All Skills

Skill	What it does
/dev-cycle	Run a feature end to end, with a session file that survives a closed terminal
`/dev