Agency Agents: A Roster of Prompt Personas for Claude Code and Beyond
Agency Agents provides role-specific agent definitions and working procedures for engineering, design, marketing, product, and community tasks.
At a glance
- What is it?
- Agency Agents is a collection of role-specific markdown files that give AI coding assistants distinct personalities and workflows. The project includes shell scripts to install these agents into a dozen tools, but its value depends on how much you trust prompt-based specialization.
- Who is it for?
- Adopt Agency Agents if you work daily in Claude Code, Cursor, or Codex and want a structured set of prompt personas for common tasks like frontend development, incident response, or community management. Skip it if you prefer writing your own prompts from scratch or if you need agents that actually execute code rather than just follow instructions.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 3 days ago.
- What is it written in?
- Mainly Shell, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What This Repository Actually Contains
Agency Agents is a collection of markdown files, each defining a single AI agent persona. The README lists agents across divisions: engineering, design, marketing, product, and community. Each file contains identity traits, workflows, deliverables, and success metrics. The repository is not a runtime or a framework. It is a set of prompts plus shell scripts that copy those prompts into the agent directories of tools like Claude Code, Cursor, and Codex. The primary language is Shell, which reflects the install and conversion scripts. The MIT license means you can reuse the content freely, but the project itself has no releases listed and no visible update history, so you cannot confirm how actively it is maintained.
The Problem It Solves: Prompt Drift and Role Consistency
When you use an AI assistant for varied tasks, you often rewrite context or restate roles each session. Agency Agents tries to standardize that. Instead of typing "act as a senior developer" every time, you install a persona file and invoke it with a phrase like "activate Frontend Developer mode." The README claims each agent is specialized, personality-driven, and deliverable-focused. That is a reasonable response to a real annoyance: generic prompts produce generic output. For teams that want consistent behavior across sessions and across multiple tools, a shared roster of personas can reduce repetition. The project's target user is someone who already uses an AI coding assistant and wants a curated set of roles rather than writing their own.
How Installation Works: Scripts and Tool Targets
The repository provides two main scripts. `convert.sh` generates integration files for all supported tools. `install.sh` copies agents into a specific tool's directory. The README shows a direct command for Claude Code: `./scripts/install.sh --tool claude-code`. You can also copy a category manually, for example `cp engineering/*.md ~/.claude/agents/`. For other tools, you run `./scripts/install.sh` interactively, and it auto-detects what you have installed. You can target a tool explicitly with flags like `--tool cursor`, `--tool gemini-cli`, or `--tool codex`. You can narrow the install by division or by individual agent. Examples include `--division engineering,security` and `--agent frontend-developer,ui-designer`. A `--dry-run` flag lets you preview what would be installed. The scripts are the core mechanism, and they appear to be plain shell, so you need a Unix-like environment or a shell emulator on Windows.
The OpenCode Limit Is a Real Constraint
The README calls out a specific limitation with OpenCode: that tool's runtime currently registers only about 119 agents and silently drops the rest. The upstream bug is referenced as issue 27988 in the OpenCode repository. The installer warns you when your selection would exceed that limit, and the recommended workaround is to install a subset using `--division`. This is a concrete, verifiable constraint that affects how you use the project. It also shows that the scripts are aware of tool-specific quirks, which is a sign of practical design. However, it also means that if you want the full roster in OpenCode, you cannot have it. You must pick a division or accept silent omissions. That is a genuine failure mode, and the project handles it honestly by warning you.
The Native App: A Different Distribution Channel
The README prominently advertises a separate application called Agency Agents at agencyagents.app. It is a native desktop app for macOS, Linux, and Windows. The app browses the full roster and installs agents into Claude Code, Cursor, Codex, Gemini, Osaurus, and more with a click. It also auto-updates. On macOS you can install it via Homebrew: `brew install --cask msitarzewski/agency-agents/agency-agents`. This app is a separate repository, and the README links to its releases page. The app is not required; the scripts work without it. But it suggests the project is moving toward a more user-friendly distribution model. The trade-off is that the app adds a dependency on a third-party binary, and you cannot verify from this README how the app handles updates or whether it respects your existing agent customizations.
What the Agents Actually Do: Prompts, Not Programs
Each agent file is a markdown document. It contains identity traits, core mission, workflows, technical deliverables with code examples, and success metrics. There is no executable logic. The agents do not run as standalone processes. They are instructions that an AI model follows when you invoke them in a chat session. This is an important distinction. The project's value is in the quality and specificity of those prompts, not in any automation. The README lists agents like Frontend Developer, Backend Architect, and Incident Response Commander. Each has a "when to use" description. For example, the Network Engineer agent is for router and switch configuration, BGP/OSPF, and ACLs. That specificity is what separates this from a generic prompt library. But the quality is subjective. You cannot test it without running the prompts through a model, and the README gives no examples of actual output.
Maintenance and Upgrade Cost: You Own It
The repository has no listed releases. That means you cannot assume active upstream maintenance. The MIT license gives you the right to fork and modify, but it also means you are responsible for keeping agents compatible with your tools. AI tools update their prompt formats and agent directory structures over time. A persona file written for Claude Code today may not work in a future version. The scripts may also break if a tool changes its installation path. The native app auto-updates, which reduces that burden, but the app itself is a separate project with its own release cycle. If you rely on the scripts, you should check the repository periodically for changes. There is no versioning scheme mentioned, so you cannot pin a specific release. This is a maintenance cost that the README does not address directly.
Alternatives and the Core Trade-Off
The obvious alternative is to write your own prompt files. That costs time but gives you full control and no dependency on a third-party roster. Another alternative is to use a tool like Cursor or Codex that has built-in persona or custom instruction features, which may already cover some roles. The difference in approach is that Agency Agents centralizes personas as portable markdown, which you can copy into multiple tools. That portability is useful if you switch tools often. But it also means you are tied to the project's definitions. You can edit them, but then you lose the auto-update benefit from the app. A more structured alternative would be a framework that actually executes agent logic, like an agent orchestration library. This project is not that. It is a prompt library with a convenient installer. The trade-off is simplicity versus depth. You get easy installation but no runtime behavior beyond what the model does with the text.
Who Should Adopt It and What to Verify First
Adopt this if you are a developer or a small team using Claude Code or Cursor daily and you want a quick way to add role-specific behavior. The installation is straightforward, and the division-based selection lets you start small. Verify that the agents you need exist in the roster. The README shows only a partial list, truncated. Check the engineering directory for specific files. Also verify that the install script works on your operating system, especially if you are on Windows without a Unix shell. Confirm that your tool's agent directory path matches what the script expects. For OpenCode, count your selected agents and stay under 119. If you use the native app, test it on a copy of your configuration first. Do not assume the agents will improve your output. Run a few sessions with and without them to see if the persona actually changes the results. If you see no difference, you have saved nothing by adopting this project.
Editorial conclusion
Adopt Agency Agents if you work daily in Claude Code, Cursor, or Codex and want a structured set of prompt personas for common tasks like frontend development, incident response, or community management. Skip it if you prefer writing your own prompts from scratch or if you need agents that actually execute code rather than just follow instructions. Before adopting, verify that the agents you plan to use are current with your tool's latest prompt format, and check the OpenCode 119-agent limit if you target that tool. The project is MIT licensed, so you can fork and adapt it freely, but you own the maintenance burden.
Community notes