agency-agents Documentation

Technical Documentation: msitarzewski/agency-agents

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (`README.md`) Copy Section

🎭 The Agency: AI Specialists Ready to Transform Your Workflow

A complete AI agency at your fingertips - From frontend wizards to Reddit community ninjas, from whimsy injectors to reality checkers. Each agent is a specialized expert with personality, processes, and proven deliverables.

🆕 There's an app now Copy Section

Agency Agents is a native app for macOS, Linux & Windows that browses the entire roster and installs it into Claude Code, Cursor, Codex, Gemini, Osaurus, and more — with a click. No clone, no scripts, and it auto-updates.

→ Download the latest release · agencyagents.app

🚀 What Is This? Copy Chapter

Born from a Reddit thread and months of iteration, The Agency is a growing collection of meticulously crafted AI agent personalities. Each agent is:

• 🎯 Specialized: Deep expertise in their domain (not generic prompt templates)
• 🧠 Personality-Driven: Unique voice, communication style, and approach
• 📋 Deliverable-Focused: Real code, processes, and measurable outcomes
• ✅ Production-Ready: Battle-tested workflows and success metrics

Think of it as: Assembling your dream team, except they're AI specialists who never sleep, never complain, and always deliver.

⚡ Quick Start Copy Chapter

Option 1: Install the app (Recommended) Copy Section

The fastest way in — no clone, no terminal. Agency Agents is a native desktop app (macOS · Linux · Windows) that browses the whole roster and installs agents into Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Qwen, and Osaurus for you, then keeps them up to date.

⬇ Download the latest release — or on a Mac:

brew install --cask msitarzewski/agency-agents/agency-agents

Prefer the command line? The script-based options below install the same agents.

Option 2: Use with Claude Code Copy Section

# Install all agents to your Claude Code directory
./scripts/install.sh --tool claude-code

# Or manually copy a category if you only want one division
cp engineering/*.md ~/.claude/agents/

# Then activate any agent in your Claude Code sessions:
# "Hey Claude, activate Frontend Developer mode and help me build a React component"

Option 3: Use as Reference Copy Section

Each agent file contains:

• Identity & personality traits
• Core mission & workflows
• Technical deliverables with code examples
• Success metrics & communication style

Browse the agents below and copy/adapt the ones you need!

Option 4: Use with Other Tools (GitHub Copilot, Antigravity, Gemini CLI, OpenCode, OpenClaw, Cursor, Aider, Windsurf, Kimi Code, Codex, Osaurus, Hermes, Mistral Vibe, DeepSeek Harness) Copy Section

# Step 1 -- generate integration files for all supported tools
./scripts/convert.sh

# Step 2 -- install interactively (auto-detects what you have installed)
./scripts/install.sh

# Or target a specific tool directly
./scripts/install.sh --tool antigravity
./scripts/install.sh --tool gemini-cli
./scripts/install.sh --tool opencode
./scripts/install.sh --tool copilot
./scripts/install.sh --tool openclaw
./scripts/install.sh --tool cursor
./scripts/install.sh --tool aider
./scripts/install.sh --tool windsurf
./scripts/install.sh --tool kimi
./scripts/install.sh --tool codex
./scripts/install.sh --tool osaurus
./scripts/install.sh --tool hermes
./scripts/install.sh --tool vibe
./scripts/install.sh --tool dsh

Install only the teams you need (not everyone wants every division):

./scripts/install.sh                                    # interactive wizard: pick tools + teams
./scripts/install.sh --tool claude-code --division engineering,security
./scripts/install.sh --tool cursor --agent frontend-developer,ui-designer
./scripts/install.sh --list teams                       # see every team + agent count
./scripts/install.sh --tool opencode --division engineering --dry-run

--agent and --agents-file take an agent's slug (as --list agents prints it), its display name, or its file name without .md — the id the runbook rosters use — so a runbook's team installs as listed:

python3 -c 'import json, sys
for r in json.load(open("strategy/runbooks.json"))["runbooks"]:
    if r["slug"] == sys.argv[1]: [print(a) for g in r["roster"] for a in g["agents"]]' startup-mvp > team.txt
./scripts/install.sh --tool claude-code --agents-file team.txt

OpenCode note: OpenCode's runtime currently registers only ~119 agents and silently drops the rest (upstream bug). Installing a subset with --division keeps you under that limit. The installer warns you when a selection would exceed it.

See the Multi-Tool Integrations section below for full details.

🎨 The Agency Roster Copy Chapter

💻 Engineering Division Copy Section

Building the future, one commit at a time.

🎨 Design Division Copy Section

Making it beautiful, usable, and delightful.

💰 Paid Media Division Copy Section

Turning ad spend into measurable business outcomes.

💼 Sales Division Copy Section

Turning pipeline into revenue through craft, not CRM busywork.

📢 Marketing Division Copy Section

Growing your audience, one authentic interaction at a time.

📊 Product Division Copy Section

Building the right thing at the right time.

🎬 Project Management Division Copy Section

Keeping the trains running on time (and under budget).

🧪 Testing Division Copy Section

Breaking things so users don't have to.

🔒 Security Division Copy Section

Defending the stack — from secure-by-design architecture to breach response.

🛟 Support Division Copy Section

The backbone of the operation.

🥽 Spatial Computing Division Copy Section

Building the immersive future.

🎯 Specialized Division Copy Section

The unique specialists who don't fit in a box.

💵 Finance Division Copy Section

Accounting, financial analysis, tax strategy, and investment research specialists.

🎮 Game Development Division Copy Section

Building worlds, systems, and experiences across every major engine.

Cross-Engine Agents (Engine-Agnostic)

Unity

Unreal Engine

Godot

Blender

Roblox Studio

📚 Academic Division Copy Section

Scholarly rigor for world-building, storytelling, and narrative design.

🌍 GIS Division Copy Section

Mapping the Earth, analyzing the built world, and extracting intelligence from geospatial data.

🏥 Healthcare Division Copy Section

Building AI agents for regulated clinical and sovereign health contexts.

🔍 Research Division Copy Section

Finding, evaluating, and synthesizing existing evidence rather than generating new primary data.

🎯 Real-World Use Cases Copy Chapter

Scenario 1: Building a Startup MVP Copy Section

Your Team:

1. 🎨 Frontend Developer - Build the React app
2. 🏗️ Backend Architect - Design the API and database
3. 🚀 Growth Hacker - Plan user acquisition
4. ⚡ Rapid Prototyper - Fast iteration cycles
5. 🔍 Reality Checker - Ensure quality before launch

Result: Ship faster with specialized expertise at every stage.

Scenario 2: Marketing Campaign Launch Copy Section

Your Team:

1. 📝 Content Creator - Develop campaign content
2. 🐦 Twitter Engager - Twitter strategy and execution
3. 📸 Instagram Curator - Visual content and stories
4. 🤝 Reddit Community Builder - Authentic community engagement
5. 📊 Analytics Reporter - Track and optimize performance

Result: Multi-channel coordinated campaign with platform-specific expertise.

Scenario 3: Enterprise Feature Development Copy Section

Your Team:

1. 👔 Senior Project Manager - Scope and task planning
2. 💎 Senior Developer - Complex implementation
3. 🎨 UI Designer - Design system and components
4. 🧪 Experiment Tracker - A/B test planning
5. 📸 Evidence Collector - Quality verification
6. 🔍 Reality Checker - Production readiness

Result: Enterprise-grade delivery with quality gates and documentation.

Scenario 4: Paid Media Account Takeover Copy Section

Your Team:

1. 📋 Paid Media Auditor - Comprehensive account assessment
2. 📡 Tracking & Measurement Specialist - Verify conversion tracking accuracy
3. 💰 PPC Campaign Strategist - Redesign account architecture
4. 🔍 Search Query Analyst - Clean up wasted spend from search terms
5. ✍️ Ad Creative Strategist - Refresh all ad copy and extensions
6. 📊 Analytics Reporter (Support Division) - Build reporting dashboards

Result: Systematic account takeover with tracking verified, waste eliminated, structure optimized, and creative refreshed — all within the first 30 days.

Scenario 5: Full Agency Product Discovery Copy Section

Your Team: All 8 divisions working in parallel on a single mission.

See the Nexus Spatial Discovery Exercise -- a complete example where 8 agents (Product Trend Researcher, Backend Architect, Brand Guardian, Growth Hacker, Support Responder, UX Researcher, Project Shepherd, and XR Interface Architect) were deployed simultaneously to evaluate a software opportunity and produce a unified product plan covering market validation, technical architecture, brand strategy, go-to-market, support systems, UX research, project execution, and spatial UI design.

Result: Comprehensive, cross-functional product blueprint produced in a single session. More examples.

Scenario 6: Smart Campus Digital Twin Copy Section

Your Team:

1. 🧠 Technical Consultant - Define the digital twin strategy: BIM for buildings, GIS for campus, IoT for real-time
2. 🏗️ BIM/GIS Specialist - Convert Revit building models to GIS scene layers, design indoor floor plans
3. 🛸 Drone/Reality Mapping - Fly the campus, generate orthomosaic and 3D mesh for context
4. 🌐 Web GIS Developer - Build the campus dashboard with MapLibre, building layer, and room finder
5. 🏔️ 3D & Scene Developer - Create immersive 3D scene with terrain, buildings, and flyover tour
6. 🤖 GeoAI/ML Engineer - Extract building footprints and tree canopy from drone imagery
7. ✅ GIS QA Engineer - Validate data accuracy, check topology, verify CRS consistency

Result: A campus digital twin that combines BIM detail, drone reality capture, 3D visualization, and web accessibility — delivered by coordinated specialists in a single pipeline.

🤝 Contributing Copy Chapter

We welcome contributions! Here's how you can help:

Add a New Agent Copy Section

1. Fork the repository
2. Create a new agent file in the appropriate category
3. Follow the agent template structure:
   • Frontmatter with name, description, color
   • Identity & Memory section
   • Core Mission
   • Critical Rules (domain-specific)
   • Technical Deliverables with examples
   • Workflow Process
   • Success Metrics
4. Submit a PR with your agent

Improve Existing Agents Copy Section

• Add real-world examples
• Enhance code samples
• Update success metrics
• Improve workflows

Share Your Success Stories Copy Section

Have you used these agents successfully? Share your story in the Discussions!

📖 Agent Design Philosophy Copy Chapter

Each agent is designed with:

1. 🎭 Strong Personality: Not generic templates - real character and voice
2. 📋 Clear Deliverables: Concrete outputs, not vague guidance
3. ✅ Success Metrics: Measurable outcomes and quality standards
4. 🔄 Proven Workflows: Step-by-step processes that work
5. 💡 Learning Memory: Pattern recognition and continuous improvement

🎁 What Makes This Special? Copy Chapter

Unlike Generic AI Prompts: Copy Section

• ❌ Generic "Act as a developer" prompts
• ✅ Deep specialization with personality and process

Unlike Prompt Libraries: Copy Section

• ❌ One-off prompt collections
• ✅ Comprehensive agent systems with workflows and deliverables

Unlike AI Tools: Copy Section

• ❌ Black box tools you can't customize
• ✅ Transparent, forkable, adaptable agent personalities

🎨 Agent Personality Highlights Copy Chapter

"I don't just test your code - I default to finding 3-5 issues and require visual proof for everything."

-- Evidence Collector (Testing Division)

"You're not marketing on Reddit - you're becoming a valued community member who happens to represent a brand."

-- Reddit Community Builder (Marketing Division)

"Every playful element must serve a functional or emotional purpose. Design delight that enhances rather than distracts."

-- Whimsy Injector (Design Division)

"Let me add a celebration animation that reduces task completion anxiety by 40%"

-- Whimsy Injector (during a UX review)

📊 Stats Copy Chapter

• 🎭 230+ Specialized Agents across every division
• 📝 10,000+ lines of personality, process, and code examples
• ⏱️ Months of iteration from real-world usage
• 🌟 Battle-tested in production environments
• 💬 50+ requests in first 12 hours on Reddit

🔌 Multi-Tool Integrations Copy Chapter

The Agency works natively with Claude Code, and ships conversion + install scripts so you can use the same agents across every major agentic coding tool.

Supported Tools Copy Section

• Claude Code — native .md agents, no conversion needed → ~/.claude/agents/
• GitHub Copilot — native .md agents, no conversion needed → ~/.github/agents/ + ~/.copilot/agents/
• Antigravity — SKILL.md per agent → ~/.gemini/config/skills/
• Gemini CLI -- .md agent files -> ~/.gemini/agents/
• OpenCode — .md agent files → .opencode/agents/
• Cursor — .mdc rule files → .cursor/rules/
• Aider — CONVENTIONS.md roster index → ./CONVENTIONS.md
• Windsurf — single .windsurfrules → ./.windsurfrules
• OpenClaw — SOUL.md + AGENTS.md + IDENTITY.md per agent
• Qwen Code — .md SubAgent files → ~/.qwen/agents/
• Kimi Code — YAML agent specs → ~/.config/kimi/agents/
• Codex — TOML custom agents → ~/.codex/agents/
• Osaurus -- SKILL.md skills -> ~/.osaurus/skills/
• Hermes -- lazy-router plugin -> ~/.hermes/plugins/
• DeepSeek Harness — SKILL.md skills → ~/.dsh/skills/ (user) or .dsh/skills/ (project)

⚡ Quick Install Copy Section

Step 1 -- Generate integration files:

./scripts/convert.sh
# Faster (parallel, output order may vary): ./scripts/convert.sh --parallel

Step 2 -- Install (interactive, auto-detects your tools):

./scripts/install.sh
# Faster (parallel, output order may vary): ./scripts/install.sh --no-interactive --parallel

The installer scans your system for installed tools, shows a checkbox UI, and lets you pick exactly what to install:

+------------------------------------------------+
  |   The Agency -- Tool Installer                 |
  +------------------------------------------------+

  System scan: [*] = detected on this machine

  [x]  1)  [*]  Claude Code     (claude.ai/code)
  [x]  2)  [*]  Copilot         (~/.github + ~/.copilot)
  [x]  3)  [*]  Antigravity     (~/.gemini/antigravity)
  [ ]  4)  [ ]  Gemini CLI      (~/.gemini/agents)
  [ ]  5)  [ ]  OpenCode        (opencode.ai)
  [ ]  6)  [ ]  OpenClaw        (~/.openclaw/agency-agents)
  [x]  7)  [*]  Cursor          (.cursor/rules)
  [ ]  8)  [ ]  Aider           (CONVENTIONS.md)
  [ ]  9)  [ ]  Windsurf        (.windsurfrules)
  [ ] 10)  [ ]  Qwen Code       (~/.qwen/agents)
  [ ] 11)  [ ]  Kimi Code       (~/.config/kimi/agents)
  [ ] 12)  [ ]  Codex           (~/.codex/agents)
  [ ] 13)  [ ]  Osaurus         (~/.osaurus/skills)
  [ ] 14)  [ ]  Hermes          (~/.hermes/plugins)

  [1-14] toggle   [a] all   [n] none   [d] detected
  [Enter] install   [q] quit

Or install a specific tool directly:

./scripts/install.sh --tool cursor
./scripts/install.sh --tool opencode
./scripts/install.sh --tool openclaw
./scripts/install.sh --tool antigravity
./scripts/install.sh --tool codex
./scripts/install.sh --tool osaurus
./scripts/install.sh --tool hermes

Non-interactive (CI/scripts):

./scripts/install.sh --no-interactive --tool all

Faster runs (parallel) — On multi-core machines, use --parallel so each tool is processed in parallel. Output order across tools is non-deterministic. Works with both interactive and non-interactive install: e.g. ./scripts/install.sh --interactive --parallel (pick tools, then install in parallel) or ./scripts/install.sh --no-interactive --parallel. Job count defaults to nproc (Linux), sysctl -n hw.ncpu (macOS), or 4; override with --jobs N.

./scripts/convert.sh --parallel                    # convert all tools in parallel
./scripts/convert.sh --parallel --jobs 8           # cap parallel jobs
./scripts/install.sh --no-interactive --parallel   # install all detected tools in parallel
./scripts/install.sh --interactive --parallel      # pick tools, then install in parallel
./scripts/install.sh --no-interactive --parallel --jobs 4

Tool-Specific Instructions Copy Section

Claude Code

Agents are copied directly from the repo into ~/.claude/agents/ -- no conversion needed.

./scripts/install.sh --tool claude-code

Then activate in Claude Code:

Use the Frontend Developer agent to review this component.

See integrations/claude-code/README.md for details.

GitHub Copilot

Agents are copied directly from the repo into ~/.github/agents/ and ~/.copilot/agents/ -- no conversion needed.

./scripts/install.sh --tool copilot

Then activate in GitHub Copilot:

Use the Frontend Developer agent to review this component.

See integrations/github-copilot/README.md for details.

Antigravity (Gemini)

Each agent becomes a skill in ~/.gemini/config/skills/agency-<slug>/.

./scripts/install.sh --tool antigravity

Activate in Gemini with Antigravity:

@agency-frontend-developer review this React component

See integrations/antigravity/README.md for details.

Gemini CLI

Installs as Gemini CLI subagents.
On a fresh clone, generate the Gemini agent files before running the installer.

./scripts/convert.sh --tool gemini-cli
./scripts/install.sh --tool gemini-cli

See integrations/gemini-cli/README.md for details.

OpenCode

Agents are placed in .opencode/agents/ in your project root (project-scoped).

cd /your/project
/path/to/agency-agents/scripts/install.sh --tool opencode

Or install globally:

mkdir -p ~/.config/opencode/agents
cp integrations/opencode/agents/*.md ~/.config/opencode/agents/

Activate in OpenCode:

@backend-architect design this API.

See integrations/opencode/README.md for details.

Cursor

Each agent becomes a .mdc rule file in .cursor/rules/ of your project.

cd /your/project
/path/to/agency-agents/scripts/install.sh --tool cursor

Rules are auto-applied when Cursor detects them in the project. Reference them explicitly:

Use the @security-engineer rules to review this code.

See integrations/cursor/README.md for details.

Aider

CONVENTIONS.md is the roster index — every agent's name, description, and the
path to its full instructions. Aider keeps a conventions file in context for the
whole session, and the full agent bodies together are about a million tokens, so the
file lists the agents rather than inlining them.

cd /your/project
/path/to/agency-agents/scripts/install.sh --tool aider

Then reference agents in your Aider session:

Use the Frontend Developer agent to refactor this component.

When you want an agent's full instructions, read its file in:

/read-only /path/to/agency-agents/engineering/engineering-frontend-developer.md

See integrations/aider/README.md for details.

Windsurf

All agents are compiled into .windsurfrules in your project root.

cd /your/project
/path/to/agency-agents/scripts/install.sh --tool windsurf

Reference agents in Windsurf's Cascade:

Use the Reality Checker agent to verify this is production ready.

See integrations/windsurf/README.md for details.

OpenClaw

Each agent becomes a workspace with SOUL.md, AGENTS.md, and IDENTITY.md in ~/.openclaw/agency-agents/.

./scripts/convert.sh --tool openclaw
./scripts/install.sh --tool openclaw

If the openclaw CLI is available, the installer registers each workspace automatically.
Run openclaw gateway restart after installation so the new agents are activated.

See integrations/openclaw/README.md for details.

Qwen Code

SubAgents are installed to .qwen/agents/ in your project root (project-scoped).

Requires Qwen Code 0.25.1 or later. Earlier releases can't launch agents whose code examples contain ${…} placeholders (#1081).

# Convert and install (run from your project root)
cd /your/project
./scripts/convert.sh --tool qwen
./scripts/install.sh --tool qwen

Usage in Qwen Code:

• Reference by name: Use the frontend-developer agent to review this component
• Or let Qwen auto-delegate based on task context
• Manage via /agents command in interactive mode

📚 Qwen SubAgents Docs

Kimi Code

Agents are converted to Kimi Code CLI format (YAML + system prompt) and installed to ~/.config/kimi/agents/.

# Convert and install
./scripts/convert.sh --tool kimi
./scripts/install.sh --tool kimi

Usage with Kimi Code:

# Use an agent
kimi --agent-file ~/.config/kimi/agents/frontend-developer/agent.yaml

# In a project
kimi --agent-file ~/.config/kimi/agents/frontend-developer/agent.yaml \
     --work-dir /your/project \
     "Review this React component"

See integrations/kimi/README.md for details.

Codex

Each agent is converted into a Codex custom agent TOML file and installed to ~/.codex/agents/.

./scripts/convert.sh --tool codex
./scripts/install.sh --tool codex

Then reference the custom agent by name in Codex:

Use the Frontend Developer agent to review this component.

See integrations/codex/README.md for details.

DeepSeek Harness

Each agent becomes a DSH skill (SKILL.md with Agent-Skills frontmatter) in ${DSH_HOME:-$HOME/.dsh}/skills/agency-<slug>/. Skills are discovered live — no restart needed.

./scripts/convert.sh --tool dsh
./scripts/install.sh --tool dsh

Custom user home:

DSH_HOME=~/.config/dsh ./scripts/install.sh --tool dsh

Project-scoped install (run from your project root):

DSH_SKILLS_DIR=.dsh/skills ./scripts/install.sh --tool dsh

Activate in DeepSeek Harness — user- and model-invocable by default:

/agency-frontend-developer review this React component

See integrations/dsh/README.md for details.

Regenerating After Changes Copy Section

When you add new agents or edit existing ones, regenerate all integration files:

./scripts/convert.sh                    # regenerate all (serial)
./scripts/convert.sh --parallel         # regenerate all in parallel (faster)
./scripts/convert.sh --tool codex       # regenerate just one tool
./scripts/convert.sh --tool cursor      # regenerate just one tool

🗺️ Roadmap Copy Chapter

• Interactive agent selector web tool
• Multi-agent workflow examples -- see examples/
• Multi-tool integration scripts (Claude Code, GitHub Copilot, Antigravity, Gemini CLI, OpenCode, OpenClaw, Cursor, Aider, Windsurf, Qwen Code, Kimi Code, Codex, Osaurus, Hermes)
• Video tutorials on agent design
• Community agent marketplace
• Agent "personality quiz" for project matching
• "Agent of the Week" showcase series

🌐 Community Translations & Localizations Copy Chapter

Community-maintained translations and regional adaptations. These are independently maintained -- see each repo for coverage and version compatibility.

Want to add a translation? Open an issue and we'll link it here.

📜 License Copy Chapter

MIT License - Use freely, commercially or personally. Attribution appreciated but not required.

🙏 Acknowledgments Copy Chapter

What started as a Reddit thread about AI agent specialization has grown into something remarkable — 230+ agents across every division, supported by a community of contributors from around the world. Every agent in this repo exists because someone cared enough to write it, test it, and share it.

To everyone who has opened a PR, filed an issue, started a Discussion, or simply tried an agent and told us what worked — thank you. You're the reason The Agency keeps getting better.

💬 Community Copy Chapter

• GitHub Discussions: Share your success stories
• Issues: Report bugs or request features
• Reddit: Join the conversation on r/ClaudeAI
• Twitter/X: Share with #TheAgency

🚀 Get Started Copy Chapter

1. Browse the agents above and find specialists for your needs
2. Copy the agents to ~/.claude/agents/ for Claude Code integration
3. Activate agents by referencing them in your Claude conversations
4. Customize agent personalities and workflows for your specific needs
5. Share your results and contribute back to the community

Overview (`examples/README.md`) Copy Section

Examples

This directory contains example outputs demonstrating how the agency's agents can be orchestrated together to tackle real-world tasks.

Why This Exists Copy Chapter

The agency-agents repo defines dozens of specialized agents across engineering, design, marketing, product, support, spatial computing, and project management. But agent definitions alone don't show what happens when you deploy them all at once on a single mission.

These examples answer the question: "What does it actually look like when the full agency collaborates?"

Contents Copy Chapter

[nexus-spatial-discovery.md](./nexus-spatial-discovery.md) Copy Section

What: A complete product discovery exercise where 8 agents worked in parallel to evaluate a software opportunity and produce a unified plan.

The scenario: Web research identified an opportunity at the intersection of AI agent orchestration and spatial computing. The entire agency was then deployed simultaneously to produce:

• Market validation and competitive analysis
• Technical architecture (8-service system design with full SQL schema)
• Brand strategy and visual identity
• Go-to-market and growth plan
• Customer support operations blueprint
• UX research plan with personas and journey maps
• 35-week project execution plan with 65 sprint tickets
• Spatial interface architecture specification

Agents used:

Key takeaway: All 8 agents ran in parallel and produced coherent, cross-referencing plans without coordination overhead. The output demonstrates the agency's ability to go from "find an opportunity" to "here's the full blueprint" in a single session.

Adding New Examples Copy Chapter

If you run an interesting multi-agent exercise, consider adding it here. Good examples show:

• Multiple agents collaborating on a shared objective
• The breadth of the agency's capabilities
• Real-world applicability of the agent definitions

Overview (`integrations/README.md`) Copy Section

🔌 Integrations

This directory contains The Agency integrations and converted formats for
supported agentic coding tools.

Supported Tools Copy Chapter

• Claude Code — .md agents, use the repo directly
• GitHub Copilot — .md agents, use the repo directly
• Antigravity — SKILL.md per agent in antigravity/
• Gemini CLI — .md agent files in gemini-cli/agents/
• OpenCode — .md agent files in opencode/
• OpenClaw — SOUL.md + AGENTS.md + IDENTITY.md workspaces
• Cursor — .mdc rule files in cursor/
• Aider — CONVENTIONS.md roster index in aider/
• Windsurf — .windsurfrules in windsurf/
• Kimi Code — YAML agent specs in kimi/
• Qwen Code — project-scoped .md SubAgents in .qwen/agents/
• Codex — .toml custom agents in codex/
• Mistral Vibe — .toml agents + prompt files generated in vibe/
• Osaurus -- SKILL.md skills generated in osaurus/
• Hermes -- lazy-router plugin generated in hermes/

Quick Install Copy Chapter

# Install for all detected tools automatically
./scripts/install.sh

# Install a specific home-scoped tool
./scripts/install.sh --tool antigravity
./scripts/install.sh --tool copilot
./scripts/install.sh --tool openclaw
./scripts/install.sh --tool claude-code
./scripts/install.sh --tool codex
./scripts/install.sh --tool osaurus
./scripts/install.sh --tool hermes

# Gemini CLI needs generated integration files on a fresh clone
./scripts/convert.sh --tool gemini-cli
./scripts/install.sh --tool gemini-cli

# Qwen Code also needs generated SubAgent files on a fresh clone
./scripts/convert.sh --tool qwen
./scripts/install.sh --tool qwen

If you install OpenClaw and the gateway is already running, restart it after installation:

openclaw gateway restart

For project-scoped tools such as OpenCode, Cursor, Aider, Windsurf, and Qwen
Code, run
the installer from your target project root as shown in the tool-specific
sections below.

Regenerating Integration Files Copy Chapter

If you add or modify agents, regenerate all integration files:

./scripts/convert.sh

Claude Code Copy Chapter

The Agency was originally designed for Claude Code. Agents work natively
without conversion.

cp -r <category>/*.md ~/.claude/agents/
# or install everything at once:
./scripts/install.sh --tool claude-code

See claude-code/README.md for details.

GitHub Copilot Copy Chapter

The Agency also works natively with GitHub Copilot. Agents can be copied
directly into ~/.github/agents/ and ~/.copilot/agents/ without conversion.

./scripts/install.sh --tool copilot

See github-copilot/README.md for details.

Antigravity Copy Chapter

Skills are installed to ~/.gemini/config/skills/. Each agent becomes
a separate skill prefixed with agency- to avoid naming conflicts.

./scripts/install.sh --tool antigravity

See antigravity/README.md for details.

Gemini CLI Copy Chapter

Agents are packaged as Gemini CLI subagents.
Subagents are installed to ~/.gemini/agents/.
Because the agent files are generated artifacts, run
./scripts/convert.sh --tool gemini-cli before installing from a fresh clone.

./scripts/convert.sh --tool gemini-cli
./scripts/install.sh --tool gemini-cli

See gemini-cli/README.md for details.

OpenCode Copy Chapter

Each agent becomes a project-scoped .md file in .opencode/agents/.

cd /your/project && /path/to/agency-agents/scripts/install.sh --tool opencode

See opencode/README.md for details.

OpenClaw Copy Chapter

Each agent becomes an OpenClaw workspace containing SOUL.md, AGENTS.md,
and IDENTITY.md.

Before installing, generate the OpenClaw workspaces:

./scripts/convert.sh --tool openclaw

Then install them:

./scripts/install.sh --tool openclaw

See openclaw/README.md for details.

Cursor Copy Chapter

Each agent becomes a .mdc rule file. Rules are project-scoped — run the
installer from your project root.

cd /your/project && /path/to/agency-agents/scripts/install.sh --tool cursor

See cursor/README.md for details.

Aider Copy Chapter

CONVENTIONS.md is the roster index — name, description, and the path to each
agent's full instructions. Aider keeps a conventions file in context for the
whole session, so the file lists the agents instead of inlining a million
tokens of them.

cd /your/project && /path/to/agency-agents/scripts/install.sh --tool aider

See aider/README.md for details.

Windsurf Copy Chapter

All agents are consolidated into a single .windsurfrules file for your
project root.

cd /your/project && /path/to/agency-agents/scripts/install.sh --tool windsurf

See windsurf/README.md for details.

Kimi Code Copy Chapter

Each agent is converted to a Kimi Code CLI agent specification (YAML format with
separate system prompt files). Agents are installed to ~/.config/kimi/agents/.

Because the Kimi agent files are generated from the source Markdown, run
./scripts/convert.sh --tool kimi before installing from a fresh clone.

./scripts/convert.sh --tool kimi
./scripts/install.sh --tool kimi

Usage Copy Section

After installation, use an agent with the --agent-file flag:

kimi --agent-file ~/.config/kimi/agents/frontend-developer/agent.yaml

Or in a specific project:

cd /your/project
kimi --agent-file ~/.config/kimi/agents/frontend-developer/agent.yaml \
     --work-dir /your/project

See kimi/README.md for details.

Qwen Code Copy Chapter

Each agent becomes a project-scoped .md SubAgent file in .qwen/agents/.

From a fresh clone, generate the Qwen files first:

./scripts/convert.sh --tool qwen

Then install them from your project root:

cd /your/project && /path/to/agency-agents/scripts/install.sh --tool qwen

See qwen/README.md for details.

Codex Copy Chapter

Each agent is converted into a standalone Codex custom agent TOML file and
installed to ~/.codex/agents/.

Because Codex uses generated TOML files rather than the source Markdown
directly, run the converter before installing from a fresh clone:

./scripts/convert.sh --tool codex
./scripts/install.sh --tool codex

See codex/README.md for details.

Overview (`integrations/aider/README.md`) Copy Section

Aider Integration

CONVENTIONS.md is the roster index: every agent's name, what it is for, its
division, and the path to its full instructions.

Why an index and not the agents Copy Chapter

Aider keeps a conventions file in context for the whole session — that is the
point of the file. The 279 agent bodies together are about 3.8 million
characters, roughly a million tokens, so a conventions file holding all of them
does not fit in any model and costs a fortune in the attempt.

The index is about 97,000 characters (~24k tokens). Load it read-only so aider
marks it cacheable, and pull in a single agent's full instructions when you
actually need them.

Install Copy Chapter

# Run from your project root
cd /your/project
/path/to/agency-agents/scripts/install.sh --tool aider

Use an agent Copy Chapter

Naming the agent is usually enough — its description is already in context:

Use the Frontend Developer agent to refactor this component.

When you want the agent's full instructions, read its file into the session.
The index gives you the path:

/read-only /path/to/agency-agents/engineering/engineering-frontend-developer.md

Manual usage Copy Chapter

aider --read CONVENTIONS.md

--read marks the file read-only and lets aider cache it when prompt caching
is enabled, so the index is not re-sent on every turn.

Regenerate Copy Chapter

./scripts/convert.sh --tool aider

Overview (`integrations/antigravity/README.md`) Copy Section

Antigravity Integration

Installs the full Agency roster as Antigravity skills. Each agent is prefixed
with agency- to avoid conflicts with existing skills.

Install Copy Chapter

./scripts/install.sh --tool antigravity

This copies files from integrations/antigravity/ to
~/.gemini/config/skills/ (global). For project-scoped skills, Antigravity
also reads /.agents/skills/.

Activate a Skill Copy Chapter

In Antigravity, activate an agent by its slug:

Use the agency-frontend-developer skill to review this component.

Available slugs follow the pattern agency-<agent-name>, e.g.:

• agency-frontend-developer
• agency-backend-architect
• agency-reality-checker
• agency-growth-hacker

Regenerate Copy Chapter

After modifying agents, regenerate the skill files:

./scripts/convert.sh --tool antigravity

File Format Copy Chapter

Each skill is a SKILL.md file with Antigravity-compatible frontmatter:

---
name: agency-frontend-developer
description: Expert frontend developer specializing in...
risk: low
source: community
date_added: '2026-03-08'
---

Overview (`integrations/claude-code/README.md`) Copy Section

Claude Code Integration

The Agency was built for Claude Code. No conversion needed — agents work
natively with the existing .md + YAML frontmatter format.

Install Copy Chapter

# Copy all agents to your Claude Code agents directory
./scripts/install.sh --tool claude-code

# Or manually copy a category
cp engineering/*.md ~/.claude/agents/

Activate an Agent Copy Chapter

In any Claude Code session, reference an agent by name:

Activate Frontend Developer and help me build a React component.

Use the Reality Checker agent to verify this feature is production-ready.

Agent Directory Copy Chapter

Agents are organized into divisions. See the main README for
the full Agency roster.

Overview (`integrations/codex/README.md`) Copy Section

Codex Integration

Converts all Agency agents into Codex custom agent TOML files. Each source
agent becomes one standalone .toml file containing the minimal Codex-required
fields: name, description, and developer_instructions.

Installation Copy Chapter

Prerequisites Copy Section

• Codex installed

Convert And Install Copy Section

# Generate integration files (required on fresh clone)
./scripts/convert.sh --tool codex

# Install agents
./scripts/install.sh --tool codex

This copies generated agent files to ~/.codex/agents/.

Generated Format Copy Chapter

Each generated file lives in:

integrations/codex/agents/<slug>.toml

The mapping is intentionally minimal:

• name is copied from the source frontmatter unchanged
• description is copied from the source frontmatter unchanged
• developer_instructions contains the full Markdown body unchanged

Source-only metadata such as color, emoji, vibe, and other unsupported
frontmatter fields are omitted.

Usage Copy Chapter

After installation, reference the custom agent by name in Codex:

Use the Frontend Developer agent to review this component.

Codex uses the name field inside the TOML file as the source of truth, so the
generated filename slug is only for filesystem safety.

Regenerate Copy Chapter

After modifying source agents:

./scripts/convert.sh --tool codex
./scripts/install.sh --tool codex

Troubleshooting Copy Chapter

Codex integration not found Copy Section

Generate the Codex artifacts before installing:

./scripts/convert.sh --tool codex

Codex not detected Copy Section

Make sure codex is in your PATH, or that ~/.codex/ already exists:

which codex
codex --help

Overview (`integrations/cursor/README.md`) Copy Section

Cursor Integration

Converts the full Agency roster into Cursor .mdc rule files. Rules are
project-scoped — install them from your project root.

Install Copy Chapter

# Run from your project root
cd /your/project
/path/to/agency-agents/scripts/install.sh --tool cursor

This creates .cursor/rules/<agent-slug>.mdc files in your project.

Activate a Rule Copy Chapter

In Cursor, reference an agent in your prompt:

@frontend-developer Review this React component for performance issues.

Or enable a rule as always-on by editing its frontmatter:

---
description: Expert frontend developer...
globs: "**/*.tsx,**/*.ts"
alwaysApply: true
---

Regenerate Copy Chapter

./scripts/convert.sh --tool cursor

Overview (`integrations/dsh/README.md`) Copy Section

DeepSeek Harness Integration

Installs the full Agency roster as DeepSeek Harness (DSH) skills. Each agent
is prefixed with agency- to avoid conflicts with built-in skills.

Install Copy Chapter

./scripts/install.sh --tool dsh

This copies files from integrations/dsh/ to ${DSH_HOME:-$HOME/.dsh}/skills/
(user-wide). Set DSH_HOME if your Harness config lives elsewhere. For
project-scoped skills, run the installer with DSH_SKILLS_DIR=.dsh/skills
from your project root — this specific override takes precedence over
DSH_HOME, and DSH reads /.dsh/skills/ automatically.

DSH discovers skills live (watched roots): new, renamed, or deleted skills
reach the next catalog without a restart. No config file to edit.

Activate a Skill Copy Chapter

In DSH, skills are user- and model-invocable by default. Activate an agent
by its slash command or by name in conversation:

/agency-frontend-developer review this React component

or:

Use the agency-frontend-developer skill to review this component.

Available slugs follow the pattern agency-<agent-name>, e.g.:

• agency-frontend-developer
• agency-backend-architect
• agency-reality-checker
• agency-growth-hacker

Regenerate Copy Chapter

After modifying agents, regenerate the skill files:

./scripts/convert.sh --tool dsh

File Format Copy Chapter

Each skill is a SKILL.md file with the standard Agent-Skills frontmatter
(required name and description, strict kebab-case name) and the agent
persona as the body:

---
name: 'agency-frontend-developer'
description: 'Expert frontend developer specializing in modern web technologies, React/Vue/Angular frameworks, UI implementation, and performance optimization'
---
...agent body...

This is byte-identical to the Antigravity and Osaurus skill output
(skill-md format), so the Agency Agents app renders it natively.

Skill Roots Scanned by DSH Copy Chapter

Project skills (rank 100/200) shadow user skills (rank 400/500) of the same
name, so a project install overrides the user-wide one for that project.

Overview (`integrations/gemini-cli/README.md`) Copy Section

Gemini CLI Integration

Packages all Agency agents as Gemini CLI subagents. These agents
install to ~/.gemini/agents/.

Install Copy Chapter

# Generate the Gemini CLI agent files first
./scripts/convert.sh --tool gemini-cli

# Then install them to ~/.gemini/agents/
./scripts/install.sh --tool gemini-cli

Use an Agent Copy Chapter

In Gemini CLI, reference an agent by name in your prompt:

Use the frontend-developer agent to help me build this UI.

Or invoke the agent directly if your version of Gemini CLI supports it:

gemini --agent frontend-developer "How should I structure this React component?"

Structure Copy Chapter

~/.gemini/agents/
  frontend-developer.md
  backend-architect.md
  reality-checker.md
  ...

Regenerate Copy Chapter

./scripts/convert.sh --tool gemini-cli

Overview (`integrations/github-copilot/README.md`) Copy Section

GitHub Copilot Integration

The Agency works with GitHub Copilot out of the box. No conversion needed —
agents use the existing .md + YAML frontmatter format.

Install Copy Chapter

# Copy all agents to your GitHub Copilot agents directories
./scripts/install.sh --tool copilot

# Or manually copy a category
cp engineering/*.md ~/.github/agents/
cp engineering/*.md ~/.copilot/agents/

Activate an Agent Copy Chapter

In any GitHub Copilot session, reference an agent by name:

Activate Frontend Developer and help me build a React component.

Use the Reality Checker agent to verify this feature is production-ready.

Agent Directory Copy Chapter

Agents are organized into divisions. See the main README for
the full current roster.

Overview (`integrations/hermes/README.md`) Copy Section

Hermes Agency Agents Router Plugin

Generated by scripts/convert.sh --tool hermes.

This integration installs one Hermes plugin named agency-agents-router instead
of adding hundreds of generated skills to skills.external_dirs. Hermes sees a
small fixed tool surface at startup, while the complete Agency roster is
stored on disk in data/agents.json and searched/loaded lazily.

Generated agent count: 282

Tools exposed to Hermes Copy Chapter

• agency_agents_search — find matching specialists by query/division.
• agency_agents_inspect — inspect one specialist's metadata or full body.
• agency_agents_load — compose one specialist prompt for the current task.
• agency_agents_delegate — delegate through Hermes' public subagent lifecycle.

Each tool is registered with Hermes' complete function-tool schema, including
its name, description, and JSON parameters. The available arguments are:

A normal flow is: search by capability, take a returned slug, then inspect,
load, or delegate to that specialist. You can ask Hermes to do this in natural
language; direct tool calls are not required.

Specialist usage instruction for Hermes Copy Chapter

When a Hermes project needs Agency specialists, explicitly ask Hermes to use
the agency-agents-router plugin/router and load only the specialists needed for
the current phase. Do not ask Hermes to install or preload the full Agency
roster as skills.

Recommended project instruction:

Use the agency-agents-router plugin. Search the Agency roster for the right
specialists, then load or delegate only the specific agents needed for each
part of the project. For multi-discipline projects, use multiple selected
specialists across the project, but keep routing lazy: do not preload the
full Agency roster and do not add agency-agents to skills.external_dirs.

Example:

For this Data Swami build, use the agency-agents-router plugin to pick
relevant Agency specialists. Search first, then delegate to selected agents
such as frontend, backend, UX, QA, data engineering, and product strategy as
needed. Load/delegate each specialist on demand rather than loading all
Agency agents at startup.

Install Copy Chapter

./scripts/convert.sh --tool hermes
./scripts/install.sh --tool hermes

The installer copies the generated plugin to:

${HERMES_HOME:-~/.hermes}/plugins/agency-agents-router

It then enables agency-agents-router under plugins.enabled in the Hermes
config. It does not write to skills.external_dirs.

Restart Hermes or start a new session after installing so the plugin and its
tool schemas are loaded. If Hermes displays these tools without their documented
arguments, regenerate and reinstall the plugin from the latest Agency Agents
checkout, then restart Hermes.

Overview (`integrations/kimi/README.md`) Copy Section

Kimi Code CLI Integration

Converts all Agency agents into Kimi Code CLI agent specifications. Each agent
becomes a directory containing agent.yaml (agent spec) and system.md (system
prompt).

Installation Copy Chapter

Prerequisites Copy Section

• Kimi Code CLI installed

Install Copy Section

# Generate integration files (required on fresh clone)
./scripts/convert.sh --tool kimi

# Install agents
./scripts/install.sh --tool kimi

This copies agents to ~/.config/kimi/agents/.

Usage Copy Chapter

Activate an Agent Copy Section

Use the --agent-file flag to load a specific agent:

kimi --agent-file ~/.config/kimi/agents/frontend-developer/agent.yaml

In a Project Copy Section

cd /your/project
kimi --agent-file ~/.config/kimi/agents/frontend-developer/agent.yaml \
     --work-dir /your/project \
     "Review this React component for performance issues"

List Installed Agents Copy Section

ls ~/.config/kimi/agents/

Agent Structure Copy Chapter

Each agent directory contains:

~/.config/kimi/agents/frontend-developer/
├── agent.yaml    # Agent specification (tools, subagents)
└── system.md     # System prompt with personality and instructions

agent.yaml format Copy Section

version: 1
agent:
  name: frontend-developer
  extend: default  # Inherits from Kimi's built-in default agent
  system_prompt_path: ./system.md
  tools:
    - "kimi_cli.tools.shell:Shell"
    - "kimi_cli.tools.file:ReadFile"
    # ... all default tools

Regenerate Copy Chapter

After modifying source agents:

./scripts/convert.sh --tool kimi
./scripts/install.sh --tool kimi

Troubleshooting Copy Chapter

Agent file not found Copy Section

Ensure you've run convert.sh before install.sh:

./scripts/convert.sh --tool kimi

Kimi CLI not detected Copy Section

Make sure kimi is in your PATH:

which kimi
kimi --version

Invalid YAML Copy Section

Validate the generated files:

python3 -c "import yaml; yaml.safe_load(open('integrations/kimi/frontend-developer/agent.yaml'))"

Overview (`integrations/mcp-memory/README.md`) Copy Section

MCP Memory Integration

Give any agent persistent memory across sessions using the Model Context Protocol (MCP).

What It Does Copy Chapter

By default, agents in The Agency start every session from scratch. Context is passed manually via copy-paste between agents and sessions. An MCP memory server changes that:

• Cross-session memory: An agent remembers decisions, deliverables, and context from previous sessions
• Handoff continuity: When one agent hands off to another, the receiving agent can recall exactly what was done — no copy-paste required
• Rollback on failure: When a QA check fails or an architecture decision turns out wrong, roll back to a known-good state instead of starting over

Setup Copy Chapter

You need an MCP server that provides memory tools: remember, recall, rollback, and search. Add it to your MCP client config (Claude Code, Cursor, etc.):

{
  "mcpServers": {
    "memory": {
      "command": "your-mcp-memory-server",
      "args": []
    }
  }
}

Any MCP server that exposes remember, recall, rollback, and search tools will work. Check the MCP ecosystem for available implementations.

How to Add Memory to Any Agent Copy Chapter

To enhance an existing agent with persistent memory, add a Memory Integration section to the agent's prompt. This section instructs the agent to use MCP memory tools at key moments.

The Pattern Copy Section

## Memory Integration

When you start a session:
- Recall relevant context from previous sessions using your role and the current project as search terms
- Review any memories tagged with your agent name to pick up where you left off

When you make key decisions or complete deliverables:
- Remember the decision or deliverable with descriptive tags (your agent name, the project, the topic)
- Include enough context that a future session — or a different agent — can understand what was done and why

When handing off to another agent:
- Remember your deliverables tagged for the receiving agent
- Include the handoff metadata: what you completed, what's pending, and what the next agent needs to know

When something fails and you need to recover:
- Search for the last known-good state
- Use rollback to restore to that point rather than rebuilding from scratch

What the Agent Does With This Copy Section

The LLM will use MCP memory tools automatically when given these instructions:

• remember — store a decision, deliverable, or context snapshot with tags
• recall — search for relevant memories by keyword, tag, or semantic similarity
• rollback — revert to a previous state when something goes wrong
• search — find specific memories across sessions and agents

No code changes to the agent files. No API calls to write. The MCP tools handle everything.

Example: Enhancing the Backend Architect Copy Chapter

See backend-architect-with-memory.md for a complete example — the standard Backend Architect agent with a Memory Integration section added.

Example: Memory-Powered Workflow Copy Chapter

See ../../examples/workflow-with-memory.md for the Startup MVP workflow enhanced with persistent memory, showing how agents pass context through memory instead of copy-paste.

Tips Copy Chapter

• Tag consistently: Use the agent name and project name as tags on every memory. This makes recall reliable.
• Let the LLM decide what's important: The memory instructions are guidance, not rigid rules. The LLM will figure out when to remember and what to recall.
• Rollback is the killer feature: When a Reality Checker fails a deliverable, the original agent can roll back to its last checkpoint instead of trying to manually undo changes.

Overview (`integrations/openclaw/README.md`) Copy Section

OpenClaw Integration

OpenClaw agents are installed as workspaces containing SOUL.md, AGENTS.md,
and IDENTITY.md files. The installer copies each workspace into
~/.openclaw/agency-agents/ and registers it when the openclaw CLI is
available.

Before installing, generate the OpenClaw workspaces:

./scripts/convert.sh --tool openclaw

Install Copy Chapter

./scripts/install.sh --tool openclaw

Activate an Agent Copy Chapter

After installation, agents are available by agentId in OpenClaw sessions.

If the OpenClaw gateway is already running, restart it after installation:

openclaw gateway restart

Regenerate Copy Chapter

./scripts/convert.sh --tool openclaw

Overview (`integrations/opencode/README.md`) Copy Section

OpenCode Integration

❌ Don't do this:

bash Copy

# WRONG — will fail with schema validation errors
cp agency-agents/engineering/*.md .opencode/agents/

✅ Do this instead:

bash Copy

/path/to/agency-agents/scripts/install.sh --tool opencode

The source files use named colors and a tools field that OpenCode rejects.
The installer converts them to #RRGGBB hex and strips incompatible fields
automatically.

OpenCode agents are .md files with YAML frontmatter stored in
.opencode/agents/. The converter maps named colors to hex codes and adds
mode: subagent so agents are invoked on-demand via @agent-name rather
than cluttering the primary agent picker.

Install Copy Chapter

# Run from your project root
cd /your/project
/path/to/agency-agents/scripts/install.sh --tool opencode

This creates .opencode/agents/<slug>.md files in your project directory.

Activate an Agent Copy Chapter

In OpenCode, invoke a subagent with the @ prefix:

@frontend-developer help build this component.

@reality-checker review this PR.

You can also select agents from the OpenCode UI's agent picker.

Agent Format Copy Chapter

Each generated agent file contains:

---
name: Frontend Developer
description: Expert frontend developer specializing in modern web technologies...
mode: subagent
color: "#00FFFF"
---

• mode: subagent — agent is available on-demand, not shown in the primary Tab-cycle list
• color — hex code (named colors from source files are converted automatically)

Project vs Global Copy Chapter

Agents in .opencode/agents/ are project-scoped. To make them available
globally across all projects, first generate the agent files, then install
with --path:

./scripts/convert.sh --tool opencode
./scripts/install.sh --tool opencode --path ~/.config/opencode/agents

Regenerate Copy Chapter

./scripts/convert.sh --tool opencode

Overview (`integrations/qwen/README.md`) Copy Section

Qwen Code Integration

Qwen Code uses project-scoped .md SubAgent files in .qwen/agents/.

The generated files come from scripts/convert.sh --tool qwen, which writes one
SubAgent Markdown file per agency agent into integrations/qwen/agents/.

Requirements Copy Chapter

Qwen Code 0.25.1 or later. Earlier releases treat every ${name} in a
SubAgent's prompt as a value to fill and refuse to launch the agent when they
have none ("Missing context values for the following keys: …"). Several agents
show ${name} in their code examples, so on those releases they can't be
launched. From 0.25.1, Qwen leaves any ${name} it doesn't fill as written
(#1081).

Qwen does fill three names: ${task_prompt}, ${hook_context} and
${external_inputs_override}. scripts/lint-agents.sh rejects them in agent
bodies, so no agent text is replaced at launch.

Generate Copy Chapter

From the repository root:

./scripts/convert.sh --tool qwen

Install Copy Chapter

Run the installer from your target project root:

cd /your/project && /path/to/agency-agents/scripts/install.sh --tool qwen

This copies the generated SubAgent files into:

.qwen/agents/

Refresh in Qwen Code Copy Chapter

After installation:

• run /agents manage in Qwen Code to refresh the agent list, or
• restart the current Qwen Code session

Notes Copy Chapter

• Qwen Code is project-scoped, not home-scoped
• The generated Qwen files use minimal frontmatter: name, description, and
  optional tools
• If you update agents in this repo, regenerate the Qwen output before
  reinstalling

Overview (`integrations/vibe/README.md`) Copy Section

Mistral Vibe Integration

Mistral Vibe uses two files per agent:

• A TOML configuration file (~/.vibe/agents/<slug>.toml)
• A Markdown prompt file (~/.vibe/prompts/<slug>.md)

The generated files come from scripts/convert.sh --tool vibe, which writes
one TOML agent configuration and one Markdown prompt file per agency agent
into integrations/vibe/agents/ and integrations/vibe/prompts/ respectively.

Generate Copy Chapter

From the repository root:

./scripts/convert.sh --tool vibe

Install Copy Chapter

Run the installer from your target directory:

cd /your/project && /path/to/agency-agents/scripts/install.sh --tool vibe

This copies the generated files into:

~/.vibe/agents/<slug>.toml
~/.vibe/prompts/<slug>.md

You can override the destination using the VIBE_HOME environment variable:

VIBE_HOME=~/.config/vibe ./scripts/install.sh --tool vibe

Generated Format Copy Chapter

Each generated agent pair lives in:

integrations/vibe/agents/<slug>.toml
integrations/vibe/prompts/<slug>.md

Agent TOML File Copy Section

The minimal Vibe agent configuration:

agent_type = "agent"
system_prompt_id = "<slug>"

Users can specify active_model in their agent TOML files or rely on their
Vibe configuration default model.

Prompt Markdown File Copy Section

The prompt file contains:

• A title header with the agent name
• The agent description
• The full Markdown body from the source agent

Usage Copy Chapter

After installation, reference agents in Mistral Vibe by their system prompt ID
(which matches the filename slug).

Example:

Use the Code Reviewer agent to analyze this pull request.

Filtering Copy Chapter

Install only specific divisions or agents:

# Install only agents from Division 1
./scripts/install.sh --tool vibe --division 1

# Install only the code-reviewer agent
./scripts/install.sh --tool vibe --agent code-reviewer

Regenerate Copy Chapter

After modifying source agents:

./scripts/convert.sh --tool vibe
./scripts/install.sh --tool vibe

Troubleshooting Copy Chapter

Mistral Vibe not detected Copy Section

Make sure vibe is in your PATH, or that ~/.vibe/ already exists:

which vibe
vibe --version

Integration files not generated Copy Section

Generate the Vibe artifacts before installing:

./scripts/convert.sh --tool vibe

Overview (`integrations/windsurf/README.md`) Copy Section

Windsurf Integration

The full Agency roster is consolidated into a single .windsurfrules file.
Rules are project-scoped — install them from your project root.

Install Copy Chapter

# Run from your project root
cd /your/project
/path/to/agency-agents/scripts/install.sh --tool windsurf

Activate an Agent Copy Chapter

In Windsurf, reference an agent by name in your prompt:

Use the Frontend Developer agent to build this component.

Regenerate Copy Chapter

./scripts/convert.sh --tool windsurf

Overview (`integrations/zcode/README.md`) Copy Section

ZCode Integration

ZCode is Z.ai's GLM-based coding agent harness. Each agency
agent is rendered as a standalone Markdown agent file with name and
description frontmatter, which ZCode discovers from its agents directory.

The generated files come from scripts/convert.sh --tool zcode, which writes
one Markdown file per agency agent into integrations/zcode/agents/. Those
generated files are not committed (see .gitignore); regenerate them locally.

Generate Copy Chapter

From the repository root:

./scripts/convert.sh --tool zcode

Install Copy Chapter

Run the installer from your target directory:

cd /your/project && /path/to/agency-agents/scripts/install.sh --tool zcode

Agents install to ~/.zcode/agents/<slug>.md (user scope) — the directory
ZCode reads subagents from. Use --division / --agent to install a subset,
or set ZCODE_AGENTS_DIR to override the destination.

--- METRICS ---

• Files Extracted: 20
• Estimated Token Budget: ~30349 tokens
• Canonical Reference: https://codewiki.google/github.com/msitarzewski/agency-agents