🙏 This repository is forked from wshobson/agents, the original creator of this comprehensive subagent collection. Thank you for building this amazing resource for the AI coding assistant community!

A comprehensive collection of specialized AI agents for both Claude Code and OpenCode, providing domain-specific expertise across software development, infrastructure, and business operations.

This repository provides production-ready agents that extend AI coding assistants' capabilities with specialized knowledge. The collection includes:

• 90+ Claude Code agents - Optimized for Claude's subagent system
• OpenCode agents - Designed with open-source principles and privacy-first approach
• Shared agents - Cross-platform compatible agents

Each agent incorporates:

• Current industry best practices and standards (2024/2025)
• Production-ready patterns and enterprise architectures
• Deep domain expertise with 8-12 capability areas per agent
• Modern technology stacks and frameworks
• Optimized model selection based on task complexity

agents/
├── claude/          # Claude Code specific agents
│   ├── business/
│   ├── infrastructure/
│   ├── languages/
│   ├── quality-security/
│   └── ...
├── opencode/        # OpenCode specific agents
│   ├── open-source/
│   ├── privacy-security/
│   ├── infrastructure/
│   └── ...
├── shared/          # Cross-platform compatible agents
├── CLAUDE.md        # Claude Code specific documentation
├── OPENCODE.md      # OpenCode specific documentation
└── README.md        # This file

• Claude Code agents: See CLAUDE.md for setup and usage
• OpenCode agents: See OPENCODE.md for setup and usage

Agents are assigned to specific Claude models based on task complexity and computational requirements. The system uses three model tiers:

OpenCode agents are designed with open-source principles, privacy-first architectures, and transparency. All 94 Claude Code agents have been converted to OpenCode format and are available in the opencode/ directory.

All language-specific programming agents from Claude Code, including:

• Python, JavaScript, TypeScript, Go, Rust, Java, C++, C, C#
• Ruby, PHP, Elixir, Scala, Flutter, iOS development
• Django, FastAPI, and mobile development

Comprehensive DevOps and cloud infrastructure agents:

• Cloud architects, Kubernetes engineers, Terraform specialists
• Database administrators, network engineers, deployment engineers
• Platform engineers, observability specialists
• self-hosting-specialist - Convert to self-hosted alternatives

Advanced security and quality assurance agents:

• Security auditors, code reviewers, debuggers
• Frontend/backend/mobile security specialists
• Performance engineers, test automators
• privacy-first-architect - Privacy-preserving systems

Domain-specific technical expertise:

• AI/ML engineers, blockchain developers, GraphQL architects
• Finance specialists (quant analysts, risk managers)
• Payment integration, developer experience optimization

Business operations and growth agents:

• Product managers, business analysts, HR professionals
• Content marketers, sales automators, customer support
• SEO specialists (10 dedicated SEO agents)

Technical writing and research agents:

• Documentation architects, API documenters, technical writers
• Data scientists, SQL specialists, search specialists
• UI/UX designers, tutorial engineers

• Gaming (2 agents): Unity developer, Minecraft Bukkit specialist
• Tools (2 agents): Visual validators, diagram creators
• Open Source (1 agent): license-compliance-guardian

• Open-source focused: Prioritizes FOSS tools and libraries
• Privacy by default: Local-first processing and data minimization
• Transparent operation: Includes reasoning traces and decision explanations
• Community oriented: Supports collaborative development patterns
• Self-hostable: Designed for on-premise and air-gapped deployments

Note: Claude Code expects agents directly in ~/.claude/agents/, not in subdirectories. See INSTALLATION.md for detailed setup options.

Quick setup with symlink:

git clone https://github.com/brianluby/agents.git ~/agents-repo
ln -s ~/agents-repo/claude ~/.claude/agents

# Clone the repository
git clone https://github.com/brianluby/agents.git

# Link OpenCode agents globally
ln -s /path/to/agents/opencode/* ~/.config/opencode/agent/

# Or link to a project
ln -s /path/to/agents/opencode/* .opencode/agent/

See OPENCODE.md for detailed OpenCode setup instructions.

Validate agent metadata before committing:

python scripts/lint_agents.py --roots opencode claude --require-model

Auto-fill missing model values:

python scripts/lint_agents.py --roots opencode --fix-missing-model anthropic/claude-sonnet-4-20250514

Auto-fix canonical key ordering & validate allowed tools:

python scripts/lint_agents.py --roots opencode claude --check-order --require-model

Soft (non-failing) report mode:

python scripts/lint_agents.py --roots opencode --require-model --warn-only

Install pre-commit hook:

ln -s ../../.githooks/agent-lint .git/hooks/pre-commit

See CHANGELOG.md for normalization history.

The repo ships lightweight tool scripts (under scripts/tools/) used by some OpenCode agents or local workflows:

• glob_tool.py – Glob file listing (no content read)
• grep_tool.py – Regex line search with match cap (default 500)
• diff_tool.py – Unified diff (file↔file / dir↔dir) with byte limit
• format_tool.py – Minimal trailing-space + final newline normalizer (dry-run by default)
• webfetch_tool.py – Disabled-by-default HTTP(S) fetch (text-only, 100 KB cap, requires --allow or OPENCODE_ALLOW_WEB=1)

List allowed agent tool names:

python scripts/lint_agents.py --list-tools

Enable only what an agent strictly needs; omit webfetch unless remote context is essential.

Claude Code automatically selects the appropriate subagent based on task context and requirements. The system analyzes your request and delegates to the most suitable specialist.

Specify a subagent by name to use a particular specialist:

"Use code-reviewer to analyze the recent changes"
"Have security-auditor scan for vulnerabilities"
"Get performance-engineer to optimize this bottleneck"

code-reviewer: Analyze component for best practices
security-auditor: Check for OWASP compliance
tdd-orchestrator: Implement feature with test-first approach
performance-engineer: Profile and optimize bottlenecks

backend-architect: Design authentication API
frontend-developer: Create responsive dashboard
graphql-architect: Design federated GraphQL schema
mobile-developer: Build cross-platform mobile app

devops-troubleshooter: Analyze production logs
cloud-architect: Design scalable AWS architecture
network-engineer: Debug SSL certificate issues
database-admin: Configure backup and replication
terraform-specialist: Write infrastructure modules

data-scientist: Analyze customer behavior dataset
ai-engineer: Build RAG system for document search
mlops-engineer: Set up experiment tracking
ml-engineer: Deploy model to production

business-analyst: Create metrics dashboard
docs-architect: Generate technical documentation
api-documenter: Write OpenAPI specifications
content-marketer: Create SEO-optimized content

Subagents coordinate automatically for complex tasks. The system intelligently sequences multiple specialists based on task requirements.

Feature Development

"Implement user authentication"
→ backend-architect → frontend-developer → test-automator → security-auditor

Performance Optimization

"Optimize checkout process"
→ performance-engineer → database-optimizer → frontend-developer

Production Incidents

"Debug high memory usage"
→ incident-responder → devops-troubleshooter → error-detective → performance-engineer

Infrastructure Setup

"Set up disaster recovery"
→ database-admin → database-optimizer → terraform-specialist

ML Pipeline Development

"Build ML pipeline with monitoring"
→ mlops-engineer → ml-engineer → data-engineer → performance-engineer

For sophisticated multi-agent orchestration, use the Claude Code Commands collection which provides 52 pre-built slash commands:

/full-stack-feature   # Coordinates 8+ agents for complete feature development
/incident-response    # Activates incident management workflow
/ml-pipeline         # Sets up end-to-end ML infrastructure
/security-hardening  # Implements security best practices across stack

Each subagent is defined as a Markdown file with frontmatter:

---
name: subagent-name
description: Activation criteria for this subagent
model: haiku|sonnet|opus  # Optional: Model selection
tools: tool1, tool2       # Optional: Tool restrictions
---

System prompt defining the subagent's expertise and behavior

• haiku: Simple, deterministic tasks with minimal reasoning
• sonnet: Standard development and engineering tasks
• opus: Complex analysis, architecture, and critical operations

Agents execute in sequence, passing context forward:

backend-architect → frontend-developer → test-automator → security-auditor

Multiple agents work simultaneously on different aspects:

performance-engineer + database-optimizer → Merged analysis

Dynamic agent selection based on analysis:

debugger → [backend-architect | frontend-developer | devops-troubleshooter]

Primary work followed by specialized review:

payment-integration → security-auditor → Validated implementation

1. Automatic selection - Let Claude Code analyze context and select optimal agents
2. Clear requirements - Specify constraints, tech stack, and quality standards
3. Trust specialization - Each agent is optimized for their specific domain

1. High-level requests - Allow agents to coordinate complex multi-step tasks
2. Context preservation - Ensure agents have necessary background information
3. Integration review - Verify how different agents' outputs work together

1. Direct invocation - Specify agents when you need particular expertise
2. Strategic combination - Use multiple specialists for validation
3. Review patterns - Request specific review workflows (e.g., "security-auditor reviews API design")

1. Monitor effectiveness - Track which agents work best for your use cases
2. Iterative refinement - Use agent feedback to improve requirements
3. Complexity matching - Align task complexity with agent capabilities

To add a new subagent:

1. Create a new .md file with appropriate frontmatter
2. Use lowercase, hyphen-separated naming convention
3. Write clear activation criteria in the description
4. Define comprehensive system prompt with expertise areas

• Ensure request clearly indicates the domain
• Be specific about task type and requirements
• Use explicit invocation if automatic selection fails

• Provide more context about tech stack
• Include specific requirements in request
• Use direct agent naming for precise control

• Normal behavior - specialists have different priorities
• Request reconciliation between specific agents
• Consider trade-offs based on project requirements

• Include background information in requests
• Reference previous work or patterns
• Provide project-specific constraints

MIT License - see LICENSE file for details.

• Claude Code Documentation
• Subagents Documentation
• Claude Code GitHub
• Claude Code Commands