How I Work With Claude, Codex, and Gemini as a Three-Agent Team

Most people treat AI like a single contractor. You hire one, give it a task, get an output.

I treat it like a team. Three agents, defined roles, shared context, deliberate handoffs.

It sounds more complicated than it is. Here's how it actually works.

Why Three Agents?

Each model has genuine strengths. Using one for everything means you're leaving capability on the table.

Claude (via Cowork): My primary collaborator for complex reasoning, writing, structured analysis, and anything requiring judgment calls. Excellent at holding nuance, maintaining brand voice, and producing long-form output that doesn't sound like a robot. Also where most of my tool integrations live, calendar, Gmail, Obsidian, sessions history.

Codex (via Claude Code CLI): My systems agent. Code review, file system operations, structured data work, and any task that benefits from running in a terminal with direct filesystem access. Better than Claude at precision file operations and less likely to drift on technical tasks.

Gemini (via AI Studio or Cowork): My research and second-opinion agent. When I want a perspective that hasn't been shaped by the same session context, or when I need broad web research, Gemini runs independently. Also useful as a reviewer, it'll catch things that Claude missed because it wasn't part of building them.

The Shared Context Layer

All three agents read the same root instruction files at the start of each session: AI.md (identity, rules, style), MEMORY.md (current state, open loops), and the relevant workstation MEMORY.md.

This is the key infrastructure piece. Without it, each agent starts cold and you spend 20 minutes on setup. With it, you spend 2.

The shared context means Codex can continue work Claude started. Gemini can review what both built. The agents aren't aware of each other, but they're all operating from the same knowledge base.

The Role Division in Practice

Here's how a content creation session actually runs:

Step 1 - Drafting (Claude): I brief Claude on the post concept, it reads the brand voice guide and content OS from Obsidian, then drafts the full piece. I review and mark up.

Step 2 - Technical review (Codex): If the post references specific systems, code, or file structures I've built, Codex verifies accuracy against the actual files. It's not reading a description of the system, it's checking the system itself.

Step 3 - Fresh read (Gemini): I paste the final draft into Gemini and ask for one thing: "What would a skeptical reader push back on?" Different model, no session history, clean read. Catches assumptions and blind spots that form when you're too close to the work.

Step 4 - Spreadsheet update (Codex): The final post goes into the Blog CMS spreadsheet via a Python script Codex runs. No manual copy-paste. Direct file operation.

What Doesn't Work

Parallel writes to the same file: two agents updating the same document simultaneously produces conflicts. Serialize writes. One agent, one file, one write.

Long chains without checkpoints: if you hand off too much context across three agents without a human review, errors compound. I review every handoff.

Asking the wrong agent for the wrong thing: Gemini for precise file operations, Claude for CLI work, both produce worse results than they're capable of. Match task type to agent strength.

The Insight

Multi-agent workflows aren't about using more AI. They're about using each tool for what it's actually good at.

One agent doing everything is like having a surgeon also do your physical therapy and handle your insurance paperwork. They might technically be able to do it. But that's not what they're optimized for.

The Takeaway

Pick one workflow you do regularly that involves both writing and technical work. Route the writing to your best reasoning model. Route the technical verification to your most precise executor. Compare the output to what you get from one agent doing both.

The gap will probably surprise you.