How I Added Goose as an External Agent to Entire

I just opened a PR to add support for Goose to Entire. Goose is an open source coding agent under the Agentic AI Foundation, the first ever MCP client, and a reference implementation for the Model Context Protocol. I am super excited about this because it is exactly where my two worlds collide. I previously worked on the team building out Goose. Although I left the team to join Entire, I still maintain the Goose documentation and stay semi-active in the project.

This post walks through how I built the integration. It also doubles as a guide for adding support for your own favorite agent to Entire.

What is Entire?

The traditional software development lifecycle was not built for AI agents, so Entire is building the one that is. We identified major friction points that make it hard for humans and agents to collaborate. For example, agents often put up massive PRs that human developers simply do not want to review. Additionally, you completely lose the reasoning behind AI-generated code days after it gets merged because no human actually wrote it.

We have much more coming down the road, but we started by launching a CLI-first tool that records your agent sessions. It logs the prompts, the agent responses, tool calls, and everything in between.

That way, when you want to find out why a feature was implemented a certain way, you can go straight to the transcript and read through it .Personally, I prefer to either ask my agent or run a command like entire checkpoint explain to get a summarized rundown of the exact conversation behind a line of code. All sessions get version controlled via git and live on a dedicated metadata branch within the same repo.

Why add your own agent?

Entire ships with built-in support for leading coding agents like Claude Code, Gemini CLI, Codex, Cursor, and Copilot CLI. But the agent ecosystem moves incredibly fast, and no single team can support every new tool that drops.

So, we built the external agent protocol that allows you self-serve add support for any agent you prefer to Entire. It gives you a completely self-serve way to add support for any agent you prefer. The user experience is identical to using a built-in agent. All the exact same commands and functionality just work. If Entire doesn't support your favorite agent yet, you don't have to wait on us. You can build the integration yourself directly in the entireio/external-agents repo.

Why Goose?

As a maintainer and former full-time developer on Goose, I've been looking for the perfect excuse to wire it up to Entire. The main technical blocker was that Goose didn’t support hooks. Hooks inform Entire when a session starts, when a user submits a prompt, and when the agent finishes a turn. This allows Entire to know when to start and stop recording the session activity.

Recently Goose implemented support for hooks, following the Open Plugins hooks spec, so now I could fulfill my dream.

What your agent needs

To wire your agent up to Entire, it needs to have the following:

A hooks or lifecycle mechanism: You need a reliable way to run an external command when a session starts, a prompt is submitted, or a turn ends. Without this, Entire cannot observe the session.
Readable session data: You need access to transcripts or an exportable session store containing the actual conversation. We need real assistant responses and precise tool calls, not generic placeholder text like "Working...".
Stable session identity: A consistent session ID that you can extract from hook payloads, ideally paired with a resume command (like goose session --resume --session-id <id>).
A non-interactive CLI mode: Running commands cleanly (for example, goose run -t "prompt") makes writing automated lifecycle tests dramatically easier.

What you need

You also need the following items on your device:

Your target agent’s CLI install and authenticated
Entire CLI installed
Go toolchain because external agents for Entire are written in Go.
Open an issue first to get alignment with the team at Entire requesting that you want to add this agent. Introducing a new agent means a long-term support commitment for us!
Optional: An agent that you would use to implement this integration. I used Claude Code with Fable 5. This way, I didn’t have to manually write all the code. Claude Code just followed the pattern to integrate Goose with Entire.

The step-by-step workflow

1. Run the Agent skill

The external-agents repo includes a built-in developer skill that automates the heavy lifting: entire-external-agent. Clone the repository, open it up in your favorite AI development tool, and run:

/entire-external-agent

2. The three development phases

Phase 1: Research - The skill analyzes the protocol spec, probes your agent's binary commands, and, crucially, writes a verification script to capture real hook payloads.

For Goose, this script wired a capture plugin into a temporary workspace, executed a real goose run prompt, and dumped the exact stdin payloads to disk. Documentation can lie, but captured payloads never do. This phase also ensures the session data is clean and stores everything in an AGENT.md summary file.

This phase revealed that Goose sessions live in a global SQLite database rather than isolated files, meaning our binary had to materialize transcripts on the fly using goose session export --format json.

Phase 2: Write tests - The skill scaffolds a fresh Go binary that stubs out the required protocol subcommands with valid JSON shapes. It registers your agent in our end-to-end testing harness. At this point, the shared compliance suite (entireio/external-agents-tests) is supposed to fail. Those specific failures become your exact development roadmap.

Phase 3 - Implement - Now that we (you and the agent implementing the integration) have specific test failures, your agent can use a test-driven development approach to identify the code needed for this to work. It can take those failures and write the code to fix them step by step. For Goose, the failing tests pulled the agent through hook installation, session read and write round trips, and transcript validation. Finally, the agent writes unit tests using the actual data it recorded back in Phase 1 to prove its translation code works perfectly.

When Entire first discovers your integration, it does a quick programmatic handshake to ask, "What features do you (the target external agent) actually support?" Your external agent binary (mine was Goose in this case) answers by declaring its capabitilies. This list tells Entire exactly what tasks it is allowed to hand off to your agent.

Here are the specific capabilities Goose declared:

hooks: Tells Entire that the binary can use Goose's native plugin system to listen for session events.
transcript_analyzer: Tells Entire that the binary can read the raw JSON data to find the user's prompts, the tool calls, and the files that were changed.
transcript_preparer: Tells Entire that the binary knows how to pull the conversation history directly out of the local SQLite database.
token_calculator: Tells Entire that the binary can track the total AI tokens used during the session.
compact_transcript: Tells Entire that the binary can clean up the raw conversation formatting so it looks readable when you run entire checkpoint explain.

The test harness (in my case Claude Code) automatically runs your new binary (Goose now integrated with Entire) through protocol compliance checks, live LLM prompt scenarios, and session persistence validation to ensure everything works perfectly.

4. Open your PR

Before putting up a pull request, remember to open an issue first to get alignment with the maintainers. Introducing a new agent means a long-term support commitment for the repository. Once aligned, push your branch and open the PR. Our CI pipeline will automatically compile your binary, run the compliance suite, and verify your unit tests.

Check for additional bugs

After the agent skill finished running, I tested the integration myself.

I ran the following command in a repo I didn’t care about:

entire enable --agent goose

Then, I prompted goose to make some file changes, commit, and push. I found one bug where it wasn’t generating the full session transcript, and it only generated the first user prompt. I had Claude Code survey past agent integrations to look for patterns and identify what was missing. I added those fixes to my PR, and then I was done!

It felt lightweight because Claude Code did all the heavy lifting.

Now, I have to wait and see if my teammates approve my PR.