DEV Community

Cover image for What Is The Agency Agents?
Preecha
Preecha

Posted on

What Is The Agency Agents?

The Agency is an open-source collection of 147 specialized AI agents for Claude Code, Cursor, Aider, Windsurf, GitHub Copilot, and more. Each agent has a distinct personality, technical deliverables, and success metrics. This technical deep dive covers agent architecture, multi-tool integration, MCP memory, and the Bash scripts that power it all.

Try Apidog today

If you’re wiring these agents into real-world API workflows, an API platform can make the process more repeatable. Apidog lets you design, mock, test, and document the APIs your agents consume, then run those workflows from a shared workspace.

Instead of prompting an AI with “Act as a senior developer” and receiving generic advice, The Agency provides 147 specialists organized into 12 divisions.

Think of it as assembling a full-service agency—except the team members are AI agents with defined responsibilities, workflows, and delivery standards.

What Is The Agency?

Feature Details
Total agents 147 specialized agents across 12 divisions
Format Markdown files with YAML frontmatter: name, description, color, and emoji
Integration Claude Code, Cursor, Aider, Windsurf, GitHub Copilot, Gemini CLI, OpenCode, OpenClaw, Qwen Code
License MIT — free for personal and commercial use
Origin Started from a Reddit thread and is now community-maintained
Key innovation Personality-driven agents with deliverables and success metrics rather than generic prompts

Image

The basic workflow is simple:

Instead of:  "Act as a developer"
Use:         "Activate Frontend Developer mode"
Enter fullscreen mode Exit fullscreen mode

The Frontend Developer agent is scoped to technologies and practices such as React, Vue, Angular, Core Web Vitals, and accessibility compliance.

Repository Structure: 12 Divisions, 147 Agents

The Agency lives at github.com/msitarzewski/agency-agents. Its agents are organized into divisions that mirror a real agency structure:

agency-agents/
├── engineering/          # 20+ agents: Frontend, Backend, DevOps, AI, Mobile, Security
├── design/               # 8 agents: UI Designer, UX Researcher, Brand Guardian, Whimsy Injector
├── marketing/            # 20+ agents: Growth Hacker, SEO, TikTok, Reddit, LinkedIn
├── sales/                # 8 agents: Discovery Coach, Deal Strategist, Sales Engineer
├── product/              # 5 agents: Product Manager, Trend Researcher, Feedback Synthesizer
├── project-management/   # 6 agents: Studio Producer, Project Shepherd, Experiment Tracker
├── testing/              # 8 agents: Reality Checker, Evidence Collector, API Tester
├── support/              # 6 agents: Support Responder, Analytics Reporter, Legal Compliance
├── spatial-computing/    # 6 agents: XR Architect, visionOS Engineer, Metal Developer
├── specialized/          # 30+ agents: MCP Builder, Blockchain Auditor, Compliance Auditor
├── game-development/     # 20+ agents: Unity Architect, Unreal Systems, Godot Scripter, Roblox
└── academic/             # 5 agents: Anthropologist, Historian, Psychologist, Narratologist
Enter fullscreen mode Exit fullscreen mode

Each division contains agents with a specific area of expertise. The Engineering division includes Frontend Developers, Backend Architects, DevOps Automators, Security Engineers, and Embedded Firmware Engineers.

Agent Anatomy: Inside a 400-Line AI Specialist

Every agent follows a similar structure. The Backend Architect agent illustrates the main components.

1. Frontmatter 

---
name: Backend Architect
description: Senior backend architect specializing in scalable system design, database architecture, API development, and cloud infrastructure
color: blue
emoji: 🏗️
vibe: Designs the systems that hold everything up — databases, APIs, cloud, scale.
---
Enter fullscreen mode Exit fullscreen mode

The metadata supports agent discovery in tools such as Cursor and Claude Code:

  • name identifies the agent.
  • description explains its scope.
  • color and emoji provide visual context.
  • vibe summarizes its working style.

2. Identity and Memory 

## 🧠 Your Identity & Memory

- **Role**: System architecture and server-side development specialist
- **Personality**: Strategic, security-focused, scalability-minded, reliability-obsessed
- **Memory**: You remember successful architecture patterns, performance optimizations, and security frameworks
- **Experience**: You've seen systems succeed through proper architecture and fail through technical shortcuts
Enter fullscreen mode Exit fullscreen mode

This section gives the model a consistent perspective and defines the agent’s expertise boundaries.

3. Core Mission 

## 🎯 Your Core Mission

### Data/Schema Engineering Excellence

- Define and maintain data schemas and index specifications
- Design efficient data structures for large-scale datasets (100k+ entities)
- Implement ETL pipelines for data transformation and unification
- Create high-performance persistence layers with sub-20ms query times
Enter fullscreen mode Exit fullscreen mode

The mission is expressed as concrete work rather than a broad instruction. Targets such as 100k+ entities and sub-20ms query times make the expected outcome more specific.

4. Critical Rules 

## 🚨 Critical Rules You Must Follow

### Security-First Architecture

- Implement defense in depth strategies across all system layers
- Use the principle of least privilege for all services and database access
- Encrypt data at rest and in transit using current security standards
Enter fullscreen mode Exit fullscreen mode

Rules define constraints that should take priority over general behavior.

5. Technical Deliverables

Deliverables distinguish these agents from one-off prompts. For example, the Backend Architect can produce runnable database and API code:

-- E-commerce database schema design
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    deleted_at TIMESTAMP WITH TIME ZONE NULL
);

CREATE INDEX idx_users_email
    ON users(email)
    WHERE deleted_at IS NULL;

CREATE INDEX idx_users_created_at
    ON users(created_at);
Enter fullscreen mode Exit fullscreen mode 
// Express.js API with security middleware
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100,
  message: 'Too many requests from this IP, please try again later.',
});
Enter fullscreen mode Exit fullscreen mode

6. Success Metrics 

## 🎯 Your Success Metrics

You're successful when:

- API response times stay under 200ms at the 95th percentile
- System uptime exceeds 99.9% availability
- Database queries perform under 100ms on average
- Security audits find zero critical vulnerabilities
Enter fullscreen mode Exit fullscreen mode

These metrics turn the agent’s instructions into engineering accountability. They give you criteria to validate instead of relying on subjective approval.

Multi-Tool Integration: One Agent, 10+ IDEs

The Agency supports more than 10 AI coding tools. The integration layer converts the common Markdown agent format into the format expected by each tool.

Supported Tools

Tool Format Install location
Claude Code .md ~/.claude/agents/
GitHub Copilot .md ~/.github/agents/
Cursor .mdc .cursor/rules/
Aider CONVENTIONS.md Project root
Windsurf .windsurfrules Project root
Antigravity SKILL.md ~/.gemini/antigravity/skills/
Gemini CLI Extension ~/.gemini/extensions/
OpenCode .md .opencode/agents/
OpenClaw SOUL.md + AGENTS.md ~/.openclaw/
Qwen Code .md ~/.qwen/agents/

The Conversion Script

The scripts/convert.sh Bash script handles format translation.

#!/usr/bin/env bash
# convert.sh — Convert agency agent .md files into tool-specific formats

set -euo pipefail

AGENT_DIRS=(
  academic design engineering game-development marketing paid-media
  sales product project-management testing support spatial-computing specialized
)

# Extract frontmatter fields
get_field() {
  local field="$1" file="$2"

  awk -v f="$field" '
    /^---$/ { fm++; next }
    fm == 1 && $0 ~ "^" f ": " {
      sub("^" f ": ", "")
      print
      exit
    }
  ' "$file"
}

# Strip frontmatter and return the body
get_body() {
  awk '
    BEGIN { fm = 0 }
    /^---$/ { fm++; next }
    fm >= 2 { print }
  ' "$1"
}
Enter fullscreen mode Exit fullscreen mode

For Cursor, the script converts an agent Markdown file into an .mdc rule:

convert_cursor() {
  local agent_file="$1"
  local slug
  slug=$(to_kebab "$(get_field 'name' "$agent_file")")

  local output_file="$OUT_DIR/cursor/.cursor/rules/agency-${slug}.mdc"

  cat > "$output_file" <<EOF
---
description: Agency agent: $(get_field 'description' "$agent_file")
---
$(get_body "$agent_file")
EOF
}
Enter fullscreen mode Exit fullscreen mode

For Aider and Windsurf, multiple agents are compiled into a single file:

convert_aider() {
  local output="$OUT_DIR/aider/CONVENTIONS.md"

  echo "# Agency Agents for Aider" > "$output"
  echo "" >> "$output"

  for dir in "${AGENT_DIRS[@]}"; do
    for file in "$REPO_ROOT/$dir"/*.md; do
      echo "---" >> "$output"
      cat "$file" >> "$output"
    done
  done
}
Enter fullscreen mode Exit fullscreen mode

Installing the Converted Agents

After conversion, install.sh copies the generated files to each tool’s expected directory.

#!/usr/bin/env bash
# install.sh — Install The Agency agents into local agentic tools

install_claude_code() {
  local src="$REPO_ROOT"
  local dest="$HOME/.claude/agents"

  mkdir -p "$dest"
  cp -r "$src"/{engineering,design,marketing,sales,specialized}/*.md "$dest/"

  ok "Claude Code: $(find "$dest" -name '*.md' | wc -l) agents installed"
}

install_cursor() {
  local src="$OUT_DIR/cursor/.cursor/rules"
  local dest="./.cursor/rules"

  mkdir -p "$dest"
  cp "$src"/*.mdc "$dest/"

  ok "Cursor: $(find "$dest" -name '*.mdc' | wc -l) rules installed"
}
Enter fullscreen mode Exit fullscreen mode

The installer can also detect available tools and let you select which integrations to install:

+------------------------------------------------+
  |   The Agency — Tool Installer                  |
  +------------------------------------------------+

  System scan: [*] = detected on this machine

  [x]  1)  [*]  Claude Code     (claude.ai/code)
  [x]  2)  [*]  Copilot         (~/.github + ~/.copilot)
  [x]  3)  [*]  Antigravity     (~/.gemini/antigravity)
  [ ]  4)  [ ]  Gemini CLI      (gemini extension)
  [x]  7)  [*]  Cursor          (.cursor/rules)

  [1-10] toggle   [a] all   [n] none   [d] detected
  [Enter] install   [q] quit
Enter fullscreen mode Exit fullscreen mode

To install in parallel:

./scripts/install.sh --parallel --jobs 8
Enter fullscreen mode Exit fullscreen mode

MCP Memory: Persistent Context Across Sessions

Most AI agents start each session without the context of previous work. The MCP Memory integration provides a way to store and retrieve decisions, deliverables, and handoff notes.

What Is MCP?

MCP, or Model Context Protocol, allows AI agents to access external tools and persistent storage.

The Agency uses MCP to support:

  • Cross-session memory
  • Agent handoffs
  • Rollback to known-good states when QA fails

The Memory Pattern

Add a memory section to an agent when it needs to maintain project context:

## Memory Integration

When you start a session:

- Recall relevant context from previous sessions using your role and project as search terms
- Review memories tagged with your agent name

When you make key decisions or complete deliverables:

- Remember the decision with descriptive tags such as agent name, project, and topic
- Include enough context for a future session to understand what was done and why

When handing off to another agent:

- Remember your deliverables tagged for the receiving agent
- Include what you completed, what is pending, and what the next agent needs to know
Enter fullscreen mode Exit fullscreen mode

MCP Tools

Tool Purpose
remember Store decisions, deliverables, and context with tags
recall Search memories by keyword, tag, or semantic similarity
rollback Restore a previous state when something fails
search Find specific memories across sessions and agents

Any MCP server that exposes compatible tools can support this pattern.

Example: Memory-Powered Workflow

Without MCP memory:

User: "Build the API"
Agent: [Builds API, session ends]

[Next session]
User: "Continue from yesterday"
Agent: "I don't have context from previous sessions. Can you paste what we did?"
Enter fullscreen mode Exit fullscreen mode

With MCP memory:

User: "Build the API"
Agent: [Builds the API and remembers:
"Backend Architect - E-commerce API - Users table, JWT auth, rate limiting"]

[Next session]
User: "Continue from yesterday"
Agent: [Recalls:
"Yesterday I designed the users table with UUID primary keys,
implemented JWT authentication with bcrypt hashing, and added
rate limiting at 100 requests per 15 minutes.
Next step: Order Service schema."]
Enter fullscreen mode Exit fullscreen mode

See integrations/mcp-memory/backend-architect-with-memory.md for a complete example.

Three Standout Agents

1. Reality Checker

The Reality Checker belongs to the Testing division. Its default stance is “NEEDS WORK” until the implementation is supported by evidence.

Its process starts with commands that verify what was actually built:

# Verify what was actually built
ls -la resources/views/ || ls -la *.html

# Cross-check claimed features
grep -r "luxury\|premium\|glass\|morphism" . \
  --include="*.html" \
  --include="*.css" \
  || echo "NO PREMIUM FEATURES FOUND"

# Capture screenshots with Playwright
./qa-playwright-capture.sh \
  http://localhost:8000 \
  public/qa-screenshots
Enter fullscreen mode Exit fullscreen mode

It then:

  1. Reviews QA findings from headless Chrome testing.
  2. Cross-checks automated screenshots with the QA assessment.
  3. Confirms or challenges the assessment with additional evidence.
  4. Reviews responsive screenshots for desktop, tablet, and mobile.
  5. Checks interaction flows such as navigation and form sequences.
  6. Reviews performance data, load times, errors, and metrics.

The goal is to require visual and runtime proof instead of approving an implementation because it “looks great.”

2. Whimsy Injector

The Whimsy Injector belongs to the Design division. It adds personality without sacrificing usability.

For example, it can define a button interaction with a hover transition and animated highlight:

/* Delightful button interactions */
.btn-whimsy {
  position: relative;
  overflow: hidden;
  transition: all 0.3s cubic-bezier(0.23, 1, 0.32, 1);
}

.btn-whimsy::before {
  content: '';
  position: absolute;
  top: 0;
  left: -100%;
  width: 100%;
  height: 100%;
  background: linear-gradient(
    90deg,
    transparent,
    rgba(255, 255, 255, 0.2),
    transparent
  );
  transition: left 0.5s;
}

.btn-whimsy:hover {
  transform: translateY(-2px) scale(1.02);
  box-shadow: 0 8px 25px rgba(0, 0, 0, 0.15);
}
Enter fullscreen mode Exit fullscreen mode

It can also define an achievement system:

class WhimsyAchievements {
  unlock(achievementId) {
    const achievement = this.achievements[achievementId];

    this.showCelebration(achievement);
    this.saveProgress(achievementId);
  }

  showCelebration(achievement) {
    const celebration = document.createElement('div');

    celebration.className =
      `achievement-celebration ${achievement.celebration}`;

    celebration.innerHTML = `
      <div class="achievement-card">
        <div class="achievement-icon">${achievement.icon}</div>
        <h3>${achievement.title}</h3>
        <p>${achievement.description}</p>
      </div>
    `;

    document.body.appendChild(celebration);

    setTimeout(() => celebration.remove(), 3000);
  }
}
Enter fullscreen mode Exit fullscreen mode

The agent also includes functional microcopy examples:

## Error Messages

**404 Page**: "Oops! This page went on vacation without telling us."

**Form Validation**: "Your email looks a bit shy – mind adding the @ symbol?"

**Network Error**: "Seems like the internet hiccupped. Give it another try?"
Enter fullscreen mode Exit fullscreen mode

The design principle is that playful elements should serve a functional or emotional purpose.

3. MCP Builder

The MCP Builder belongs to the Specialized division. It creates custom tools that extend an agent’s capabilities.

Here is a TypeScript MCP server skeleton:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "my-server",
  version: "1.0.0",
});

server.tool(
  "search_items",
  {
    query: z.string(),
    limit: z.number().optional(),
  },
  async ({ query, limit = 10 }) => {
    const results = await searchDatabase(query, limit);

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(results, null, 2),
        },
      ],
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);
Enter fullscreen mode Exit fullscreen mode

The agent emphasizes four implementation rules:

  • Use descriptive names such as search_users instead of query1.
  • Validate parameters with Zod.
  • Provide defaults for optional parameters.
  • Return structured output and fail gracefully instead of crashing the server.

Community and Translations

The Agency started from a Reddit thread and has grown into a community-maintained project with:

  • 147 agents across 12 divisions
  • More than 10,000 lines of personality, process, and code examples
  • Community translations, including Simplified Chinese forks
  • More than 10 integrations maintained through conversion scripts

Notable forks include:

  • agency-agents-zh by @jnMetaCode: 100 translated agents and 9 China-market originals
  • agent-teams by @dsclca12: An independent translation with Bilibili, WeChat, and Xiaohongshu localization

Installation: Quick Start

Option 1: Install for Claude Code

Copy the agents into your Claude Code directory:

cp -r agency-agents/* ~/.claude/agents/
Enter fullscreen mode Exit fullscreen mode

Then activate an agent in a session:

Hey Claude, activate Frontend Developer mode and help me build a React component.
Enter fullscreen mode Exit fullscreen mode

Option 2: Install for Multiple Tools

Generate the integration files:

./scripts/convert.sh
Enter fullscreen mode Exit fullscreen mode

Run the interactive installer:

./scripts/install.sh
Enter fullscreen mode Exit fullscreen mode

Or install for a specific tool:

./scripts/install.sh --tool cursor
./scripts/install.sh --tool aider
Enter fullscreen mode Exit fullscreen mode

Option 3: Use the Agents as References

Browse the agents at github.com/msitarzewski/agency-agents and adapt the ones you need.

Each file contains some combination of:

  • Identity and working style
  • Core mission
  • Critical rules
  • Workflows
  • Technical deliverables
  • Code examples
  • Success metrics

What Makes This Different?

The Agency vs. Generic AI Prompts

Generic prompts The Agency
“Act as a developer” “Activate Frontend Developer mode”
Vague and one-size-fits-all Specialized for a specific domain
No deliverable structure Complete code examples and workflows
No success metrics Measurable outcomes

The Agency vs. Prompt Libraries

Prompt libraries The Agency
One-off prompt collections Comprehensive agent systems
Static text Personality, workflows, and memory
No integration layer More than 10 tool integrations

The Agency vs. AI Tools

AI tools The Agency
Black box and difficult to customize Transparent, forkable, and adaptable
Vendor lock-in MIT-licensed and community-maintained
Single model Works with any LLM through MCP

Technical Takeaways

  • Specialization beats generalization: 147 focused specialists provide more targeted behavior than one “do everything” prompt.
  • Structure drives output: Frontmatter, identity, mission, rules, deliverables, and metrics provide a repeatable agent format.
  • Integration matters: Bash scripts convert the agents into more than 10 tool-specific formats.
  • Memory enables continuity: MCP addresses the problem of losing project context between sessions.
  • Community scales the system: A Reddit thread evolved into 147 agents, translations, and multi-tool support.

Next Steps

To try The Agency:

  1. Browse the full agent roster.
  2. Install it for Claude Code, Cursor, Aider, or another supported tool.
  3. Activate a specialist by name: 
   Use the Reality Checker to verify this is production-ready.
Enter fullscreen mode Exit fullscreen mode
  1. Contribute new agents, improve existing ones, or share success stories.

If you’re building AI agents yourself, use The Agency’s structure as a reference:

  • Add frontmatter for discovery.
  • Define the agent’s identity and persona.
  • Scope its mission.
  • Set non-negotiable rules.
  • Specify technical deliverables.
  • Define measurable success metrics.
  • Add MCP memory when the workflow spans multiple sessions or agents.

The Agency demonstrates that specialization is useful for AI systems too. Instead of asking one model to handle every task, you can assemble a team of specialists with clearly defined responsibilities.

Top comments (0)