Skip to content

Elephant-Goldfish Design Review: Deep-Context Drafting with Zero-Context Review

A long-context session drafts a design document with the human, then fresh reviewer subagents with no conversation history read it and report gaps.

The Elephant-Goldfish Model (EGM) splits design work across three roles. A long-context Elephant session interviews the developer and drafts the specification. Goldfish reviewer subagents read the draft and its referenced files "without the earlier conversation", and the human approves the specification (EGM README). The design document is the output, and it carries decisions across a phase boundary. The upstream workflow then asks the author to send the design to another human as a pull request (getting started). Implementation happens afterward, when you "Tell AI to build to the plan" (getting started).

EGM is an Apache 2.0 plugin from Google engineers, and its README says it is "not an officially supported Google product" (README). The method comes from Dave Rensin's article, whose abstract describes the Goldfish as "A brand-new AI chat session with no memory". The abstract has the human ask that session to read the design document. If it "cannot understand the plan based only on that document, the document needs more details". The plugin automates that check with seven reviewer personas. The Google Open Source Blog launch post frames the problem as faster production of slop, bugs, and session context collapse. This page describes the plugin at commit 36343a1.

Roles, flow, and artifacts

The packager requires 7 skills and 9 persona files: 7 reviewers, a synthesizer, and a bootstrap orchestrator (pack_plugin.py). Every skill sets disable-model-invocation: true (egm-review). On Claude Code this stops the model from starting a skill on its own, and the user starts the workflow. A running review then reads and follows the loop and resolve skills in the same thread (Claude integration). Prompts direct the staging and the approvals, and no separate controller that enforces them appears in the plugin (inference). The design-only rule and the one-question-per-turn rule live in resources/execution_instructions.md, which egm-draft must read (egm-draft, rules). They are prompt text too.

Skill Output Human role
egm-brainstorm concepts_brief.md Answers open questions over many turns and confirms the "anchored working hypothesis" before six reviewers, each with a different lens, run in parallel
egm-draft design_draft.md, then docs/designs/<feature>.md by default (final placement) Approves each gated section (gates) and picks every architecture option
egm-review One report per stage Picks one of 4 presets: all stages with checkpoints, an uninterrupted consolidated report, stages 5 to 8 only, or stage 9 only. Checkpointed presets offer proceed, edit by hand, or pause at every gate. The gates after stages 7 and 9 also offer agent resolution (gates)
egm-review-loop goldfish_review_report.md per round Runs within stages 7 and 9 before their final gates, or on its own. Approves each new round and decides at the cap or on churn
egm-resolve Annotated report and edits Chooses auto accept, continue without fixes, interactive breakdown, or comments
egm-drift-report {YYYY-MM-DD}_DRIFT_REPORT.md Picks whether the doc or the code changes (design)
egm-bootstrap Per-directory README.md contracts Approves runs over 15 directories 
graph TD
    H[Human] <-->|one question per turn| E[Elephant session]
    E --> B[concepts_brief.md]
    B --> D[design doc]
    D --> G[Goldfish review stages]
    G --> R[Stage reports]
    R --> E
    E -->|re-review| G
    E -->|fix, contest, escalate, decline| H
    D -->|approved| P[Peer review by another human]
    P --> I[Implementation]

Except in the feature-only preset, the review skill splits the document at ## Detailed Implementation Plan into a feature range and a detailed range. The feature-only preset skips the split and treats the whole document as the feature range (egm-review). A full review then runs five stages in order, and reviewers inside one stage run in parallel (Claude integration). The stages are numbered 5 to 9 after four setup steps in the skill: inputs, preset, split, and staging (egm-review):

Stage Reviewers Target
5 Zoom Out zoom_out Full document
6 Comprehension comprehension, dispatched directly Both ranges
7 Critic design_critic, structural, style Feature range
8 Intermediate Zoom Out zoom_out, focused on additions Full document
9 Implementation readiness implementation_readiness, codebase_details, style Detailed range

Why EGM works this way

The table marks each reason as stated by the authors, with a quote, or as inference. Inference applies where the upstream text gives a rule and no reason. Many quotes come from design docs, and issue #271 reports that those docs drift from the shipped skills.

Choice Reason Basis
Separate drafter and reviewer contexts "The model validates its own faulty assumptions instead of detecting errors." Stated, architecture.md
Fresh reviewers "The model assumes the context it holds in memory is obvious from the text" Stated, review.md
Stop when no fresh subagent exists "a review in the same context is not a Goldfish review" Stated, egm-review
Human owns every design decision "AI is a tool, not a decision-maker." Stated, docs index
Design only, no production code Coding agents "default to writing code immediately in nearby files" Stated, architecture.md
Write artifacts, not chat Long chat output "degrades LLM context performance" Stated, architecture.md
Brainstorm before drafting Plain chat brainstorming "runs the risk of sycophancy" Stated, brainstorm.md
Brainstorm lenses run in parallel The skill runs them simultaneously "to prevent sequential bias" Stated, egm-brainstorm
Drafter does not grade its draft "The session that wrote the draft agrees with it" Stated, egm-draft
Drafter reconciles the draft against the brief "No Goldfish can do this check, because no Goldfish reads the brief" Stated, egm-draft
Directory-level docs for existing code (bootstrap) Without them agents "lack context on local invariants, public interfaces, and side effects" Stated, bootstrap.md
A drift report on existing designs An outdated spec makes people and agents "make flawed assumptions" Stated, drift_report.md
Zoom Out runs first Checks problem framing and reuse of existing infrastructure "before investing in detailed review passes" Stated, review.md
Zoom Out runs again at stage 8 The second pass purges "speculative complexity and YAGNI elements" that earlier fixes added; see altitude-first staged review Stated, review.md
The loop needs two clean rounds "One clean round is not enough, because the next fresh reviewer can find a different gap in the same text" Stated, egm-review-loop
Synthesizer sits between parent and reviewers Direct fan-out "floods the primary context window" Stated, synthesizer.md
Comprehension skips the synthesizer "its report keeps only findings, and the author must see the paraphrase" Stated, egm-review
Comprehension writes a paraphrase first "A list of undefined terms does not find a document whose terms are all defined but whose parts do not connect." Stated, persona
Owner picks architecture; the agent may not rank options or mark a default The rule is stated without a reason. Keeping accountability with the human fits it. Inference from egm-draft, consistent with the stated principle in the docs index
One question per turn, no (Recommended) tag No reason given. The rule keeps the human on one decision without steering. Inference from egm-review
Same model for drafter and reviewers The Claude adapters set model: inherit. Independence then comes from the context reset and the rubric. Config stated, intent inferred, Claude integration

How it is built

Reviewer roster

All seven reviewers open with the same preamble: strictly read-only, no conversation history (design_critic). Each persona has a REVIEW mode and a BRAINSTORM mode.

Persona Review focus
zoom_out YAGNI, reuse of existing code, problem framing
comprehension Paraphrase first, then undefined project terms (persona)
design_critic Faulty assumptions, single points of failure
structural Headings, hierarchy, links
style Filler and subjective claims
implementation_readiness Plans that leave no design choice open
codebase_details Doc against code; a contradiction is a Blocker (persona)
synthesizer Spawns reviewers, removes duplicates, sorts Blocker, Major, Nit
bootstrap_orchestrator Partitions a source tree for per-directory docs

Bootstrap workers return JSON that follows worker-return.schema.json. It requires only subtree_index, with a path and a summary per entry. The skill asks workers to follow it (egm-bootstrap). The repository ships no validator for it (inference from the repository contents).

Document standards

Most rubrics under resources/document_standards/ embed a fresh-reader test. The zoom-out standard instead opens with a context-sufficiency check that fails at once when the objective is unclear. The feature-spec standard passes when "a competent engineer (or fresh AI session) who is unfamiliar with the codebase" understands the feature and its trade-offs (feature-spec). Its Alternatives Rule fails a spec that proposes one path with no rejected alternatives (Alternatives Rule). The implementation-readiness standard's Zero-Decision Rule fails a plan that leaves the implementer to pick a schema, API path, or dependency (implementation-readiness).

Isolation and its limits on each host

The parent spawns a new reviewer per review and never forks or resumes one. It passes only the task, target, persona and standard paths, and an optional reading list the human supplies (Claude integration, egm-review). Reviewers also read every file the design document links. The authors state the boundary: "This is context and tool isolation, not filesystem isolation" (Claude integration).

Host Fresh-context mechanism What enforces read-only
Claude Code Agent tool; the reviewer adapters set tools: [Read, Grep, Glob] and omitClaudeMd: true (needs Claude Code 2.1.271 or later). The synthesizer adapter has Agent, Read, Grep, Glob, Write and no omitClaudeMd Host tool list (claude.md)
Claude Cowork Subagents cannot nest, so the main context dispatches reviewers (claude.md) Reviewer tool restrictions remain unverified there (claude.md, TESTING.md)
Codex fork_context: false or fork_turns: "none"; a general-purpose child reads the persona file (codex.md) No host control documented; the shared persona text asks for read-only (inferred, see #262 below)
Antigravity invoke_subagent with named personas (harnesses.md) No host control documented; the shared persona text asks for read-only and has no tool list (design_critic) (inferred, see #262 below)
ChatGPT The package declares local execution. Some Work sessions expose spawn_agent with fork_turns: "none"; without it the skill stops (codex.md) Not verified. One Work run completed nine reviewers, with the final artifact and child tool traces outstanding (TESTING.md)
omp (community-tested) Native task agents with nesting, and a Claude-compatible manifest fallback (harnesses.md) Not verified. The end-to-end fixtures were not run (TESTING.md)
Standalone Antigravity IDE No subagent tool Review stops (harnesses.md)

Not every EGM subagent is read-only. The bootstrap orchestrator adapter allows Bash and Edit, and its Bash is not a filesystem or network sandbox (Claude integration). omitClaudeMd is how Claude reviewers avoid project instruction files; see per-subagent instruction inheritance. Other hosts have no equivalent in the plugin, which is the subject of issue #237 below.

Resolution and convergence

The Elephant answers each finding with one of four verdicts: PROPOSE FIX, CONTEST, ESCALATE, or DECLINE (egm-resolve). A contest must cite evidence the reviewer could read, such as a file and symbol. When the evidence sits outside every readable file, the finding goes to the human as ESCALATE. The skill says "Do not add context only to satisfy a reviewer". Add context a human reader needs, and ESCALATE what only a zero-context subagent needs. The skill also forbids contesting a comprehension gap, because a fresh reader who could not follow the document shows the document is missing context (egm-resolve). The resolver also guards against its own bias: "A wish to contest is not evidence that the reviewer is wrong" (egm-resolve). The protocol has its own page, four producer verdicts for resolving reviewer findings.

Within egm-review, stages 7 and 9 invoke the review loop in every preset except the consolidated report (stage 7, stage 9, consolidated report). The loop skill also runs on its own. The human confirms each new round (egm-review-loop). The loop stops after two consecutive clean rounds, at a cap of 5 rounds, or on churn. Churn means a new finding lands at the scope of an applied fix, and reverting that fix would resolve it. A round is clean when no reviewer raises an unsettled Blocker or Major finding, judged on the findings before that round's fixes. Nits do not block, and a reviewer that did not run makes the round not clean. The skill explains why zero findings is the wrong target: "Fresh reviewers sample differently each round" (egm-review-loop).

A contested finding or an accepted risk is settled and stays closed. A fixed finding re-opens if a later reviewer raises it again (settled and fixed findings). At the cap or on churn the human chooses to accept, continue, or return to drafting. The cap is a checkpoint, not a hard limit (cap and churn). A reviewer that fails twice is recorded as "not run", never as zero findings (egm-review-loop).

A separate cap allows one re-audit per stage after a manual edit or an agent resolution. If the human requests another manual update after that re-audit, the skill records the residual findings as accepted trade-offs. It then advances to the next stage (egm-review). The skills do not state how the two caps interact.

Packaging

One source tree feeds every host. scripts/pack_plugin.py builds a claude and an openai target from explicit allowlists (pack_plugin.py). Antigravity installs from the repository root (harnesses.md). A unit test compares every path and byte of the checked-in distributions/claude/ with a fresh build (test). Upstream rejects separate packages because "Separate hand-maintained packages would drift" (runtime_packaging.md, L100).

Install the whole plugin, because the skills read agents/ and the standards at run time (harnesses.md). The Claude marketplace entry points at the repository root, not at distributions/claude/ (marketplace.json). The freshness test therefore guards the generated bundle only, and it says nothing about host isolation. The general practice is in portable agent definitions and per-surface plugin verification.

Trade-offs

Chose Over Cost
Context reset plus rubric (inferred; upstream does not discuss a second model) A second model family Same-model blind spots can repeat (see the next section)
Many narrow reviewers in stages One general critic 9 reviewer launches in one full review pass. The recorded fixture runs launched 15 or 16 with brainstorm included (test_codex.py, TESTING.md). Review loops and retries add launches
Recall over precision Fewer findings "This will provide a lot of feedback by design" (getting started); the human triages
A human gate at each step An autonomous flow with no human decisions Excessive documentation "can become a bottleneck" (FAQ); skip EGM for a small, clear bug fix (README). The consolidated preset skips the stage checkpoints and keeps the final human triage
Stop without a fresh context Fall back to same-context review Unusable on hosts with no subagent tool
Normal host permissions An auto-approve hook More permission prompts (inference). A denied read stops that reviewer, and upstream says "A denied read must stop the affected reviewer" (runtime_packaging.md)

The authors also state limits. "A review does not replace tests or human judgment" (README). A document complete enough for a zero-context agent is achievable "Sometimes, but not always" (FAQ).

Same model or different model

EGM and the critic agent pattern disagree on where reviewer independence comes from. The critic page says a different model creates genuine disagreement because it does not share the planner's blind spots. It cites a 64.5% self-correction blind-spot rate. That study injects the same error into a conversation and credits it to the model or to the user. It tests 14 open-source non-reasoning models (arXiv 2507.02778). It does not test one model reviewing another model's output. A fresh reviewer receives the draft by path with no author attached, so it may not treat the draft as its own output (inference). The figure therefore does not decide between the two designs. EGM's Claude adapters use model: inherit (Claude integration). The authors do not say why. Independence then comes from a context reset, a rubric file, and read access to source code (inference). The launch post says the Goldfish "share no 'blind spots' with the designer" (Google Open Source Blog). With inherited models that holds for conversation history and not for training (inference). The adversarial multi-model pipeline combines both, a fresh context and a different model family.

An outside review argues that reviewers on the same base model can repeat the same API misconception. Its author did not run the plugin (Digital Applied). No source compares same-model and cross-model Goldfish reviewers, so the question stays open.

Evidence

Upstream reports no controlled measurement of design quality, defects, or productivity. What exists:

  • An adoption claim, "Thousands of Google engineers use EGM", with no count, dates, or method (README).
  • Harness runs that show the machinery works. On Codex, two live tests passed in 573 s and a full live suite in 482 s, and each run completed 15 reviewers. Antigravity ran 16 (TESTING.md). Claude Code passed after an initial stage-order failure. A usage limit stopped Cowork at stage 8.
  • One bootstrap run per version on a 4-package fixture, where symbol citations rose from 0 to 52 across 5 READMEs (PR #109). The PR author reported it as "evidence, not a benchmark", the reviewer did not re-run it, and it counts citations, not their accuracy.
  • No source reports the token cost of a review. The one upstream cost statement says runtime and token costs "have not been measured" for three proposed hosts (scope, multi_harness_support.md).

One design doc calls the review skill's test_scenarios.yaml a benchmark of "review precision and recall" (review.md). The scenario files in the skills are regex pattern checks, and the only test checks that each file exists and is well formed. Nothing runs the scenarios (test_scenario_coverage.py). The FAQ states the limit: "Completing the EGM workflow alone does not demonstrate a productivity improvement" (FAQ).

Known upstream gaps

These three issues were open on 2026-11-03:

  • #237: on Codex host-injected AGENTS.md files reach reviewers, and on Antigravity AGENTS.md and GEMINI.md files do, despite the fresh context. The harness guide lists these hosts as passing reviewer isolation (harnesses.md).
  • #262: a low-severity hardening task from a read-only security review of commit 403d888, on file paths, write targets, and parallelism. Its completion criteria include a per-host statement of whether reviewer read-only is host-enforced or prompt-only.
  • #271: a contributor ran egm-drift-report at commit 403d888 and found the design docs out of step with the shipped skills.

Example

The Claude adapter for the comprehension reviewer carries the isolation settings. The shared persona file holds the review instructions (adapter):

---
name: egm-comprehension
description: Naive reader and comprehension reviewer.
license: Apache-2.0
tools: [Read, Grep, Glob]
model: inherit
color: yellow
omitClaudeMd: true
---

Read `${CLAUDE_PLUGIN_ROOT}/agents/comprehension.md` before reviewing.
Follow that canonical persona's instructions. This adapter defines your Claude
tool and context restrictions. Resolve bundled standards against
`${CLAUDE_PLUGIN_ROOT}`. Remain read-only and use only the task and explicitly
supplied review context.
Before returning findings, read the target and every supplied standard. If a
required file cannot be read, report an incomplete review instead of a verdict.

Everything below the frontmatter is prompt text. The tools list backs its read-only line, and Claude Code enforces omitClaudeMd. The model alone enforces the rest.

Key Takeaways

  • Treat "zero context" as no earlier conversation. Goldfish reviewers still read the document, the files it links, the rubric, and any reading list the human supplies.
  • Check per host whether reviewer read-only and instruction-file exclusion are enforced by the host or only by the prompt.
  • Stop a stochastic review loop on consecutive clean rounds, and record a failed reviewer as not run.
  • Make the producer cite reviewer-readable evidence to contest a finding, and send the rest to the human.
  • Do not cite EGM as proof that the method improves designs; upstream reports no controlled measurement of design quality or productivity.
Emerging — single recent source Last reviewed: 2026-11-03