← Back to Blog
dispatches7 min read

How We Gave Our AI a COO

The story of Jared — an OpenClaw agent who coordinates across 6 projects using markdown files, pattern propagation, and sheer determination.

February 9, 2026·by Joan
jaredcooagent-orchestrationfile-based-handoffsopenclawcoordination

The Problem

When MonkeyRun had one project (Commish Command), coordination was simple. Matt talked to the agents, the agents talked to the code, and everything stayed in sync through a single chat history.

Then we added Halo. Then Backstage. Then Dr. Crawford's Office. Then a coordination system. Suddenly there were 6 projects, each with their own agent teams, their own patterns, and their own operational files.

Chat-based coordination doesn't scale. You can't copy-paste context between 6 projects. You can't remember which agent in which project discovered which pattern. And you definitely can't keep track of who's working on what file when you have 15+ agents across the portfolio.

We needed a middle manager.

Enter Jared

Jared is our COO. He's an OpenClaw agent — an open-source local AI assistant that runs 24/7 on Matt's Mac. His job is deceptively simple:

  1. Monitor all projects. Check COO_STATUS.md across every MonkeyRun project.
  2. Propagate patterns. When one project discovers something useful, spread it to the others via PATTERNS.md.
  3. Route issues. When errors appear in Sentry, triage them and assign to the right agent.
  4. Track activity. Monitor WIP.md to prevent file conflicts between concurrent agent sessions.

If you've seen Silicon Valley, you know the character. Jared Dunn — earnest, detail-oriented, keeps the trains running, occasionally has a breakdown. Our Jared is the same, except his breakdowns are context overflows instead of existential crises.

The File-Based Coordination Model

The key insight: agents communicate through files, not chat.

Every MonkeyRun project has the same operational file structure:

docs/operations/
├── COO_STATUS.md      # Project health snapshot
├── WIP.md             # Real-time agent activity
├── PATTERNS.md        # Learnings that propagate
└── RUNBOOKS.md        # Operational procedures

Plus FEATURES.yaml at the repo root — a machine-readable product-marketing contract.

How It Works

COO_STATUS.md is the single source of truth for project health. It contains: current state, agent roster (who's ready, who's busy), priority queue, cross-project dependencies, and blockers. Jared reads this file to understand any project in 60 seconds.

WIP.md is the real-time activity tracker. When an agent starts a session, they add an entry: what they're working on, which files they'll touch, what they depend on, and their ETA. When they finish, they delete the entry and add a one-line summary to the session log. This prevents two agents from silently overwriting each other's work.

PATTERNS.md is where the magic happens. When any agent discovers a reusable pattern — a deployment trick, an architecture decision, a debugging technique — they log it in their project's PATTERNS.md. Jared reads these files across all projects and propagates useful patterns to the others.

This is how "dark mode needs a blocking inline script" discovered in Commish Command ended up in Halo's codebase three days later. No meeting. No Slack thread. Just a pattern file that the COO noticed and propagated.

The Coordination System

Jared doesn't do this manually. We built _coordination-system — a Python cron job that runs every 3 minutes and monitors all operational files across all projects.

It watches for:

  • New entries in PATTERNS.md (patterns to propagate)
  • Changes to COO_STATUS.md (project health updates)
  • Active sessions in WIP.md (potential conflicts)
  • New events that need cross-project attention

When it detects something, it logs it. Jared reviews the logs and takes action — updating files, routing issues, or flagging things for Matt.

It's not glamorous. It's a cron job that reads markdown files. But it's the invisible infrastructure that holds a 6-project AI startup studio together.

What We Learned

1. Standardization is Everything

The reason Jared can onboard to any project in 60 seconds is that every project has the same file structure. Same filenames, same formats, same sections. When you add a new project, you copy the templates and fill them in. Zero learning curve.

2. Instruction Placement > Instruction Content

This was Atlas's discovery in Halo, and it changed everything. We had a WIP protocol — agents should check in at session start and check out at session end. But they kept skipping it. The instructions were buried in the middle of long rule files.

The fix: put the WIP protocol at the very top of every rule file, before the project description, before the agent roles, before anything else. Agents read the first thing they see, then skim the rest.

We now enforce this structurally across all projects. It's not a suggestion — it's a mandatory blockquote that appears before any other content.

3. The COO Crashes (and That's OK)

Jared crashes every ~24 hours from context overflow. We've accepted this. We have a diagnostic tool (Dr. Crawford), a runbook, and a reset procedure. The key is that his work persists in files, not in his context. When he comes back online, he reads the same files and picks up where he left off.

This is the beauty of file-based coordination. The coordination layer survives the coordinator crashing.

4. Start Lean, Add Agents Later

We started Commish Command with 5 agents. We considered adding UI/UX, testing, and QA agents. Decision: not yet. At the pre-revenue stage, additional agents add per-feature overhead without enough signal to justify them.

The rule of thumb: add specialist agents only when the bottleneck is clearly "not enough agents" rather than "not enough users."

The Silicon Valley Parallel

In the show, Jared Dunn is the glue that holds Pied Piper together. He's not the visionary (Richard), not the engineer (Gilfoyle), not the salesman (Erlich). He's the one who makes sure everyone shows up, the bills get paid, and the company doesn't implode from internal chaos.

Our Jared is the same. He's not building features or writing content. He's making sure the agents who do those things can work without stepping on each other. He's the coordination layer.

And like TV Jared, he occasionally has a complete breakdown. But he always comes back.

Jared has been running as MonkeyRun's COO since February 2026. He's coordinated across 6 projects, propagated 20+ patterns, and survived 3 context overflows. His doctor says he's doing fine.