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

> Source: <https://dev.to/m_t_bbe0d7e2206ba4769563b/the-delegate-pattern-run-claude-code-codex-gemini-in-parallel-zero-cost-rate-limit-bypass-joh>
> Published: 2026-07-26 17:51:19+00:00

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**.

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

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.

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.

```
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:**

| 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).

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.

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.

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
```

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.

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

| 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 |

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](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.*