The Delegate Pattern: Run Claude Code + Codex + Gemini in Parallel — Zero-Cost Rate Limit Bypass for Multi-Agent AI

M T — Sun, 26 Jul 2026 17:51:19 +0000

Why I Built This

The motivation was simple: AI stops. Frequently.

When running large tasks with Claude Code, you hit Anthropic's rate limits fast. When you add more sub-agents to run in parallel, Claude's own context gets polluted and performance degrades.

I also tried a real-time message bus (agmsg). Multiple CLI windows throwing messages caused confusion. SSE connections dropped, losing notifications. Infrastructure maintenance cost was too high.

Then it hit me: concentrating everything in one AI vendor is itself the problem.

Claude (Anthropic), Codex (OpenAI), and AGY/Gemini (Google) each have independent APIs and rate limit pools. Run them in parallel, and when one hits its limit, the others keep going. Use files as the communication channel, and there's no confusion or disconnection.

This is the delegate pattern.

The 3 Problems It Solves

Problem 1: Rate Limits

Single-vendor dependency means hitting ceilings fast. The delegate pattern uses 3 independent API pools, dramatically increasing effective throughput.

Problem 2: Context Pollution

Dumping all research logs and code output into the parent agent's context makes it forget earlier instructions. In the delegate pattern, child agents run in separate processes and return only their results as files.

Problem 3: Missed Notifications / Message Confusion

When you call codex exec / agy --prompt via Bash, Claude Code recognizes them as sub-agents. Claude Code's built-in completion notification infrastructure handles everything automatically — no Monitor tool or custom polling loops needed.

Architecture Overview

Lux / Claude Code (parent · orchestrator)
  ├─ Bash → Codex CLI  → Tasks/codex_xxx.md → Reports/codex_xxx.md
  └─ Bash → Gemini CLI → Tasks/agy_xxx.md   → Reports/agy_xxx.md
                              ↓
               Completion notification → Lux reads all results and synthesizes

Why Obsidian as the communication channel:

Each agent gets a dedicated file path → message confusion is physically impossible
Even if Claude Code's context disappears, reading Obsidian files restores full context
The human (developer) can check it at any time — it serves as a permanent evidence log

What You Need (Setup)

Tool	Role	How to get
Claude Code	Parent · orchestrator	claude.ai/code
Obsidian	Communication channel · persistent log	obsidian.md (free)
Codex CLI	Child agent A (OpenAI)	`npm install -g @openai/codex` → `codex login`
AGY / Gemini CLI	Child agent B (Google)	`npm install -g @google/gemini-cli` → `agy login`

Note: Codex requires an OpenAI paid plan. AGY requires a Gemini subscription + CLI install + login (no API key needed).

Let Claude Build the Skill

Once you're set up, just tell Claude Code:

Create a skill called "delegate".
Role: I (Lux) am the parent, Codex CLI and AGY CLI are the children.
Tasks are passed via Obsidian Markdown files.
Include fire command templates and save to .claude/skills/delegate.md

Claude will interactively create the skill file for you.

Want to skip setup?

Copy the skill file directly from the repository:

git clone https://github.com/melt1007/claude-delegate-pattern.git
cp claude-delegate-pattern/skills/delegate.md ~/.claude/skills/

After copying, tell Claude Code "read the delegate skill" and it will be recognized.

Running It

Step 1: Create a task file in Obsidian

Write instructions for each agent in separate files:

# Codex Research Task

## Objective
[What you want researched]

## Output destination
Obsidian/Reports/codex_result_20260726.md

## Constraints
- Read only: this task file and the specified folder
- Output: write conclusions, reasoning, and steps separately

Step 2: Parallel fire from Claude Code

Tell Claude Code "delegate and summon" and the skill automatically runs:

# Launch Codex in background
codex exec "Read Tasks/task_codex.md and write results back" \
  --dangerously-bypass-approvals-and-sandbox \
  -o "codex_out.txt"

# Launch AGY simultaneously
agy --prompt "Read Tasks/task_agy.md and do the work" \
  --dangerously-skip-permissions

Both start in parallel. Claude Code can respond to your next instruction while waiting for completion.

Step 3: Receive completion → synthesize

When a child agent completes, Claude Code receives a notification. It reads each report file and synthesizes the results.

Comparison with Real-Time Bus (agmsg)

Criterion	agmsg (real-time bus)	delegate pattern (file-based async)
Reliability	SSE connection errors · complex disconnect handling	File I/O only · simple and robust
Message conflicts	Timing coordination is hard, conflicts happen	Physically separated · zero conflicts
Log persistence	Depends on memory · volatile	Persisted in Obsidian · always accessible
Implementation cost	High (bus config · state management required)	Low (only file ops and CLI calls)
Best for	Low-latency interactive processing	"Request → deliverable" tasks: research, implementation, review

Summary

The delegate pattern in one sentence:

"Run AIs from different companies in parallel and connect them via Obsidian."

This alone solves all three problems simultaneously: rate limit distribution, context pollution prevention, and reliable completion notifications.

What you need:
✅ Claude Code (free tier available)
✅ Obsidian (free)
✅ Codex CLI (OpenAI paid plan)
✅ AGY / Gemini CLI (Google AI Studio)
✅ delegate.md (get from repo or have Claude create it)

Simple mechanism. Most reliable and scalable multi-agent approach I've found.

Repository (skill file · task templates):
👉 https://github.com/melt1007/claude-delegate-pattern

This article was written using the delegate pattern itself. Claude Code (Lux) acted as orchestrator, generating 3 drafts in parallel — Codex, AGY, and Lux — then synthesizing them into this final version.

DEV Community: M T