# Building an AI Software Dev Team with OpenClaw

> How I set up 10 specialized AI agents as a full software development team — with Discord, Mission Control, and smart API routing. This is just general overview and plan idea. Source code and Prompts not included.

* * *

## The Idea

I wanted a real AI dev team, not just a single chatbot. Something that mirrors how an actual small dev team works — a PM, an architect, frontend, backend, QA, DevOps, security, code reviewer, doc writer, and a scrum master. Each agent with its own role, personality, and tools.

The stack I landed on:

*   **OpenClaw** — always-on agent runtime (runs Claude Code under the hood)
    
*   **Discord** — the team's communication hub (dedicated server: *Geek*)
    
*   **Mission Control** — Kanban + token analytics dashboard
    
*   **Agency-Swarm** — Python orchestration for multi-agent pipelines
    
*   **Promptfoo** — QA evaluations and security red teaming
    
*   **Impeccable** — design language guidelines for frontend AI output
    

* * *

## The Team — 10 Geek Agents

All agents share the `geek-` prefix. No human names — just clean role IDs.

| Agent | Role | Model |
| --- | --- | --- |
| `geek-pm` | Product Manager | MiniMax |
| `geek-architect` | Tech Lead & Architect | Claude |
| `geek-frontend` | Frontend Developer | MiniMax |
| `geek-backend` | Backend Developer | MiniMax |
| `geek-qa` | QA Engineer | Codex |
| `geek-devops` | DevOps Engineer | Codex |
| `geek-reviewer` | Code Reviewer & Bug Fixer | Claude |
| `geek-docwriter` | Documentation Writer | MiniMax |
| `geek-security` | Security Auditor | Claude |
| `geek-scrum` | Scrum Master | MiniMax |

### API Routing Logic

Three API keys, used strategically:

*   **Claude** → fixing issues, code reviews, security audits (high reasoning tasks)
    
*   **Codex** → test generation, DevOps scripts (code-execution tasks)
    
*   **MiniMax** → development, documentation, planning (high-volume tasks)
    

* * *

## Workspace Structure

Each agent lives in its own workspace directory:

```plaintext
~/.openclaw/
├── workspace-geek-pm/
│   ├── AGENT_PROMPT.md      ← role instructions
│   ├── IDENTITY.md          ← name, emoji, vibe
│   ├── SOUL.md              ← personality
│   ├── TEAM_CONTEXT.md      ← injected by switch-team.sh
│   ├── MEMORY.md            ← persistent memory
│   └── memory_steps/        ← SOPs by task type
├── workspace-geek-architect/
│   └── ...
├── workspace-geekteam/      ← shared team workspace
│   ├── scripts/
│   │   ├── switch-team.sh   ← swap web ↔ mobile context
│   │   ├── api-router.sh    ← route task to right API
│   │   └── pipeline.sh      ← run full feature pipeline
│   ├── agency-swarm/        ← Python orchestration layer
│   ├── team-profiles/
│   │   ├── web.yaml         ← Next.js 15 + TS + Tailwind + PG
│   │   └── mobile.yaml      ← React Native + Expo + EAS
│   └── api-routing/
│       └── routing-rules.yaml
```

* * *

## Multi-Team Support Without Duplicating Agents

One of the design goals: run a web team today, switch to mobile tomorrow — without creating 10 new agents.

The solution is `TEAM_CONTEXT.md` injection. One script rewrites the context file for all 10 agents at once:

```bash
./switch-team.sh web
# → writes web stack context to all 10 agents' TEAM_CONTEXT.md
# → no restart needed, agents pick it up on next message

./switch-team.sh mobile
# → same agents, now thinking React Native + Expo
```

Team profiles (`web.yaml`, `mobile.yaml`) define:

*   Tech stack
    
*   Per-agent context overrides
    
*   API routing preferences
    
*   OpenViking namespace for tiered context loading
    

* * *

## Discord Setup — 3 Bots, 3 Servers

OpenClaw's multi-account Discord support lets each server have its own bot identity:

```json
"discord": {
  "accounts": {
    "default": { "token": "...", ... },   // @KLinked — KLinked HQ
    "blog":    { "token": "...", ... },   // @Blogs   — Blog server
    "devteam": { "token": "...", ... }    // @Geek    — Geek server
  }
}
```

Bindings route each agent to the right channel:

```json
{ "agentId": "geek-scrum",    "match": { "channel": "discord", "accountId": "devteam", "guildId": "..." } },
{ "agentId": "blog-research", "match": { "channel": "discord", "accountId": "blog", "peer": { "kind": "channel", "id": "..." } } }
```

The Geek server currently routes all messages to `geek-scrum` as the default handler in the `#general` channel. As more channels are added, each agent gets its own dedicated channel.

* * *

## Mission Control Dashboard

[builderz-labs/mission-control](https://github.com/builderz-labs/mission-control) connects directly to the OpenClaw gateway:

```plaintext
Mission Control (localhost:3000)
    ↕ WebSocket
OpenClaw Gateway (localhost:18789)
    token: [gateway auth token]
```

What it gives the team:

*   **Kanban board** — track tasks across all 10 agents
    
*   **Token analytics** — monitor Claude / Codex / MiniMax usage per agent
    
*   **Session viewer** — see what each agent is working on
    
*   **Natural language scheduler** — queue tasks across agents
    

Setup was straightforward:

```bash
git clone https://github.com/builderz-labs/mission-control
cd mission-control
pnpm install
# configure .env with OPENCLAW_GATEWAY_* vars
pnpm build && pnpm start
```

* * *

## Agency-Swarm Pipeline

For complex features, a Python orchestration layer chains agents together:

```plaintext
User request
    → geek-pm (requirements)
    → geek-architect (design)
    → geek-frontend + geek-backend (parallel build)
    → geek-qa (tests)
    → geek-reviewer (review)
    → geek-docwriter (docs)
```

Each agent in the pipeline uses LiteLLM for model routing, and delegates all file writes to Claude Code via `claude --print`:

```python
# api routing via LiteLLM
AGENT_MODEL_MAP = {
    "geek-architect": "claude-sonnet-4-6",
    "geek-qa":        "openai/gpt-5.3-codex",
    "geek-pm":        "minimax/minimax-code-01",
    ...
}
```

* * *

## QA & Security

**geek-qa** runs Promptfoo evaluations on every PR:

*   Component rendering tests
    
*   API response shape validation
    
*   Edge case coverage
    

**geek-security** runs OWASP Top 10 red team scenarios:

*   SQL injection probes
    
*   Auth bypass attempts
    
*   XSS payload testing
    

Both agents write results back to Mission Control via the `/api/tokens` endpoint.

* * *

## What's Next

*   \[ \] Add per-channel Discord routing as team grows (architecture, backend-work, qa-reports, etc.)
    
*   \[ \] Wire Sprint board to Mission Control Kanban
    
*   \[ \] Enable OpenViking L1/L2 context tiers as memory builds up
    
*   \[ \] Set up Impeccable design language enforcement in geek-frontend's review loop
    
*   \[ \] Mobile team profile live run with React Native project
    

* * *

## Lessons Learned

**OpenClaw binding schema is strict.** Only `channel`, `accountId`, `guildId`, and `peer` are valid in match objects. Adding unknown fields (`channelName`, `description`) silently blocks all config reloads — check `gateway.err.log` first when things don't reload.

**Multi-Discord via accounts, not channel plugins.** Custom channel IDs like `discord-blog` don't work. The correct approach is `discord.accounts.<name>` with bindings using `accountId`.

**TEAM\_CONTEXT.md injection > agent duplication.** 10 agents covering both web and mobile is always better than 20 agents with half sitting idle.

**MiniMax for volume, Claude for quality, Codex for code execution.** This split keeps costs manageable while routing the right reasoning power to the right tasks.