Agency Agents: A Complete AI Agency at Your Fingertips
In the rapidly evolving landscape of AI-assisted development, having the right agent for the right job can make the difference between a mediocre output and an exceptional deliverable. Agency Agents, an open-source project with over 75,000 stars on GitHub, represents a paradigm shift in how we approach AI agent orchestration. This comprehensive framework provides 147+ specialized AI agent personalities, each designed with unique expertise, workflows, and deliverable templates.
What is Agency Agents?
Agency Agents is a meticulously curated collection of specialized AI agent definitions that transform generic AI coding assistants into domain-specific experts. Unlike traditional prompt engineering approaches that require you to craft detailed instructions for each task, Agency Agents provides pre-built, battle-tested agent personalities that understand their role, follow established processes, and deliver consistent results.
The project addresses a fundamental challenge in AI-assisted development: context switching overhead. When you work with a generic AI assistant, you spend significant time explaining the context, requirements, and expected outputs. Agency Agents eliminates this friction by providing agents that already understand their domain, know the best practices, and have predefined workflows for common tasks.
Understanding the 12 Divisions
The organizational structure of Agency Agents mirrors a professional services agency, with 12 distinct divisions each specializing in a particular domain. This architecture ensures that every aspect of software development is covered by dedicated experts who understand the nuances and complexities of their respective fields.
Division Overview:
The divisions are organized to provide comprehensive coverage across the entire software development lifecycle. From initial planning and architecture through implementation, testing, deployment, and community engagement, each division contains multiple agents with specialized skills. This modular approach allows teams to scale their AI assistance precisely where needed without overwhelming a single agent with disparate responsibilities.
Engineering Division (30+ Agents): The largest division houses agents specializing in frontend development, backend systems, DevOps practices, and quality assurance. Frontend specialists include React experts, Vue.js architects, and CSS artisans who understand modern component architectures. Backend agents cover REST API design, GraphQL schema development, database optimization, and microservices patterns. DevOps agents bring expertise in CI/CD pipelines, container orchestration, and infrastructure as code. QA agents specialize in test strategy, automation frameworks, and quality metrics.
Creative Division (15+ Agents): Creative agents focus on user experience design, visual design, and content creation. UX researchers conduct user interviews and synthesize findings into actionable insights. Visual designers create style guides, icon systems, and responsive layouts. Content specialists handle technical documentation, marketing copy, and user-facing communications.
Strategy Division (12+ Agents): Strategic agents handle product management, business analysis, and project planning. Product managers define roadmaps, prioritize features, and coordinate stakeholder communication. Business analysts document requirements, model processes, and identify optimization opportunities. Project coordinators manage timelines, track dependencies, and facilitate team communication.
Data Division (18+ Agents): Data specialists cover analytics engineering, machine learning operations, and data visualization. Analytics engineers design data pipelines, build ETL processes, and ensure data quality. ML engineers develop model training pipelines, manage experiment tracking, and deploy inference systems. Visualization experts create dashboards, reports, and interactive data experiences.
Security Division (10+ Agents): Security agents specialize in vulnerability assessment, compliance, and secure development practices. Security auditors conduct code reviews, penetration tests, and risk assessments. Compliance specialists ensure adherence to regulatory requirements like GDPR, HIPAA, and SOC 2. Secure development advocates integrate security practices into the development workflow.
Infrastructure Division (14+ Agents): Infrastructure agents manage cloud resources, networking, and system administration. Cloud architects design scalable, cost-effective infrastructure solutions. Network engineers optimize connectivity, implement security groups, and manage DNS configurations. System administrators handle server configuration, monitoring, and incident response.
Mobile Division (8+ Agents): Mobile specialists cover iOS, Android, and cross-platform development. iOS developers bring expertise in Swift, UIKit, and App Store guidelines. Android specialists understand Kotlin, Jetpack Compose, and Play Store requirements. Cross-platform agents work with React Native, Flutter, and progressive web applications.
Growth Division (10+ Agents): Growth agents focus on marketing, SEO, and user acquisition. SEO specialists optimize content for search engines, conduct keyword research, and implement technical SEO improvements. Marketing automation agents design campaign workflows, manage email sequences, and track conversion funnels. Growth hackers identify viral opportunities and optimize onboarding flows.
Community Division (6+ Agents): Community agents manage social media presence, forum engagement, and developer relations. Social media coordinators schedule posts, respond to mentions, and track engagement metrics. Community managers moderate discussions, organize events, and foster member connections. Developer advocates create educational content and represent the project at conferences.
Documentation Division (8+ Agents): Documentation specialists create and maintain technical content. Technical writers produce API documentation, user guides, and knowledge base articles. Documentation architects design information architecture and establish style guidelines. Tutorial creators develop step-by-step learning materials for different skill levels.
Research Division (10+ Agents): Research agents explore emerging technologies, conduct competitive analysis, and synthesize industry trends. Technology scouts identify promising new tools and frameworks. Competitive analysts benchmark against alternatives and identify differentiation opportunities. Trend synthesizers create reports on industry directions and emerging practices.
Support Division (6+ Agents): Support agents handle user assistance, bug triage, and issue resolution. Support specialists respond to user questions and troubleshoot common problems. Bug triage agents categorize issues, identify root causes, and coordinate fixes. Onboarding specialists help new users get started with guides and personalized assistance.
Agent Design Philosophy
The brilliance of Agency Agents lies not just in its breadth but in its thoughtful design philosophy. Each agent is crafted with three core principles: personality-driven interaction, process-oriented workflows, and deliverable-focused outputs.
Personality-Driven Design:
Every agent has a distinct personality that shapes how it communicates and approaches problems. A senior architect agent speaks with authority and focuses on strategic decisions, while a junior developer agent asks clarifying questions and seeks guidance. This personality layer makes interactions more natural and helps set appropriate expectations for the type of assistance provided.
The personality is defined through carefully crafted prompts that establish the agent’s expertise level, communication style, and decision-making approach. For example, a security auditor agent might be configured to be conservative and thorough, flagging potential issues even when they seem unlikely. A creative designer agent might be more experimental, suggesting bold alternatives and encouraging exploration.
Process-Oriented Workflows:
Each agent follows established processes rather than ad-hoc problem solving. A code review agent doesn’t just read code randomly - it follows a systematic checklist covering security, performance, maintainability, and style. A deployment agent follows a release workflow including preparation, execution, verification, and rollback planning.
These processes are encoded in the agent definitions, ensuring consistency across interactions. When you engage a particular agent multiple times, you get consistent behavior following best practices rather than varying approaches based on how the question was phrased.
Deliverable-Focused Outputs:
Agents are designed to produce concrete, usable outputs rather than just advice or explanations. A requirements analyst agent produces a structured requirements document. A test engineer agent produces executable test cases. A documentation agent produces formatted, ready-to-publish content.
This deliverable focus means you can immediately use the agent’s output in your workflow. The agents understand the expected format, include necessary sections, and follow conventions that make their outputs directly actionable.
The NEXUS Workflow System
At the heart of Agency Agents lies the NEXUS workflow system - a seven-phase pipeline that ensures quality and consistency across all agent interactions. NEXUS stands for Navigate, Explore, Execute, Validate, Update, Sign-off, representing the key stages of professional work delivery.
Phase 1: Navigate (Planning and Strategy)
The Navigate phase establishes the foundation for successful work. Agents analyze the request, identify stakeholders, define success criteria, and create a detailed plan. This phase prevents scope creep and ensures alignment before significant effort is invested.
During navigation, agents ask clarifying questions, identify dependencies, and assess risks. They document assumptions and constraints, creating a shared understanding of the work ahead. The output is a comprehensive plan that guides subsequent phases.
Phase 2: Explore (Research and Discovery)
The Explore phase involves deep investigation into the problem space. Agents research existing solutions, analyze similar implementations, and gather necessary context. This phase ensures that work builds on established knowledge rather than reinventing approaches.
Exploration includes reviewing documentation, examining codebases, and consulting relevant resources. Agents document their findings, identify patterns, and synthesize insights that inform the execution phase.
Phase 3: Execute (Implementation and Creation)
The Execute phase is where the primary work happens. Agents create deliverables following the plans and insights from previous phases. They apply best practices, maintain consistency, and produce high-quality outputs.
Execution is iterative, with agents making decisions, handling edge cases, and adapting to discovered complexities. They maintain focus on the deliverable while remaining flexible to necessary adjustments.
Phase 4: Validate (Quality Assurance)
The Validate phase ensures deliverables meet quality standards. Agents review their work against requirements, test functionality, and verify completeness. This phase catches issues before delivery, reducing revision cycles.
Validation includes automated checks where applicable, peer review simulation, and stakeholder acceptance criteria verification. Agents document validation results and address any identified issues.
Phase 5: Update (Refinement and Iteration)
The Update phase incorporates feedback and refines deliverables. Agents address issues found during validation, improve based on stakeholder input, and polish the final output. This phase ensures the deliverable meets or exceeds expectations.
Updates are tracked and documented, maintaining a clear history of changes. Agents explain their refinements and ensure the final deliverable is production-ready.
Phase 6: Sign-off (Delivery and Documentation)
The Sign-off phase completes the workflow with formal delivery. Agents package deliverables, provide usage instructions, and document decisions made during the process. This phase ensures smooth handoff and future maintainability.
Sign-off includes creating or updating relevant documentation, archiving working materials, and providing clear next steps for stakeholders.
Phase 7: Quality Gates (Continuous Improvement)
Throughout all phases, quality gates ensure work meets standards. These checkpoints verify that prerequisites are met before proceeding, deliverables are complete before delivery, and lessons learned are captured for future improvement.
Quality gates are configurable, allowing teams to set appropriate rigor levels for different types of work. Critical projects might require extensive validation, while quick iterations might use streamlined gates.
Agent File Structure
Understanding the agent file structure helps you customize and extend Agency Agents for your specific needs. Each agent is defined in a YAML + Markdown format that combines structured metadata with detailed instructions.
Understanding Agent File Architecture
The agent file structure represents a thoughtful balance between machine-readable metadata and human-readable instructions. This dual-format approach enables both programmatic processing and easy manual editing, making the system accessible to developers and non-developers alike.
YAML Frontmatter:
The frontmatter section contains structured metadata that defines the agent’s identity and capabilities. This section uses standard YAML syntax and appears at the top of each agent file, enclosed in triple-dash delimiters.
---
agent_id: frontend-react-architect
name: React Architect
division: Engineering
specialization: Frontend Development
expertise_level: Senior
tools:
- claude-code
- cursor
- windsurf
- continue
- cline
- aider
- goose
- copilot
- codex
- roo
- amp
tags:
- react
- typescript
- component-architecture
- state-management
- testing
deliverables:
- component-libraries
- architecture-documents
- code-reviews
- migration-plans
processes:
- component-design
- state-architecture
- performance-optimization
- accessibility-compliance
---
The metadata fields serve specific purposes:
- agent_id: A unique identifier used for programmatic access and references
- name: A human-readable display name for UI and documentation purposes
- division: The organizational division this agent belongs to
- specialization: The specific area of focus within the division
- expertise_level: The seniority level (Junior, Mid, Senior, Principal)
- tools: A list of supported AI coding tools this agent works with
- tags: Keywords for search and categorization
- deliverables: Expected output types this agent produces
- processes: Standard workflows this agent follows
Markdown Body:
Following the frontmatter, the Markdown body contains detailed instructions for the agent. This section is written in natural language and provides the context, personality, and specific guidance that shapes the agent’s behavior.
# React Architect Agent
## Role and Personality
You are a senior React architect with 10+ years of experience building
large-scale applications. You approach problems with a focus on
long-term maintainability, performance, and developer experience.
Your communication style is direct but supportive. You explain the
reasoning behind architectural decisions and provide alternatives
when appropriate.
## Core Competencies
### Component Architecture
- Design reusable component APIs with clear prop interfaces
- Establish component composition patterns
- Define component boundaries and responsibilities
- Implement component testing strategies
### State Management
- Evaluate state management solutions for specific use cases
- Design state shapes that minimize updates
- Implement efficient selectors and derived state
- Handle asynchronous state with proper loading states
### Performance Optimization
- Identify and eliminate unnecessary re-renders
- Implement code splitting strategies
- Optimize bundle size through tree shaking
- Use React DevTools Profiler for analysis
## Workflow
When engaged for architecture work, follow this process:
1. **Discovery**: Understand the current state, constraints, and goals
2. **Analysis**: Identify patterns, anti-patterns, and improvement areas
3. **Proposal**: Present options with trade-offs clearly explained
4. **Implementation**: Guide the implementation with code examples
5. **Review**: Validate the implementation meets requirements
6. **Documentation**: Create architecture decision records
## Deliverable Templates
### Architecture Decision Record
```markdown
# ADR-001: [Decision Title]
## Status
[Proposed | Accepted | Deprecated]
## Context
[Describe the situation and problem]
## Decision
[Describe the chosen solution]
## Consequences
[Describe the results and trade-offs]
The body section allows for rich formatting including code blocks, headers, lists, and examples. This flexibility enables comprehensive agent definitions that cover all necessary aspects of the agent's behavior.
**File Organization:**
Agent files are organized in a directory structure that mirrors the division hierarchy:
agency-agents/ ├── engineering/ │ ├── frontend/ │ │ ├── react-architect.md │ │ ├── vue-specialist.md │ │ └── css-artisan.md │ ├── backend/ │ │ ├── api-designer.md │ │ ├── database-architect.md │ │ └── microservices-expert.md │ └── devops/ │ ├── ci-cd-pipeline.md │ ├── kubernetes-admin.md │ └── infrastructure-as-code.md ├── creative/ │ ├── ux-researcher.md │ └── visual-designer.md ├── strategy/ │ ├── product-manager.md │ └── business-analyst.md └── …
This organization makes it easy to find relevant agents and understand the overall structure. New agents can be added by creating files in the appropriate directory with the correct format.
## Multi-Tool Integration
One of Agency Agents' most powerful features is its support for 11 different AI coding tools. This tool-agnostic approach means you can use the same agent definitions across your preferred development environment.
### Supported AI Coding Tools
The multi-tool architecture demonstrates Agency Agents' commitment to flexibility and developer choice. Rather than locking users into a single ecosystem, the framework provides consistent agent experiences across the most popular AI coding assistants available today.
**Claude Code:**
Anthropic's Claude Code represents the gold standard for AI coding assistants, offering deep code understanding and sophisticated reasoning capabilities. Agency Agents leverages Claude's strengths for complex architectural decisions, detailed code reviews, and nuanced problem-solving. The agent definitions are optimized for Claude's context window and reasoning patterns.
**Cursor:**
Cursor has gained significant traction for its seamless IDE integration and real-time coding assistance. Agency Agents works with Cursor's inline suggestions and chat interface, providing specialized expertise directly in your editor. The framework adapts agent outputs to Cursor's preferred format for optimal integration.
**Windsurf:**
Windsurf brings AI assistance to the Codeium ecosystem, offering fast suggestions and intelligent completions. Agency Agents provides Windsurf-compatible agent definitions that enhance the tool's capabilities with domain-specific expertise. The integration supports both inline completions and chat-based interactions.
**Continue:**
Continue is an open-source AI code assistant that works across multiple IDEs. Agency Agents embraces Continue's extensibility, providing agent definitions that integrate smoothly with its configuration system. Users can easily add agency agents to their Continue setup through simple configuration changes.
**Cline:**
Cline offers a terminal-based AI assistant experience, perfect for developers who prefer command-line workflows. Agency Agents adapts to Cline's text-focused interface, providing clear, actionable guidance without relying on visual elements. The agent definitions work well with Cline's conversation-based interaction model.
**Aider:**
Aider specializes in pair programming with AI, focusing on collaborative code development. Agency Agents enhances Aider's capabilities with specialized agents that understand specific domains and workflows. The integration supports Aider's unique approach to iterative code refinement.
**Goose:**
Goose provides AI assistance with a focus on code generation and modification. Agency Agents works with Goose's generation capabilities, providing context and constraints that guide output quality. The framework helps Goose produce more targeted, domain-appropriate code.
**GitHub Copilot:**
Microsoft's GitHub Copilot is the most widely deployed AI coding assistant. Agency Agents provides Copilot-compatible prompts and context that enhance its suggestions with domain expertise. The integration works with both inline suggestions and Copilot Chat.
**Codex:**
OpenAI's Codex powers many AI coding tools and offers direct API access. Agency Agents provides structured prompts optimized for Codex's capabilities, enabling custom integrations and specialized workflows. The framework helps developers build Codex-powered tools with expert agent behaviors.
**Roo:**
Roo is an emerging AI coding assistant with unique capabilities for code understanding. Agency Agents supports Roo's approach to code analysis and generation, providing agent definitions that leverage its strengths. The integration enables specialized expertise within Roo's workflow.
**Amp:**
Amp offers AI assistance with a focus on code quality and refactoring. Agency Agents enhances Amp's capabilities with agents specialized in code improvement, technical debt reduction, and architecture evolution. The integration supports Amp's analysis-driven approach.
**Integration Architecture:**
The multi-tool support is achieved through a layered architecture:
1. **Core Agent Definitions**: The YAML + Markdown files that define agent behavior
2. **Tool Adapters**: Components that translate agent definitions to tool-specific formats
3. **Configuration Generators**: Scripts that create tool-specific configuration files
4. **Synchronization Layer**: Ensures consistency when agent definitions are updated
This architecture allows agent definitions to be maintained in a single canonical format while supporting multiple output formats. When a new tool emerges, only a new adapter needs to be created - the core definitions remain unchanged.
## Notable Agents
With 147+ agents available, it's worth highlighting some unique specialists that demonstrate the framework's depth:
**Frontend Wizards:**
The React Architect agent specializes in large-scale React application architecture. It understands component composition patterns, state management trade-offs, and performance optimization strategies. When engaged, it produces architecture decision records, component library designs, and migration plans.
The Vue Specialist brings expertise in Vue.js ecosystem including Vuex, Vue Router, and Composition API. It helps teams structure Vue applications, implement reactive patterns, and optimize bundle sizes.
The CSS Artisan focuses on styling architecture, implementing design systems, and creating responsive layouts. It understands modern CSS features, CSS-in-JS solutions, and accessibility requirements.
**Backend Masters:**
The API Designer agent creates RESTful and GraphQL API designs following best practices. It produces OpenAPI specifications, GraphQL schemas, and implementation guides that ensure consistent, maintainable APIs.
The Database Architect specializes in schema design, query optimization, and data modeling. It helps teams choose between SQL and NoSQL solutions, design efficient indexes, and plan for scale.
The Microservices Expert guides teams through distributed system design, service boundaries, and communication patterns. It understands the trade-offs between monoliths and microservices and helps teams make informed decisions.
**DevOps Champions:**
The CI/CD Pipeline architect designs automated build, test, and deployment workflows. It creates pipeline definitions for various platforms including GitHub Actions, GitLab CI, and Jenkins.
The Kubernetes Administrator manages container orchestration, including deployment configurations, service mesh setup, and cluster optimization. It produces manifests, Helm charts, and operational runbooks.
The Infrastructure as Code specialist works with Terraform, Pulumi, and CloudFormation to define cloud resources programmatically. It ensures infrastructure is version-controlled, reviewable, and reproducible.
**Reddit Community Ninjas:**
The Community Manager agent handles social media presence and community engagement. It schedules posts, responds to comments, and tracks engagement metrics across platforms.
The Content Creator specializes in producing engaging content for various platforms. It understands platform-specific best practices, audience expectations, and content optimization.
The Growth Hacker identifies viral opportunities and optimizes user acquisition funnels. It analyzes metrics, runs experiments, and implements strategies to grow user base and engagement.
## Getting Started
Installing and using Agency Agents is straightforward. Follow these steps to integrate specialized agents into your workflow:
**Step 1: Clone the Repository**
```bash
git clone https://github.com/msitarzewski/agency-agents.git
cd agency-agents
Step 2: Choose Your Tool
Select the AI coding tool you want to use with Agency Agents. The repository includes setup instructions for each supported tool.
Step 3: Configure Your Tool
For Claude Code, add agent definitions to your project’s .claude/agents directory:
cp -r agency-agents/engineering/frontend/* ~/.claude/agents/
For Cursor, add agent prompts to your .cursorrules file:
cat agency-agents/engineering/frontend/react-architect.md >> .cursorrules
For Continue, add agents to your config.json:
{
"agents": [
{
"name": "React Architect",
" "path": "./agency-agents/engineering/frontend/react-architect.md"
}
]
}
Step 4: Engage Agents
Start your AI coding tool and reference the agent in your prompts:
@react-architect Help me design a component library for a design system
The agent will respond with its specialized expertise, following its defined processes and producing appropriate deliverables.
Step 5: Customize for Your Needs
Modify agent definitions to match your team’s conventions and preferences:
---
agent_id: frontend-react-architect
name: React Architect
custom_instructions:
- Use TypeScript strict mode
- Follow our internal style guide
- Prefer functional components
- Use React Query for data fetching
---
Best Practices
To get the most from Agency Agents, follow these best practices:
Choose the Right Agent:
Select agents based on the task’s domain, not just the general area. For React performance optimization, use the React Architect rather than a general Frontend Developer. The specialized agent has deeper expertise and more relevant processes.
Provide Context:
While agents have domain expertise, they need context about your specific situation. Share relevant code, explain constraints, and describe goals. The more context you provide, the more targeted the agent’s assistance.
Follow the Process:
Agents define processes for a reason - they represent best practices refined through experience. Allow the agent to follow its workflow rather than jumping directly to solutions. The process ensures thoroughness and quality.
Iterate on Deliverables:
Agent outputs are starting points, not final products. Review deliverables, provide feedback, and iterate. The Update phase of NEXUS is designed for this refinement.
Contribute Improvements:
Agency Agents is open source. If you find improvements or create useful agent variations, contribute them back. The community benefits from shared expertise.
Conclusion
Agency Agents represents a significant advancement in AI-assisted development. By providing 147+ specialized agents across 12 divisions, it transforms generic AI assistants into domain-specific experts. The personality-driven design, process-oriented workflows, and deliverable-focused outputs ensure consistent, high-quality results.
The NEXUS workflow system provides a structured approach to work that mirrors professional practices. Quality gates ensure deliverables meet standards before delivery. The multi-tool support means you can use Agency Agents with your preferred AI coding assistant.
Whether you’re a solo developer looking for specialized expertise or a team seeking consistent practices, Agency Agents provides the framework to elevate your AI-assisted development. Clone the repository, choose your agents, and experience the difference that specialized expertise makes.
Related Posts
- AgentSkillOS: Skill Orchestration System
- MattPocock Skills: AI Agent Workflows
- DESIGN.md: AI-Powered Design Systems
