Open Reader

ACP: The Universal Remote Control for AI Agents — Alex Hancock, Block

completed 11:00 Sep 09, 2026 Watch on YouTube

Current Status

completed

Video ID

YkNulwcc5jk

RAG / Chat

Enabled
ACP: The Universal Remote Control for AI Agents — Alex Hancock, Block
Description

Alex Hancock built one of the clients in this talk the night before he gave it, which is roughly the point. Hancock is a software engineer at Block, works on the open source agent harness Goose, now donated to the Linux Foundation, and maintains the Rust SDK for MCP. His argument is that the agentic stack already has a good standard for agents reaching outward to do things, which is MCP, and that the strongest thing about MCP is not its design but the fact that everyone uses it. What is missing is the other direction, a standard way for client software to tell a harness what to work on and to get updates back. Most harnesses today expose a bespoke interface, and in the worst case exactly one application can drive them. He compares it to needing a different browser for every website. His candidate is ACP, the agent client protocol, which came out of the Zed and JetBrains teams wanting one high quality editor client capable of driving any harness. It runs on JSON RPC and carries sessions, user messages, tool call notifications, and permission requests. It is deliberately extensible through underscore prefixed custom methods, so common patterns can surface from real usage across projects and then move onto a standards track. Hancock demonstrates Zed and a terminal client from Poolside driving the same Goose agent, then the remote HTTP and websocket transport his team specified, since the protocol had none. With remote transports for the protocol, for MCP, and for models, all four pieces of the stack, client, harness, tools, and model, become independently placeable. He expects a real client market to push user experience upward. Speaker info: - https://x.com/alexjhancock - https://www.linkedin.com/in/alexjhancock/ Timestamps: 0:00 - Goose, MCP, and ACP 1:23 - Every harness has a bespoke interface 2:21 - Standards create ecosystems 3:02 - ACP, where it came from and how it works 6:17 - Two clients driving the same agent 7:24 - Remote transport and four movable pieces

Summary

Generated by gpt-5.6-terra

At-a-Glance

  • Verdict: Watch fully
  • Core thesis: ACP (Agent Client Protocol) should become the open, transport-independent control plane between AI-agent clients and harnesses, analogous to how MCP standardized agents' access to tools.
  • Why it matters: It addresses a critical interoperability gap: without a common way for UIs, orchestration layers, and headless applications to send tasks to agent harnesses and receive state, tool, and permission updates, each harness remains locked into bespoke clients.
  • Best use: Use this as a concise architectural case for separating the agent client from the harness, evaluating ACP support in OpenClaw-style systems, and tracking the emerging client-control-plane standards layer alongside MCP.

Executive Summary

Alex Hancock of Block argues that agent systems now have a widely adopted interoperability layer for outward actions—MCP for tools, resources, and external systems—but lack an equivalent standard for controlling the agent harness itself. Today, a client that gives an agent work, displays progress, renders tool activity, and handles approvals is often custom-built for one harness. Hancock frames that as the equivalent of requiring a different browser for every website.

His proposed answer is ACP, the Agent Client Protocol, initially developed by Zed and JetBrains so their editors could control multiple agent harnesses through one client implementation. ACP establishes client-to-harness connections with declared capabilities, creates sessions, transmits user or programmatic messages, and streams back outputs such as text, images, audio, tool-call notifications, and permission requests.

The strategically important addition from the Goose team is remote transport: HTTP plus WebSocket upgrade while preserving the same protocol messages and semantics used locally over standard I/O. Hancock's four-part stack is client, harness, tools (often MCP), and model; with remote-capable standards at each boundary, these components can be independently placed on-device, in containers, or in the cloud.

The talk is partly a standards pitch rather than a production-readiness assessment, but it contains a reusable system-design principle: standardize the control surface separately from the tool surface. ACP's extensibility model—custom underscore-prefixed methods that can later be promoted into the standard based on ecosystem convergence—is intended to let the protocol evolve from actual client and harness usage.

Key Takeaways

  • Claim: The missing interoperability layer in agent stacks is not tool access but client-to-harness control: assigning work, receiving progress, and mediating approvals. | Evidence: Hancock contrasts MCP's broad adoption for agents calling tools and reading resources with the current state of harness interfaces, which are often bespoke and can be usable from only one client application. | Implication: Ken should treat agent control-plane interoperability as a separate architectural concern from MCP; adopting MCP alone does not make an agent system portable across clients or orchestration surfaces. | Caveat: This is a proposal for an emerging standard, not evidence that ACP has already achieved MCP-level adoption or ecosystem depth.
  • Claim: ACP is designed as a universal interface from an agent client to an agent harness, enabling one client implementation to control multiple compatible harnesses. | Evidence: The protocol originated with Zed and JetBrains, whose practical objective was to let an editor such as Zed or IntelliJ send tasks to any supported harness, get results, and observe edited files without writing harness-specific integrations. | Implication: A company can build a specialized desktop, terminal, mobile, domain-specific, or white-label agent client without coupling its user experience to one agent runtime.
  • Claim: ACP carries both task input and the operational events needed for a real agent UI or supervision layer. | Evidence: Connections expose capabilities; within sessions, clients send user or programmatic messages, while harnesses return text, images, audio, updates, tool-call notifications with metadata, and permission requests that a client can present for approval. | Implication: ACP is more than a prompt/response API: it can serve as the interaction boundary for observability and human-in-the-loop authorization, provided clients properly implement those event and approval flows.
  • Claim: ACP's remote HTTP and WebSocket transport makes the same client-harness contract usable for local processes and cloud-hosted agents. | Evidence: Goose added an HTTP transport with a WebSocket upgrade because the original project lacked remote support; Hancock demonstrates the same Goose process being controlled over the network with the same messages and library used in the local case. | Implication: A local developer client can evolve into a remote execution topology without rewriting its interaction model, but production deployments need an explicit security and identity layer around the transport. | Caveat: The demonstration runs over the network to a process on Hancock's own machine; it establishes protocol portability, not a complete account of production authentication, authorization, tenancy, or security controls.
  • Claim: Standard remote boundaries across client, harness, tools, and models allow the agentic stack to be physically rearranged without changing its core integrations. | Evidence: Hancock identifies four components—client, harness/tool-calling loop, tools often accessed through MCP, and model—and notes that ACP remote transport, MCP remote tool access, and existing remote model APIs let each component run locally or remotely. | Implication: For OpenClaw-like architectures, preserve these boundaries: move harness execution into containers or the cloud while keeping a local client, or relocate tools/model endpoints independently, instead of treating the agent as one inseparable application.
  • Claim: ACP intends to evolve through implementation-led standardization rather than attempting to define every client and harness feature upfront. | Evidence: ACP uses JSON-RPC and permits custom methods under an underscore-prefix convention; Hancock expects repeated custom methods across projects such as Codex, Goose, and clients to reveal candidates for the core standard. | Implication: If experimenting with ACP, keep extensions narrow, namespaced, documented, and measurable; distinguish portable core functionality from proprietary control-plane features. | Caveat: Extensibility can accelerate experimentation but can also produce incompatible vendor-specific behavior if common extensions do not converge.

Detailed Brief

Demonstrated interoperability and intended market effect

  • Claims: The protocol is intended to support a broader client category than code editors, including desktop apps, mobile apps, terminals, personal agent consoles, headless applications, and business-domain-specific clients.; A common harness interface could create competition on client quality rather than making users accept the UX attached to their chosen harness.
  • Evidence: Hancock shows Goose responding to the same project-inspection task through Zed and through a terminal-based client from Poolside AI, including streamed text and tool-call visibility.; He describes a client he 'vibe coded' the prior night as evidence that a basic ACP client can be created quickly once the harness exposes the interface.; Potential applications named include personal orchestration clients, company-specific or domain-specific clients, and white-label clients that work across harnesses.
  • Caveats: The demos validate basic interoperability for a simple HTML-project task; they do not test long-running jobs, recovery, concurrent sessions, audit trails, or cross-vendor feature consistency.; The anticipated marketplace effect depends on meaningful multi-harness and multi-client adoption.
  • Implications: Client experience can become a separable product layer: organizations can choose or build the workflow surface that fits their operators while retaining flexibility in harness choice.; The most valuable early validation is likely a cross-client, cross-harness compatibility matrix rather than a single polished integration.

Notable Concepts & Terms

  • ACP (Agent Client Protocol): An open protocol for the control relationship between a client application and an agent harness: task submission, session interaction, streaming events, and approvals.
  • MCP (Model Context Protocol): The complementary tool-access layer; Hancock uses its broad adoption as the argument that a client-control standard can similarly unlock an ecosystem.
  • Agent harness: The runtime/program that implements the agent's tool-calling loop and coordinates model, tools, and execution behavior.
  • Goose: Block's open-source agent harness, now donated to the Linux Foundation, used in the talk as an ACP implementation and demo agent.
  • Capability-based connection: An ACP connection declares the capabilities available between a particular client and harness, allowing sessions to operate within a negotiated feature set.
  • JSON-RPC: The simple request/event message format ACP uses, enabling implementations to share semantics across local and remote transports.
  • HTTP transport with WebSocket upgrade: ACP's remote connectivity option, intended to retain the same client-harness semantics whether the harness is a local process, container, or cloud service.
  • Underscore-prefixed custom methods: ACP's extension convention for experimental or vendor-specific features; recurring extensions can later inform the formal standard.

Operator Notes / Why Ken Should Care

  • Decide whether OpenClaw's client-facing interface should be modeled explicitly as an ACP-compatible control plane rather than exposing harness-specific APIs directly.
  • Prototype a minimal ACP adapter around one existing harness and verify that two dissimilar clients—a terminal/headless controller and a rich UI—can run the same session, render tool events, and complete approval flows.
  • Before exposing remote ACP, define the missing production controls not addressed in the talk: client identity, authorization by tool/action, session tenancy, approval provenance, encryption, rate limits, and audit logging.
  • Maintain a compatibility ledger for core ACP versus custom extensions; avoid placing essential workflow logic behind unstandardized underscore methods unless there is a migration plan.
  • Monitor ACP adoption by Goose, Zed, JetBrains, Codex-adjacent projects, and other harnesses before making a broad platform bet; ecosystem participation is the source of the protocol's proposed value.

Source/Metadata

  • Title: ACP: The Universal Remote Control for AI Agents — Alex Hancock, Block
  • Transcript words: 3600
  • Duration seconds: 660
  • Timestamp note: No timestamps or chapters were present in the supplied transcript; the transcript also contains a near-complete repeated segment.

Transcript

1991 words en Processed in 59.1s

[SPEAKER_00] Alex Hancock Hey everybody. My name is Alex Hancock. Today I'm going to talk about a universal remote control for AI. Before I start, I just want to say the previous speaker said that MCP client maintainers haven't implemented support for tasks because they're smart. I'm an MCP client maintainer. I can tell you it's just because I'm lazy. I haven't done it. Okay, so a little bit about me before we start. I am a software engineer at Block, which is the parent company of Cash App and Square and Title. We have a few different things going on now. I've worked there for a long time. I worked on Square product stuff and Cash App stuff, but I've been doing open source AI for the last couple years. Specifically, I work on this open source harness project called Goose, which started as an internal project at Block. Yeah, some Goose fans out there. And then, yeah, we open sourced it and we donated it to the Linux Foundation. So now the IP is there, but lots of us from Block still work on it. I'm also a maintainer of MCP, the Model Context Protocol. I work on the Rust SDK for that project. And more recently, I've also started some work on ACP, the Agent Client Protocol, which is what I'm going to talk about today. So I think we have an issue with harnesses that I want to propose to you all today as a problem, and then recommend a solution. What I've been noticing recently is that we've got lots of great harnesses out there. There are ones from the labs, ones from different companies. There's lots of open standards-based ones. But I noticed that the interface to them is often custom or bespoke, and in the worst case, you might have some harnesses where there's literally only one client application you can use to control that harness. I think this has a couple issues with it, but the analogy I'll make with the web is it would be like if you had to use one browser or one given protocol to connect to every website. That just wouldn't work. You wouldn't have something like the open web if that were the reality with browsers. So I think we can do better. The thing about standards is that they create ecosystems and markets. I would argue that in the agentic AI space, we have a good standard for the agent going out and doing things—calling tools, taking actions, and other systems reading resources, reading data. We've all benefited as a community from having MCP. The most powerful thing about MCP is not anything about MCP itself, but it's that everyone uses MCP. That's why we have thousands or tens of thousands of servers around the world and all the agents can connect to them and do things in those other systems. I would say that we don't yet have a good solution or a standard for client software to tell agents what to do, giving it tasks, telling it what to work on, and getting updates. So I'm going to put forward an option today that I think is a good option, that we on our team have been working on, and we think is a good solution in the open standard space. This is ACP. Agent Client Protocol is the name of this project. It came from editor companies. It came from the Zed text editor folks and JetBrains folks. The Zed folks and JetBrains folks teamed up and proposed a standard for clients to be able to control harnesses. It makes sense if you put yourself in their shoes. What they wanted to be able to do is write a single high-quality client implementation in an editor, maybe in Zed or in IntelliJ or something like that, and be able to control any harness with that single client implementation, sending tasks, getting results back, seeing what files are being edited, etc. It makes a ton of sense if you put yourself in their shoes. But we saw this on the Goose team, and we think that there is a much broader utility than just editors. It's relatively neutral and it doesn't have many editor-specific features. So we think that this can be spread to a wider range of client software. To go into a little bit more depth about ACP's design and what you can do with it: It lets you establish connections between clients and agent harnesses that have a given set of capabilities associated with the connection. And then you can make sessions. Within sessions, you can send user messages—the things that a user is typing into the app or that the client software wants to send. The agent can then respond to those with text, images, audio, etc., or updates about what's going on. For example, if a tool is called, it can send a tool call notification and explain what tool was called and what the metadata was. And it can also send things like permission requests, so if the client software needs to show the user "Should I do this tool call? Yes or no?" it can go over this protocol. It's pretty simple in its design. It uses JSON RPC messages. The thing we like about it most is that it's extensible. You're not limited to just what's in the vanilla protocol; you can add custom methods. The convention is you put an underscore and then you put your custom methods. The thing I like about this is that if enough harness projects or client projects adopt this, we can start to see what we're all doing that's the same. If the Codex team has some custom methods, the Goose team has some custom methods, the client team has some custom methods—whoever—we can see what emerges in the ecosystem and what makes sense to get on a standards track and bring into the protocol itself. So this is shaped by usage and shaped by the community. I'm going to do a demo of a standard I/O version of this. So I'm going to open Zed. I just have a really simple project here. I'll say "tell me about this project." This is a single HTML file. You can see I was able to type my query into Zed. The agent in play here is Goose. So it's using Goose's ACP interface. It's sending text back. It's sending tool call information back about what it read and what it did. And then it found that it's a single HTML file and explained it. I'll do another one. This is one from a company called Poolside AI. I'll say "tell me about this project" in the same project. This is a terminal-based client getting exactly the same experience from the same agent. One implementation on the harness side, and you can now use any client. You can see it did the same thing. It showed me some text results back. It showed a tool call. And then it showed it streaming in a summary. So that's a basic demo showing two clients talking to the same agent over standard I/O locally in this case. But local obviously isn't enough. If you want this to take off, you have to be able to do remote. Agents are going to be running in the cloud. So when we came to this project, we saw that it did not have remote support yet. So we specified an HTTP transport. There's an HTTP version and a WebSocket upgrade. The messages are the same. The protocol semantics are the same. But there's a new transport that is just landing now that enables remote. The way we think about this on the Goose team, the agentic stack has these four important components: You have the client, which is the app that the user is using or a headless app running somewhere on the machine. There's the harness, which is the program that implements the tool calling loop. There are the tools themselves, often MCP. And then there's the model. If you do a remote transport for the Agent Client Protocol, and MCP has remote transport for tool calling, and the models have all had remote endpoints like OpenAI APIs for a long time now, you have the flexibility to move all of these four components around. They could all be on the same machine. The harness could be on a different machine than the client. The model could be the only thing that's remote. The tools could be the only thing that's remote. Aligning on standards and making sure that they have good transport stories is what's going to let us move all the pieces of this agentic stack around. I can show a quick demo of this as well. This is a client just to show how easy it is to create clients for this. I just vibe coded this last night. I'll say "write a poem." This is again connecting to that same process on my machine. In this case, I'm running it over the network, but it's on my machine. It's connecting and sending Goose instructions for what to do remotely. So this could be in a container. It could be up in the cloud. But the messages are the same and the library you use is the same, so you can just switch between local and remote very easily. So if you want to get plugged into this ecosystem, start experimenting with support, either making your own clients or adding stuff to harnesses. This will link you to the Agent Client Protocol site for how to get started. There's a number of clients and agent servers already out there. This ranges from editors, desktop applications, mobile applications, terminal-based things. There's a proliferation. I think the use cases are potentially huge if we get some interoperability going here. You can have people make personal clients that are exactly how you want them, orchestrating your agents. You could have clients created for certain business domains or an individual company. You could customize a white-label client and have it work with all the harnesses. I also think if we make a new category here, we're going to see the quality of the clients go up. Any time you get an ecosystem or a marketplace going with many options, users can vote with their feet. If clients aren't meeting their needs, people will start to compete on the quality of the user experience. Overall, I think this should drive up the user experience of using AI. That's what I've got today. Thank you very much. If you want to chat with me, find me after or send me an email. Happy to get you plugged into this work. Thank you. So I think I think we have an issue with harnesses that I want to I want to try to put to you all today Propose to you all today as a problem and then and then recommend a solution so What I've been noticing recently? Is that we've got lots of great harnesses out there right there are ones from the labs there one from ones from different companies There's lots of open standards based ones But I noticed that the interface to them is often custom or bespoke and in the worst case It's like you might have some harnesses where there's literally only one client application you can use to control that harness right and I think this has a couple issues with it, but the analogy that I'll make with the web is it would be like if you had to use one browser or a One given protocol to connect to a to every website, right? That just wouldn't work You wouldn't have something like the open web if if that were the reality With browsers and so I think we can do better and the thing about standards by finding a standard and the thing about standards is that they create ecosystems and markets and I would argue that in the agentic AI space we have a Good standard for the agent going out and doing things right calling tools taking actions and other systems reading resources reading data We've all benefited as a community from having MCP Right and the most powerful thing about MCP is not anything about MCP itself, but it's that everyone uses MCP and That's why we have you know thousands or tens of thousands of servers around the world and all the agents can connect to them and Go and do things in those other systems. I would say that we don't yet have a good solution or a standard for for client software to tell agents what to do giving it tasks telling it what to work on and getting updates and so I'm going to put forward an option today that I think is a good option that that we on our team Have been working on and we think is a good a good solution in the open standard space and This is ACP so agent client protocol is the name of this project and it came from the editor companies It came from like if you've used the Zed text editor or you've used any of JetBrains products the Zed folks in the JetBrains JetBrains folks teamed up and proposed the standard for clients to be able to control harnesses and it makes sense if you put yourself in their shoes, right? What they wanted to be able to do is write a single high quality client implementation in an editor Maybe in Zed or in IntelliJ or something like that and be able to control any harness by with that single client implementation Sending tasks getting results back Seeing what files are being edited etc. It makes a ton of sense if you put yourself in their shoes, right? But we saw this on the goose team and we think that there is a much broader utility than just editors, right? So it's a it's it's relatively neutral and it doesn't have many editor specific features And so we think that this can can go to a be spread to a wider range of client software To go into a little bit more depth about ACP's design and what you can do with it It lets you establish connections between clients and agent harnesses that have a given Set of capabilities associated with the connection and then you can make sessions Within sessions you can send user messages the things that a user is maybe typing into the app or that the client software wants to send the agent can then respond to those with text More images or audio text etc or updates about what's going on So like if a tool is called it can send a tool call notification and explain what tool was called and what the metadata was And it can also send things like permission requests so that if the client software needs to show the user You know should I do this tool call yes or no it can go over this This protocol and it's it's pretty simple and its design It uses json RPC messages and the thing we like about it most is that it's extensible as well So you're not limited to just what's in the vanilla protocol you can add custom methods So the pre the convention is you put an underscore and then you start to put your custom methods And the thing I like about this is that if enough harness projects or client projects adopt this We can start to see what we're all doing. That's the same right Like if the codex team has some custom methods the goose team has some custom methods The client team has some custom methods whoever we can see what emerges in the in the ecosystem And what makes sense to get on a standards track and bring into the protocol itself so that this is sort of shaped by usage and shaped by the community I'm going to do a demo of a standard I O version of this So I'm going to open zed and I just have a really simple project here Where I'll say tell me about this project and so this is a single html file so you can see I was able to type my query into zed and this is the agent in play here is goose So it's using goose's acp interface and it's you can see it's like sending text back. It's sending tool call information back About what it read and what it did and then it found you know that it's a single html file and explained it and I'll do another I'll do another one. This is one from a company called poolside AI I'll say tell me about this project in the same project and so this is a terminal based client Getting exactly the same experience from the same agent one implementation on the harness side and you can now use any client Right and so you can see it did the same thing it showed me Some text results back it showed a tool call and then it showed it. It's streaming in a summary So that's a basic demo showing two clients talking to the same agent Over standard IO locally in this case But local obviously isn't enough right if you want this to take off you have to be able to do remote as well Agents are going to be running in the cloud and so when we came to this project We saw that it did not have remote support yet. So we specified an HTTP transport There's an HTTP version and there's a web socket upgrade and so now the messages are the same the protocol semantics are the same But there's a new transport that is just landing now that enables remote and The way we think about this on the goose team the agentic stack is there's sort of these four important components, right? You have the client Which is like the app that the user is using or a headless app running somewhere on the machine? There's the harness which is the program that implements the tool calling loop There are the tools themselves as often MCP and then there's the model, right? and if you do a remote transport for the agent client protocol and MCP has remote transport for tool calling and And the models have kind of all had remote endpoints like responses apis for a long time now you have the flexibility to move All of these four components around they could all be on the same machine the harness could be on a different machine than the client The model could be the only thing that's remote the tools could be the only thing that's remote Aligning on standards and making sure that they have good transport stories is what's going to let us move all the pieces of this agentic stack around And I can show a quick demo of this as well So this is a client just to show how easy it is to create clients for this I just vibe coded this you know last night and I'll say write a poem So this is again connecting to that same process on my machine In this case, I'm running it over the network, but it's on my machine It's connecting and sending goose instructions for what to do Remotely so this could be in a container it could be up in the cloud But the messages are the same and the library you use is the same so you can just switch between local and remote very very easily So if you want to get plugged into this ecosystem start experimenting with support either making your own clients or adding stuff to harnesses This is a this will link you to the agent client protocol site for How to get started there's a number of clients and and agent servers already out there This ranges from editors desktop applications mobile applications terminal based things like there's a proliferation and I think the use cases are Are potentially huge right if we if we get some interoperability going here because you can have people can make personal clients That's exactly how you want it orchestrating your agents You could have sort of clients created for certain business domains or an individual company or A set of clients from a company you could customize like a white label Client and have it work with all the harnesses and I also think if we make a new category here We're going to see quality of the clients go up right because any any time you get an ecosystem or a marketplace going and there's many options Users can vote with their feet if clients aren't meeting their needs And so people will start to compete on the quality of the user experience and and like overall I think this should drive up The user experience of using AI That's what I've got today. Thank you very much And if you want to chat with me find me after or send me an email Happy to get you plugged into this work Thank you Thank you