Agency Agents: A Roster of Prompt Personas for Claude Code and Beyond

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 repository has no GitHub releases, though its last push was on 2026-10-25.

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.

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 Mobile App Builder. 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 judge it without running the prompts through a model.

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. Because there are no GitHub releases, there is no release to pin.

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. 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. 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, design, 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.

Frequently asked questions

Official sources

1. Official README
2. Project repository
3. README
4. Releases