Agent Client Protocol (ACP)(agentclientprotocol.com)
agentclientprotocol.com
Agent Client Protocol (ACP)
https://agentclientprotocol.com/overview/introduction
103 comments
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.
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.
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.
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
The question doesn't even make sense, there is no overlap between LSP and ACP
Your response is an exact proof of what I said in my comment. Thanks
Edit: Ok elaboration for the well intended. There is a HUGE overlap of LSP and ACP. LSP solves the problem of "oh we have many IDEs and many language integration plugins, we have an NxM problem, let's make it a N+M". ACP goes to do exactly that but for agents (which is an implementation detail), which means they could very well piggy back on top of LSP
Edit: Ok elaboration for the well intended. There is a HUGE overlap of LSP and ACP. LSP solves the problem of "oh we have many IDEs and many language integration plugins, we have an NxM problem, let's make it a N+M". ACP goes to do exactly that but for agents (which is an implementation detail), which means they could very well piggy back on top of LSP
This kind of arguments don't make sense because of scope creep. LSP is for programming languages, why would the maintainers of LSP consider AI agents as a valid language server? And ACP is useful beyond code editors that supporting LSP just for the sake of it makes even less sense.
The overlap being... they are both... protocols?
Really hope for this to get traction so I’m not bound to the usual IDE
I’m going to be hungry all day, everyday if this catches on and we call it ACP
Arroz con Pollo? Now that's an abbreviation I've not heard in a long time.
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.
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.
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.
I welcome them openly collaborating.
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
This is the top rated discussion on Github though: https://github.com/zed-industries/zed/discussions/26770
I’m sure anyone invested enough could contribute that xD
Like, I agree that that’s the thing I want most out of Zed right now, but not enough to do it myself.
Like, I agree that that’s the thing I want most out of Zed right now, but not enough to do it myself.
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.
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.
It's fine, it sounds like you're an enterprise programmer and that suits your role/use case.
I use zed with the inbuilt terminal, additional terminals + tools like pgcli and docker. I would feel trapped/impotent using an IDE, esp combined with the lack of snappiness a java app gives you.
I use zed with the inbuilt terminal, additional terminals + tools like pgcli and docker. I would feel trapped/impotent using an IDE, esp combined with the lack of snappiness a java app gives you.
Couldn’t be further from Enterprise luckily, but it leaves me wondering if I’m missing the forest for the trees?
Maybe it’s just a difference in working style. I would feel exhausted by having to learn and maintain a bunch of tools instead of just one, sprinkled with occasional anxiety if there is a better or upstart competing tool that I should be using.
Maybe it’s just a difference in working style. I would feel exhausted by having to learn and maintain a bunch of tools instead of just one, sprinkled with occasional anxiety if there is a better or upstart competing tool that I should be using.
I don't think youre missing out necessarily. I would riot if i couldn't use Pycharm anymore, for big python projects just nothing beats it right now.
I do use VSCode too, but mostly for quick scripting or non-programming projects. and even then i installed a bunch of extensions to make it more like Pycharm.
I do use VSCode too, but mostly for quick scripting or non-programming projects. and even then i installed a bunch of extensions to make it more like Pycharm.
It’s most likely about different ecosystems. JetBrains provides excellent support for many programming ecosystems, but if yours isn’t supported, you don’t have much choice. I was an avid JetBrains user until I needed to work with Elixir. You simply can’t do Elixir in their IDEs. So I switched to VS Code. After more than a year of using VS Code, you develop muscle memory for it. At this point, I don’t really care about the differences anymore and I’m happy with VS Code.
In my case, my employers forbid tools like JetBrains so I am paying out of pocket for tooling I cannot even use most of my day. I rather just invest in making a different tool better, even if that means doing a few PRs here and there.
> 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.
But you have this with any modern language that have LSP and debugger, no? Zed,VS Code, neovim - pretty much any modern editor have those features either out of the box or via a plugin.
But you have this with any modern language that have LSP and debugger, no? Zed,VS Code, neovim - pretty much any modern editor have those features either out of the box or via a plugin.
100% this. Zed is snappier to open multiple projects etc but even basic things like auto-complete are horrendous compared to JetBrains. And my python code is often filled with squiggles due to ruff, and when I remove ruff from my settings, then I get some obscure error. Sure I could spend hours tweaking the settings.json to come with the right combo that will work (maybe) but the recommended settings should be documented clearly somewhere. I’ve filed issues several times on their GitHub but gave up eventually.
> I don’t understand why anyone would want to miss out on all the automatic inference and interlinked code base, the integrated tooling…
It's almost like you can get that experience with other editors too, not just IDEs :) I'm using vim/neovim and have the same stuff I see others do with IDEs, but I can definitely see why a bunch of people use IDEs anyways, I'm not blind got the fact that other more barebones editors need a bit more fiddling to get to your liking.
It's almost like you can get that experience with other editors too, not just IDEs :) I'm using vim/neovim and have the same stuff I see others do with IDEs, but I can definitely see why a bunch of people use IDEs anyways, I'm not blind got the fact that other more barebones editors need a bit more fiddling to get to your liking.
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.
when is it coming to vscode?
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!
You need to define an interface for Ai to click buttons? Or to create keyboard macros that simulate clicking buttons? We are all doomed!
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.
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.
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.
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.
> 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
The IDE is in-between because it asks the user for confirmation before doing anything, if that's what you are asking. It's not adding any indirection or something, this is just how coding agents talk to the IDE already, all this does is standardize the language they speak which would be a win for everybody.
The IDE is in-between because it asks the user for confirmation before doing anything, if that's what you are asking. It's not adding any indirection or something, this is just how coding agents talk to the IDE already, all this does is standardize the language they speak which would be a win for everybody.
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.
It's like the Jupyter protocol, from which people do derive utility.
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/
https://xkcd.com/927/
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.
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.
> 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.
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.
> 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).
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).
What size of codebases are we talking here? I've had a lot of issues trying to do pretty much anything across a 1.7 million LOC codebase and generally found it faster to use traditional IDE functionalities.
I've had much more success with things under 20k LOC but that isn't the stuff that I really need any assistance with.
I've had much more success with things under 20k LOC but that isn't the stuff that I really need any assistance with.
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
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
> the obvious problems can mostly be solved by having the agent try to compile the program
The famous "It compiles on my machine." Is that where engineering is going? Spending $billions to get the same result as the laziest developer ever?
The famous "It compiles on my machine." Is that where engineering is going? Spending $billions to get the same result as the laziest developer ever?
If it compiles on my machine then the library and all called methods exist and are not hallucinated. If it runs on my machine then the called external APIs exist and are not hallucinated
That obviously does not mean that it's good software. That's why the rest of my comment exists. But "AI is hallucinating libraries/APIs" is something that can be trivially solved with good software practices from the 00s, and that the AI can resolve by itself using those techniques. It's annoying for autocomplete AI, but for agents it's a non-issue
That obviously does not mean that it's good software. That's why the rest of my comment exists. But "AI is hallucinating libraries/APIs" is something that can be trivially solved with good software practices from the 00s, and that the AI can resolve by itself using those techniques. It's annoying for autocomplete AI, but for agents it's a non-issue
The subtle bugs are horrible.
We used Claude Code the other day to add a new record type to an API and it was mostly right. CC decided (for some weird reason) to use a slightly different return shape on a list endpoint than the entire rest of the API. It changed two field names (count/items became total_count/data). This divergence was missed until the code was released because it 'worked' and had full tests and everything. But when the standard client lib code was used to access the API it failed on the list endpoint. Didn't take long to discover the issue. Luckily, it was a new feature so nothing broke, but it was a very clear reminder that you have to be very thorough when reviewing coding agent PRs.
FWIW, I use CC frequently and have mostly positive things to say about it as a tool.
We used Claude Code the other day to add a new record type to an API and it was mostly right. CC decided (for some weird reason) to use a slightly different return shape on a list endpoint than the entire rest of the API. It changed two field names (count/items became total_count/data). This divergence was missed until the code was released because it 'worked' and had full tests and everything. But when the standard client lib code was used to access the API it failed on the list endpoint. Didn't take long to discover the issue. Luckily, it was a new feature so nothing broke, but it was a very clear reminder that you have to be very thorough when reviewing coding agent PRs.
FWIW, I use CC frequently and have mostly positive things to say about it as a tool.
[deleted]
Hard disagree. LLMs are now incredibly good for any coding task (with popular languages).
You can't disagree with facts. Every time I try to give a chance to all those LLMs, they always use old APIs, APIs that don't exist, or mix things up. I'll still try that once a month to see how it evolves, but I have never been amazed by the capabilities of those things.
> with popular languages
Don't know, don't care. I write C++ code and that's all I need. JS and React can die a painful death for all I care as they have injected the worst practices across all the CS field. As for Python, I don't need help with that thanks to uv, but that's another story.
> with popular languages
Don't know, don't care. I write C++ code and that's all I need. JS and React can die a painful death for all I care as they have injected the worst practices across all the CS field. As for Python, I don't need help with that thanks to uv, but that's another story.
If you want them to not make shit up, you have to load up the context with exactly the docs and code references that the request needs. This is not a trivial process and ime it can take just as long as doing stuff manually a lot of the time, but tools are improving to aid this process and if the immediate context contains everything the model needs it won't hallucinate any worse than I do when I manually enter code (but when I do it, I call it a typo)
there is a learning curve, it reminds me of learning to use Google a long time ago
there is a learning curve, it reminds me of learning to use Google a long time ago
So, I've done this, I've pasted in the headers and pleaded with it to not imagine ABIs that don't exist, and multiple models just want to make it work however they can. People shouldn't be so quick to reply like this, many people have tried all this advice... It also doesn't help that there is no independent test that can describe these issues, so all there is anecdote to use a different vendor or that the person must be doing something wrong? How can we talk about these things with these rhetorical reflexes?
There is a significant gap between agents and models.
Agents use multiple models, can interact with the environment, and take many steps. You can get them to reflect on what they have done and what they need to do to continue, without intervention. One of the more important things they can do is understand their environment, the libraries and versions in use, fetch or read the docs, and then base their edits on those. Much of the hallucinating SDKs can be removed with this, and with running compile to validate, they get even better.
Models typically operate in a turn-by-turn basis with only the context and messages the user provides.
Agents use multiple models, can interact with the environment, and take many steps. You can get them to reflect on what they have done and what they need to do to continue, without intervention. One of the more important things they can do is understand their environment, the libraries and versions in use, fetch or read the docs, and then base their edits on those. Much of the hallucinating SDKs can be removed with this, and with running compile to validate, they get even better.
Models typically operate in a turn-by-turn basis with only the context and messages the user provides.
You can't make any guarantees and manually watching everything is not tenable. "Much" instead of "all" means having to check it all because "much" is random.
You don't have to watch it like you don't have to watch your peers. We have code review processes in place already
You're never going to get all, you don't have all today. Humans make mistakes too and have to run programs to discover their errors
You're never going to get all, you don't have all today. Humans make mistakes too and have to run programs to discover their errors
> You can't disagree with facts. Every time I...
Anecdotes are not facts, they are personal experiences, which we know are not equal and often come with biases
Anecdotes are not facts, they are personal experiences, which we know are not equal and often come with biases
Add "Look up version 4 of the library, make sure to use that version".
My Python work has to be told we are using uv, and sometimes that I am on a mac. This is not that different to what you would have to tell another programmer, not familiar with you tools.
My Python work has to be told we are using uv, and sometimes that I am on a mac. This is not that different to what you would have to tell another programmer, not familiar with you tools.
What's your explanation for why others report difficulty getting coding agents to produce their desired results?
And don't respond with a childish "skill issue lol" like it's Twitter. What specific skill do you think people are lacking?
And don't respond with a childish "skill issue lol" like it's Twitter. What specific skill do you think people are lacking?
Thought experiment: you can ride a bike. You can see other people ride bikes. Some portion of people get on a bike and fall off, then claim that bikes are not useful for transportation. Specify what skill they are lacking without saying 'ability to ride a bike'.
For a bike? Balance, fine motor control, proprioception, or even motivation. You can always break it down.
Knowing those things won't help them acquire the skill. What will help them be able to ride a bike is practicing trying to riding a bike until they can do it.
Not OP but my two cents - probably laziness and propensity towards daydreaming.
I have extreme intolerance to boredom. I can't do the same job twice. Some people don't care.
This pain has caused me to become incredibly effective with LLMs because I'm always looking for an easier way to do anything.
If you keep hammering away at a problem - i.e. how to code with LLMs - you tend to become dramatically better at other people who don't do that.
I have extreme intolerance to boredom. I can't do the same job twice. Some people don't care.
This pain has caused me to become incredibly effective with LLMs because I'm always looking for an easier way to do anything.
If you keep hammering away at a problem - i.e. how to code with LLMs - you tend to become dramatically better at other people who don't do that.
In no particular order:
LLMs seem, for some reason, to be worse at some languages than others.
LLMs only have so much context available, so larger projects are harder to get good results in.
Some tools (eg a fast compiler) are very useful to agents to get good feedback. If you don't have a compiler, you'll get hallucinations corrected more slowly.
Some people have schedules that facilitate long uninterrupted periods, so they see an agent work for twenty minutes on a task and think "well I could've done that in 10-30 minutes, so where's the gain?". And those people haven't understood that they could be running many agents in parallel (I don't blame people for not realizing this, no one I talk to is doing this at work).
People also don't realize they could have the agent working while they're asleep/eating lunch/in a meeting. This is why, in my experience, managers find agents more transformative than ICs do. We're in more meetings, with fewer uninterrupted periods.
People have an expectation that the agent will always one-shot the implementation, and don't appreciate it when the agent gets them 80% of the way there. Or that, it's basically free to try again if the agent went completely off the rails.
A lot of people don't understand that agents are a step beyond just an LLM, so their attempts last year have colored their expectations.
Some people are less willing to attempt to work with the agent to make it better at producing good output. They don't know how to do it. Your agent got logging wrong? Okay, tell it to read an example of good logging and to write a rule that will get it correct.
LLMs only have so much context available, so larger projects are harder to get good results in.
Some tools (eg a fast compiler) are very useful to agents to get good feedback. If you don't have a compiler, you'll get hallucinations corrected more slowly.
Some people have schedules that facilitate long uninterrupted periods, so they see an agent work for twenty minutes on a task and think "well I could've done that in 10-30 minutes, so where's the gain?". And those people haven't understood that they could be running many agents in parallel (I don't blame people for not realizing this, no one I talk to is doing this at work).
People also don't realize they could have the agent working while they're asleep/eating lunch/in a meeting. This is why, in my experience, managers find agents more transformative than ICs do. We're in more meetings, with fewer uninterrupted periods.
People have an expectation that the agent will always one-shot the implementation, and don't appreciate it when the agent gets them 80% of the way there. Or that, it's basically free to try again if the agent went completely off the rails.
A lot of people don't understand that agents are a step beyond just an LLM, so their attempts last year have colored their expectations.
Some people are less willing to attempt to work with the agent to make it better at producing good output. They don't know how to do it. Your agent got logging wrong? Okay, tell it to read an example of good logging and to write a rule that will get it correct.
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.
Maybe it's because the libraries I use are made from small files which easily fit into the context window.
Same here, very low hallucination rate and it can pretty quickly correct itself (Claude Code). To force it to use recent versions of libraries instead of old ones, it's good to have it specifically required in CLAUDE.md and also having docs MCP (like context7) can help.
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)
Prompt / context engineering is still an underrated and underutilized activity (imo)
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.
AI is no more capable of reliably one shotting solutions that you are.
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.
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.
The folks that makes CodeCompagnion are doing interesting things!
With already https://agentcommunicationprotocol.dev (ACP) same name seems confusing now. even though differences are there in both.
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...
https://lfaidata.foundation/communityblog/2025/08/29/acp-joi...
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?
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?
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
lol. So hedonistic.
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.
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.
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.
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
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
Is there an open LSP standard that allows IDEs like Lazyvim to work?
LSP is an open standard. Protocols like this need to be implemented in editor.
...and cover your tracks by making Gemini the only supported agent...
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.
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.
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.
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.
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.
> 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
One great reason is to avoid M*N problem: https://matklad.github.io/2022/04/25/why-lsp.html
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.
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.
I would love it, but please don't add JSON-RPC to the world...
It's too heavy for editor.
Is there a better option?
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?
Are people who assert that JSON-RPC is "heavy" writing code we all rely on?
Harsh. But fair. JSON-RPC is one of the leanest protocols out there.
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.
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.
I don't know if your complaint is specifically about the capitalization, but I find these clear rules useful when interpreting specifications.
We SHALL replace them with MAYBE, IF YOU FEEL LIKE IT, and OR WHATEVER. Will sure make for lighter reading.
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.
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?
Another discussion on the same topic from 3 days ago:
https://news.ycombinator.com/item?id=45038710
https://news.ycombinator.com/item?id=45038710
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.
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.
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.
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.
naming things isn't that hard. at least put something with AI/LLM and code/IDE in the name.
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.
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.
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.
Found this repo the other day in case that's useful: https://github.com/Xuanwo/acp-claude-code
the difference between using, for example, Gemini via ACP vs Gemini via the ide own agent is not so clear
How's this better than MCP?
Does anyone else find it funny that LLMs need a protocol to execute tooling? Like, it understands language, right?
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.