agency-agents: Build Your AI Expert Team

The Lone-Wolf Problem

Here is a situation most developers have encountered. You open Claude Code and ask it to build a landing page. The code it produces is competent. The HTML is semantic, the CSS is reasonable, the logic works. But it does not feel like a frontend specialist wrote it. There is no obsession with animation timing, no opinion on spacing rhythm, no instinct for accessibility edge cases. It feels like a generalist did a decent job.

Now imagine asking the same agent to write a Terraform pipeline. Again, competent. But it does not think like a DevOps engineer who has been burned by state file conflicts at 2 AM. It does not reflexively add rollback strategies or check for drift detection.

The pattern is obvious once you see it. A single AI agent, no matter how capable, defaults to generalist behavior. It knows a little about everything and a lot about nothing in particular. This is fine for quick prototyping. It is not fine when you need production-grade work from someone who lives and breathes a specific domain.

This is the problem that agency-agents sets out to solve. Instead of one generalist agent, you get an agency of 130+ specialists, each with a distinct personality, defined processes, and concrete deliverables. Think of it like hiring a digital agency where every team member has a decade of domain experience, never takes a vacation, and costs nothing.

As of March 2026, the project has 9,600 GitHub stars and gained over 7,000 of them in a single week.

What Is in the Box

The agency-agents repository is a collection of Markdown files. Each file defines a specialist agent persona. When you load one of these files into your AI coding assistant, the assistant stops behaving like a generalist and starts behaving like that specific expert.

The collection spans 16 divisions and 130+ agents. Here is the roster.

Engineering (21 agents) covers the full spectrum: Frontend Developer, Backend Architect, Mobile App Builder, AI/ML Engineer, DevOps Automator, Security Engineer, Database Optimizer, Software Architect, Embedded Firmware Engineer, Smart Contract Developer, and more. The Senior Developer agent, for example, specializes in premium web experiences with Laravel, Livewire, Three.js, and advanced CSS. It has hard rules about maintaining 60fps animations and sub-1.5-second load times.

Design (8 agents) includes UI Designer, UX Researcher, Brand Guardian, Accessibility Auditor, and a Whimsy Injector whose job is to add delightful micro-interactions.

Marketing (28 agents) is the largest division. Platform-specific specialists cover Twitter, TikTok, Instagram, Reddit, Xiaohongshu, and Bilibili. There are also region-specific operators for China e-commerce and livestream commerce.

Testing (8 agents) brings Evidence Collectors, Performance Benchmarkers, Accessibility Auditors, and API Testers. Each one follows systematic validation processes rather than ad-hoc checking.

Paid Media (7 agents) has PPC Strategists, Search Analysts, Creative Strategists, and Measurement Specialists focused on advertising ROI.

Sales (8 agents) includes Discovery Coaches, Deal Strategists, Proposal Specialists, and Sales Engineers who emphasize consultative selling.

Product (5 agents) provides Product Managers, Trend Researchers, Feedback Synthesizers, and a Behavioral Nudge Engineer.

Project Management (6 agents) covers Producers, Project Shepherds, Operations Managers, and Experiment Trackers.

Support (6 agents) handles customer-facing work: Support Responders, Analytics Reporters, Finance Trackers, and Compliance Checkers.

Spatial Computing (6 agents) focuses on XR architecture, Vision Pro development, and spatial interaction design.

Game Development (20+ agents) is split between cross-engine designers and engine-specific specialists for Unity, Unreal, Godot, Roblox, and Blender.

Academic (5 agents) brings unconventional expertise: Anthropologists, Geographers, Historians, Narratologists, and Psychologists for world-building and narrative validation.

Specialized (20+ agents) includes multi-agent orchestrators, blockchain auditors, compliance specialists, and recruitment consultants.

The remaining divisions cover Strategy, Integrations, and emerging specialties like AI data remediation and agentic identity systems.

How Each Agent Is Structured

Every agent in the repository follows a consistent format. This is not an accident. Consistency is what makes the system composable. Here is the anatomy.

Identity and Personality. Each agent has a defined role, a tech stack focus, personality traits, and a core philosophy. The Senior Developer agent, for instance, describes itself as "creative, detail-oriented, performance-focused, innovation-driven" with the philosophy that "every pixel should feel intentional and refined." This is not flavor text. The personality shapes how the agent communicates, what it prioritizes, and what it refuses to compromise on.

Mission. A clear statement of what the agent exists to do. The Frontend Developer's mission is different from the Security Engineer's mission, even when they work on the same codebase. The mission constrains the agent's scope and prevents drift.

Processes and Workflows. Step-by-step sequences the agent follows. The Senior Developer uses a three-phase approach: Analysis (parse requirements, identify enhancement opportunities), Execution (build using style guides and advanced patterns), and Assurance (test interactivity, responsiveness, animation smoothness). Every agent has its own process tailored to its domain.

Deliverables. Concrete outputs, not vague advice. The agent produces completed code with enhancement documentation, clean performant files, and functioning interactive elements. This is the part that distinguishes agency-agents from a pile of system prompts. Each agent knows what "done" looks like.

Success Metrics. Quantifiable standards. The Senior Developer measures itself against sub-1.5-second load times, 60fps animation fluidity, perfect responsive implementation, and WCAG 2.1 AA compliance. When you can measure an agent's output against its own declared metrics, you can evaluate whether the persona is actually improving the work.

Critical Rules. Hard constraints specific to the domain. The Senior Developer mandates light/dark/system theme toggles on all sites and requires referencing official component documentation for current APIs.

Communication Style. Each agent documents its technical choices in a specific way. The Senior Developer references exact patterns ("glass morphism," "Three.js particle system") and notes performance optimizations. A Backend Architect communicates differently, focusing on data flow, scaling bottlenecks, and API contract stability.

Learning Architecture. Agents remember successful patterns, optimization techniques, and what distinguishes excellent work from merely adequate work in their domain.

This structure means every agent is self-documenting. You can read the Markdown file and know exactly what the agent will do, how it will do it, and how to evaluate the result.

Installation: One Script, Many Tools

Getting started is straightforward. The repository includes scripts that handle conversion and installation across multiple platforms.

For Claude Code, the simplest path is copying agent files directly to your agents directory:

# Clone the repository
git clone https://github.com/msitarzewski/agency-agents.git

# Copy agents to Claude Code
cp -r agency-agents/* ~/.claude/agents/

For multi-tool setups, the automated scripts handle conversion:

# Generate tool-specific files from the markdown agents
./scripts/convert.sh

# Interactive installer — walks you through platform selection
./scripts/install.sh

# Target a specific tool directly
./scripts/install.sh --tool cursor
./scripts/install.sh --tool aider

The conversion script transforms Markdown agent definitions into the format each tool expects. Cursor gets .mdc rule files. Aider gets a compiled CONVENTIONS.md. Windsurf gets .windsurfrules. The source Markdown stays canonical. The scripts also support a --parallel flag for faster processing and non-interactive modes for CI/CD pipelines.

Supported platforms as of March 2026:

• Claude Code — Native Markdown agents, no conversion needed
• GitHub Copilot — Native Markdown support
• Cursor — Converted to .mdc rule files
• Aider — Compiled into CONVENTIONS.md
• Windsurf — Compiled into .windsurfrules
• Gemini CLI / Antigravity — Skill-based installation
• OpenCode, OpenClaw, Qwen Code — Specialized formats

Cross-Agent Compatibility

This is where agency-agents reflects a broader trend in the agent skills ecosystem. The agents are plain text. Markdown in, behavior out. Any tool that can read structured text can consume these agents.

The practical consequence: your team does not need to standardize on a single AI coding tool. One developer uses Claude Code, another prefers Cursor, a third likes Aider. All three can load the same Frontend Developer agent and get the same specialized behavior. The personality, the processes, the success metrics, all of it transfers.

This is the same portability principle that makes SKILL.md files work across agents. Knowledge encoded once, applied everywhere. Agency-agents takes this principle and applies it to role specialization rather than process enforcement.

The compatibility is not theoretical. The repository's install script explicitly targets seven different tools. Community contributors have added format adapters for newer platforms as they emerge. The conversion layer means agent definitions stay tool-agnostic while deployment is tool-specific.

How to Customize and Extend

Agency-agents is designed for forking. The consistent structure makes it straightforward to modify existing agents or create entirely new ones.

Adjusting an existing agent: Open the Markdown file, change what needs changing. If your team uses Vue instead of React, modify the Frontend Developer's tech stack. If your security requirements are stricter than WCAG 2.1 AA, tighten the Success Metrics. The format is self-evident.

Creating a new agent: Follow the established structure. Define the identity, write the mission, document the processes, specify deliverables, set metrics, list rules. The repository's existing agents serve as templates. A good starting point: pick the existing agent closest to your desired role, duplicate it, and adapt.

Team-specific configurations: Some teams create a division directory for their organization, containing agents customized to internal conventions. Your company's "Platform Engineer" agent knows about your specific Kubernetes cluster layout, your CI/CD pipeline, your observability stack. This is tribal knowledge encoded as a portable agent persona.

Contributing back: The repository is MIT-licensed and actively welcomes pull requests. The community has contributed agents for specialties the original creator did not anticipate, including academic researchers, game developers, and region-specific marketing specialists.

Real-World Usage Patterns

The README documents several multi-agent workflows that show how specialists compose into teams.

Startup MVP Assembly combines Frontend Developer + Backend Architect + Growth Hacker + Rapid Prototyper + Reality Checker. The Reality Checker is particularly interesting. Its job is to push back on scope creep and ensure the MVP stays minimal.

Enterprise Feature Development pairs Project Manager + Senior Developer + UI Designer + Experiment Tracker + Evidence Collector + Reality Checker. The Experiment Tracker ensures features are built with measurement from the start, not bolted on afterward.

Multi-Agent Orchestration is the advanced pattern. The Nexus Spatial Discovery example demonstrates 8 agents working simultaneously: one designs the API, another handles security review, a third optimizes database queries, a fourth manages UX research. The orchestrator agent coordinates handoffs between specialists.

These patterns work best when you can run multiple agent sessions in parallel. If you are managing several specialist agents on different tasks simultaneously, having separate terminal workspaces for each agent keeps the work streams clean and observable.

Agency-Agents vs. Superpowers: Different Tools, Same Ecosystem

If you have read about Superpowers, you might wonder how it relates to agency-agents. The distinction is clean.

Superpowers is methodology. It enforces how your agent works: TDD, structured planning, systematic debugging, subagent coordination. It is about process discipline. Superpowers does not care whether your agent is a frontend specialist or a backend architect. It cares that the agent writes tests first, asks questions before coding, and diagnoses root causes before applying fixes.

Agency-agents is role specialization. It defines who your agent is: a Security Engineer with specific threat models, a UX Researcher with particular interview techniques, a DevOps Automator with opinions about infrastructure-as-code. It is about domain expertise and personality.

These two approaches are complementary, not competitive. You can load a Superpowers TDD skill and an agency-agents Senior Developer persona into the same session. The agent then has both the discipline (write tests first, plan before coding) and the expertise (knows Three.js patterns, cares about 60fps, insists on accessibility). Methodology plus specialization is stronger than either alone.

Think of it like a hospital. Superpowers is the operating procedure manual that every doctor follows: wash hands, verify patient identity, document everything. Agency-agents is the specialist directory: cardiologist, neurologist, orthopedic surgeon. You want both. A surgeon who skips hand-washing is dangerous. A generalist who follows procedure but has no surgical training is useless.

Getting Started in 5 Minutes

1. Clone the repository:

   git clone https://github.com/msitarzewski/agency-agents.git
   

2. Browse the divisions. Open the repo and scan the directory structure. Each folder is a division, each file is an agent. Read two or three agent definitions to understand the format.

3. Pick your first specialist. Choose the agent closest to your current task. Building a React component? Load the Frontend Developer. Setting up CI/CD? Load the DevOps Automator.

4. Install for your tool:

   ./scripts/install.sh --tool claude-code
   

5. Start a task and observe the difference. Ask the specialist agent to do something in its domain. Notice how the responses change: more opinionated, more specific, with domain terminology and concrete success criteria instead of generic advice.

The repository is MIT-licensed, actively maintained, and growing fast. From zero to 9,600 stars with 7,000 gained in a single week suggests the project is hitting a nerve. Developers want their AI agents to be experts, not generalists. Agency-agents makes that possible with nothing more than well-structured Markdown files.

If you have been looking for a way to make your AI coding assistant feel less like a chatbot and more like a team of colleagues who actually know their craft, this is the most practical starting point available today.