Intro to Agent Client Protocol (ACP): The Standard for AI Agent-Editor Integration

I code best when I sit criss-cross applesauce on my bed or couch with my laptop in my lap, a snack nearby, and no extra screens competing for my attention. Sometimes I keep the editor and browser side by side; other times, I make them full screen and switch between applications. I don't like using multiple monitors, and my developer environment is embarrassingly barebones.

The described setup allows me to fall into a deep flow state, which is essential for staying productive as a software engineer. It gives me the focus to dig beneath the surface of a problem, trace its root cause, and think about how every fix or improvement affects both users and the system as a whole. While quick bursts of multitasking may work well for other fields, real productivity in engineering often comes from long stretches of uninterrupted thought.

Recently, my workflow changed.

The Three-App Problem

Now that I use an AI agent regularly, I need to juggle three applications: my editor, my AI agent, and my browser to see what gets rendered. This creates several challenges that disrupt my flow:

• Reduced screen real estate. When I try to keep all three windows visible at once in a split-screen layout, each window becomes cramped. My editor shrinks to a narrow column, making it hard to read code. The AI agent window can't display full responses without scrolling. And my browser preview gets squeezed into a tiny viewport that doesn't reflect how users will actually see the app.

• The temptation to go agent-only. To avoid the cramped feeling, I sometimes keep only the AI agent window open full-screen, trusting whatever it generates without switching to my editor to review the actual code changes or examine diffs. While this works fine for experimental projects, production systems require human oversight and careful code review.

• Awkward context switching. My other approach is to keep the AI agent full-screen but actually do the responsible thing and review its work. I'll read the agent's suggestion, switch windows to my editor to see the change, switch to my browser to check what rendered, then switch back to the agent to continue refining the code through iterative prompts (what Patrick Erichsen from Continue calls chiseling). This constant window-switching breaks my concentration and creates opportunities for distraction (hello, Twitter/X).

Common Workarounds

Many developers have tried to solve this integration challenge:

• IDE-integrated agents like Cursor have an AI agent baked into the code editor. However, this creates vendor lock-in where you must use their specific agent with their specific editor. If I preferred VS Code as an editor and Claude Code as my agent, I'd be out of luck. I can't mix and match the tools I want.

• CLI agents in the terminal work for some people. They run the agent directly in their editor's terminal pane. goose has a CLI I could use this way, but I prefer the desktop app's interface for readability and navigating responses. The tradeoff is the constant window-switching I was trying to avoid.

• IDE extensions and plugins seem like an obvious solution, but maintaining these integrations is incredibly difficult. In the past year, multiple maintainers built VS Code extensions and even an IntelliJ plugin for goose, but our twice-weekly releases quickly made them outdated. Maintaining these extensions became a constant game of catch-up that our community couldn't win. Extensions have to mirror goose's functionality to work properly, so every change to goose requires updating the extensions. Maintainers couldn't keep pace, and building specific integrations for every editor simply doesn't scale when agents evolve at such a fast pace.

Introducing Agent Client Protocol

Zed Industries, the creators of the Zed code editor, developed a solution called Agent Client Protocol (ACP) that resolves these integration challenges. ACP allows you to bring any AI agent into any supporting editor without vendor lock-in. More importantly, it solves the maintenance problem because the AI agent and editor communicate directly through a standardized protocol.

This standardization is achieved by defining a common language via JSON-RPC. Instead of every editor and agent building private, complex handshakes, ACP uses a simple, predictable sequence of structured messages to manage the agent-editor session:

• session/initialize: Your AI agent tells the editor what capabilities it supports (audio, text prompts, etc.)
• session/new: When you start a new session, the agent and editor establish communication
• session/prompt: When you send a prompt, the agent receives and processes it
• session/update: The agent sends responses back to the editor
• session/cancel: When you cancel a session, the agent stops processing

Today, editors that support ACP include Zed, Neovim, and Marimo. Supported agents include Claude Code, Codex CLI, Gemini, StackPack, and of course, goose.

Restoring Developer Flow

For developers like me who have specific ways of achieving flow state, this means we can add AI assistance without completely restructuring our work environment. I can keep my criss-cross applesauce position, my split-screen setup, and my focused workflow while having goose integrated directly into my editor.

Beyond personal workflow preferences, ACP lowers the barrier to innovation by allowing AI agents and editors to evolve independently while speaking a shared language. And it's part of a broader movement toward open standards in AI tooling.

You might have heard of MCP, which standardizes how AI agents connect to data sources and tools. ACP and MCP complement each other perfectly: MCP handles the what (what data and tools can agents access), while ACP handles the where (where the agent lives in your workflow). Together, they create an ecosystem where developers can mix and match the best tools without vendor lock-in.

The goose team continues working to keep goose cutting-edge in the AI agent space, and we're excited about a future where open protocols let developers work however they work best.

See ACP in Action

If you're ready to see how fast and simple this setup really is, watch the full livestream recording of my ACP setup with goose below

Ready to integrate goose directly into your editor? Get started with our ACP setup guide and share your experience in our Discord community.