Stop Wasting Tokens on Bloated AI Tools: 185 Agents That Actually Work

Stop Wasting Tokens on Bloated AI Tools: 185 Agents That Actually Work

Your AI assistant is drowning in context. Every time you fire up Claude Code, you're hemorrhaging tokens on irrelevant plugins, bloated instructions, and agents you'll never touch. The result? Slower responses, ballooning API bills, and that creeping frustration when Claude "forgets" what you actually asked for.

Sound familiar? You've probably tried monolithic AI extensions that promise everything and deliver bloat. Or maybe you've stitched together a dozen brittle scripts that break when the wind changes. What if there was a radically different approach—one where you install only what you need, when you need it, and nothing more?

Enter wshobson/agents—a surgical, production-ready orchestration ecosystem that flips the script on AI tooling. With 185 specialized agents, 16 multi-agent workflow orchestrators, 153 progressive skills, and 80 razor-focused plugins, this isn't another kitchen-sink framework. It's intelligent automation designed by someone who actually ships code.

Ready to stop feeding tokens to the bloat monster? Let's dissect what makes this system genuinely different.

What Is wshobson/agents?

wshobson/agents is a comprehensive plugin marketplace and orchestration framework for Claude Code, Anthropic's powerful AI coding assistant. Created by Seth Hobson (wshobson), this open-source ecosystem transforms Claude Code from a capable pair programmer into a multi-agent development powerhouse with domain expertise spanning the entire software lifecycle.

The repository's core philosophy is granular composability. Instead of loading a massive "dev tools" extension that consumes thousands of tokens, you install single-purpose plugins—each containing exactly the agents, commands, and skills needed for one job. The python↗ Bright Coding Blog-development plugin loads ~1,000 tokens for 3 Python agents and 16 skills. Not the entire 185-agent marketplace. Not even close.

Why it's trending now:

• Updated for Opus 4.7, Sonnet 4.6 & Haiku 4.5 — Three-tier model strategy optimized for performance and cost
• Gemini CLI native support — Same 153 skills, zero plugin installation, discoverable on-demand
• PluginEval framework — First rigorous quality certification system for AI plugins (static analysis + LLM judge + Monte Carlo simulation)
• Agent Teams experimental support — Parallel multi-agent workflows using Claude Code's newest orchestration feature

The numbers are staggering: 25 categories, 80 plugins, 100 commands, and 100% agent coverage across every plugin. Yet the average plugin contains just 3.6 components—precisely within Anthropic's recommended 2-8 pattern for optimal token efficiency.

This isn't hobbyist tooling. It's battle-tested infrastructure for teams shipping production systems.

Key Features That Separate Winners from Wannabes

Granular Plugin Architecture: Surgical Precision

Most AI extensions follow the "more is more" philosophy. wshobson/agents inverts this entirely. Each of the 80 plugins has a single, focused purpose with clear boundaries:

• Minimal token usage — No unnecessary resources loaded into context
• Composable design — Mix kubernetes-operations + security-scanning + observability for a hardened deployment pipeline
• Isolated components — Every plugin maintains its own agents/, commands/, and skills/ directories

185 Specialized Agents: True Domain Expertise

These aren't generic "coding assistant" personas. They're deep specialists:

153 Agent Skills: Progressive Disclosure Done Right

Following Anthropic's progressive disclosure architecture, skills load knowledge in three tiers:

1. Metadata — Name and activation criteria (always loaded, minimal tokens)
2. Instructions — Core guidance (loaded when skill activates)
3. Resources — Examples and templates (loaded on demand only)

This means your async-python-patterns skill sits dormant until you ask about concurrency, then delivers expert-level asyncio guidance without cluttering every other conversation.

16 Workflow Orchestrators: Multi-Agent Symphonies

Complex operations require coordinated agent teams. The orchestrators handle:

• Full-stack feature development — 7+ agents in sequence: architect → database → frontend → testing → security → deployment → observability
• Security hardening — SAST, dependency scanning, code review in parallel
• ML pipelines — Data validation, model training, evaluation, deployment
• Incident response — Diagnostics, root cause analysis, remediation, communication

Three-Tier Model Strategy: Cost Intelligence

Not all agents need Opus-level reasoning. The system strategically assigns models:

The killer insight: Opus 4.7 achieves 80.8% on SWE-bench (industry-leading) with 65% fewer tokens on complex tasks. The higher rate often pays for itself through efficiency.

Real-World Use Cases: Where This Actually Shines

1. Production-Grade Full-Stack Feature Delivery

You're tasked with OAuth2 authentication for a SaaS product. Traditionally: days of context-switching between backend, frontend, security, and DevOps^{↗ Bright Coding Blog} concerns.

With wshobson/agents:

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

Seven specialized agents activate in orchestrated sequence. The backend architect designs the token flow. The database architect schemas refresh tokens. The frontend developer implements the UI. The security auditor validates against OWASP. The deployment engineer containerizes. The observability engineer instruments. You review and approve at checkpoints.

Result: Production-ready in hours, not days, with verified security posture.

2. Security Hardening Without the Audit Fatigue

Security reviews are notoriously tedious. The security-scanning plugin with comprehensive-review creates genuine defense in depth:

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

Multi-agent assessment runs SAST, dependency scanning (vulnerable transitive deps), secrets detection, and architectural risk analysis simultaneously. The block-no-verify plugin even guards against git hook bypass attacks—a subtle vector most teams miss.

3. Modern Python Development at Velocity

The python-development plugin isn't just syntax help. It's production Python expertise:

/python-development:python-scaffold fastapi-microservice

Instantly activates:

• async-python-patterns — Structured concurrency, asyncio best practices
• python-testing-patterns — pytest fixtures, parametrize, mocking strategies
• uv-package-manager — Sub-second dependency resolution, lockfile management
• python-packaging — Modern pyproject.toml, wheel building, distribution

You get opinionated, current guidance—not Stack Overflow answers from 2019.

4. Kubernetes That Won't Wake You at 3 AM

Production Kubernetes is a specialty, not a weekend learn. The kubernetes-operations plugin bundles:

# Activates automatically when you mention K8s deployment
"Create production Kubernetes deployment with Helm chart and GitOps"

Four specialized skills engage: manifest design, Helm templating, GitOps workflows (Argo/Flux), and security policies (PodSecurity, NetworkPolicies). The kubernetes-architect agent knows why latest tags destroy reproducibility and how to structure multi-env Helm values.

5. Multi-Agent Parallel Code Review

The experimental Agent Teams feature (via agent-teams plugin) enables parallel specialized review:

/team-review src/ --reviewers security,performance,architecture

Three reviewers analyze simultaneously. Security finds the SQL injection. Performance spots the N+1 query. Architecture questions the service boundary. No single reviewer fatigue. No sequential delays.

Step-by-Step Installation & Setup Guide

Prerequisites

• Claude Code installed and authenticated
• Basic familiarity with slash commands (/help for reference)

Step 1: Add the Marketplace

This makes all 80 plugins discoverable without loading anything into context:

# Add wshobson's agent marketplace to Claude Code
/plugin marketplace add wshobson/agents

Critical: This step zeroes your token cost. Browse without commitment.

Step 2: Discover Available Plugins

# List all available plugins with descriptions
/plugin

You'll see 25 categories. Start with essentials based on your stack.

Step 3: Install Targeted Plugins

# Core development (install only what matches your stack)
/plugin install python-development          # 3 agents, 16 skills, scaffolding
/plugin install javascript↗ Bright Coding Blog-typescript       # 2 agents, 4 skills
/plugin install backend-development         # 3 architecture skills

# Infrastructure & operations
/plugin install kubernetes-operations       # K8s architect, 4 deployment skills
/plugin install cloud-infrastructure        # Multi-cloud, 4 skills

# Quality & security
/plugin install security-scanning           # SAST, security skill
/plugin install comprehensive-review        # Multi-perspective analysis

# Advanced orchestration
/plugin install full-stack-orchestration    # Multi-agent workflows
/plugin install agent-teams                 # Parallel agent execution
/plugin install conductor                   # Context-driven project management

Step 4: Verify Installation

# Check loaded plugins and their agents
/plugin list

Each plugin shows its token footprint. Confirm you're not accidentally bloated.

Troubleshooting Common Issues

"Plugin not found" error?

You're likely using agent names instead of plugin names. Remember:

# ❌ WRONG — typescript-pro is an agent, not a plugin
/plugin install typescript-pro

# ✅ CORRECT — install the containing plugin
/plugin install javascript-typescript@claude-code-workflows

Plugins not loading or stale?

Clear the cache aggressively:

# Remove cached plugin data and reinstall
rm -rf ~/.claude/plugins/cache/claude-code-workflows && \
rm ~/.claude/plugins/installed_plugins.json

Gemini CLI Alternative (Zero Plugin Installation)

Prefer Google's Gemini CLI? Same ecosystem, different interface:

# Install as native extension
gemini extensions install https://github.com/wshobson/agents

• 153 skills discoverable by describing your task
• Opt-in slash commands generated locally per plugin (make generate-plugin PLUGIN=<name>)
• Protocol Orchestrator with checkpoint approvals matching Claude Code's discipline

REAL Code Examples from the Repository

Let's examine actual commands and workflows from wshobson/agents, with detailed explanations of what happens under the hood.

Example 1: Full-Stack Feature Orchestration

# Triggers the full-stack-orchestration plugin's primary command
/full-stack-orchestration:full-stack-feature "user authentication with OAuth2"

What executes behind the scenes:

This isn't a single agent guessing at full-stack work. The orchestrator sequentially activates 7+ specialized agents, each with defined handoff criteria:

1. backend-architect (Opus 4.7) — Designs OAuth2 flow: authorization code vs. PKCE, token storage strategy, refresh rotation
2. database-architect (Opus 4.7) — Schemas user tables, token tables with TTL, indexes for lookup performance
3. frontend-developer (Sonnet 4.6 or inherited) — Implements login UI, token management in browser, redirect handling
4. test-automator (Sonnet 4.6) — Generates integration tests for the auth flow, edge cases (expired tokens, CSRF)
5. security-auditor (Opus 4.7 — always Opus for security) — Validates against OWASP Top 10, checks for implicit flow misuse, secrets handling
6. deployment-engineer (Sonnet 4.6) — Containerizes, generates Docker^{↗ Bright Coding Blog} Compose or K8s manifests
7. observability-engineer (Sonnet 4.6) — Adds structured logging for auth events, metrics for failure rates

The checkpoint system pauses between phases for your approval. No black-box automation. You retain control.

Example 2: Security Hardening with Tiered Assessment

# Comprehensive security assessment with multi-layer scanning
/security-scanning:security-hardening --level comprehensive

Technical breakdown:

The --level comprehensive flag activates three parallel assessment streams:

• Static Application Security Testing (SAST) — Pattern-based detection of injection flaws, insecure deserialization, weak crypto
• Dependency Analysis — Scans package-lock.json, requirements.txt, Cargo.lock against vulnerability databases
• Multi-Agent Code Review — security-auditor (Opus 4.7) performs semantic analysis: "Is this JWT validation actually correct?"

The comprehensive-review plugin's three-reviewer pattern (architect-review, code-reviewer, security-auditor) ensures no single perspective dominates.

Example 3: Python Project Scaffolding with Skill Activation

# Scaffold a production-ready FastAPI microservice
/python-development:python-scaffold fastapi-microservice

What you get (and why it matters):

This command doesn't just create main.py. It activates four specialized skills with progressive disclosure:

# Generated structure (simplified representation)
fastapi-microservice/
├── pyproject.toml              # Modern packaging, not requirements.txt
├── uv.lock                     # Reproducible dependency resolution
├── src/
│   ├── __init__.py
│   ├── main.py                 # Lifespan context manager, structured logging
│   ├── api/
│   │   ├── __init__.py
│   │   └── v1/
│   │       └── health.py       # Kubernetes-ready /health probe
│   ├── core/
│   │   ├── config.py           # Pydantic Settings with env validation
│   │   └── logging.py          # JSON structured logs for observability
│   └── models/
│       └── base.py             # SQLModel or SQLAlchemy base with async session
├── tests/
│   ├── conftest.py             # pytest-asyncio fixtures, test DB setup
│   └── test_health.py          # Async test patterns
└── Dockerfile                  # Multi-stage, non-root user, distroless final

Skills automatically available (load on demand):

• async-python-patterns — asyncio.gather vs. asyncio.create_task, cancellation handling
• python-testing-patterns — Fixture composition, pytest.mark.parametrize, httpx.AsyncClient for API testing
• uv-package-manager — uv add --dev, uv run pytest, lockfile semantics
• python-packaging — Entry points, optional dependencies, build backends

Example 4: Agent Teams Parallel Review

# Experimental: Parallel multi-agent review with specified focus areas
/team-review src/ --reviewers security,performance,architecture

Execution model:

This leverages Claude Code's experimental Agent Teams feature. Three agent instances spawn with isolated context windows:

Results merge into consolidated report with severity classification and fix suggestions.

Example 5: PluginEval Quality Certification

# Evaluate a custom skill before production deployment
uv run plugin-eval certify path/to/your/skill

The three-layer evaluation:

# Quick validation (static analysis only, instant feedback)
uv run plugin-eval score path/to/skill --depth quick

# Standard evaluation (static + LLM judge for semantic quality)
uv run plugin-eval score path/to/skill --depth standard

# Full certification (all layers + statistical confidence intervals + Elo ranking)
uv run plugin-eval certify path/to/skill

Quality dimensions scored:

Anti-patterns automatically flagged: OVER_CONSTRAINED, EMPTY_DESCRIPTION, MISSING_TRIGGER, BLOATED_SKILL, ORPHAN_REFERENCE, DEAD_CROSS_REF.

CI integration:

# Gate deployments on minimum quality threshold
uv run plugin-eval score path/to/skill --threshold 85 || exit 1

Advanced Usage & Best Practices

Model Cost Optimization Strategy

The inherit tier is your cost control lever. Start sessions strategically:

# Complex architecture work — pay for Opus
claude --model opus

# Routine development — Sonnet balances capability and cost
claude --model sonnet

# Documentation updates — Haiku handles this effortlessly
claude --model haiku

Pro tip: The orchestration pattern Opus (architecture) → Sonnet (development) → Haiku (deployment) optimizes both quality and spend.

Plugin Composition Patterns

Microservice Development Stack:

/plugin install python-development backend-development kubernetes-operations observability

Security-First Pipeline:

/plugin install security-scanning comprehensive-review block-no-verify protect-mcp

AI/ML Experimentation:

/plugin install llm-applications data-engineering ml-operations

Conductor for Project Management

The conductor plugin transforms Claude Code into a structured project management tool:

# Initialize project context, tech stack, style guides
/conductor:setup

# Create feature track with specification and phased plan
/conductor:new-track "Implement real-time notifications"

# Execute with TDD verification checkpoints
/conductor:implement

# Revert by logical unit if needed (not just git reset)
/conductor:revert --scope track

State persists across sessions. Resume weeks later with full context intact.

Skill Development Guidelines

Building custom skills? Follow the progressive disclosure architecture:

1. Metadata (skill-name.md header) — 50-100 tokens, always loaded
2. Instructions (main body) — 500-2000 tokens, loaded on activation trigger
3. Resources (separate files in resources/) — Examples, templates, loaded on explicit request

This keeps inactive skills invisible to token counting.

Comparison with Alternatives

The decisive advantage: wshobson/agents is the only ecosystem combining granular composability, deep specialization, quality certification, and cross-platform availability—while remaining fully open source.

FAQ: What Developers Actually Ask

Does this work with the latest Claude models?

Yes. Updated for Opus 4.7, Sonnet 4.6, and Haiku 4.5. The three-tier model strategy explicitly maps agents to optimal models for their complexity.

How much does this cost to run?

You control costs. Install only needed plugins (~1,000 tokens each). Use inherit tier to choose your model. Opus's 65% token reduction on complex tasks often offsets higher rates. Haiku handles simple ops at $1/$5 per million tokens.

Can I use this without Claude Code?

Partially. The Gemini CLI extension provides all 153 skills with on-demand discovery. Plugin-based orchestration (multi-agent workflows, Agent Teams) requires Claude Code's plugin architecture.

How do I create custom agents or skills?

Add .md files to plugins/your-plugin/agents/, commands/, or skills/ following the repository's naming conventions. Update .claude-plugin/marketplace.json. See Architecture Documentation for detailed guidelines.

What's the difference between agents and plugins?

Plugins are installable bundles. You run /plugin install javascript-typescript. Agents are the specialists inside. The javascript-typescript plugin contains javascript-pro and typescript-pro agents. You cannot install agents directly.

Is this production-ready or experimental?

Production-ready. The ecosystem includes quality certification (PluginEval), structured documentation, and active maintenance. Agent Teams and Conductor have experimental aspects clearly marked.

How does progressive disclosure actually save tokens?

Skills load in three tiers: metadata always (negligible), instructions when triggered (moderate), resources on explicit request (heavy). A dormant Python skill consumes ~20 tokens of metadata. A loaded skill might use 2,000. You only pay when you use it.

Conclusion: The Orchestration Layer You Didn't Know You Needed

wshobson/agents solves a problem most developers haven't named yet: AI tooling bloat is silently destroying productivity. Every irrelevant plugin loaded, every generic response generated, every context window wasted on capabilities you'll never use—that's engineering time and API budget evaporating.

This ecosystem's granular architecture, deep specialization, and intelligent orchestration represent a fundamental shift from "AI assistant" to "AI engineering team." The 185 agents aren't features on a slide. They're practitioners you can summon, combine, and dismiss—paying only for the expertise you invoke.

The PluginEval framework proves this isn't hype. Rigorous quality measurement, statistical confidence, and anti-pattern detection separate genuine capability from marketing fluff.

My assessment? If you're using Claude Code for serious development—especially multi-service systems, security-critical applications, or AI/ML pipelines—this is the most impactful plugin ecosystem available. The token efficiency alone justifies adoption. The orchestration capabilities transform what's possible.

Stop feeding the bloat. Start orchestrating intelligence.

👉 Explore wshobson/agents on GitHub — Star the repo, install your first plugin, and experience what 185 specialized agents can accomplish when they're not competing for your context window.

Have you tried multi-agent orchestration in your workflow? What's your biggest pain point with current AI coding tools? Drop your experience in the comments—let's discuss what actually moves the needle.