Google's open Elephant-Goldfish plugin makes AI coders plan before coding

Google has published the Elephant-Goldfish Model (EGM), an open-source plugin that makes AI coding agents write a design specification first and then hand it to reviewer agents that have not seen the planning conversation, before any code is written. The project is released under the Apache 2.0 licence, installs into Claude Code, Codex and Antigravity, and its README states that it is not an officially supported Google product.

The plugin is drawing attention quickly. The repository tracker Faundr lists it at about 14,000 GitHub stars, with 6,166 of them gained in the last seven days, and places it at number 21 for the week. The idea behind it is simple. Plan reviews by agents are more useful when the reviewers do not inherit the planner’s assumptions.

How the Elephant-Goldfish split works

EGM assigns three roles that each get different information:

• Elephant: receives project history, architecture, user goals and the design conversation. Its job is to clarify the problem and write a reviewable specification.
• Goldfish: receives the design document, relevant code and an assigned review lens, but not the prior chat. Its job is to try to explain, simplify or break the plan before code is written.
• Human: receives the competing reports and the real product constraints. This person chooses trade-offs, rejects weak feedback and approves the work.

The key design choice is the information boundary, not the number of agents. Reviewers get the written plan and the code but not the conversation that led the main agent to its conclusions. They can therefore question assumptions that the planning session may have started to treat as settled. “Zero context” in this sense means no inherited conversation. It does not mean no information at all.

JQ AI Systems, which reviewed the project, attributes the model to Google’s open-source announcement and to a foundational essay by Dave Rensin. The same coverage reports that the Google Open Source Blog describes the method as developed internally and used by Google engineers.

What the plugin’s commands do, step by step

EGM appears to the coding agent as a set of slash commands. According to JQ AI Systems’ review of the repository, the workflow runs as follows:

1. Bootstrap (optional). /egm-bootstrap maps an existing codebase and creates or updates directory-level README “contracts”, which are written statements of what each part of the code is supposed to do. The official guide says existing design documents may already provide enough context, so this step can be skipped.
2. Brainstorm. /egm-brainstorm questions the proposed feature and uses separate reviewer lenses to stress-test the concept. It produces a concept brief, not code.
3. Draft. /egm-draft builds a Markdown design under docs/designs/. The design covers problem scope, user journeys, technical approach, alternatives and implementation steps.
4. Review and resolve. /egm-review docs/designs/<feature>.md runs fresh-context reviewers across comprehension, design criticism and implementation readiness. A human then resolves their findings.
5. Implement, test, check drift. The developer builds against the approved spec and runs normal tests. Later, /egm-drift-report compares the design contracts with the live code.

The repository’s workflow guide also recommends a human review of the design pull request.

Five reviews, or a multi-stage pipeline?

Some descriptions of EGM say a spec passes five review stages. The sources give a narrower picture. The demonstration video that JQ AI Systems analysed shows five review rounds in the run it chose. The repository’s current architecture describes the review as a multi-stage pipeline. Builders should read “five” as what one demo showed, not as a fixed number in the tool.

Key details at a glance

Item	Detail
Name	Elephant-Goldfish Model (EGM)
Licence	Apache 2.0
Support status	Created at Google; README says not an officially supported Google product
Hosts with install routes	Claude Code, Codex, Antigravity
Main language	Python
Repository created	13 September 2026
GitHub stars / forks	About 14k stars, 1.1k forks
Cost	Free to download; agent calls consume your model allowance or API budget

What the independent demo showed, and what it did not

The most detailed public test so far comes from AI Labs, which ran EGM on a demo fashion app. The team did not ask an agent to build a new seller analytics page right away. Instead it mapped the app, debated the feature, wrote a design, and sent fresh-context agents to challenge that design. In that run the bootstrap step produced 28 new READMEs for the demo app.

After implementation, the drift check found a separate rule violation. Shop owners could delete a product after it had sold, but the documented rule allowed sold products to be hidden, not deleted. JQ AI Systems describes this as a good example of the method’s value, because the problem was a business rule that spans data and UI behaviour, not a malformed line of code.

The limits of this evidence are significant:

• The fashion-app results come from AI Labs’ own demonstration and transcript. JQ AI Systems says it did not run the app or reproduce the bug.
• The video includes a sponsorship and promotes AI Labs’ own community and software service.
• The video shows the drift report identifying the deletion issue. It does not establish that EGM found every defect or that the new analytics feature was fully correct.

No source provides benchmark numbers for EGM, such as defect rates, time saved or comparisons against agents that skip the planning step. The evidence so far is the repository, Google’s description of internal use as reported by JQ AI Systems, and one demo by an interested party.

Access, cost and support

EGM is open source and free to download. Every Elephant and Goldfish step is a model call, though, so running it still consumes your model allowance or API budget. A multi-reviewer pipeline makes several calls per design, so builders on metered API plans should expect each planned feature to cost more than a single prompt-and-implement pass. The sources do not quantify that cost.

The project’s harness guide lists separate install routes for Claude Code, Codex and Antigravity. Faundr’s tags for the repository also include Gemini, multi-agent workflows and spec-driven development. JQ AI Systems advises reviewing the repository and its version before giving any plugin access to a valuable project.

The support status matters for teams adopting it. The project was created at Google, but the README says it is not an officially supported Google product. JQ AI Systems suggests treating it as community-maintained open-source software rather than a Google support contract.

What it means for builders, and where it falls short

For teams that already use coding agents, EGM turns a common manual habit into a repeatable workflow: ask for a plan, have someone else poke holes in it, then build. The specific contribution is giving reviewers a clean slate so they are less likely to repeat the planner’s blind spots.

JQ AI Systems recommends EGM for features where a wrong data rule, user journey or architectural decision would be expensive to undo. For small, contained fixes, the repository’s own getting-started guide says not to force the full workflow.

The sources also set out clear limits:

• Reviewers can be wrong. A Goldfish can overlook a problem, misunderstand the code, or share the same model biases as the Elephant. Its report is evidence to weigh, not an automatic veto.
• Generated documentation can mislead. Bootstrap-generated READMEs need review before teams rely on them. A drift finding can mean either the code is wrong or the document is stale, and a person has to decide which to change.
• It does not replace engineering process. EGM does not define a team’s build, security or test strategy. A detailed plan feeds those checks but does not replace them.
• Findings need verification. For the demo’s deletion bug, JQ AI Systems says a production fix would still require reproducing the deletion path, checking affected orders and permissions, adding a regression test, and deciding whether the rule or the code should change.

Related Google Research work on agent harnesses

EGM is not the only recent Google project focused on the scaffolding around coding agents rather than the models themselves. A separate Google Research repository, Harness², defines a harness as “the system around a model that enables it to act as an agent: prompts, tools, memory, skills, orchestration, and more”. It is a framework for automatically refining that system while model weights stay fixed. It supports OpenCode and Codex executors and lists plugins among its eight editable harness components. The sources do not connect the two projects. Taken together, they show attention shifting toward how agents are organised, not only which model sits underneath.

What to watch next

• Independent results. So far the public evidence is one sponsored demo. Reproducible comparisons of EGM-planned features against direct implementation would show whether the extra review calls pay off.
• Whether the review pipeline settles. The difference between the demo’s five rounds and the repository’s “multi-stage pipeline” description suggests the review design is still changing.
• Adoption and maintenance. The star growth on Faundr’s tracker shows strong early interest. Because the project carries no official Google support, how actively it is maintained will matter for teams that build it into their workflow.
• Host coverage. Install routes currently cover Claude Code, Codex and Antigravity. Support for other agent hosts would widen who can use it.

For related reading on coding-agent risks, see Unicorn API’s earlier report on Claude Code committing secrets to public repos.