About toru-claude-agents

Multi-agent team for Claude Code: 7 AI specialists (strategy, dev, security, sales, design, data, research) that collaborate and challenge you. Dev-cycle workflow with machine-verifiable completion.

t

Published by

toruai

Visit View Profile

README.md

View on GitHub

Toru Claude Agents

A team of AI specialists for Claude Code

What is this? A configuration package that gives Claude Code a team of specialized agents, development workflows, and a memory system.

Who made this? ToruAI. This is how we work with Claude Code internally, now open source.

The Vision

Most AI tools give you one generic assistant. We give you a team.

Each agent has a role, a personality, and expertise. They collaborate. They challenge each other. They challenge you. Growth comes from people who push you to be better, not yes-machines.

Strategy - Garry prioritizes, delegates, sees the big picture
Development - Bob builds, tests, ships quality code
Security - Sentinel audits before it becomes tomorrow's headline
Sales - Maya transforms how you pitch and communicate
Design - Luna makes complexity invisible
Data - Arlo finds patterns, validates assumptions
Research - Scout explores, brings back what matters

Quick Start

# Requires: Claude Code installed, Node.js 20+
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 what will happen

Try it now - open Claude Code in any project and type:

/scout what does this codebase do?

Start a dev session:

/dev-cycle implement user authentication

Garry plans, Bob builds, Sentinel audits security. The workflow handles iteration until tests pass.

The Team

Seven agents, each with a role. Claude Code spawns them as subagents when needed.

Agent	Role	What They Do	Model
Garry	Chief of Staff	Plans, delegates, sees the big picture	Opus (smartest, slowest)
Bob	Technical Builder	Writes code, fixes bugs, ships quality	Sonnet (balanced)
Sentinel	Security Specialist	Audits for vulnerabilities, zero BS	Opus
Scout	Codebase Explorer	Fast reconnaissance, answers questions	Haiku (fastest, cheapest)
Arlo	Pattern Whisperer	Finds patterns in data, validates assumptions	Inherit (uses current)
Luna	Design Architect	Makes complexity invisible	Inherit
Maya	Challenger Salesperson	Client communication, transforms thinking	Inherit

How to use agents:

Automatic: Skills like /dev-cycle delegate to agents internally
Direct: Ask Claude "have Bob review this code" or "let Sentinel audit security"
Explicit: Use the Task tool with subagent_type: "bob" (for advanced users)

The Dev Workflow

/dev-full-auto  →  Fully autonomous: spec in, working software out
/dev-cycle      →  Start or resume development session (interactive)
/dev-qa         →  Run tests, lint, types, build
/dev-security   →  Sentinel security audit
/dev-rc         →  Release candidate - final gate before merge
/dev-finish     →  Commit, PR, capture learnings

Full auto vs dev-cycle:

/dev-full-auto - Give me a spec, walk away. I build, test, secure, document. You review working code.
/dev-cycle - Interactive. I plan, you approve. Good for learning or sensitive work.

The loop: Build → Check → Pass? → Done. If not, fix and repeat. Exit conditions are objective (tests pass, lint clean, security audit green) - not "feels done."

All Skills

Skill	What It Does
`/dev-full-auto`	Autonomous mode: spec in, production-ready software out
`/dev-cycle`	Interactive dev sessions with planning and iteration
`/dev-qa`	Run tests, lint, type checks, build verification
`/dev-security`	Security audit with Sentinel
`/dev-rc`	Release candidate checks before merge
`/dev-finish`	Close session: commit, PR, capture learnings
`/scout`	Quick codebase exploration and research
`/branch-workflow`	Git branch conventions for autonomous work
`/megg-learn`	Capture learnings to knowledge base
`/megg-state`	Session state for cross-session handoff
`/openspec-workflow`	Specification-driven development
`/cc-docs`	Access Claude Code documentation
`/claude-code-mastery`	Learn to build agents, skills, hooks
`/self-improvement`	Reflect and improve workflows

Requirements

Claude Code - Install first
Node.js 20+ - for megg memory system
jq (optional) - for git push protection hook (brew install jq)

What the Installer Does

Symlinks agents, skills, docs to ~/.claude/
Copies config files (settings.json with hooks)
Installs megg - memory system for agents
Configures megg MCP server - required for /dev-cycle, /megg-* skills

If megg MCP fails to configure automatically:

claude mcp add --transport stdio --scope user megg -- npx megg mcp

How It Works

The installer symlinks into ~/.claude/ (or ./.claude/ with --local). A timestamped backup is created before any changes. Your local repo stays intact - update with:

./update.sh  # pulls changes, cleans stale symlinks, adds new items

Hooks (in settings.json):

SessionStart: Auto-loads megg context every session
PreToolUse: Blocks accidental git push - you push when ready

The Philosophy

Ralph Loop: Continuous iteration until machine-verifiable completion. Tests pass? Lint clean? Security green? Then you're done. The filesystem is AI memory - git commits, test results, build logs persist across sessions.

Why agents? One generic assistant optimizes for "helpful." Specialists optimize for their domain. Sentinel doesn't care about your feelings - he cares about your attack surface. Bob doesn't over-engineer - he ships. Garry delegates because he sees the whole board.

Uninstall

./uninstall.sh              # Remove symlinks, keep your modifications
./uninstall.sh --restore    # Remove and restore previous state from backup
./uninstall.sh --list-backups  # See available backups

Documentation

Getting Started - First 15 minutes walkthrough
Concepts - Agents, skills, megg, MCP explained
Troubleshooting - Common issues and fixes

License

MIT

Built by ToruAI | Report issues

toru-claude-agents