Skip to content
BSWEN
Blog

What is The Agency? A Collection of 144 Specialized AI Agents for Every Professional Role

Cowrie
Cowrie
Dev @ Bswen

I asked my AI coding assistant for help with a React performance issue. It gave me technically correct advice, but nothing about Core Web Vitals, accessibility compliance, or bundle size optimization. That’s when I realized: I didn’t need a generalist. I needed a frontend specialist.

That’s exactly what The Agency provides.

The Problem: Generalists Are Shallow

Generic AI assistants try to be everything to everyone. When you ask for help with frontend development, you get advice that’s technically correct but lacks depth:

generalist_vs_specialist.txt
Generalist AI response:
"Use React.memo to prevent re-renders. Here's how..."


Specialist AI response:
"For this React component, I recommend:
 1. React.memo with custom comparison for this specific use case
 2. Virtualization for lists > 100 items (react-window)
 3. Code-split with React.lazy for this route
 4. Consider accessibility: ARIA labels, focus management
 5. Bundle impact: ~2KB gzipped if you lazy-load
 Here's the implementation..."

The specialist knows performance, accessibility, and production realities simultaneously. The generalist gives you a single tool from a vast toolkit.

What is The Agency?

The Agency is an open-source collection of 144+ specialized AI agent personalities. Each agent has:

  • Deep domain specialization - Not just “a developer” but “a frontend developer who knows React/Vue/Angular, Core Web Vitals, and WCAG accessibility”
  • Personality-driven communication - Each agent has a distinct voice and approach
  • Concrete code examples - Production-ready code, not theoretical snippets
  • Measurable success metrics - Clear outputs and quality indicators

Born from a Reddit thread and months of iteration, The Agency is now a battle-tested resource for anyone using Claude Code, Cursor, Aider, or similar AI tools.

Agency Structure
┌─────────────────────────────────────────────────────────────────┐
│                      THE AGENCY (144+ Agents)                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Engineering (23)      Marketing (27)      Design (8)          │
│  ├── Frontend Dev      ├── SEO Specialist   ├── UX Designer    │
│  ├── Backend Dev       ├── Social Media     ├── UI Designer    │
│  ├── AI Engineer       ├── Content Writer   ├── Brand Designer │
│  ├── DevOps            ├── China Platforms  └── Visual Story   │
│  └── ...              └── ...                                  │
│                                                                 │
│  Sales (8)            Product (12)       Testing (15)          │
│  ├── Outbound         ├── PM             ├── QA Engineer       │
│  ├── Discovery        ├── Analyst        ├── Performance       │
│  └── Deal Strategy    └── Strategist     └── Security Test     │
│                                                                 │
│  Plus: Support, Spatial Computing, Game Dev, Academic          │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Why This Matters

I tried using generic prompts for months. Then I switched to specialized agents. The difference was immediate.

Speed: No Prompt Engineering Required

Before The Agency, I spent time crafting prompts:

old_workflow.txt
Me: "I need you to act like a senior frontend developer who
     specializes in React performance optimization and knows
     about accessibility and modern bundling strategies and..."


AI: "Sure, I can help with that..."


[15 minutes of back-and-forth to get the right context]

With The Agency:

new_workflow.txt
Me: [activates frontend-developer agent]
Me: "Optimize this component"


AI: [immediately delivers specialist-level output with all
     the context pre-loaded]

Quality: Proven Workflows, Not Random Output

Each agent includes:

  1. Workflow process - Step-by-step approach refined through iteration
  2. Code templates - Production-ready starting points
  3. Quality checks - Built-in verification steps

Here’s an example from the AI Engineer agent:

ai-engineer-workflow.txt
Workflow:
1. Understand requirements → User story format
2. Design approach → Model selection, data pipeline
3. Implement → Code with error handling
4. Validate → Metrics and tests
5. Deploy → MLOps considerations


Built-in checks:
- [ ] Model selection justified?
- [ ] Training/validation split documented?
- [ ] Bias and fairness considered?
- [ ] Monitoring in place?

Consistency: Same Agent = Same Approach

This matters for teams. When I use the “Code Reviewer” agent, I get consistent review criteria every time. My teammate uses the same agent, we get aligned feedback.

consistency-benefit.txt
Without specialized agents:
  Dev A review: "Looks good, just fix the naming"
  Dev B review: "You're missing error handling and tests"


With specialized agents:
  Agent X review: Same criteria, same thoroughness, every time

The Categories Explained

The Agency organizes agents into divisions. Here’s what each offers:

Engineering Division (23 Agents)

From frontend to backend, mobile to AI, DevOps to security:

engineering-agents.txt
Frontend Developer
- React/Vue/Angular expertise
- Core Web Vitals optimization
- WCAG accessibility compliance
- Bundle optimization


Backend Developer
- API design patterns
- Database optimization
- Microservices architecture
- Security best practices


AI Engineer
- ML model development
- MLOps pipelines
- Ethics and safety
- Production deployment

Marketing Division (27 Agents)

This includes platform-specific specialists:

marketing-agents.txt
Standard Platforms:
- SEO Specialist
- Content Writer
- Social Media Manager


China-Specific Platforms:
- WeChat Specialist (公众号运营)
- Douyin Specialist (抖音运营)
- Xiaohongshu Specialist (小红书运营)

Design Division (8 Agents)

Not just UI, but strategic design:

design-agents.txt
UX Designer → User research, journey maps, usability
UI Designer → Visual systems, components, accessibility
Brand Designer → Identity, voice, consistency
Visual Storyteller → Data visualization, presentations

How Agents Are Structured

Each agent follows a consistent structure:

agent-structure.yaml
---
name: Frontend Developer
description: Expert in modern frontend development
emoji: ":computer:"
vibe: Performance-obsessed, accessibility-champion
---


## Identity & Memory
Deep expertise in React ecosystem, performance optimization,
accessibility standards, and modern build tools.


## Core Mission
Deliver production-ready frontend code that is fast,
accessible, and maintainable.


## Critical Rules
1. Always consider Core Web Vitals
2. WCAG 2.1 AA minimum for accessibility
3. Bundle size matters - justify every dependency


## Technical Deliverables
[Production-ready code examples]


## Workflow Process
1. Understand requirements
2. Design component structure
3. Implement with optimization
4. Test and validate


## Success Metrics
- Lighthouse score > 90
- Accessibility score = 100
- Bundle size < target

This structure ensures every agent delivers consistent, high-quality output.

Real Examples: Before and After

Example 1: API Design

Generalist output:

generalist_api.py
@app.route('/users', methods=['GET'])
def get_users():
    users = User.query.all()
    return jsonify([u.to_dict() for u in users])

Backend Developer agent output:

specialist_api.py
@app.route('/users', methods=['GET'])
@rate_limit(limit=100, window=60)  # Rate limiting
@cache_response(ttl=300)           # Caching
def get_users():
    """
    Get users with pagination and filtering.


    Query params:
        - page: int (default: 1)
        - per_page: int (default: 20, max: 100)
        - status: str (optional filter)


    Returns:
        {
            "data": [...],
            "meta": {"total": 150, "page": 1, "per_page": 20}
        }
    """
    page = request.args.get('page', 1, type=int)
    per_page = min(request.args.get('per_page', 20, type=int), 100)
    status = request.args.get('status')


    query = User.query
    if status:
        query = query.filter_by(status=status)


    paginated = query.paginate(page=page, per_page=per_page)
    return jsonify({
        "data": [u.to_dict() for u in paginated.items],
        "meta": {
            "total": paginated.total,
            "page": page,
            "per_page": per_page
        }
    })

The specialist agent includes rate limiting, caching, pagination, and documentation automatically.

Example 2: Reddit Marketing

Generalist response:

generalist_marketing.txt
Post valuable content, engage with comments, and don't
be too promotional. Build trust with the community.

Reddit Community Builder agent:

specialist_marketing.txt
Reddit Strategy for r/programming:


1. Follow the 90/10 Rule
   - 90% genuine value, 10% self-promotion
   - Track your ratio in a spreadsheet


2. Authentic Engagement Checklist
   - [ ] Comment history shows genuine participation
   - [ ] Account age > 30 days before any promotion
   - [ ] Contribute to 5+ threads before posting your own


3. Post Types That Work (in order of success rate):
   - Detailed tutorials with code (47% success)
   - "I built X, here's what I learned" (38%)
   - AMA if you have credentials (31%)
   - Open source project releases (28%)
   - Blog post links (12% - highest rejection rate)


4. Title Formula:
   [Outcome] + [How] + [Specific Detail]
   Example: "Reduced API latency 80% by switching from REST to GraphQL"


5. Common Mistakes to Avoid:
   - Posting only to promotional subreddits
   - Ignoring negative comments
   - Using corporate language
   - Deleting posts that don't get upvotes

The specialist provides a complete playbook, not vague advice.

Getting Started

To use The Agency:

  1. Clone the repository: git clone https://github.com/coder/agency
  2. Choose an agent: Browse the divisions to find your specialist
  3. Copy to your tool: Each agent file is ready for Claude Code, Cursor, or Aider
  4. Activate and use: The agent loads with full context pre-configured
usage-example.txt
# In Claude Code
/agent frontend-developer


# Or copy the agent content to your CLAUDE.md
# The agent personality becomes your assistant's default behavior

The Community Aspect

The Agency is MIT licensed and PRs are welcome. This means:

  • Battle-tested patterns: Real-world usage refines the agents
  • Growing collection: New agents added regularly
  • Community fixes: Issues get addressed quickly

I’ve contributed fixes to agents I’ve used. The maintainers are responsive and the contribution guidelines are clear.

When to Use Specialized Agents

Use specialized agents when:

  • You need deep expertise in a specific domain
  • Consistency across sessions matters
  • You’re tired of prompt engineering
  • You want production-ready output immediately

Stick with generalist mode when:

  • You’re exploring and don’t know what you need yet
  • Your task spans multiple domains unpredictably
  • You want to maintain full control over the AI’s behavior

Summary

The Agency transforms generic AI assistants into specialized team members. Instead of crafting prompts to get the behavior you want, you activate a pre-built specialist who already knows the domain.

The key benefits:

  1. Speed - No prompt engineering, immediate specialist output
  2. Quality - Proven workflows, production-ready code
  3. Consistency - Same agent, same approach, every time
  4. Community - Open-source, battle-tested, constantly improving

Think of it as assembling your dream team, except they’re AI specialists who never sleep, never complain, and always deliver.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: