AI Engineer Europe 2026
Building an ACP-Compatible Agent Live — Bennet Fenner, Zed
Read the talk
Building an ACP-Compatible Coding Agent in Zed
A minimal TypeScript agent gains sessions, streaming text, visible tool calls, editor-aware file access and a terminal tool through the Agent Client Protocol.
From a talk by Bennet Fenner
Before you start: Familiarity with TypeScript, asynchronous events and basic model tool calling will help you follow the implementation.
Bring your agent to your editor
How can an editor let users bring their preferred coding agent while giving them a consistent interface? That is the problem Bennet Fenner starts with at Zed, an AI code editor written in Rust. Claude Code, Codex and Gemini CLI have made the terminal a common home for coding agents. Supporting each one through a separate editor integration would mean repeatedly solving the same communication problem.
Agent Client Protocol, or ACP, provides a shared interface between agents and clients. It is an open-source, JSON-RPC-based protocol, analogous to the role MCP and LSP play in connecting otherwise separate systems. The editor can present an agent's work without needing to understand that agent's native interface.
Agents can participate through an adapter that translates their native interface into ACP, or implement ACP directly. Fenner names OpenCode and Cursor as examples with built-in ACP modes. Fenner estimates that up to forty clients supported ACP at the time of the talk. He describes OpenClaw as both a client and an agent, and names JetBrains and Obsidian among the supporting clients. The live coding session takes the agent side of that boundary: start with an ordinary coding agent and make its work accessible to Zed.
Suggest correction
Start with the model loop
The starting code is TypeScript, although Fenner introduces himself as a Rust developer with little TypeScript experience. It already implements a minimal coding agent, with two tools and no ACP support. A read tool accepts a file path and returns its contents. An edit tool accepts a path, the old text to find and the new text to substitute into an existing file. These tools provide the ability to inspect and change code before any editor integration exists.
The agent uses Anthropic's API. Because model requests are stateless, the agent maintains the conversation and sends the accumulated history with each request. Its loop follows a small procedure:
- Append the user's prompt to the conversation and call the model.
- Receive the model's response. An
end_turnstop reason means the turn is finished. - If the model requests a tool, execute the read or edit locally and collect its result.
- Add that result to the conversation and call the model again.
The tool handler initially reads directly from the filesystem. ACP does not need to replace this reasoning-and-tool loop; it needs to connect the loop to a client.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give the agent an ACP session
Fenner begins the conversion with a goal of doing it in ten minutes, using boilerplate from the ACP TypeScript SDK. The recording uses an interface-based implementation of an agent. Current SDK documentation instead recommends fluent agent() and client() APIs and deprecates the older connection classes; the walkthrough here retains the recording's interface-based structure.
The first method is initialize. The demo returns its latest supported protocol version and keeps capabilities minimal. More precisely, initialization negotiates a version: an agent returns the client's requested version if it supports that version, otherwise its own latest supported version. Both sides can advertise capabilities. The demo needs no interactive authentication flow because it obtains its Anthropic API key from an environment variable.
A session corresponds to a thread in the editor. Creating one generates a random identifier, instantiates the coding agent with the working directory supplied by the client, stores that instance in an internal map and returns the identifier. Subsequent prompts use that ID to reach the same agent and its conversation history.
A prompt request carries the session ID and an array of content blocks. ACP can carry text, images and other content, but this agent supports only text. The adapter looks up the session's agent, filters out non-text blocks and passes the resulting text to the existing prompt function. That starts the model-and-tool loop described above.
Fenner also wires cancellation through to the session's agent as a convenience. At this point the adapter has the basic path from initialization to session creation, prompting and cancellation. The completed code on screen shows prompt handling followed by the cancellation method that retrieves the agent and calls its cancel method.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A completed prompt with no visible answer
Zed does not need special code for this agent. Its configuration specifies an ACP-compatible agent launched with Node and the path to the compiled JavaScript file. Fenner builds the project, launches a fresh instance and enters a prompt. Zed shows a wait indicator, then finishes without displaying an answer.
The ACP debug view explains the missing piece. Zed sends session/new, receives a session ID, sends a prompt and gets a stop reason. Red adapter errors also appear in the view. Anthropic is producing output behind the scenes, but the agent has not forwarded that output to Zed. Handling the prompt request is not the same as publishing the response content. The adapter needs to send notifications while the turn is running.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Forward model text as session updates
To make output visible, Fenner passes the ACP connection and the session ID into the coding agent. The Anthropic SDK exposes text events through stream.on. Each event becomes a session update: a notification associated with the conversation, rather than the final response to the original prompt request.
The update type for model text is agent_message_chunk. Its content contains the new text, and its enclosing message identifies the session. The TypeScript wiring has this shape, with stream, connection and sessionId supplied by the agent's prompt handler:
typescript
stream.on("text", (text: string) => {
void connection.sessionUpdate({
sessionId,
update: {
sessionUpdate: "agent_message_chunk",
content: {
type: "text",
text,
},
},
});
});
The client can react to these notifications as they arrive; it does not have to wait for the prompt's stop reason to display the answer.
After rebuilding and restarting the agent, Fenner sends a greeting. This time Opus responds visibly in Zed, with individual chunks streaming into the conversation. The model loop was already producing text; the added notification path is what gives the editor something to render.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Introduce a tool call before updating it
Text output alone does not expose what a coding agent is doing. Fenner asks the agent to read helpers.ts. Its existing tool runs, and the model describes the file, but Zed does not show the read operation itself. The next layer is to publish tool activity through session updates too.
The agent first emits a tool_call update. It includes an identifier, a title, metadata describing the operation, an in_progress status and a file location. Those fields let Zed give the operation a useful presentation, including an appropriate icon and a connection to the affected file. The selected frame shows this initial read notification being added to the handler.
Once the client knows about that call, the agent sends tool_call_update messages for the same identifier. A later update can change the status and provide result content.
| Update | Purpose | Typical contents |
|---|---|---|
tool_call | Introduce the operation | ID, title, kind, status, locations |
tool_call_update | Update that operation | Same ID, new status, result content |
The ordering matters: the initial notification establishes the object the client will display; subsequent notifications change that object instead of introducing unrelated operations.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Read the editor's version of a file
The read handler still calls fs.readFile, which reads the file on disk. ACP offers a different path: when the client advertises the relevant filesystem capability, the agent can ask the client to read the file for it. This is explicit client-mediated file access, not automatic interception of filesystem calls.
The reason is an ordinary editor state: unsaved changes. A buffer can contain code that does not yet exist on disk. Calling readTextFile over ACP lets the editor return that current content, so the agent works with the version the user is looking at. The read capability must be available; read and write support are separate capabilities.
typescript
const { content } = await connection.readTextFile({
sessionId,
path: absolutePath,
});
The agent's read tool still returns text to the model. What changes is which component supplies that text.
Fenner runs npm run build, restarts the demo agent and asks it to read the file again. The read tool calls now appear in Zed. The test also exposes duplicated output, which remains visible as the demonstration moves on.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Show an edit as a diff
The read result now exposes the file's actual content in the client. Fenner applies analogous tool notifications to the edit handler, compiles again and restarts the agent. He asks it to add a Hello World comment at the top of src/agent.ts.
The edit produces a diff in Zed because the agent sends diff content over ACP. The integration has progressed from displaying model text to displaying a concrete code change. Duplicated initial tokens are still present; Fenner suspects something is wrong with the connection but does not debug the cause during the session.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Use the agent to add its next tool
With reads and edits working, the agent can modify its own implementation. Fenner gives it a prepared prompt asking it to add a terminal tool to itself. The prompt supplies information about the relevant ACP APIs, so the agent can use its existing file tools to implement the new capability.
Terminal support follows the same capability boundary as file access. A client can advertise that it creates and manages terminals for an agent. An agent could instead manage terminals itself, but using the client gives the editor a way to expose the running operation interactively. In the demo, the agent begins by adding a new tool description and proceeds to implement the terminal tool.
The generated implementation builds successfully. Fenner restarts the agent and asks it to wait five seconds and then list the directory. Zed displays a running terminal, followed by its output. This completes a useful progression: the original read and edit tools are enough to build another tool, while ACP gives the client a way to present the new operation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The demo's handoff
Fenner describes the ACP conversion as taking about fifteen minutes. He points viewers to the protocol site, but explicitly warns against using the agent-generated demo code in production. At recording time, the companion repository is empty; uploading the code is his stated next action. The closing repository slide is a handoff address, not evidence that the code is already available.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What the client computes, and how it connects
The first audience question clarifies who computes the diff. ACP supports a structured diff content type: the agent sends the file path and its old and new text, and Zed computes the displayed difference. The agent therefore does not need to generate the editor's visual diff or send a precomputed patch. It supplies the two versions; the client owns their presentation.
The final question asks whether the connection is local. Fenner specifies standard I/O as the transport used by the demonstrated implementation. He says remote-transport work is underway, tentatively attributing it to JetBrains contributors, and expects it soon. That is a forecast, not a capability demonstrated here. The working connection in this session is the editor launching the agent process and communicating with it over standard input and output.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Overview of the protocol connecting coding agents to editors and other clients.
Connect an ACP editor to OpenClaw or exercise its bridge with the built-in debugging client.
Run Cursor as an ACP agent and connect a custom client over standard I/O.
Further reading
Protocol-version negotiation and capability declarations for both sides of an ACP connection.
Message examples for tool progress, results, file locations and old/new-text diffs.
Read and write methods that let agents work with files and unsaved editor state.
Updates since the talk
Installation, runnable examples and current fluent APIs for implementing ACP agents and clients.
Read the complete timestamped transcript
- 0:00
[upbeat music] I'm Bennet.
- 0:15
I work at Zed, and we build like an AI code editor, uh, all written in Rust. And last year was kind of, as you probably all know, the rise of the, uh, AI coding agent terminal user interfaces with every major model provider, like building Claude Code, Codex, Gemini CLI, and so on.
- 0:34
And so at Zed, we asked ourselves, like how can we let users bring their agent of choice to our tool and enjoy like a nice interface that is unified across all of them?
- 0:47
And so that's why we decided we need some kind of- type of protocol, uh, called Agent Client Protocol, uh, which is similar to like MCP or, uh, LSP. It's a JSON-RPC based protocol, and the idea is basically that, uh, agents and clients can talk to each other through, through a unified interface.
- 1:06
And, uh, yeah, the... It's, yeah, o-online. It's open source. Uh, you can contribute if you want. Um, at this point, we have a wide variety of agents already supporting this, either by like an adapter that kind of like translates,
- 1:24
um, the agent's native language to the ACP one. Uh, and then we have like, for example, OpenCode and co-- uh, and Cursor, uh, having like ACP mode built into their like CLI agents.
- 1:36
And we also have a bunch of, uh, clients at this point, up to forty that, uh, implement this, including OpenClaw for example. Like OpenClaw itself is a client and a server actually, like a client and an agent.
- 1:49
Um, and JetBrains and Obsidian and other people are supporting this. Um, great. So, um, I'm gonna do a live coding session. Let's see how well that goes. Um, so- [laughs]
- 2:03
Right. Um, basically we have some pre-existing code. So this is Zed. Uh, here I have some TypeScript code. Also bear with me, I'm, I'm a Rust developer. I have basically zero clue about TypeScript.
- 2:15
So if you see anything that you don't do in TypeScript, tell me afterwards. [laughs] Um, but yeah, like here's a very minimal coding agent that just doesn't support ACP, but it's kind of the bare minimum you need to like build a coding agent.
- 2:29
So all it has is really like two tools. One to read a file and one to edit an existing file. Um, yeah, this is like pretty basic. It provides...
- 2:39
The model has to provide a path. Then it has to provide an old text that is like then just replaced with new text, and that's kind of everything.
- 2:48
And then we have, uh, in this case, like I'm using Anthropic. Uh, there's a way to prompt the agent, um,
- 2:55
uh, with... Yeah, the user can prompt the agent, which is the function that we were gonna call here. And then we enter the agent loop and that is kind of like the way all agents basically work, is the model APIs are stateless, so you just attach some like conversation up to this point.
- 3:12
You call the endpoint. In this case it's like the Anthropic API. And then we, um, yeah, we get like a message from the model, and either it can be like a end turn.
- 3:22
That means like the model decided to, uh, yeah, just output some text and do nothing or it can call a tool. And in this case it would be like a read or a write, uh, tool call.
- 3:33
And then in the case of a tool call, we like run the, for example, the edit file tool call locally, um, collect the result, and then send it up to the model.
- 3:42
Again, that's why there's this loop. Um, and then we call the API again with the conversation up to that point, and that's kind of everything. And then we have like these-- this like handle tool call function here, which, yeah, handles like read and write, uh, tool calls, which does what you expect.
- 4:00
We get the path, we read it from the file system, and we return some, some, uh, result. Right. So now the question is: How do we make this thing ACP compatible?
- 4:11
And hopefully we can do it in ten minutes. So let's see. Um, so yeah, I have some boilerplate here. Uh, in this case, I'm using the TypeScript SDK, as I said.
- 4:21
Um, and the way this works, you implement, uh, the agent interface provided by this, uh, library. And then you have to, at minimum, implement these three, uh, four functions.
- 4:33
So the first one that we're looking at is kind of this initialize here. Um, all we really have to do here is like respond with the protocol version we support, which in this case is just the latest.
- 4:44
There's also like some capabilities like client and, uh, the agent can itself advertise capabilities of stuff it supports. But we're building a bare minimum coding agent, so we don't support anything outside that's necessary, I guess.
- 4:57
And then for us, like authentication is irrelevant since it's just using my API key from an env var. And then there's this concept of sessions in ACP. So basically every time you start a thread in Zed or in a different editor or client, uh, you, you call a new session.
- 5:15
And in a session you can prompt and then, yeah, from there on you can like get, get your output. So all we really do here is like we generate a random ID.
- 5:27
Um, then we, um, instantiate, uh, this coding agent with the current working directory, which we get from the client. Um, we store it in our internal map and then just return the ID to the client so that the client knows, um, yeah, knows the ID and that is kind of then used inside prompt.
- 5:50
Um, because what prompt does in this case, um, it like prompt-- the prompt request, if we go to the definition here, all this is kind of doing is, uh, it provides a prompt, which is an array of content blocks that can be like text, images, whatever.
- 6:06
The session ID for reference- And so all we kind of have to do here is, yeah, we look it up in our internal state. We get the relevant agent, uh, for that, uh, current session.
- 6:18
And then I have a hel- helper function here, which just in this case ignores everything that's not a text because we don't support images and stuff like this. Um, and then we call this like prompt function I showed earlier, which then, uh, runs the tool calling loop.
- 6:34
And so then just like as a nice-to-have, uh, feature, we also support cancellation. Uh, that's also pretty, pretty simple. So these are kind of like the four minimal things we have to implement, and I have this hooked up in Zed just by there's no special code.
- 6:51
All I have is kind of like I tell Zed there's some a- ACP-compatible agent, and you can run it with Node and then my path to that agent JS file.
- 7:02
Um, so when I... Uh, let's do that in here as well. So when I run, I'm gonna build, um,
- 7:11
I'm gonna build, right? And then I'm going to restart, uh, yeah, launch a new ACP demo agent. And you can see if I ask it for something, you can see a wait indicator,
- 7:26
and now it's done. So nothing. [laughs] Which is what we expect, right? Because, like what we can see here, if I go over... Oops. Oh.
- 7:37
If I go over here, we have some kind of like ACP debug view in Zed, so to make it easier for us to develop. And you can see, like Zed sends a session new request.
- 7:47
We respond with a session ID, and as soon as I type in something,
- 7:53
we get prompt, and now we get a stop reason, right? So these red errors come from the, uh, from the adapter that we are building from the agent, but it's not outputting tokens, right?
- 8:06
Like behind the scenes, it's obviously like Anthropic is giving us tokens, but how do we make them show up in Zed? So that's the next thing that we, uh, yeah, wanna focus on.
- 8:16
So the first thing that we kind of need to do, like our coding agent itself, uh, needs to have a way to, um, send something over the connection. So what we're gonna do here is like the coding agent is gonna take the ACP connection and then also the session ID, and then inside here we have to provide
- 8:37
this, uh, connection and the ID. And then if we go... Okay, I'm just gonna close this. Right. If we go back here, now inside of a prompt, Anthropic, like this is the Anthropic SDK.
- 8:55
So in this case, like in... Oops. You can just use, um, this like stream on, uh, yeah. That's like a Anthropic, uh, SDK. Like you can react to a text event.
- 9:07
So every time we basically get a chunk, uh, we send this kind of what ACP calls a session update. As I said, a session is like a single thread or a conversation, and then you can send updates, kind of like notifications to the client that are not like a usual request response, right?
- 9:22
It can happen at any time, and the client reacts to it. And so here we are associating with the session update with a session ID. And then this like, uh, there's a type of session updates.
- 9:31
There are multiple. We will see more in a second. But this agent message chunk is just like, okay, hey, here's some new output from the model.
- 9:40
And so if we build again, uh, we go back to Zed. I'm gonna have to restart the agent. I go here,
- 9:51
and I say hello. Hello, hello. Well, here's Opus talking, right? You can see like we're streaming in these individual, uh,
- 10:07
chunks, right? Right, that we get from Anthropic. So, so far, so good. Let's hope the demo gods, uh, stay with us. Um, right. So that's one piece. The next thing though is like I wanna, like it's a coding agent, right?
- 10:21
It's supposed to edit code. So I can actually tell it
- 10:26
already because we have tool support, right? I can tell it to read, for example, this like helpers.ts file,
- 10:34
and it's gonna give me, if the WiFi isn't too slow, it's giving me a description of what this file actually contains. Like if you look here,
- 10:45
that's basically the description of the file. But again, you don't see it in the UI, right?
- 10:51
So now we need to emit more session updates similar to like what we did for text. So if we actually go towards the read file,
- 11:01
kind of what we need to do here is like the way it works usually in ACP, like you emit an initial tool call update, uh, which I'm gonna paste in here.
- 11:13
So yeah, again, we're emitting a session update. In this ta- in this case, it's a type of tool call.
- 11:21
And then there are multiple properties we can specify, for example, like the title, kind of some kind of metadata, um, that Zed uses, for example, for like, yeah, using some icons and stuff like this.
- 11:33
And then we indicate that the status is in progress, and you can also like associate tool calls with like actual, uh,
- 11:40
locations. And so now we signaling over ACP that something is in progress, right? This tool call. But then we also want to, at the end, like once the tool call is finished, like at the bottom here, we kind of wanna send another update.
- 11:56
And in this case, it's not tool call itself, but it's a tool call update. So you have to emit on the agent. You have to emit like a tool call, like session update of type tool call.
- 12:07
And then once, once the client knows about it, uh, you can emit updates for that. Uh, and this is the way that we set the status, and we can also return the content.
- 12:18
Um, and then one additional thing that I'm gonna do here is the, um, instead of like you can see here, we're calling, I guess it's a bit hard to see, but like here we're calling FS read file, right?
- 12:31
So we're just using the native file system APIs. But MC, uh, ACP actually proxies the file system too. Like the client can provide a, uh, uh, a file system capability and if it does, um, we can like proxy those, uh, file system tool calls over ACP and it kind of makes sense, for example, for an editor, right?
- 12:50
You wanna, um, if I have unsaved changes in my buffer, they're not actually on the file system, but the agent should still see them. So that's why we call this like, uh, read text file, um, over ACP.
- 13:04
And so now if you go back here
- 13:09
and hit NPM run build and then go back here,
- 13:15
restart and say read, uh, this file. Oops, not Rust.
- 13:29
Then we should be seeing, um... Yeah, so now we see read tu- uh, tool calls, right? Okay, something is going wrong because everything is duplicated. [laughs]
- 13:42
Um, yeah, but like here you can see the output, um, of the actual file and because I think I'm low on time, um, we're, we're gonna basically gonna do the same for edit file.
- 13:57
Um, and then we're gonna compile again. And if I again restart
- 14:08
and say add a comment at the top of
- 14:14
agent, src/agent.typescript, then you're gonna see, um, uh, "Hello World" is good.
- 14:31
Hopefully Cla- uh, Opus is gonna decide to add Hello World at the top of the file and we actually get a diff here because the, over ACP we sent like a diff of the file.
- 14:40
Okay. Is it duplicating the first two tokens? Yeah, I think there's something going w- wrong with the connection. I'm, yeah, uh, uh, yeah, no time to debug right now. [laughs] [laughs]
- 14:51
Sorry. Uh, am I out of time or do I still have...? Um,
- 14:57
let's have a look.
- 14:58
There's more time.
- 14:59
Crack on. [laughs] Okay. May- maybe like we can see. So now that-- Okay, just another minute. Um, now that the coding agent supports reading and writing files, we can actually- You've got about five minutes.
- 15:11
Oh, great. Uh, okay, then I don't need to rush. Um, now we can kind of bootstrap the agent itself, right? Like the coding agent supports reading and writing files.
- 15:22
I can just ask it, I prepared a prompt here, to add a terminal tool to itself, right? Let's see how this works out with like the duplication we're seeing.
- 15:32
Uh, but basically, yeah, I'm telling it some of, something about the ACP, um, APIs and there's some, there's some, uh, APIs in ACP which also, that's another like capability of the client, where the client can, um,
- 15:46
advertise that it, uh, supports creating terminal and managing terminals for the agent. Like the agent can also do it itself of course. Um, but it's a nice way, uh, for us to add some more interactivity and so the agent here decided to add a new tool description.
- 16:01
Now it... Yeah. I'm vibe coding basically this terminal tool. [laughs] Um, and let's see if
- 16:10
it actually builds. It does. Well, that's good. Um, and then again, I'm gonna restart the agent. I'm gonna run our demo agent and I'm gonna ask it to run sleep five LS.
- 16:26
Let's see. There you go. You can see a terminal running.
- 16:32
Sleeping five seconds. There is the output. And there's... Yeah, and that's it basically. [clapping]
- 16:42
Thank you. Yeah. So that's how you kind of build an ACP compatible coding agent in 15 minutes or so. [laughs] Um, yeah, if you wanna, uh, check it out, just go to agentclientprotocol.com.
- 16:58
Um, in case anyone wants the demo code, but please don't use it in production, it's all agent generated. Um, it's not uploaded yet, but it, it's an empty repository.
- 17:09
I'm gonna upload it in a second. Uh, yeah. Thank you for listening. Happy to answer questions.
- 17:17
That's it. Yeah. [laughs] [clapping] Yeah. How does it handle the diffs? Is it only on the client side or? Uh, the diffs? Uh, yeah, we have like in, in ACP there are multiple content types and one content type is diff and so the agent sends old text, new text and then Zed does the diffing for you.
- 17:38
Yeah. Okay, great. Yeah. Awesome. Yeah. Cool. Do I need to go or can I? One more. Okay, one more question. Yes.
- 17:47
Um, so the connection, is it all localhost between the two? Yeah, the connection works over standard I/O. Uh, there are some folks, uh, I think from the JetBrains people are wor- working on like remote, uh, transport.
- 17:59
Uh, which we're gonna have soon I think so yeah. But right now it works over standard I/O. Yeah. [outro jingle]