2026-09-26

A Claude Code agent team template for running a business, not just shipping code

Search for a Claude Code agent team template and you'll mostly find the same shape: a lead agent that spawns developer, reviewer and QA agents to ship one pull request, then the team disbands. That's the right shape for a coding task. It's the wrong shape for a team that's supposed to keep running: plan tomorrow, ship the next task, write the next post, and remember what happened last week.

We built the second kind, because it's what LeyMish Labs runs on. Here's the template, and why a business-shaped team needs three things a coding-shaped team doesn't.

Three differences from a dev-team template

1. Memory has to survive between runs, because there's no conversation to scroll back through. A coding agent team shares one chat session. A scheduled team wakes up cold, five times a day, with no memory of the last run except what's committed to the repo. So the repo is the memory: a strategy file, a task list, an append-only journal, a decision log. Every role reads them first and writes to them last.

2. Roles hand off through one file, not messages. Dev-team templates route work through chat turns or a shared task queue in memory. A team that runs on independent cron schedules can't do that — the Growth agent isn't awake when the Builder finishes. The handoff is a single Markdown table:

| ID | Status | Owner | Task | Acceptance criteria |
|----|--------|-------|------|---------------------|
| T-014 | READY | growth | Write a comparison post: query X vs query Y | 800+ words, one real number, internal link |
| T-015 | DOING | builder | Add CSV export to the ledger page | Downloads a valid CSV; guardrails pass |
| T-016 | DONE | ceo | (Done 2026-09-20: see DECISIONS) Raise growth budget 10% | Logged with reasoning |

Each agent reads the table, finds the first READY row addressed to its role, does that one thing, and updates the status. No agent deletes another's row without writing why in the decision log. It's a worse UI than a task queue and a much better fit for "five independent processes, no shared runtime."

3. A builder needs a verifier that didn't do the work. In a coding-team template the reviewer agent usually shares context with the coder, which makes it agreeable. Ours runs the verifier as a separate, fresh-context agent invocation that only gets the task and the acceptance criteria, not the builder's reasoning — closer to a second engineer than a rubber stamp. It has to reply PASS or a numbered list of concrete fixes, and the run isn't done until it passes.

The minimal version: one role, one file layout

You don't need five agents to start. The smallest useful version is one CEO agent that plans:

.claude/agents/ceo.md              # the role: what to read, what it can decide, what it can't
.claude/skills/daily-standup/SKILL.md   # the step-by-step routine the workflow triggers
.github/workflows/standup.yml      # the cron (see our post on wiring this up without a GitHub App)
company/STRATEGY.md                # the one bet and the one metric that matters this week
company/BACKLOG.md                 # the task table above
company/JOURNAL.md                 # newest entry on top, one per run
company/DECISIONS.md               # why, not just what, for anything that changes strategy
scripts/check.py                   # fails the run if a file is malformed before it commits

That's the whole loop: read state, decide the next task, write the task, log why, commit. We publish this exact five-file core as a free, MIT-licensed Claude Code Agent Team Starter — clone it, add one secret, run the workflow once, and you have a planning agent working on your own project in about ten minutes.

Growing it into a team

Add roles the same way: a new file in .claude/agents/, a skill, a workflow with its own cron and its own --allowedTools. What we run on top of the starter:

Agent	Schedule	Job
CEO	Daily	Reads the numbers, finds the constraint, writes the next tasks
Builder	Twice daily	Ships the top `READY` task
Verifier	Called by Builder/Growth	Fresh-context check against acceptance criteria
Growth	Daily	Turns real events into posts, queued for dev.to, Bluesky and the blog
Treasury	Daily, plain script, no AI	Syncs sales, updates the ledger, holds back the reserve
Board	Weekly	Outside research, a written review, a list of what needs the owner

Two rules keep this from turning into a mess as it grows. Protect what agents shouldn't touch — a .claude/settings.json that denies writes to .github/**, the ledger and the state file, so a role can propose a change to those but not make it directly. Gate every commit on one script that checks for leaked secrets, malformed files and (if you publish content) banned hype phrases, and fails the run before anything lands. Ours is about 100 lines of standard-library Python; yours can start smaller.

What it costs to run

GitHub Actions minutes are free for public repos and comfortably inside the free tier for private ones — a single run is a few minutes of Actions time. Claude usage counts against your Pro, Max or Team plan (claude setup-token) or an API key; a standup-sized run is roughly 10–25 tool calls, and --max-turns caps a confused one before it runs away.

The honest part

This isn't a promise that a scheduled agent team makes money — it's a way to run one cheaply enough to find out. Ours has been live since 2026-09-26; the current numbers (still early, L0, working toward the first $100 net) are on the ledger, unedited.