Ask Claude Code to "act as a senior backend developer" and you get a marginally different tone, not a different level of output. Agency Agents is built on the bet that the gap between a one-line role prompt and something genuinely useful is process, not personality — each of its 230+ agent definitions bundles a specific workflow, concrete deliverables, and success criteria for one narrow job, rather than asking a general-purpose model to improvise a specialist from a sentence. The project has picked up a striking amount of attention since it grew out of a Reddit thread, and it's now installable across more than a dozen different coding agents, not just Claude Code.
Quick answer: Agency Agents is a free, MIT-licensed library of 230+ markdown persona files — each with a defined workflow, deliverables, and success criteria — that installs into Claude Code, Cursor, Copilot, and a dozen other tools via a desktop app or script. It's worth it for divisions that map to work you do repeatedly; skip the full 230-agent install, since at least one supported tool silently drops agents past ~119. The rest of this piece covers installation, what to verify before trusting it, and where it's genuinely strong.
What's Actually in the Box
Each entry in the roster is a markdown file describing one agent: its area of expertise, a defined workflow it follows, the concrete outputs it's expected to produce, and criteria for what "done well" looks like for that specific job. The roster is organized into divisions — Engineering, Design, Marketing, Sales, Security, Testing, Product, Finance, Game Development, Healthcare, GIS, and more — each with agents scoped to a specific slice of that domain rather than one generalist per department. Engineering alone spans everything from a frontend developer and backend architect down to narrower roles like a database optimizer, an incident response commander, and an embedded firmware engineer.
The pitch, in practice, is the difference between telling a model "write me a database migration" and handing it an agent definition that already encodes how a database optimizer should think about indexing trade-offs, what a finished migration plan should include, and what counts as a red flag before shipping it. Whether that difference is worth a dedicated file per role — versus just writing a good prompt yourself — is really a question of how much repeat use a given task gets in your workflow.
Installing It
There are two paths, and they lead to meaningfully different amounts of manual work:
| Path | What it does |
|---|---|
| Desktop app (macOS, Linux, Windows) | Browses the full roster and installs agents into any supported tool with a click, and keeps them updated automatically |
Scripts (convert.sh + install.sh) | Generates per-tool integration files, then installs interactively — auto-detecting which coding agents you have, letting you pick specific divisions or individual agents rather than all 230+ at once |
The script path is worth using deliberately rather than installing everything: the project's own documentation flags that at least one supported tool's runtime currently caps out around 119 registered agents and silently drops the rest past that limit, so scoping an install to the divisions you actually need (--division engineering,security, for instance) isn't just tidiness — it avoids a real, documented failure mode.
Built for More Than One Agent Harness
What separates this from a typical prompt collection is the multi-tool conversion layer. The same source agent definitions get translated into whatever format a given coding tool expects — native markdown for Claude Code and GitHub Copilot, SKILL.md files for Antigravity and Osaurus, .mdc rules for Cursor, a single consolidated CONVENTIONS.md for Aider, YAML specs for Kimi Code, TOML for Codex — across more than a dozen supported harnesses.
That's a meaningful engineering commitment beyond just writing good prompts: it means the roster isn't locked to whichever tool the author happens to use, and a team standardizing on a house set of agent personas isn't forced to pick one coding assistant to get value from it.
What "Well-Designed" Means Here
The project states its own design philosophy directly rather than leaving it implicit, and it's worth taking at face value because it explains what a contributor is actually supposed to build when adding a new agent: strong personality (real character and voice, not a generic template), clear deliverables (concrete outputs rather than vague guidance), success metrics (measurable standards for what "done" looks like), a proven workflow (a step-by-step process, not improvisation), and a learning-memory element aimed at pattern recognition over repeated use. That fifth point is a stated design goal rather than a mechanism the README documents in technical detail, so it's worth treating as intent rather than a guaranteed feature when evaluating a given agent file.
The project also frames itself explicitly against three alternatives: a one-line "act as a developer" prompt, a flat prompt library with no workflow attached, and a closed AI tool you can't inspect or fork — positioning every agent definition as forkable and adaptable by design, which is the same MIT-licensed openness already covered above.
What a Multi-Agent Team Actually Looks Like
The README's own worked examples are a more concrete way to judge the pitch than the feature list. One scenario walks through a paid-media account takeover: a Paid Media Auditor runs a full account assessment, a Tracking & Measurement Specialist verifies conversion tracking is actually accurate, a PPC Campaign Strategist redesigns the account architecture, a Search Query Analyst cleans up wasted spend from search terms, and an Ad Creative Strategist refreshes ad copy and extensions — five narrow roles chained into one takeover process instead of one generalist agent attempting the whole audit.
Another example composes a smart-campus digital twin from seven agents spanning BIM/GIS specialists, drone reality-mapping, web GIS development, and QA validation — divisions (GIS, Healthcare, Game Development) well outside typical software engineering work that the roster also covers. Whether either scenario maps to your own workload is exactly the judgment call this kind of library asks you to make: the value isn't in any single agent, it's in whether a chained sequence of them matches a process you actually run.
That judgment call is easier once you know what to check before installing anything — which is exactly what the next section covers.
What to Verify Before Relying on It
A few things are worth checking directly rather than taking on faith, which is true of any large third-party prompt library you're about to hand real work to:
- Read an agent file before installing it wholesale. Personality-driven prompts are easy to write persuasively and harder to verify actually produce better output than a plain, carefully written prompt for the same task — read a couple of the agents most relevant to your stack and judge the actual workflow and deliverable criteria they encode, not just the framing.
- Scope installs to what you'll use. Beyond the OpenCode agent-count ceiling already mentioned, installing all 230+ agents into a tool you use daily adds real surface area to whatever discovery or activation mechanism that tool uses — most teams are better served installing a handful of divisions relevant to their actual work.
- Treat it like any other MIT-licensed third-party content you're pulling into a workflow. It's forkable and adaptable by design, which is a real strength if you want to tune an agent's workflow to match your team's actual standards rather than someone else's defaults.
- Popularity signals on GitHub aren't always what they look like. This repo's star count is unusually high relative to its age and the size of a shell-and-markdown project — worth judging the library on the agent definitions themselves rather than the star count alone.
Practical Takeaway
The underlying idea — that a role prompt gets meaningfully better when it's backed by an explicit workflow and deliverable checklist instead of a one-line persona — is sound, and it's the same principle behind well-scoped Agent Skills generally: narrow, well-specified instructions beat a generic system prompt asked to improvise. Whether a 230-agent library is the right shape for your team depends on how many of those roles actually map to work you do repeatedly. For a handful of divisions that match your real workflow, it's a reasonable head start over writing role prompts from scratch; for a broad, unscoped install across every division, you're carrying more surface area than most teams need.
If you're evaluating it today, do this rather than installing everything:
- Read 2-3 agent files closest to your stack before installing anything, and judge the workflow and deliverables, not the framing.
- Scope the install to matching divisions (
--division engineering,security) instead of the full 230+. - Fork and tune the ones you keep so the workflow matches your team's actual standards, not the default.
Teams building custom Claude Code or multi-agent workflows — whether that means adopting a library like this or writing house-specific agent definitions from scratch — can get hands-on help from Woyce Technologies.
FAQ
What is Agency Agents?
Agency Agents is an open-source library of 230+ specialized AI agent persona definitions — covering engineering, design, marketing, security, and more — installable into Claude Code and over a dozen other AI coding tools.
Is Agency Agents free to use?
Yes, it's released under the MIT License and available on GitHub, along with a free desktop app for installing agents into supported tools.
How is this different from just writing my own custom prompt?
Each agent bundles a defined workflow, concrete deliverable expectations, and success criteria for one specific role, rather than a single-line persona instruction. Whether that's worth using over a well-written custom prompt depends on how often you need that specific role and how closely the packaged workflow matches how your team actually works.
Which AI coding tools does it support?
Claude Code, GitHub Copilot, Cursor, Aider, Windsurf, Gemini CLI, OpenCode, Codex, Kimi Code, Qwen Code, Antigravity, and several others — each gets agent definitions converted into that tool's native format.
Can I install just some of the agents instead of all 230+?
Yes — the install script supports selecting specific divisions or individual agents rather than installing the full roster, which is also necessary for at least one supported tool that currently has a hard limit on how many agents it can register.
Should I trust an agent library with this many GitHub stars?
Star count is a weak signal on its own — judge a prompt or agent library by reading the actual definitions and testing them against your real workflow, not by popularity metrics, which can be inflated independent of a project's actual quality or adoption.
Is there a desktop app, or do I have to usame as improve this blogse the command line?
There's a native desktop app for macOS, Linux, and Windows that browses the full roster and installs agents into supported tools with a click, auto-updating after that. On a Mac it's also installable via brew install --cask msitarzewski/agency-agents/agency-agents. The script-based install (convert.sh and install.sh) covers the same ground for anyone who prefers the terminal.
Can I contribute a new agent to the library?
Yes — it accepts pull requests. The project asks contributors to follow a specific template: frontmatter with name, description, and color, an identity and memory section, a core mission, domain-specific critical rules, technical deliverables with real examples, a defined workflow, and success metrics. That same template is a useful checklist for judging how complete any existing agent file actually is.