Andreas Heige

· 10 min · review, harness engineering, information engineering

How Claude, Codex, Copilot and Gemini talk to each other

They never chat. They pass each other a diff, a JSON record, a closed question or a one-line fact, and code decides what happens next.

Contents · 9 sections

Abstract

Four model tools from three families work on this site, and none of them talks to another directly. This is the wiring: who reviews whom and how the reviewer is picked, when an agent asks the other family before it asks me, the memory every CLI reads, where Gemini fits (outside the wiring), and what it all costs in tokens and Touch ID prompts.

Four model tools from three families work on this site: Claude Code, Codex CLI, Copilot CLI and Gemini. None of them talks to another directly. They pass each other a diff, a JSON record, a closed question or a one-line fact in a Markdown file, and code decides what happens next. The rule behind all of it is short: whoever wrote a change doesn’t grade it.

The pieces have their own posts: review-loop for the review, devsecops-workflow for the two loops and the tester, Autograph for the vault. This post is about the wires between them.

Who does what

ToolFamilyIts job hereHow it is called
Claude Code (Opus 5.5, Sonnet 5.5)AnthropicWrites the code, orchestrates, runs the subagentsInteractive session
Copilot CLI running gpt-6.1-solOpenAIFinder and verifier in every end-of-ticket reviewreview-loop eot, inside a scratch worktree
Codex CLIOpenAIAnswers closed questions, checks docs against code, reviewed the epic’s seamscodex exec --sandbox read-only
GeminiGoogleA brainstorm partner, in a chat of its ownPasted into a Claude session by hand
Me—Accepts findings that weaken a control, merges, deploysTouch ID, or a “y” typed at the terminal

One correction to my own build log. It says Codex checked Claude’s work. For questions and the doc check, it did. The review records tell a different story for the review itself: every record in the blog’s repo that ran a model names the same worker, Copilot running gpt-6.1-sol, in 97 finder, 4 security-finder and 70 verifier runs. Since a change on 28 October, review-loop sends Claude-authored work to Copilot by default, “until Codex quota is back”. review-loop cares about the family, not the CLI:

FAMILY = {"claude": "claude", "codex": "gpt", "copilot": "gpt"}  # copilot runs a GPT model
# …
NON_AUTHOR = {"claude": ["copilot"], "gpt": ["claude"], "unknown": ["claude", "copilot"]}  # copilot until Codex quota is back

How a change crosses families

  1. Claude writes + Co-Authored-By
  2. scan, finder, verifier; code sets the status
  3. a person accepts needs_human
  4. land
  1. Claude writes + Co-Authored-By leads to scan, finder, verifier; code sets the status: trailer → author family
  2. scan, finder, verifier; code sets the status leads to a person accepts needs_human: control-weakening
  3. scan, finder, verifier; code sets the status leads to land: pass
  4. scan, finder, verifier; code sets the status leads to Claude writes + Co-Authored-By: blocking: fix, recheck (max 2) (back to the author)
  • a person accepts needs_human leads to land
  • gpt-6.1-sol
    • scan, finder, verifier; code sets the status
Fig. 1 — One ticket crosses families: Claude writes, a GPT model finds and verifies, code decides, a person accepts what weakens a control.

Claude finishes a ticket and commits. The commit message ends with an honest trailer, Co-Authored-By: Claude Opus 5.5, and that line is load-bearing: it is how the review learns who wrote the change. From review_loop/eot.py:

def author_family(repo: str, base: str, head: str) -> str:
    """From the commit trailers of the range (the model, not the harness); mixed or none → unknown."""
    log = git(repo, "log", "--format=%B", f"{base}..{head}").stdout.decode("utf-8", "replace")
    found = set()
    for m in re.finditer(r"^co-authored-by:\s*(.+)$", log, re.I | re.M):
        who = m.group(1).lower()
        if "claude" in who or "anthropic" in who:
            found.add("claude")
        elif any(k in who for k in ("codex", "openai", "gpt")):
            found.add("gpt")
    return found.pop() if len(found) == 1 else "unknown"

A missing or mixed trailer gives unknown, and then both families review, and a finding blocks only if every verifier confirms it. A lying trailer would pick the wrong reviewer, which is why the blog’s workflow asks for an honest one in so many words.

The calls from one ticket, as the blog’s workflow runs them:

npm run build && git commit -m "…"   # the gates, chained: the build runs check and tests first
review-loop eot --ticket docs/tickets/<id>.md --base <commit before the ticket>
# fix what blocks, commit through the same chain, then
review-loop recheck --ticket docs/tickets/<id>.md --base <commit before the ticket>

eot scans first, so a secret stops the run before any model sees the diff. Then the Copilot finder reads the diff and the ticket and answers in a strict JSON schema, and a fresh verifier gets one finding at a time and tries to refute it. Code, not a model, turns that into a status. The finder and verifier run with the agent config stripped out of their worktree, AGENTS.md included, so the file that carries the shared memory (below) is the one file the reviewer may not read. The review-loop post has the rest.

Over the blog’s two builds, review-loop stats counts 116 records over 34 tickets, a median of 2 rounds and 52.5 s per round. The findings: 20 hard scanner hits, 8 blocking, 118 advisory, and 30 that the verifier threw out.

Asking the other family before asking me

Reviews come after the work. Questions come in the middle of it. When an agent would otherwise stop and ask me, it first asks Codex a closed question (section 12.5 of the blog’s deep dive):

codex exec --sandbox read-only --skip-git-repo-check -C ~/Dev/blog "<question with the files to read, the options a/b/…, and: answer with one line ANSWER: <x> and at most 4 lines of reasons>" < /dev/null

The < /dev/null is there because codex exec otherwise waits on stdin. If both families give the same answer, the agent goes ahead and writes a decision row that says “agreed by Claude and Codex”. If they differ, or the question is open-ended, the item goes red on the board and waits for me. Some areas never go to Codex at all: accepting findings, auth, payments, PII, migrations, infrastructure, merging, anything outward-facing.

In v4, ten decisions were settled that way. Codex is not only a tie-breaker, though. For the model behind Ask (D80) it agreed with the choice and added something Claude hadn’t: turn thinking off, because reasoning tokens bill as output. In the doc check it found that the answer cache had no version, so a content or prompt deploy served day-old answers (D82).

Codex as a subagent

There is a second door to Codex: OpenAI’s Codex plugin for Claude Code. Its codex-rescue subagent is, in its own words, a thin forwarding wrapper. It makes one shell call and returns Codex’s output untouched:

node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-companion.mjs" task --write "<the task, as Claude phrased it>"

It is installed, and its stop-time review gate is off. The plugin’s state for the blog lists no jobs today, and the build logs count 18 plain codex exec sessions (13 in v4, 5 in v4.1). The difference is who drives. A plain codex exec is a call an agent or a script makes: a read-only sandbox, one question, one answer. /codex:rescue hands Codex the work itself. The subagent’s own description says to use it “when Claude Code is stuck, wants a second implementation or diagnosis pass, needs a deeper root-cause investigation”, and Claude may reach for it without being told to. An implementation request gets a run that can write to the repo; review, diagnosis and research stay read-only. It runs in the foreground unless asked for the background, and when there is a Codex thread to pick up, it asks whether to continue that thread or start a new one. On this site no agent has needed it yet.

One memory, three readers

  1. Codex CLI, Copilot CLI symlink and env var
  2. ~/.agent-global AGENTS.md
  3. Autograph vault one fact per file
  4. Claude Code ~/.claude/CLAUDE.md
  1. ~/.agent-global AGENTS.md leads to Autograph vault one fact per file: read before work, write a fact
  2. Claude Code ~/.claude/CLAUDE.md leads to Autograph vault one fact per file: same text, inline (Claude reads the same instructions from its own file)
  • Codex CLI, Copilot CLI symlink and env var leads to ~/.agent-global AGENTS.md
Fig. 2 — One memory, three readers: each CLI reaches the vault through its own global instructions; nothing in a repo points at it.

Every CLI reads the same memory: a folder of one-fact-per-file Markdown in the Autograph vault. Nothing in a repo points at it. Each tool gets there through its own global instructions. The shared file is ~/.agent-global/AGENTS.md:

# Global agent instructions

Machine-wide facts not tied to any one repo — preferences, cross-project
conventions, tool setup — live in
`~/.autograph/vault/personal/memory/memory.md`, shared across Claude Code,
Codex CLI, and GitHub Copilot CLI. This file is what makes that global rather
than per-repo:

- Codex CLI loads it automatically from `~/.codex/AGENTS.md`, which is a
  symlink to this file.
- GitHub Copilot CLI loads it automatically via the `COPILOT_CUSTOM_INSTRUCTIONS_DIRS`
  environment variable (set in `~/.zshrc`) pointing at this file's directory.
- Claude Code gets the same instructions inline in `~/.claude/CLAUDE.md`
  (global, applies to every project already).

Every fact records who wrote it in metadata.added_by. Today the vault holds 52 facts: 31 written by Claude Code, 21 by the nightly dreaming job, none by Codex CLI or Copilot CLI. The memory is shared by design. So far, one family writes it and the others read it.

It is also not shared with everyone. Wiki pages built from client material are marked as such and may go only to the Anthropic API or a local Ollama model, so the global file tells Codex and Copilot to skip them. Even inside the vault, which family may read what is a rule written down, not a default.

Gemini, outside the wiring

Gemini has no hook, no worker slot and no trailer. On 7 November I worked out how to describe my role in a Gemini chat and pasted it into the blog session. Gemini has been my sounding board for a long time, and for that job I think it is among the best.

Gemini proposed a chain: information engineering, then AI architecture, then AI-native systems, then autonomous workflows, “with no human hands”. The About page kept the shape and changed two things. Harness engineering went in as the step that makes autonomy safe, because it is most of what these posts are about. “No human hands” became “a person where it matters”, because this site has human gates on purpose: Touch ID accepts, the PR merge, the deploy. The disagreement wasn’t between two models. It was between a model’s general answer and the way this site is actually built.

What it costs

In tokens, the other family is a small share. Across v4, Claude made 4,467 API calls with 4.10 M output tokens and 870 M cache reads. Codex used 13 sessions: 9.08 M input tokens, 8.24 M of them cached, and 22 k output. v4.1 was the same shape, smaller: 1.02 M output for Claude, 5 Codex sessions with 12 k output. The Copilot reviewers’ tokens aren’t in either number: review-loop records tokens_total 0, a gap that is filed but not fixed.

The cost that hurts is my attention. Anything that weakens a control (a changed test pin, a new suppression comment, a fix after the recheck cap) is needs_human, and only a human may accept it. An accept record from the blog’s accepts.jsonl:

{"finding_id": "sec-reviewloop-1c5c35ed18ae", "rule_class": "control-weakening", "reason": "D98: hover-mode test moved from the class switch to the data-noise-hover attribute and the off rule's declarations", "expires": "2026-12-07", "accepted_at": "2026-11-07T10:14:24+00:00", "tty": true}

v4 produced 184 needs_human findings, counting a finding again in each round. The accepts ledger held 351 rows by 7 November: 199 from 3–4 November (v4) and 152 from 5–7 November (v4.1). On the afternoon of 6 November, 26 Touch ID prompts held three tickets idle between review and landing. Every one was a test pin widened or moved, a suppression comment with its reason, or a size flag, and the orchestrator had checked each one before asking. The progress-board plan puts it plainly: “The human added nothing the orchestrator hadn’t already checked.” What I said that day: “we MUST do something about this approve, it blocks and is bad DX”.

The Touch ID confirmation itself is on a branch of review-loop that isn’t on the public main yet. The public accept asks for a “y” typed at the terminal, which an agent’s shell doesn’t have. The fixes queued for it: one Touch ID for a batch of findings, accepts that survive a follow-up commit when the finding hasn’t moved, and routine classes settled by the two families agreeing, logged as model-settled and never as human. The target is at most one prompt per ticket.

Where they disagreed

  • D33, the reading-progress line. Codex chose CSS only, so all motion stays in CSS behind the motion switch. Claude wanted a small script fallback for browsers without scroll-driven animations. It went to me, and it is still marked pending. CSS only ships by default.
  • The verifier against the finder. Both are gpt-6.1-sol, but in fresh runs with different jobs, and the verifier discarded 30 findings. Same family, different context, and they still disagree.
  • A reviewer looking at the past. One finding about the portrait’s EXIF orientation was accepted with the reason “already fixed in 391937a … finding compared an old state of the branch”. A wrong finding costs a prompt too.
  • Gemini against the house. “No human hands” against “a person where it matters”, above.

For a closed question outside the human-only areas, agreement lets the agent go on without me. Disagreement shows up as a single red item on the board, and D33 is the only one v4 produced.

The red line

On the site’s thread graph this post is tagged review, harness and information engineering, and it links to the three posts that each hold one of those: review-loop, devsecops-workflow and Autograph. Those posts describe the boxes; this one describes the edges, the same edges the red signal runs along in the figures above.

Before I read this draft, Codex checked it against its sources, under the rule it describes: the family that wrote it didn’t grade it.