agents

Multi-harness agentic plugin marketplace for Claude Code, Codex CLI, Cursor, OpenCode, GitHub Copilot, and Gemini CLI

38,567 stars Python Markdown Skills API Spec #agent-skills#agentic-ai#agents#ai-agents
AI Prompts & Specs

Repository: wshobson/agents


Stars: 33770

CLAUDE.md

Project: claude-agents

Claude Code plugin marketplace — 79 plugins (77 local + 2 external via git-subdir), 184 agents, 150 skills, 98 commands.

Repository Structure

text
claude-agents/
├── .claude-plugin/marketplace.json   # Registry of all plugins
├── plugins/                          # All 77 local plugins (2 more installed via git-subdir from external repos)
│   ├── <plugin-name>/
│   │   ├── .claude-plugin/plugin.json
│   │   ├── agents/*.md
│   │   ├── commands/*.md
│   │   └── skills/<skill-name>/SKILL.md
│   └── ...
├── docs/                             # Documentation
│   ├── plugins.md                    # Plugin catalog
│   ├── agents.md                     # Agent reference
│   ├── agent-skills.md               # Skills reference
│   ├── usage.md                      # Usage guide
│   ├── architecture.md               # Design principles
│   └── plugin-eval.md                # Evaluation framework
└── tools/                            # Development utilities

Plugin Authoring Conventions

Agent frontmatter

yaml
---
name: agent-name
description: "What this agent does. Use PROACTIVELY when [trigger conditions]."
model: opus|sonnet|haiku|inherit
color: blue|green|red|yellow|cyan|magenta # optional
tools: Read, Grep, Glob # optional — restricts available tools
---

Skill structure

text
skills/<skill-name>/
├── SKILL.md              # Required — frontmatter + content
├── references/           # Optional — supporting material
│   └── *.md
└── assets/               # Optional — templates, configs

Skill frontmatter:

yaml
---
name: skill-name
description: "Use this skill when [specific trigger conditions]."
---

Command frontmatter

yaml
---
description: What this command does
argument-hint: <path> [--flag]
---

plugin.json

Only name is required. Agents, commands, and skills are auto-discovered from directory structure.

json
{ "name": "plugin-name" }

marketplace.json

Lists all plugin component paths for the registry. Agents as ./agents/name.md, skills as ./skills/skill-name (directory, not SKILL.md).

Model Tiers

| Tier | Model | Use Case |
| ------ | ------- | ------------------------------------------------------ |
| Tier 1 | Opus | Architecture, security, code review, production coding |
| Tier 2 | Inherit | Complex tasks — user chooses model |
| Tier 3 | Sonnet | Docs, testing, debugging, support |
| Tier 4 | Haiku | Fast ops, SEO, deployment, simple tasks |

PluginEval — Quality Evaluation Framework

Three-layer evaluation system in plugins/plugin-eval/. Full docs: docs/plugin-eval.md.

Quick Reference

bash
cd plugins/plugin-eval
Run tests

uv run pytest
Evaluate a skill (static only)

uv run plugin-eval score path/to/skill --depth quick --output json
Evaluate with LLM judge

uv run plugin-eval score path/to/skill --depth standard
Full certification (all 3 layers)

uv run plugin-eval certify path/to/skill
Compare two skills

uv run plugin-eval compare path/to/skill-a path/to/skill-b
Build corpus for Elo ranking

uv run plugin-eval init plugins/

Evaluation Layers

1. Static (Layer 1) — Deterministic structural analysis. < 2 seconds, free, always runs.
2. LLM Judge (Layer 2) — Semantic evaluation via Claude (Haiku + Sonnet). ~30s, 4 LLM calls.
3. Monte Carlo (Layer 3) — Statistical reliability via N simulated runs. ~2–5 min, 50–100 calls.

10 Dimensions (weights)

triggering_accuracy (25%), orchestration_fitness (20%), output_quality (15%), scope_calibration (12%), progressive_disclosure (10%), token_efficiency (6%), robustness (5%), structural_completeness (3%), code_template_quality (2%), ecosystem_coherence (2%)

Badges

Platinum ≥90, Gold ≥80, Silver ≥70, Bronze ≥60

Anti-Patterns

OVER_CONSTRAINED (>15 MUST/ALWAYS/NEVER), EMPTY_DESCRIPTION (<20 chars), MISSING_TRIGGER (no "Use when…"), BLOATED_SKILL (>800 lines no refs), ORPHAN_REFERENCE (dead link), DEAD_CROSS_REF (missing skill)

Tech Stack

- Python ≥ 3.12, uv, ruff, ty, pytest
- Dependencies: pydantic, typer, rich, pyyaml
- Optional: claude-agent-sdk (LLM layers), anthropic (API alternative)

Development

Python Tooling

Use the Astral Rust toolchain: uv (package manager), ruff (linter/formatter), ty (type checker). Do not use pip, mypy, or black.

Adding a Plugin

1. Create plugins/<name>/ with .claude-plugin/plugin.json
2. Add agents in agents/, commands in commands/, skills in skills/
3. Update .claude-plugin/marketplace.json
4. Follow naming conventions: lowercase, hyphen-separated


README.md

Claude Code Plugins: Orchestration and Automation

⚡ Updated for Opus 4.7, Sonnet 4.6 & Haiku 4.5 — Three-tier model strategy for optimal performance

![Run in Smithery](https://smithery.ai/skills?ns=wshobson&utm_source=github&utm_medium=badge)

🎯 Agent Skills Enabled — 150 specialized skills extend Claude's capabilities across plugins with progressive disclosure

A comprehensive production-ready system combining 184 specialized AI agents, 16 multi-agent workflow orchestrators, 150 agent skills, and 98 commands organized into 78 focused, single-purpose plugins for Claude Code.

Overview

This unified repository provides everything needed for intelligent automation and multi-agent orchestration across modern software development:

- 78 Focused Plugins - Granular, single-purpose plugins optimized for minimal token usage and composability
- 184 Specialized Agents - Domain experts with deep knowledge across architecture, languages, infrastructure, quality, data/AI, documentation, business operations, and SEO
- 150 Agent Skills - Modular knowledge packages with progressive disclosure for specialized expertise
- 16 Workflow Orchestrators - Multi-agent coordination systems for complex operations like full-stack development, security hardening, ML pipelines, and incident response
- 98 Commands - Optimized utilities including project scaffolding, security scanning, test automation, and infrastructure setup

Key Features

- Granular Plugin Architecture: 78 focused plugins optimized for minimal token usage
- Comprehensive Tooling: 98 commands including test generation, scaffolding, and security scanning
- 100% Agent Coverage: All plugins include specialized agents
- Agent Skills: 150 specialized skills following for progressive disclosure and token efficiency
- Clear Organization: 25 categories with 1-10 plugins each for easy discovery
- Efficient Design: Average 3.6 components per plugin (follows Anthropic's 2-8 pattern)

How It Works

Each plugin is completely isolated with its own agents, commands, and skills:

- Install only what you need - Each plugin loads only its specific agents, commands, and skills
- Minimal token usage - No unnecessary resources loaded into context
- Mix and match - Compose multiple plugins for complex workflows
- Clear boundaries - Each plugin has a single, focused purpose
- Progressive disclosure - Skills load knowledge only when activated

Example: Installing python-development loads 3 Python agents, 1 scaffolding tool, and makes 16 skills available (~1000 tokens), not the entire marketplace.

Quick Start

Step 1: Add the Marketplace

Add this marketplace to Claude Code:

bash
/plugin marketplace add wshobson/agents

This makes all 78 plugins available for installation, but does not load any agents or tools into your context.

Step 2: Install Plugins

Browse available plugins:

bash
/plugin

Install the plugins you need:

bash
Essential development plugins

/plugin install python-development          # Python with 16 specialized skills
/plugin install javascript-typescript       # JS/TS with 4 specialized skills
/plugin install backend-development         # Backend APIs with 3 architecture skills
Infrastructure & operations

/plugin install kubernetes-operations       # K8s with 4 deployment skills
/plugin install cloud-infrastructure        # AWS/Azure/GCP with 4 cloud skills
Security & quality

/plugin install security-scanning           # SAST with security skill
/plugin install comprehensive-review       # Multi-perspective code analysis
Full-stack orchestration

/plugin install full-stack-orchestration   # Multi-agent workflows

Each installed plugin loads only its specific agents, commands, and skills into Claude's context.

Plugins vs Agents

You install plugins, which bundle agents:

| Plugin | Agents |
| ----------------------- | ------------------------------------------------- |
| comprehensive-review | architect-review, code-reviewer, security-auditor |
| javascript-typescript | javascript-pro, typescript-pro |
| python-development | python-pro, django-pro, fastapi-pro |
| blockchain-web3 | blockchain-developer |

bash
❌ Wrong - can't install agents directly

/plugin install typescript-pro
✅ Right - install the plugin

/plugin install javascript-typescript@claude-code-workflows

Troubleshooting

"Plugin not found" → Use plugin names, not agent names. Add @claude-code-workflows suffix.

Plugins not loading → Clear cache and reinstall:

bash
rm -rf ~/.claude/plugins/cache/claude-code-workflows && rm ~/.claude/plugins/installed_plugins.json

Documentation

Core Guides

- Plugin Reference - Complete catalog of all 78 plugins
- Agent Reference - All 184 agents organized by category
- Agent Skills - 150 specialized skills with progressive disclosure
- Usage Guide - Commands, workflows, and best practices
- Architecture - Design principles and patterns
- PluginEval - Quality evaluation framework (layers, dimensions, scoring)

- Installation - Get started in 2 steps
- Essential Plugins - Top plugins for immediate productivity
- Command Reference - All slash commands organized by category
- Multi-Agent Workflows - Pre-configured orchestration examples
- Model Configuration - Haiku/Sonnet hybrid orchestration

What's New

PluginEval — Quality Evaluation Framework (NEW)

A three-layer evaluation framework for measuring and certifying plugin/skill quality:

bash
/plugin install plugin-eval@claude-code-workflows

- Three Evaluation Layers — Static analysis (instant), LLM judge (semantic), Monte Carlo simulation (statistical)
- 10 Quality Dimensions — Triggering accuracy, orchestration fitness, output quality, scope calibration, progressive disclosure, token efficiency, robustness, structural completeness, code template quality, ecosystem coherence
- Quality Badges — Platinum (★★★★★), Gold (★★★★), Silver (★★★), Bronze (★★)
- Anti-Pattern Detection — OVER_CONSTRAINED, EMPTY_DESCRIPTION, MISSING_TRIGGER, BLOATED_SKILL, ORPHAN_REFERENCE, DEAD_CROSS_REF
- Statistical Rigor — Wilson score CI, bootstrap CI, Clopper-Pearson exact CI, Elo ranking
- CLI + Claude Code — uv run plugin-eval score/certify/compare or /eval, /certify, /compare commands
- CI Gate — --threshold flag exits non-zero below a minimum score

bash
Quick evaluation (static only, instant)

uv run plugin-eval score path/to/skill --depth quick
Standard evaluation (static + LLM judge)

uv run plugin-eval score path/to/skill --depth standard
Full certification (all layers + Elo)

uv run plugin-eval certify path/to/skill

→ View PluginEval documentation

Agent Teams Plugin

Orchestrate multi-agent teams for parallel workflows using Claude Code's experimental Agent Teams feature:

bash
/plugin install agent-teams@claude-code-workflows

- 7 Team Presets — review, debug, feature, fullstack, research, security, migration
- Parallel Code Review — /team-review src/ --reviewers security,performance,architecture
- Hypothesis-Driven Debugging — /team-debug "API returns 500" --hypotheses 3
- Parallel Feature Development — /team-feature "Add OAuth2 auth" --plan-first
- Research Teams — Parallel investigation across codebase and web sources
- Security Audits — 4 reviewers covering OWASP, auth, dependencies, and secrets
- Migration Support — Coordinated migration with parallel streams and correctness verification

Includes 4 specialized agents, 7 commands, and 6 skills with reference documentation.

→ View agent-teams documentation

Conductor Plugin — Context-Driven Development

Transforms Claude Code into a project management tool with a structured Context → Spec & Plan → Implement workflow:

bash
/plugin install conductor@claude-code-workflows

- Interactive Setup — /conductor:setup creates product vision, tech stack, workflow rules, and style guides
- Track-Based Development — /conductor:new-track generates specifications and phased implementation plans
- TDD Workflow — /conductor:implement executes tasks with verification checkpoints
- Semantic Revert — /conductor:revert undoes work by logical unit (track, phase, or task)
- State Persistence — Resume setup across sessions with persistent project context
- 3 Skills — Context-driven development, track management, workflow patterns

→ View Conductor documentation

Agent Skills (150 skills across 37 plugins)

Specialized knowledge packages following Anthropic's progressive disclosure architecture:

Language Development:

- Python (5 skills): async patterns, testing, packaging, performance, UV package manager
- JavaScript/TypeScript (4 skills): advanced types, Node.js patterns, testing, modern ES6+

Infrastructure & DevOps:

- Kubernetes (4 skills): manifests, Helm charts, GitOps, security policies
- Cloud Infrastructure (4 skills): Terraform, multi-cloud, hybrid networking, cost optimization
- CI/CD (4 skills): pipeline design, GitHub Actions, GitLab CI, secrets management

Development & Architecture:

- Backend (3 skills): API design, architecture patterns, microservices
- LLM Applications (8 skills): LangGraph, prompt engineering, RAG, evaluation, embeddings, similarity search, vector tuning, hybrid search

Blockchain & Web3 (4 skills): DeFi protocols, NFT standards, Solidity security, Web3 testing

Project Management:

- Conductor (3 skills): context-driven development, track management, workflow patterns

And more: Framework migration, observability, payment processing, ML operations, security scanning

→ View complete skills documentation

Three-Tier Model Strategy

Strategic model assignment for optimal performance and cost:

| Tier | Model | Agents | Use Case |
| ---------- | -------- | ------ | ----------------------------------------------------------------------------------------------- |
| Tier 1 | Opus 4.7 | 42 | Critical architecture, security, ALL code review, production coding (language pros, frameworks) |
| Tier 2 | Inherit | 42 | Complex tasks - user chooses model (AI/ML, backend, frontend/mobile, specialized) |
| Tier 3 | Sonnet | 51 | Support with intelligence (docs, testing, debugging, network, API docs, DX, legacy, payments) |
| Tier 4 | Haiku | 18 | Fast operational tasks (SEO, deployment, simple docs, sales, content, search) |

Why Opus 4.7 for Critical Agents?

- 80.8% on SWE-bench (industry-leading)
- 65% fewer tokens for complex tasks
- Best for architecture decisions and security audits

Tier 2 Flexibility (inherit):
Agents marked inherit use your session's default model, letting you balance cost and capability:

- Set via claude --model opus or claude --model sonnet when starting a session
- Falls back to Sonnet 4.6 if no default specified
- Perfect for frontend/mobile developers who want cost control
- AI/ML engineers can choose Opus for complex model work

Cost Considerations:

- Opus 4.7: $5/$25 per million input/output tokens - Premium for critical work
- Sonnet 4.6: $3/$15 per million tokens - Balanced performance/cost
- Haiku 4.5: $1/$5 per million tokens - Fast, cost-effective operations
- Opus's 65% token reduction on complex tasks often offsets higher rate
- Use inherit tier to control costs for high-volume use cases

Orchestration patterns combine models for efficiency:

text
Opus (architecture) → Sonnet (development) → Haiku (deployment)

→ View model configuration details

Full-Stack Feature Development

bash
/full-stack-orchestration:full-stack-feature "user authentication with OAuth2"

Coordinates 7+ agents: backend-architect → database-architect → frontend-developer → test-automator → security-auditor → deployment-engineer → observability-engineer

→ View all workflow examples

Security Hardening

bash
/security-scanning:security-hardening --level comprehensive

Multi-agent security assessment with SAST, dependency scanning, and code review.

Python Development with Modern Tools

bash
/python-development:python-scaffold fastapi-microservice

Creates production-ready FastAPI project with async patterns, activating skills:

- async-python-patterns - AsyncIO and concurrency
- python-testing-patterns - pytest and fixtures
- uv-package-manager - Fast dependency management

Kubernetes Deployment

bash
Activates k8s skills automatically

"Create production Kubernetes deployment with Helm chart and GitOps"

Uses kubernetes-architect agent with 4 specialized skills for production-grade configs.

→ View complete usage guide

Plugin Categories

25 categories, 78 plugins:

- 🎨 Development (6) - debugging, backend, frontend, multi-platform
- 📚 Documentation (4) - code docs, API specs, diagrams, C4 architecture, HADS (Human-AI Document Standard)
- 🔄 Workflows (5) - git, full-stack, TDD, Conductor (context-driven development), Agent Teams (multi-agent orchestration)
- ✅ Testing (2) - unit testing, qa-orchestra (multi-agent QA toolkit with Chrome MCP validation)
- 🔍 Quality (3) - comprehensive review, performance
- 🤖 AI & ML (4) - LLM apps, agent orchestration, context, MLOps
- 📊 Data (2) - data engineering, data validation
- 🗄️ Database (2) - database design, migrations
- 🚨 Operations (4) - incident response, diagnostics, distributed debugging, observability
- ⚡ Performance (2) - application performance, database/cloud optimization
- ☁️ Infrastructure (5) - deployment, validation, Kubernetes, cloud, CI/CD
- 🔒 Security (6) - scanning, compliance, backend/API, frontend/mobile, block-no-verify (git hook bypass guard)
- 🛡️ Governance (1) - protect-mcp (Cedar policy enforcement + Ed25519 signed receipts)
- 💻 Languages (10) - Python, JS/TS, systems, JVM, scripting, functional, embedded
- 🔗 Blockchain (1) - smart contracts, DeFi, Web3
- 💰 Finance (1) - quantitative trading, risk management
- 💳 Payments (1) - Stripe, PayPal, billing
- 🎮 Gaming (1) - Unity, Minecraft plugins
- 🎨 Creative (1) - creative tooling
- ♿ Accessibility (1) - WCAG and a11y
- 📢 Marketing (4) - SEO content, technical SEO, SEO analysis, content marketing
- 💼 Business (4) - analytics, HR/legal, customer/sales
- 🔌 API (2) - API tooling
- 🛠️ Utilities (4) - general-purpose helpers
- 🔧 Modernization (2) - legacy migration and refactoring

→ View complete plugin catalog

Plugins hosted in their own marketplaces — install from the source for the latest releases:

- Pensyve — Universal memory runtime with cross-session cognitive memory for Claude Code. Intelligent capture, entity-aware recall, 6 commands, 4 skills, 2 agents, and 6 lifecycle hooks.

bash
/plugin marketplace add major7apps/pensyve
  /plugin install pensyve@major7apps-pensyve

Architecture Highlights

Granular Design

- Single responsibility - Each plugin does one thing well
- Minimal token usage - Average 3.6 components per plugin
- Composable - Mix and match for complex workflows
- 100% coverage - All 184 agents accessible across plugins

Progressive Disclosure (Skills)

Three-tier architecture for token efficiency:

1. Metadata - Name and activation criteria (always loaded)
2. Instructions - Core guidance (loaded when activated)
3. Resources - Examples and templates (loaded on demand)

Repository Structure

text
claude-agents/
├── .claude-plugin/
│   └── marketplace.json          # 77 plugins
├── plugins/
│   ├── python-development/
│   │   ├── agents/               # 3 Python experts
│   │   ├── commands/             # Scaffolding tool
│   │   └── skills/               # 5 specialized skills
│   ├── kubernetes-operations/
│   │   ├── agents/               # K8s architect
│   │   ├── commands/             # Deployment tools
│   │   └── skills/               # 4 K8s skills
│   └── ... (67 more plugins)
├── docs/                          # Comprehensive documentation
└── README.md                      # This file

→ View architecture details

Contributing

To add new agents, skills, or commands:

1. Identify or create the appropriate plugin directory in plugins/
2. Create .md files in the appropriate subdirectory:
- agents/ - For specialized agents
- commands/ - For tools and workflows
- skills/ - For modular knowledge packages
3. Follow naming conventions (lowercase, hyphen-separated)
4. Write clear activation criteria and comprehensive content
5. Update the plugin definition in .claude-plugin/marketplace.json

See Architecture Documentation for detailed guidelines.

Resources

Documentation

- Claude Code Documentation
- Plugins Guide
- Subagents Guide
- Agent Skills Guide
- Slash Commands Reference

This Repository

- Plugin Reference
- Agent Reference
- Agent Skills Guide
- Usage Guide
- Architecture

License

MIT License - see LICENSE file for details.

Star History

![Star History Chart](https://www.star-history.com/#wshobson/agents&type=date&legend=top-left)