Bring Your Own Agents to Entire

You can now bring your own agent to the Entire CLI. Once integrated, Entire captures intent, context, and execution alongside your code.

Since launching in February, we've added native support for popular agents including Claude Code, Codex, Gemini CLI, Cursor, FactoryAI, OpenCode, and GitHub Copilot CLI. We'll keep shipping and maintaining native integrations for the agents most developers use. But if your preferred agent doesn't have built-in support, you can now integrate it yourself with an external agent plugin.

Build Your Own Plugin

You don't need to edit Entire's source code to add support for a new agent. Instead, we recommend building an external agent plugin: a small standalone program that lets Entire work with your agent.

There are two ways to build an external agent plugin. You can use the External Agents Skill, or you can build one from scratch. Our External Agent Plugin docs cover the full architecture in detail.

Use the External Agent Skill

The fastest way to build a plugin is with the workflow we've set up in the external-agents repo. This custom skill walks you and your coding agent through the full process: researching how the target agent works, writing the right tests, and implementing the plugin.

To get started:

1. Install the skill from the external-agents repo for your preferred coding agent.
2. Run /entire-external-agent.
3. Follow the prompts through the three phases: research, testing, and implementation.

We also provide a companion test suite, so you can verify that your plugin follows the rules for communicating with Entire. If you want a starting point for your own plugin, we built roger-roger as a reference implementation you can adapt to your agent.

If you prefer, you can also build the plugin from scratch. Let's walk through what that looks like in practice. We'll use Pi, one of our most recent integrations, as a concrete example.

Name Your Plugin Binary for Discovery

To begin, name your plugin binary using the entire-agent-<name> convention and make sure it is available on your system PATH.

For our example, we named the executable entire-agent-pi. When the plugin binary is on your PATH and follows this naming pattern, Entire can discover it automatically.

Support the Entire CLI Command Set

For Entire to communicate with your plugin, it expects a set of subcommands that let it gather information and trigger actions. You must implement a core command set, including info, detect, install-hooks, parse-hook, and read-transcript.

In our Pi implementation, we handle this with a standard Go switch statement that routes incoming requests:

switch os.Args[1] {
case "info":
    // Returns metadata about the Pi plugin
case "detect":
    // Checks if Pi is installed on the system
case "parse-hook":
    // Translates Pi events into Entire events
case "install-hooks":
    // Injects the TypeScript extension into Pi
case "read-transcript":
    // Parses Pi JSONL logs
}

Map Native Events to Agent Hooks

Agent hooks are how the Entire CLI observes what an agent is doing. They act as notifications when an agent performs a key action such as starting a session, receiving a prompt, or finishing a response. Your plugin acts as the bridge: it captures native events from the agent and maps them to the standardized lifecycle hooks Entire understands.

In our Pi implementation, the plugin installs a small TypeScript extension under .pi/extensions/entire/. This extension listens for Pi's internal events and forwards them to the plugin as normalized lifecycle events:

pi.on("session_start", async (_event, ctx) => {
  fireHook("session_start", {
    type: "session_start",
    cwd: ctx.cwd,
    session_file: ctx.sessionManager.getSessionFile(),
  })
})

pi.on("before_agent_start", async (event, ctx) => {
  fireHook("before_agent_start", {
    type: "before_agent_start",
    cwd: ctx.cwd,
    session_file: ctx.sessionManager.getSessionFile(),
    prompt: event.prompt,
  })
})

pi.on("agent_end", async (_event, ctx) => {
  fireHook("agent_end", {
    type: "agent_end",
    cwd: ctx.cwd,
    session_file: ctx.sessionManager.getSessionFile(),
  })
})

Inside the plugin, those hook events get translated into the protocol format Entire expects:

switch hookName {
case "session_start":
    return &protocol.EventJSON{
        Type:      1, // SessionStart
        SessionID: sessionID,
        Timestamp: now,
    }, nil

case "before_agent_start":
    return &protocol.EventJSON{
        Type:       2, // TurnStart
        SessionID:  sessionID,
        SessionRef: payload.SessionFile,
        Prompt:     payload.Prompt,
        Timestamp:  now,
    }, nil

case "agent_end":
    return &protocol.EventJSON{
        Type:       3, // TurnEnd
        SessionID:  sessionID,
        SessionRef: sessionRef,
        Timestamp:  now,
    }, nil
}

Expose Transcripts to Entire

Entire captures Checkpoints, which are snapshots of both code changes and the session context behind them. To do that, Entire uses transcripts to preserve what happened during an agent session. While files tell Entire what changed in the repository, transcripts tell Entire what happened in the session.

Your plugin needs to tell Entire where the transcript lives so it can read it. For Pi, transcripts are stored as JSONL session files. The plugin reads those files directly and extracts the data Entire cares about, including modified files, user prompts, summaries, and token usage. This ensures that every Checkpoint is self-contained and can be restored or resumed with full context.

If you want to see what that looks like in practice, the Pi transcript implementation is a good reference for handling custom log formats.

Enable and Verify the Integration

Once the plugin binary is on your PATH, you're ready to activate it:

$entire enable --agent pi

Entire will discover the plugin, run its installation hooks, and start tracking your sessions. To verify everything is working, run a real session with your agent. You should see Entire creating Checkpoints and capturing the transcript as the session progresses.

Ready to Integrate?

Bringing your own agent to Entire means you don't have to wait for first-party support before your workflow can benefit from Checkpoints, transcripts, and session context.

If an agent you rely on isn't supported yet, you can integrate it yourself and keep your existing workflow while gaining a full development history alongside your code.

Explore the docs to get started, and join us on Discord if you'd like help or want to share what you build.