For the last few years, the dominant mental model for working with AI has been simple: one assistant, one conversation, one set of capabilities stretched across every task you throw at it. Ask it to write code, then ask it to write marketing copy, then ask it to review a contract — same model, same context, same generic competence across wildly different domains.
Agency Agents, an open-source project on GitHub by developer msitarzewski, starts from a different premise. Instead of one AI trying to be good at everything, what if you assembled a team — a frontend specialist, a backend architect, a copywriter, a QA engineer, a compliance officer — each with deep, narrow expertise, and let them work on your project the way a real agency would?
This article unpacks what that actually means in practice: how the framework is structured, the thinking behind multi-agent AI systems generally, how the various departments in Agency Agents work, and how a developer can start experimenting with this approach today.
Key Takeaways
- Agency Agents provides 232 specialized AI agent personas organized into 16 divisions — far more than a typical single-assistant workflow, and considerably broader than the original conception of the project.
- Each agent is a structured prompt file (not custom software) defining a personality, mission, technical deliverables, and success metrics — designed to be loaded into AI coding tools you already use.
- It works natively with Claude Code, and ships conversion and install scripts for GitHub Copilot, Cursor, Gemini CLI, Windsurf, Aider, OpenCode, Antigravity, Codex, and more.
- The project is released under the MIT License, making it free to use, fork, and modify for commercial or personal projects.
- Agents are organized into divisions including Engineering, Design, Marketing, Product, Project Management, Testing, Security, Support, Sales, Finance, Game Development, Academic, GIS, Paid Media, Spatial Computing, and a Specialized catch-all division.
- There is a dedicated Agents Orchestrator agent and a Multi-Agent Systems Architect agent designed specifically to coordinate complex projects involving multiple specialists.
- This is fundamentally a prompt engineering and organizational framework, not an autonomous execution engine — the underlying intelligence still comes from whichever AI tool you connect it to.
Quick Information
| Project Name | Agency Agents (also referred to as "The Agency") |
| Developer | msitarzewski |
| Repository | github.com/msitarzewski/agency-agents |
| License | MIT License |
| Programming Language | Markdown agent definitions, with shell scripts for installation and conversion |
| Open Source Status | Fully open source; community contributions welcomed via pull requests |
| Number of AI Agents | 232 specialized agents (as documented in the repository at time of writing) |
| Departments | 16 divisions: Engineering, Design, Marketing, Paid Media, Sales, Product, Project Management, Testing, Security, Support, Finance, Game Development, Academic, GIS, Spatial Computing, Specialized |
| Supported AI Coding Platforms | Claude Code (native), GitHub Copilot, Cursor, Gemini CLI, Antigravity, OpenCode, OpenClaw, Aider, Windsurf, Kimi Code, Codex |
| Primary Purpose | Provide structured, specialized AI personas that can be installed into existing AI coding tools to simulate a full cross-functional team |
Quick Verdict
| Best For | Developers and founders who want structured, role-specific AI assistance across an entire project lifecycle rather than one generalist assistant |
| Difficulty Level | Beginner-to-intermediate — installation is a script-based process; getting real value requires some thought about which agents to combine |
| Runs Locally | Yes — agent definitions are local files; actual AI inference still depends on your connected tool (Claude Code, Copilot, etc.) |
| Open Source | ✓ Yes (MIT License) |
| Commercial Use | ✓ Permitted under MIT License |
| Platforms | Claude Code, GitHub Copilot, Cursor, Gemini CLI, Aider, Windsurf, and other supported AI coding tools |
| Recommended Users | Solo developers, startup founders, indie hackers, and small teams who want the structure of a full-service agency without the headcount |
What Is Agency Agents?
Agency Agents is an open-source collection of structured AI agent definitions — described by its creator as "a complete AI agency at your fingertips." Each agent is a Markdown file containing a carefully written persona: a name, a specialty, a personality, a working process, example deliverables, and success metrics. There are 232 of these files, organized into 16 divisions that mirror the structure of a real creative or technology agency.
The project began, according to its README, from a Reddit thread and has grown through months of community iteration. It is not a piece of software you run as a standalone application. Instead, it is a library of carefully engineered prompts designed to be installed directly into AI coding tools you already use — Claude Code, Cursor, GitHub Copilot, and others — transforming a general-purpose AI assistant into a specific named specialist with a defined way of working.
This distinction matters. Agency Agents does not provide its own AI model or inference engine. What it provides is structure: a way of organizing prompts, personas, and workflows so that the AI tool you're already using behaves more like a domain expert and less like a generic chatbot.
What Is a Multi-Agent AI System?
Before going further, it's worth explaining the underlying concept in plain language, because the term "multi-agent" gets used loosely across the AI industry.
A single AI assistant handles a conversation with one continuous context and one general behavior profile. You can ask it to switch from writing code to writing a blog post, and it will do its best, but it's drawing on the same broad, generalized training regardless of the task.
A multi-agent system, by contrast, breaks a workflow into multiple distinct "agents" — each with a narrower role, a more specific set of instructions, and sometimes a different underlying model or configuration. Rather than one assistant trying to be a generalist across every domain in a single conversation, you have several assistants, each behaving like a specialist, working on different parts of a problem.
This is conceptually similar to how human organizations work. You don't ask your accountant to also design your website. You don't ask your frontend developer to write your sales copy. Specialization allows each contributor to go deeper in their domain, develop sharper judgment within that domain, and produce more reliable output for the specific type of work they're suited to.
Agency Agents applies that same organizational logic to AI prompting. Instead of one assistant configuration, you load dozens of narrowly defined ones, each tuned — through its prompt — to behave like an expert in a specific function.
Why One AI Agent Is Not Always Enough
It's worth being honest about why this approach has gained traction rather than simply taking it on faith. There are a few concrete reasons a single general-purpose AI assistant runs into limits on complex projects.
Context Dilution
When you ask one AI assistant to handle frontend code, backend architecture, marketing copy, and QA testing within the same extended conversation, the context window fills with material from every domain. The assistant has to hold all of that simultaneously, which can dilute the precision of any single task — particularly in longer working sessions.
Generic Instruction Following
A default AI assistant configuration is, by design, built to be reasonably good at everything. That breadth comes at a cost: it lacks the sharply defined behavioral instructions that a specialized prompt provides. A generic prompt asking an AI to "review this code" produces a different — usually shallower — result than a prompt that has been engineered specifically around the mindset, checklist, and standards of a senior code reviewer.
Lack of Role Discipline
Real specialists know the boundaries of their job. A backend architect doesn't redesign your brand identity. A QA engineer doesn't rewrite your business logic. Without explicit role definition, a single AI assistant has no equivalent discipline — it will happily wander across domains in a single response, sometimes diluting focus on the task actually at hand.
Missing Domain-Specific Process
Experienced professionals don't just have knowledge — they have processes. A penetration tester follows a structured methodology. A technical writer follows a documentation standard. Agency Agents bakes these processes directly into each agent's instructions, rather than relying on the AI to infer the right process from a vague request.
How Specialized AI Agents Collaborate
It's important to be precise about what "collaboration" means in the context of Agency Agents, because the framework does not include an autonomous multi-agent runtime that automatically routes tasks between agents without human involvement. What it provides is the structural foundation for collaboration, executed in one of a few practical ways.
Sequential Activation
The most common pattern, based on the project's own documented examples, is sequential: a developer activates one agent for a specific task, reviews the output, then activates a different agent for the next stage of work. For example, activating the Backend Architect to design an API, then switching to the Frontend Developer to build the interface that consumes it.
Orchestrated Coordination
The repository includes a dedicated Agents Orchestrator agent within the Specialized division, described as handling "multi-agent coordination, workflow management" for "complex projects requiring multiple agent coordination." There is also a separate Multi-Agent Systems Architect agent in the Engineering division focused specifically on "multi-agent pipeline design & governance" — covering topology, context handling, trust, and failure recovery for agent systems. These agents are themselves specialized personas designed to help a developer think through how to structure a multi-agent workflow, rather than an automated execution engine that runs agents without supervision.
Parallel Deployment in a Single Session
The README documents an example — the "Nexus Spatial Discovery Exercise" — where eight agents from different divisions (a product trend researcher, backend architect, brand guardian, growth hacker, support responder, UX researcher, project shepherd, and XR interface architect) were deployed together to evaluate a single product opportunity from multiple angles simultaneously, producing a unified cross-functional plan covering market validation, technical architecture, brand strategy, go-to-market, and more.
In practice, what this means for a developer is that "collaboration" in Agency Agents is closer to assembling a structured team of consultants you can call on individually or in sequence, with the option to use the orchestrator and architect agents to help plan how those specialists should be sequenced or combined for a particular project.
Understanding AI Departments
The 232 agents in Agency Agents are organized into 16 divisions. This is significantly broader than a typical software-focused agent framework — the project has expanded well beyond engineering into sales, finance, game development, academic research, and geospatial analysis. Here's a closer look at the divisions most relevant to the typical developer or founder audience.
Software Engineering Department
The Engineering division is the largest and most detailed in the repository, containing dozens of agents spanning frontend development, backend architecture, mobile development, AI/ML engineering, DevOps, database optimization, software architecture, site reliability engineering, embedded firmware, and several CMS and e-commerce specializations (WordPress/WooCommerce, Drupal Commerce). It also includes more unusual specialists like a Solidity Smart Contract Engineer for DeFi work and an Incident Response Commander for production crisis management.
Design Department
The Design division covers UI design, UX research, UX architecture (the technical implementation side of design systems), brand identity, visual storytelling, and even an "Image Prompt Engineer" specialized in writing prompts for tools like Midjourney and DALL-E. A standout inclusion is the Whimsy Injector — an agent explicitly dedicated to adding personality, delight, and micro-interactions to a product, with the stated philosophy that "every playful element must serve a functional or emotional purpose."
Marketing Department
Marketing is the single largest division by agent count, reflecting how fragmented modern marketing channels have become. It includes generalist roles like Growth Hacker and Content Creator alongside deeply platform-specific specialists: Twitter/X strategists, TikTok strategists, Instagram curators, Reddit community builders, and an extensive set of agents for Chinese platforms including Xiaohongshu, WeChat, Zhihu, Bilibili, Douyin, Kuaishou, and Weibo — reflecting real demand for AI assistance navigating distinct regional marketing ecosystems.
Research Department
Research-oriented capability is spread primarily across the Product division (the Trend Researcher agent, focused on market intelligence and competitive analysis) and the dedicated Academic division, which includes an Anthropologist, Geographer, Historian, Narratologist, and Psychologist — agents explicitly designed for grounding fictional worldbuilding, narrative design, and character psychology in real scholarly frameworks rather than generic creative writing tropes.
Product Management Department
The Product division includes a Sprint Prioritizer for agile planning, a Trend Researcher for market intelligence, a Feedback Synthesizer for turning raw user feedback into structured insight, a Behavioral Nudge Engine grounded in behavioral psychology, and a full-lifecycle Product Manager agent covering discovery, PRD writing, roadmap planning, go-to-market, and outcome measurement.
Quality Assurance Department
The Testing division includes agents for visual QA with required screenshot evidence (the Evidence Collector), production-readiness certification (the Reality Checker — whose stated philosophy is to "default to finding 3-5 issues and require visual proof for everything"), performance benchmarking, API testing, accessibility auditing against WCAG standards, and workflow optimization. A separate Security division covers threat modeling, application security, penetration testing, cloud security, incident response, and compliance auditing (SOC 2, ISO 27001, HIPAA, PCI-DSS).
Operations Department
Operational capability spans the Support division (customer service, analytics reporting, finance tracking, infrastructure maintenance, legal compliance, executive summary generation) and the Project Management division (studio-level portfolio orchestration, cross-functional coordination, day-to-day process optimization, and meeting notes synthesis). The Specialized division also contains a long tail of operational roles including an Operations Manager grounded in Lean/Six Sigma methodology and an M&A Integration Manager for post-merger work.
| Division | Focus | Example Agents |
|---|---|---|
| Engineering | Software development, infrastructure | Frontend Developer, Backend Architect, SRE |
| Design | Visual and UX design | UI Designer, UX Researcher, Whimsy Injector |
| Marketing | Content, social, SEO, growth | Growth Hacker, SEO Specialist, Content Creator |
| Product | Strategy, planning, prioritization | Product Manager, Sprint Prioritizer |
| Project Management | Coordination, scoping, delivery | Studio Producer, Project Shepherd |
| Testing | QA, performance, accessibility | Reality Checker, API Tester |
| Security | AppSec, pentesting, compliance | Penetration Tester, Compliance Auditor |
| Support | Operations, finance, customer support | Support Responder, Finance Tracker |
| Sales | Prospecting, deals, pipeline | Outbound Strategist, Deal Strategist |
| Finance | Accounting, FP&A, tax, investment | Financial Analyst, Tax Strategist |
| Paid Media | Ad campaigns, tracking, creative | PPC Strategist, Tracking Specialist |
| Game Development | Engine-specific game dev (Unity, Unreal, Godot) | Game Designer, Unity Architect |
| GIS | Geospatial data and mapping | GIS Analyst, Web GIS Developer |
| Spatial Computing | AR/VR/XR development | XR Interface Architect, visionOS Engineer |
| Academic | Scholarly grounding for narrative work | Historian, Anthropologist |
| Specialized | Everything else — legal, HR, healthcare, niche markets | Agents Orchestrator, Legal Document Review |
How Tasks Flow Between Agents
Based on the project's documented use cases, a typical task flow looks less like an automated pipeline and more like a structured human workflow that happens to involve AI specialists at each stage. Here is the general pattern, illustrated through the kind of startup MVP scenario the README itself documents:
- Define the task and select the relevant agent. A developer identifies which part of the project they're working on — say, designing a database schema — and activates the corresponding specialist, such as the Backend Architect.
- The agent works within its defined process. Because each agent's instructions include a documented workflow and success metrics, the output tends to follow a more consistent, professional structure than an ad hoc prompt would produce.
- Output is reviewed and handed to the next specialist. The developer reviews the deliverable, then activates the next relevant agent — for instance, switching from the Backend Architect to the Frontend Developer once the API contract is settled.
- Quality gates are applied near the end. Testing and Security division agents, like the Reality Checker or Application Security Engineer, are typically brought in closer to completion to verify the work meets production standards before launch.
- For complex, multi-domain projects, the Orchestrator or Multi-Agent Systems Architect can help plan the sequence. Rather than guessing which specialists to involve and in what order, a developer can consult these meta-level agents to design the overall workflow before executing it.
It is worth being clear-eyed here: this flow is developer-directed. Agency Agents structures and disciplines the prompts; it does not (based on documented features) autonomously hand off tasks between agents without a human in the loop choosing when to switch.
How Agency Agents Integrates with Claude Code, Cursor, GitHub Copilot, Gemini CLI, and Other AI Coding Tools
Agency Agents is explicitly designed to be tool-agnostic, working as a layer on top of whatever AI coding assistant a developer already uses, rather than requiring a separate platform.
Claude Code (the recommended native option)
The documented quick-start path is built around Claude Code. Running the project's install script with the claude-code tool flag copies agent definitions into the appropriate Claude Code agents directory. From there, a developer can activate any agent within a Claude Code session using a natural-language instruction — the README's documented example is simply telling Claude to "activate Frontend Developer mode and help me build a React component."
Other Supported Tools
For developers using other AI coding tools, the repository documents a two-step process: first running a conversion script that generates integration files appropriate for each supported tool, and then running an install script that can either auto-detect which tools are installed on the system or target a specific tool directly. The documented list of supported tools includes GitHub Copilot, Cursor, Gemini CLI, Antigravity, OpenCode, OpenClaw, Aider, Windsurf, Kimi Code, and Codex.
Selective Installation
Because 232 agents is a substantial number to load into any single tool, the installer documented in the README supports installing only specific divisions or specific agents rather than the entire roster — for example, installing only the Engineering and Security divisions, or only naming individual agents like the Frontend Developer and UI Designer. This is particularly relevant for tools like OpenCode, where the README notes a documented upstream limitation: OpenCode's runtime currently registers only around 119 agents and silently drops any beyond that limit, making selective installation a practical necessity rather than just a convenience for that specific tool.
Reference Use Without Installation
The project also documents a third, simpler option: using the agent files purely as reference material. Each Markdown file contains the agent's identity, mission, workflows, and example deliverables in readable form — a developer can simply open the relevant file, copy the parts that are useful, and adapt them manually into their own prompts without running any installation scripts at all.
Real-World Workflow Examples
The repository documents several concrete use-case scenarios. Here is what they reveal about how the framework is meant to be applied in practice.
Building a Startup with AI Teams
The README's first documented scenario is a startup MVP build, assembling a Frontend Developer to build the React application, a Backend Architect to design the API and database, a Growth Hacker to plan user acquisition, a Rapid Prototyper to drive fast iteration cycles, and a Reality Checker to verify quality before launch. The stated outcome is shipping faster by having specialized expertise available at each distinct stage of the build, rather than relying on one generalist assistant across the entire project.
Managing Large Software Projects
For larger, more structured engineering work, the documented "Enterprise Feature Development" scenario combines a Senior Project Manager for scoping, a Senior Developer for complex implementation, a UI Designer for the design system, an Experiment Tracker for A/B test planning, an Evidence Collector for quality verification, and a Reality Checker for final production-readiness sign-off — explicitly framed as delivering "enterprise-grade delivery with quality gates and documentation."
Content Production Pipelines
The documented "Marketing Campaign Launch" scenario assembles a Content Creator to develop campaign material, a Twitter Engager and Instagram Curator for platform-specific execution, a Reddit Community Builder for authentic community engagement, and an Analytics Reporter to track and optimize performance — described as producing a "multi-channel coordinated campaign with platform-specific expertise."
Research Automation
While the README does not document a dedicated "research automation" scenario by that name, the framework's Academic division (Historian, Anthropologist, Geographer, Narratologist, Psychologist) combined with the Product division's Trend Researcher agent illustrate how a developer could assemble a research-focused team — for instance, using the Trend Researcher for market intelligence and the Academic agents for grounding any narrative or cultural claims in established scholarly frameworks.
Business Process Automation
The documented "Paid Media Account Takeover" scenario is the closest the repository comes to a full business-process workflow: a Paid Media Auditor performs a comprehensive account assessment, a Tracking & Measurement Specialist verifies conversion tracking accuracy, a PPC Campaign Strategist redesigns account architecture, a Search Query Analyst cleans up wasted ad spend, an Ad Creative Strategist refreshes ad copy, and an Analytics Reporter builds ongoing reporting dashboards — described as a "systematic account takeover" achievable within the first 30 days.
Advantages
- Genuine depth over generic breadth. Each agent's prompt is built around a specific domain's actual working process, not a one-line role description — this is meaningfully different from typing "act as a marketing expert" into a chat window.
- Enormous coverage across both technical and non-technical domains. Few open-source projects span from Solidity smart contract auditing to hospitality guest services to Unreal Engine multiplayer architecture under a single coherent framework.
- Works with tools developers already use. Because it integrates into Claude Code, Cursor, Copilot, and others rather than requiring a new platform, the adoption barrier is low for anyone already using an AI coding assistant.
- Fully transparent and forkable. Every agent definition is a readable Markdown file under an MIT license — nothing is hidden behind a black-box API, and developers can freely modify any agent to fit their needs.
- Documented success metrics and processes embedded in each agent. This pushes outputs toward consistency and professional structure rather than relying entirely on prompt quality in the moment.
- Active, structured contribution model. The project documents a clear template and process for adding or improving agents, which has clearly driven its rapid growth from an initial Reddit thread to 232 documented agents.
Limitations
- It is a prompt framework, not an autonomous agent runtime. There is no documented evidence of agents automatically executing tasks, calling APIs, or coordinating with each other without a human selecting which agent to activate and when. Developers expecting a fully autonomous multi-agent system out of the box should recalibrate expectations.
- Output quality is still bounded by the underlying AI model. A well-engineered persona prompt improves consistency and focus, but it cannot exceed the actual reasoning capability of whichever model (Claude, GPT, Gemini, etc.) is powering the session.
- Choosing the right agents requires judgment. With 232 agents across 16 divisions, there is a genuine learning curve in knowing which specialist to activate for a given task, particularly for less common domains.
- Platform-specific limitations exist. The documented OpenCode agent-count ceiling is one concrete example of how the breadth of the project can run into practical constraints depending on which tool you're using.
- No built-in inter-agent memory system is documented. Each agent activation appears to operate within the context of the session it's used in, rather than persisting a shared, structured memory across every agent automatically — context-passing between agents is the developer's responsibility.
- Quality varies somewhat by agent given the scale of community contribution. With this many agents contributed over time, some are likely to be more thoroughly tested and refined than others, particularly newer or more niche additions.
Comparison with Traditional AI Assistants
| Aspect | Traditional Single AI Assistant | Agency Agents |
|---|---|---|
| Role definition | Generic, defined ad hoc per prompt | Pre-engineered, persistent persona per domain |
| Process consistency | Depends on how the user phrases each request | Documented workflow embedded in each agent |
| Domain coverage | Broad but shallow per domain | 232 narrow, deep specializations |
| Setup effort | None — use immediately | Installation and agent selection required |
| Context switching | Single continuous context across domains | Explicit switching between specialized personas |
| Cost | Whatever the assistant costs | Free framework on top of your existing AI tool cost |
Comparison with Other Multi-Agent Frameworks
It's important to place Agency Agents accurately within the broader multi-agent AI landscape, since the term covers a range of genuinely different architectures.
| Framework Type | Architecture | Autonomy Level |
|---|---|---|
| Agency Agents | Structured persona library installed into existing AI coding tools | Developer-directed; human selects and sequences agents |
| Code-level orchestration frameworks (e.g. agent SDKs with programmatic handoffs) | Software libraries where agents call each other programmatically | Can run with significant autonomy once configured |
| Single-purpose autonomous agents (e.g. browsing or coding agents that execute multi-step tasks unsupervised) | One agent executing a defined task type autonomously | High autonomy within a narrow task scope |
The practical distinction is this: Agency Agents is closer to a meticulously organized prompt library and team-structuring philosophy than it is to a software framework for building autonomous agent pipelines. That makes it more accessible — there's no SDK to learn — but it also means the "collaboration" is structured by the developer's own judgment about sequencing, not by an underlying execution engine.
For developers specifically interested in the more autonomous end of this spectrum — agents that operate independently across a desktop environment, for instance — it's worth reading our coverage of UI-TARS Desktop, ByteDance's open-source desktop AI agent, which represents a different point on that autonomy spectrum.
Who Should Use Agency Agents?
Agency Agents is most valuable for people who are already working with an AI coding tool and want more structure, consistency, and domain depth than a generic prompt provides.
Solo developers and indie hackers building a product end-to-end will find the framework's coverage — from rapid prototyping through frontend, backend, design, marketing, and QA — particularly useful for compensating for the breadth of skills a single person realistically can't have at expert depth.
Startup founders without a full team yet can use the framework to simulate the cross-functional input of an agency: getting product strategy, growth thinking, and design feedback structured around documented professional processes rather than improvised prompting.
AI automation engineers exploring multi-agent system design will find the Multi-Agent Systems Architect and Agents Orchestrator agents directly useful as thinking partners for structuring more complex automated workflows, even outside the specific context of this repository.
Technical product managers can use the Product division agents alongside the Project Management division to bring more rigor to discovery, prioritization, and cross-functional coordination.
Open-source contributors interested in prompt engineering as a discipline will find genuine value in studying how the existing 232 agents are structured — the documented template (identity, mission, critical rules, technical deliverables, workflow process, success metrics) is itself a useful reference for writing better specialized prompts generally.
Students learning about both software development and AI prompting can use the framework as a structured way to explore what professional-grade prompt engineering looks like across dozens of real domains, rather than learning from generic tutorials alone.
Future of Multi-Agent Organizations
Multi-agent AI is one of the more actively contested frontiers in AI tooling right now, and projects like Agency Agents sit at an interesting point in that evolution. The current generation of multi-agent tools, broadly speaking, splits into two camps: developer-directed frameworks like this one, where a human chooses which specialist to activate and when, and increasingly autonomous orchestration systems where AI models themselves decide how to break down and route subtasks.
The trajectory across the industry points toward more autonomy over time — models becoming more capable of reliably deciding when to hand off a task to a different specialized configuration, and frameworks emerging to govern that handoff safely. The presence of agents in this very repository dedicated to "agentic identity & trust" and "multi-agent pipeline design & governance" is a signal that the community building around these tools is already thinking seriously about the harder problems that come with more autonomous agent coordination: how do you verify which agent did what, how do you recover from a failure partway through a multi-agent pipeline, and how do you maintain consistent context as work passes between specialists.
What seems likely is that frameworks like Agency Agents — built around well-engineered, narrowly scoped personas — will increasingly become the building blocks for more autonomous systems, rather than being replaced by them. The quality of a multi-agent system, autonomous or not, still depends fundamentally on how well each individual agent's role, process, and judgment are defined. That's exactly the kind of work this project has already done at scale.
For a broader view of where the open-source agent ecosystem is heading, our roundup of new open-source AI agent frameworks covers several adjacent projects worth comparing against this one.
Expert Analysis
What makes Agency Agents worth paying attention to isn't novelty in the underlying AI technology — it doesn't introduce a new model, a new protocol, or a new execution engine. What it demonstrates is something more practical: that careful prompt engineering, applied systematically and at scale across genuinely distinct professional domains, produces a meaningfully different experience than ad hoc prompting, even using exactly the same underlying AI models.
The project's growth trajectory — from a single Reddit thread to 232 documented agents across 16 divisions, with the README citing 50+ requests in the first 12 hours of its public existence — suggests it tapped into a real, underserved need: developers and founders who wanted more structure and domain rigor from their AI coding tools than default configurations provide, without wanting to build that structure themselves from scratch for every new task.
The breadth is both the project's greatest strength and its most legitimate point of scrutiny. Spanning from Solidity smart contract auditing to WeChat marketing to visionOS development to legal billing time-tracking is an impressive demonstration of how flexible the underlying "specialized persona" pattern is. At the same time, with a corpus this large built through open community contribution, it would be reasonable to expect variance in how thoroughly each individual agent has been tested in real production use — a concern the project's own documentation implicitly acknowledges by describing the work as "battle-tested in production environments" without specifying which specific agents have received that level of validation.
The more durable contribution here may be conceptual rather than purely practical: Agency Agents is a clear, well-documented demonstration of the "specialized team over generalist assistant" philosophy, applied at a scale that makes the pattern legible. Even developers who don't adopt the framework wholesale can learn from studying how its agent definitions are structured — and that structural template (identity, mission, critical rules, deliverables, workflow, success metrics) is arguably as valuable as any individual agent in the collection.
Frequently Asked Questions
1. What is Agency Agents?
Agency Agents is an open-source GitHub project providing 232 specialized AI agent personas organized into 16 functional divisions, designed to be installed into AI coding tools like Claude Code, Cursor, and GitHub Copilot to simulate the structure of a full cross-functional team.
2. Is Agency Agents free to use?
Yes. The project is released under the MIT License, which permits free use, modification, and distribution, including for commercial projects.
3. Does Agency Agents work with ChatGPT?
The documented installer supports a specific list of AI coding tools: Claude Code (native), GitHub Copilot, Cursor, Gemini CLI, Antigravity, OpenCode, OpenClaw, Aider, Windsurf, Kimi Code, and Codex. Standard ChatGPT is not listed among the documented integrations, though the agent definitions can be used as reference material and manually adapted into any AI chat interface, including ChatGPT.
4. How many agents does Agency Agents have?
The repository documents 232 specialized agents across 16 divisions at the time of writing. This number has grown substantially through community contribution since the project's original launch and may continue to change.
5. Do I need to be a developer to use Agency Agents?
Installation via the provided scripts assumes basic command-line comfort. However, the agent definitions themselves are plain Markdown files that anyone can read and adapt manually, which makes the underlying content accessible even to non-developers comfortable copying text into an AI chat interface.
6. Can Agency Agents fully automate my project without my involvement?
No. Based on the documented features, Agency Agents provides structured prompts and personas that a developer activates and sequences manually within their AI tool of choice. There is no documented autonomous execution engine that runs the agents without human direction.
7. What is the difference between Agency Agents and a regular AI assistant?
A regular AI assistant uses one general-purpose configuration across every task. Agency Agents provides dozens of pre-engineered, narrowly scoped personas — each with a defined personality, process, and success metrics — that you activate individually for specific tasks within your existing AI tool.
8. Which AI coding tool works best with Agency Agents?
Claude Code is the documented "recommended" option with the most direct native installation path. Other supported tools require an additional conversion step but are otherwise fully supported according to the project's documentation.
9. What is the Agents Orchestrator?
The Agents Orchestrator is a specialized agent within the Specialized division, described as handling multi-agent coordination and workflow management for complex projects that require multiple specialists working together. It functions as a planning aid for structuring multi-agent workflows.
10. Can I install only specific agents instead of all 232?
Yes. The documented installer supports selective installation by division (for example, only Engineering and Security) or by individually named agents, rather than requiring the entire roster to be installed at once.
11. Is there a limit to how many agents I can install in a single tool?
It depends on the tool. The documentation specifically notes that OpenCode's runtime currently registers only around 119 agents and silently drops any beyond that limit due to a documented upstream bug, making selective installation important for that particular tool. Other supported tools are not documented as having this specific constraint.
12. What license is Agency Agents released under?
The MIT License, as confirmed in the repository's LICENSE file and README badge.
13. Can I contribute my own agent to the project?
Yes. The repository documents a clear contribution process: fork the repository, create a new agent file in the appropriate category following the documented template structure (frontmatter, identity, core mission, critical rules, technical deliverables, workflow process, success metrics), and submit a pull request.
14. Does Agency Agents include agents for non-technical business functions?
Yes, extensively. Beyond engineering and design, the repository documents dedicated divisions and agents for sales, finance, paid media, legal document review, HR onboarding, healthcare customer service, real estate transactions, and many other non-technical business functions within its Specialized and other divisions.
15. How is Agency Agents different from a generic prompt library?
The project's own documentation draws this distinction explicitly: unlike a "one-off prompt collection," Agency Agents provides what it describes as "comprehensive agent systems with workflows and deliverables" — meaning each agent includes a structured process and measurable success criteria, not just a single descriptive prompt.
16. Will Agency Agents work for non-software projects, like game development or worldbuilding?
Yes. The repository includes dedicated divisions for Game Development (covering Unity, Unreal Engine, Godot, Blender, and Roblox Studio specifically) and Academic agents (Historian, Anthropologist, Geographer, Narratologist, Psychologist) explicitly designed for grounding fictional worldbuilding and narrative design in scholarly frameworks.
Read Next
If this deep dive into multi-agent AI was useful, these related pieces on Provixx explore adjacent territory in the open-source AI agent ecosystem:
- UI-TARS Desktop: ByteDance's Open-Source Desktop AI Agent — A look at a more autonomous category of AI agent, designed to operate a desktop environment directly rather than working through developer-directed prompts.
- New Open-Source AI Agent Frameworks — A broader survey of the multi-agent and agentic framework landscape that places Agency Agents in context against other approaches.
- GitHub Spec Kit: The AI Coding Framework Developers Should Know — A complementary look at structured, specification-driven AI development, which pairs naturally with the role-based discipline Agency Agents brings to a project.
- AI in Education: How Open-Source AI Is Reshaping Learning — Relevant for students and educators exploring how structured, specialized AI tools — including agent frameworks like this one — are changing how technical skills are taught and learned.
Final Thoughts
The shift from "one AI assistant for everything" to "a structured team of specialized AI personas" may turn out to be one of the more consequential changes in how developers and founders actually work with AI day to day. It isn't a change in the underlying models — it's a change in how we organize and direct them, and that organizational layer matters more than it might initially seem.
Agency Agents is a clear, well-documented, and genuinely substantial example of this philosophy in practice. With 232 agents spanning engineering, design, marketing, finance, security, game development, and a long tail of specialized business functions, it demonstrates just how far the "specialized persona" pattern can be pushed when applied systematically and refined through real community use.
It is important to be precise about what this framework is and isn't. It is not an autonomous multi-agent execution engine that runs your project without supervision. It is a meticulously organized library of professional-grade prompts, paired with installation tooling that makes them easy to bring into the AI coding tools developers already rely on. That distinction doesn't diminish its value — if anything, it makes the project more immediately useful, because there's no new platform to learn and no black box to trust blindly.
For developers and founders curious about where multi-agent AI is heading, experimenting with a framework like this one is a low-risk, genuinely informative way to start. You don't need to rebuild your workflow around a new execution engine. You just need to install a few agents relevant to your next project, activate them deliberately, and see firsthand what changes when "ask the AI" becomes "ask the right specialist."
