A complete organizational structure for running a software house using AI agents. Each agent has a single, clear responsibility with defined inputs, outputs, and boundaries.

• One agent = one repeatable job
• If work piles up → create a new agent
• If a process repeats 3x → create a playbook
• Strict boundaries prevent chaos

This is not a general-purpose AI assistant. It's a structured organization where every role has clear ownership.

1. Clone this repo
2. Pick a playbook for what you're trying to do (e.g., playbooks/product-launch.md)
3. Follow the pipeline, invoking each agent in sequence
4. Each agent file tells you exactly what inputs it needs and what outputs it produces

├── client-management/    # Client relationships and scope
├── design/               # UX research and UI design
├── engineering/          # Build and ship code
├── legal/                # Contracts, IP, NDAs
├── marketing/            # Growth and content
├── operations/           # Finance, support, knowledge
├── playbooks/            # End-to-end workflows
├── product/              # Requirements and prioritization
├── project-management/   # Delivery and coordination
├── sales/                # Lead gen to close
├── security/             # Protection and compliance
└── testing/              # QA and bug management

See AGENTS.md for the complete index with descriptions.

Every agent follows this structure:

# Agent Name

## Outcome
A clear, verifiable result this agent produces.

## Inputs
- What the agent receives
- In what format

## Steps
1. Explicit operational steps
2. No creativity outside the role
3. No decisions outside authority

## Outputs
- Final deliverables
- Ready for other agents to consume

## Boundaries
- ✅ What this agent does
- ❌ What this agent does NOT do (and who owns it)

Feed the relevant agent file(s) into your AI tool as context. The agent definition provides:

• Clear scope (what to do)
• Guardrails (what not to do)
• Expected output format

Use these definitions to:

• Clarify role responsibilities
• Onboard new team members
• Identify gaps in your organization
• Create job descriptions

Chain agents using playbooks:

product-manager (requirements)
→ estimator (effort)
→ sprint-planner (scope)
→ engineering (build)
→ qa-tester (validate)
→ infrastructure-maintainer (deploy)

1. Identify a pile of work with no clear owner
2. Create a file in the appropriate department
3. Follow the standard format
4. Define boundaries clearly (especially what the agent does NOT do)

1. Notice a multi-step process you repeat
2. Map the pipeline (which agents, in what order)
3. Add checkpoints and templates
4. Include decision criteria

If an agent isn't being used:

1. Check if another agent absorbed its work
2. If yes, update that agent's boundaries
3. Delete the unused agent file

1. Single Responsibility: One agent, one outcome
2. Clear Boundaries: Every agent knows what it does NOT do
3. Explicit Handoffs: Outputs from one agent are inputs to another
4. No Heroics: If an agent can't do something, it routes to the right owner
5. Documentation as Code: Agent definitions are the source of truth

☕ Buy me a coffee if this helped

See CONTRIBUTING.md for guidelines.

Apache 2.0 - see LICENSE