Agent Client Protocol (ACP)

https://agentclientprotocol.com/overview/introduction

by vinhnx • 11 months ago

281 98 11 months ago

agentclientprotocol.com

baggiponte2• 11 months ago

Really hope for this to get traction so I’m not bound to the usual IDE

johnhamlin• 11 months ago

I’m going to be hungry all day, everyday if this catches on and we call it ACP

falcor84• 11 months ago

Arroz con Pollo? Now that's an abbreviation I've not heard in a long time.

cube2222• 11 months ago

Fingers crossed for this - it seems like Zed is kinda “going back to the roots” (of working on collaboration) and leaving this in place to disrupt the agentic IDE category (and make themselves not have to spend time on competing in it).

Curious to see how adoption among cli agents will go (it’s nice to see Gemini cli already in).

The level of competition in the LLM and coding assistant market is always nice to see, and this only helps to make costs of switching between offerings even smaller.

giancarlostoro2• 11 months ago

I'm basically sold on Zed, it has everything I have wanted from an editor for years, and that's without the amazing other things that they added that I wasn't even envisioning. For years I've prototyped a few different editors because of frustration with the status quo. There's a lot of work that goes into a good editor, and Zed has definitely done the legwork.

I welcome them openly collaborating.

iamkd• 11 months ago

Zed is awesome, but the absence of side-by-side diffs just drives me crazy, so I'm back to Cursor / VSCode. Turns out I can't work without it.

This is the top rated discussion on Github though: https://github.com/zed-industries/zed/discussions/26770

9dev2• 11 months ago

You can take my IntelliJ IDE out of my cold, dead hands. I don’t understand why anyone would want to miss out on all the automatic inference and interlinked code base, the integrated tooling… Every time I try something like Zed or VS Code, I end up disappointed or install a no longer supported plugin only to learn it falls way short.

Yes, Zed's startup time is way better, and it definitely feels snappier. But when I work on code, I need to jump around the code. I want the debugger to show me the current line in the file, annotating the value of every variable right in the source. I want to jump to property usages. I want to automatically rename a function everywhere intelligently, not using search-replace. I want to get completion for my database tables, and browse them from the IDE. And lots more.

WD-42• 11 months ago

Seriously. I really hope this puts an end to the crappy VS Code forks so Zed can start getting the credit it’s due. These ai editors have really sucked all the air out of the room.

faangguyindia• 11 months ago

when is it coming to vscode?

fijiaarone• 11 months ago

The protocol for interacting with code is files and text.

You need to define an interface for Ai to click buttons? Or to create keyboard macros that simulate clicking buttons? We are all doomed!

baggiponte2• 11 months ago

I’m afraid you missed a bit the mark :(

This is the equivalent of LSP but for coding agents. So any editor does not have to rebuild an interface to support each and every new one.

jmull• 11 months ago

The question is why…

The purpose of an ide is to pull together the tools a developer needs to develop software… first, reading/navigating and writing code, next running and debugging code, then (potentially) a variety of other tools: profilers, doc browsers, etc… all into a unified UI.

But coding agents seem to already be able to use the command line and mcp quite well to do this.

So why mediate using these tools through an IDE (over a new protocol) rather than just using the tools directly through the command line or mcp? It’s two extra levels of indirection, so there needs to be a really good reason to do it.

There may very well be some actual problem this solves, but I don’t know what it is.

quotemstr5• 11 months ago

There's a long history of REPL interaction protocols decoupling development environments from tools and making things nicer overall. This thing is an empty in the same tradition. (That said, I'm not convinced its author knew the tradition existed.)

It's like the Jupyter protocol, from which people do derive utility.

Lucasoato• 11 months ago

I really hope that APC will get the necessary traction from the community, even if I suspect that many standards that are currently proposed in the LLM field will be abandoned soon.

https://xkcd.com/927/

mg2• 11 months ago

I'm fine with treating AI like a human developer:

I ask AI to write a feature (or fix a bug, or do a refactoring) and then I read the commit. If the commit is not to my liking, I "git reset --hard", improve my prompt and ask the AI to do the task again.

I call this "prompt coding":

https://www.gibney.org/prompt_coding

This way, there is no interaction between my coding environment and the AI at all. Just like working with a human developer does not involve them doing anything in my editor.

Disposal84333• 11 months ago

Nowadays, it is better to write prompts

Very big doubt. AI can help for a few very specific tasks, but the hallucinations still happen, and making things up (especially APIs) is unacceptable.

NitpickLawyer• 11 months ago

but the hallucinations still happen, and making things up (especially APIs) is unacceptable.

The new models are much better at reading the codebase first, and sticking to "use the APIs / libraries already included". Also, for new libraries there's context7 that brings in up-to-date docs. Again, newer models know how to use it (even gpt5-mini works fine with it).

wongarsu2• 11 months ago

In languages with strong compile-time checks (like say rust) the obvious problems can mostly be solved by having the agent try to compile the program as a last step, and most agents now do that on their own. In cases where that doesn't work (more permissive languages like python, or http APIs) you can have the AI write tests and execute them. Or ask the AI to prototype and test features separately before adding them to the codebase. Adding MCP servers with documentation also helps a ton.

The real issues I'm struggling with are more subtle, like unnecessary code duplication, code that seems useful but is never called, doing the right work but in the wrong place, security issues, performance issues, not implementing the prompt correctly when it's not straight forward, implementing the prompt verbatim when a closer inspection of the libraries and technologies used reveals a much better way, etc. Mostly things you will catch in code review if you really pay attention. But whether that's faster than doing the task yourself greatly depends on the task at hand

salomonk_mur• 11 months ago

Hard disagree. LLMs are now incredibly good for any coding task (with popular languages).

mg2• 11 months ago

Do others here encounter that problem? I never do. I can't remember the last time I saw a hallucination in a commit.

Maybe it's because the libraries I use are made from small files which easily fit into the context window.

verdverm4• 11 months ago

Writing prompts makes these issues way less significant and makes the agents way more capable.

Prompt / context engineering is still an underrated and underutilized activity (imo)

tomjen32• 11 months ago

Its surprisingly fine, as long as you allow the AI to iterate on its work. It will discover that it doesn't compile, and then maybe lookup the API and then it will most often fix it and move on.

AI is no more capable of reliably one shotting solutions that you are.

zarzavat• 11 months ago

I don't let it commit. I almost always need to modify its work in one way or another.

Most of the time I don't bother reprompting it either. If it doesn't understand the first time then I'm better off making the change myself, rather than sink time into a cycle of reprompting and rejection.

On the other hand, if it understands what I want the first time I have more confidence that it's on the same wavelength as me.

qiine• 11 months ago

The folks that makes CodeCompagnion are doing interesting things!

xmorse• 11 months ago

Zed should start improving the diff view. It's one of the worst. It does not even have word level diff highlight or split diff view

nicce• 11 months ago

Only reason I use VSCode these days is Git Merge Editor.

darkbatman• 11 months ago

With already https://agentcommunicationprotocol.dev (ACP) same name seems confusing now. even though differences are there in both.

schwentkerr• 11 months ago

IBM announced in March 2025 its Agent Communication Protocol (ACP) but is now abandoning the ACP name and merging ACP efforts with Google’s Agent2Agent (A2A) protocol at the Linux Foundation. The ACP team is winding down as the industry backs A2A for open, community-driven AI agent interoperability under Linux Foundation governance. This move aims to unify protocols and avoid fragmentation in AI agent standards.

https://lfaidata.foundation/communityblog/2025/08/29/acp-joi...

derefr• 11 months ago

That seems odd. Even with an A2A protocol, don’t you still need to standardize a client “surface” or “API” or whatever, so agents can describe IDE actions they want to trigger in the expected terms over that protocol?

Or is A2A like USB, where it acts as both a registry of, and “standardized standardization process” for, suites of concrete message types for each use-case?

Like, yeah, when a "client" drives an "agent", that's no different than what any generic "agent" would be doing to drive an "agent"; an IDE or what-have-you can just act as the "parent agent" in that context.

But when an "agent" is driving a "client", that's all about the "agent" understanding that the "client" isn't just some generic token-driven inference process, but an actual bundle of algorithms that does certain concrete things, and has to be spoken to a certain way to get it to do those concrete things.

I had assumed that IBM's older ACP was in large part concerned with formalizing that side of interoperation. Am I wrong?

greatgib• 11 months ago

The big question is why it can't be just a LSP server or extension to the LSP protocol to provide all that might be needed by the LLM.

gtsop2• 11 months ago

Because there is no ai hype in LSP. AI is literally going through the same phase as early javascript libraries did. An explosion of tools, completely ignoring/bypassing previous accumulated knowledge, solving the wrong problems with the wrong tools.

And this will pile up the bloat stack, similar to js libraries, because new problems will rise from the wrong solutions, requiring even more wrong solutions to be incorporated in the stack.

nsonha3• 11 months ago

did you actually think about the question or you just want to shout an opinion?

The question doesn't even make sense, there is no overlap between LSP and ACP

awestroke• 11 months ago

Claude, come up with a protocol for communicating between AI agents and IDEs/editors. Create node, python and rust libraries. Create a website with a landing page

ivape• 11 months ago

lol. So hedonistic.

bsimpson• 11 months ago

Honestly, I'm tempted to see if Gemini can write a Sublime Text plugin that implements this protocol.

Feels like a lot of mindshare has shifted towards VSCode, so that's where the tooling investment goes. I don't want to be forced off of subl because new tools stop supporting it - it's a great editor, and it's not sponsored by a massive company.

kgthegreat• 11 months ago

Shouldn’t be too hard. I wrote this emacs plugin to do similar things but without this protocol - https://github.com/kgthegreat/protagentic . Heavily used AI assisted coding for it.

pickledish• 11 months ago

Yeah agreed!

As you suggest, I've had a moderately successful time trying to get AI to write its own Sublime Text plugins so our favorite editor doesn't get left behind, so might be cool to try with this too?

https://github.com/pickledish/llm-completion

favflam• 11 months ago

Is there an open LSP standard that allows IDEs like Lazyvim to work?

sdenton4• 11 months ago

...and cover your tracks by making Gemini the only supported agent...

adobrawy• 11 months ago

MCP also started as JSON-RPC over stdio. With solutions like GitHub Codespaces, devcontainers, or "background agents", I wonder if we'll see the development of JSON over SSE.

Currently, my environment uses Claude Code on bare metal, and my application runs in a container, and the agent can do "docker compose exec backend" without any restrictions (YOLO).

My biggest obstacles to adopting workflows with git worktree are the need to share the database engine (local resource constrains) and the initial migration time. Offloading to cloud might be interesting for that.

hari-trata• 11 months ago

I don’t see why we need so many protocols. In such a greenfield tech, many are eager to define rules. There’s already a protocol called AG-UI that does the similar thing, but even its purpose isn’t entirely clear to me.

Rather than rushing to create standards, I think the focus should be on building practical implementations, AI-centric UI components that actually help developers design more AI-friendly interfaces. Once the space matures and stabilizes, that’s when standardization will make more sense. Right now, it feels too early.

triyambakam• 11 months ago

I do agree it seems like too many protocols. I wonder why this couldn't be mcp. But regarding ag-ui in its name it's for UI - streaming from a backend agent to a client frontend. I actually have been working a lot with it this week.

ivanjermakov• 11 months ago

I don’t see why we need so many protocols

One great reason is to avoid M*N problem: https://matklad.github.io/2022/04/25/why-lsp.html

nsonha3• 11 months ago

I don't know about other protocols but for this one it's because AI vendors decided to ship their agents in the form of TUIs, which are not programmable. They need to be wrapped into something to be build on top of.

I actually prefer something like opencode which is one TUI to rule them all (albeit still lacking in some area), it also provides an an SDK that abstracts away the underlying model.

acomagu• 11 months ago

I would love it, but please don't add JSON-RPC to the world... It's too heavy for editor.

mi_lk• 11 months ago

Is there a better option?

quotemstr5• 11 months ago

Anyone else noticing an uptick in confidently stated nonsense on HN? To write that JSON-RPC is "too heavy for editor", you have to not only misunderstand the cost of JSON encoding (trivial) but also the frequency of editor-tool interaction (seldom) and volume of data transferred (negligible). In addition, you have to look at LSP, MCP, and other JSON-y protocols and say "yep. There's where the UI latency is. Got it.". (Nope)

Are people who assert that JSON-RPC is "heavy" writing code we all rely on?

willm• 11 months ago

Harsh. But fair. JSON-RPC is one of the leanest protocols out there.

quotemstr5• 11 months ago

I see they've also caught the RFC2119 bug. This "MUST", "SHALL", "MAY" thing is a linguistic blight on our standards landscape and should be eradicated. HTML5 is written without this unnecessary level of linguistic pretense and works fine.

If your proposed spec is full of "SHALL", "MUST", and "MAY", I'm going to dock you ten points of credibility from the outset. It's a signal you've set out to imitate the vibes of seminal RFC specs without independently considering the substance.

PhilipRoman• 11 months ago

I don't know if your complaint is specifically about the capitalization, but I find these clear rules useful when interpreting specifications.

elteto• 11 months ago

We SHALL replace them with MAYBE, IF YOU FEEL LIKE IT, and OR WHATEVER. Will sure make for lighter reading.

lvl155• 11 months ago

Why don’t they focus on IDE first? I still can’t use their IDE as my daily. They also need to hire someone for UI. It took me 10 minutes to figure out how to bring up their AI chat window.

Aeolun2• 11 months ago

If it took you 10 minutes to bring that up I can’t understand why. Presumably you’ve switched to any of the other panels in Zed before?

jasonjmcghee• 11 months ago

Another discussion on the same topic from 3 days ago:

https://news.ycombinator.com/item?id=45038710

lukaslalinsky• 11 months ago

I really wish Anthropic will adopt this for Claude Code, and I hope it provides at least the kind of integration they have with VS Code. Would be nice if it had access to at least diagnostics from the editor.

vlaaad• 11 months ago

I love this idea; I hope it gains traction. One thing that is not clear to me is file search vs unsaved files. It's common for agents to use, e.g., ripgrep to search the file system. But if the communication protocol includes read/write access to unsaved files, there is a desync in terms of accuracy.. rg can't search unsaved files.

tekacs• 11 months ago

It's interesting to see that there's the beginnings of an implementation for Claude Code, here:

https://github.com/zed-industries/zed/blob/main/crates%2Fage...

https://www.npmjs.com/package/@zed-industries/claude-code-ac...

Even though that doesn't seem to be mentioned on the site yet.

Eduard• 11 months ago

naming things isn't that hard. at least put something with AI/LLM and code/IDE in the name.

akattelu• 11 months ago

So much negativity in this thread. After seeing the recent demo of gemini cli working in zed, I'm actually pretty excited for standardization in this space.

Helix has been my favorite editor ever since I started using it, but the lack of integrated AI features has been becoming more of a deal-breaker for me lately. Though, I can see why the maintainers are hesitant to build for it, because there hasn't been a standardized protocol. I hope ACP changes that.

rmonvfer• 11 months ago

I’ve been writing a tool to enable Claude Code to use ACP (because I use CC and Zed a lot) and so far I’ve been pretty successful (using the Claude Code SDK and the ACP Client library) although there are some rough edges. I will polish it a little bit and publish it tomorrow I guess.

vincelt• 11 months ago

Found this repo the other day in case that's useful: https://github.com/Xuanwo/acp-claude-code

upcoming-sesame• 11 months ago

the difference between using, for example, Gemini via ACP vs Gemini via the ide own agent is not so clear

cranberryturkey• 11 months ago

How's this better than MCP?

joeyguerra• 11 months ago

Does anyone else find it funny that LLMs need a protocol to execute tooling? Like, it understands language, right?

csomar• 11 months ago

I feel these solutions are approaching the problem backward. What I want is not a Claude Code in my Neovim but a Neovim in my Claude Code. That is, when the agent fails, I am able to hop in momentarily with all the perks of an IDE (ie: type-setter, LSP, etc.) and do some editing and then give control back to the agent.

Agent Client Protocol (ACP)

Related Stories