13 ms·

The Agent2Agent Protocol (A2A)

• deleted 2y ago
  [deleted]
• sharemywin 2y ago
  on it's face this kind of seems dumb. aren't agents supposed to be adaptable enough to handle any protocol?
  • bfeynman 2y ago
    shhhh - that's the big announcement for next year - the "Agnostic" General Interface (AGI) ... works with any endpoint no more lengthy MCP or A2A setup!
    • _pdp_ 2y ago
      you are too late already... there are now mcp servers that wrap other mcp servers in a single mcp interface... mmcp
  • skeeter2020 2y ago
    yeah - I don't get it. I'm all for abstraction but the entire point of using agents at the UX-level is you didn't need a single agreed-upon protocol to make it work. Feels like they're using the old Microsoft fire and motion strategy to keep people busy on their tech, or artificially introduce structure & coupling that - suprise - benefits the maker of shovels, not the diggers.
    • Maxious 2y ago
      > In infantry battles, he told us, there is only one strategy: Fire and Motion. You move towards the enemy while firing your weapon. The firing forces him to keep his head down so he can’t fire at you. https://www.joelonsoftware.com/2002/01/06/fire-and-motion/ https://www.joelonsoftware.com/2002/01/06/fire-and-motion/
  • esafak 2y ago
    1. Agents don't know the APIs. This is a way for you to declare them. 2. You get to decide what functionality you want to expose agents to. 3. An API enables reliable tool use.
    • wild_egg 2y ago
      The APIs have docs. The agent can go read them and build against them.
      • esafak 2y ago
        The agent doesn't know what tools are available on your host. And searching for the documentation is slower and less reliable. It's an optimization.
        • bfeynman 2y ago
          the guiding promise of AI was able to figure out unstructured data. Manually crafting prompts and description examples for tools is a step orthogonal to progress. Searching for docs, great now you have 1000 tools saying they do same thing exposed to model, now we need another search on top of that?
• zellyn 2y ago
  It’s frustratingly difficult to see what these (A2A and MCP) protocols actually look like. All I want is a simple example conversation that includes the actual LLM outputs used to trigger a call and the JSON that goes over the wire… maybe I’ll take some time and make a cheat-sheet. I have to say, the endorsements at the end somehow made this seem worse…
  • laichzeit0 2y ago
    Take a look at the samples: https://google.github.io/A2A/#/documentation https://google.github.io/A2A/#/documentation
    • zellyn 2y ago
      Oh, that's really nice. I'd also like to see what syntax the LLM uses to _trigger_ these calls, and what prompt is sent to the LLM to tell it how to do that. I should probably just go read Goose's code…
      • medbrane 2y ago
        That's dependent on the particular LLM one uses. But it can be a json with the tool name and the payload for the tool.
      • laichzeit0 2y ago
        The LLM returns a message called ToolMessage which then describes which function to call and the parameters (you register these functions/tools as part of the initialisation step, like when you pass it temperature, or whatever other options your LLM allows you to set). So think of it as instead of steaming back text, it’s streaming back text to tell you “please call this function with these args” and you can do with that what you want. Ideally you’d call that function and then give the output back to the LLM. Nothing magic really.
  • ronameles 2y ago
    https://www.youtube.com/watch?v=5_WE6cZeDG8 https://www.youtube.com/watch?v=5_WE6cZeDG8 - I work at an industrial software company. You can kind of think of us as an API layer to factory data, that is generally a mess. This video shows you what MCP can do for us in terms of connecting factory data to LLMS. Maybe it will help. A2A is new to me, and I need to dig in. Basically if we expose our API over MCP, agents can "figure it out". But MCP isn't secure enough today, so hoping that gets enhanced.
• trash_cat 2y ago
  This is very interesting. I feel like we are going towards a future where you will have personal agents that know a lot about us and will interact with other corporate and government agents to complete beurocratic and non beurocratic tasks. Those with more capable agents will have to pay a premium.
• _pdp_ 2y ago
  Link to repo: https://github.com/google/A2A https://github.com/google/A2A Docs: https://google.github.io/A2A/#/documentation https://google.github.io/A2A/#/documentation I think they are trying to ride the MCP hype as well with their own implementation that is also meh. MCP itself is also an over-engineered implementation of AI plugins by OpenAI. Obviously the end game is control over a standard which can act as a strategic tool for boosting valuations or even better product positioning. The better approach is to simply use open standards that already exists but I guess this is just not sexy.
  • skeeter2020 2y ago
    Marginally technical executives are really dangerous here. My CTO is "all in" on MCP but fails to see it's an over-engineered attempt by one player to own the thin veneer on top of the bog-standard plumbing that's actually doing all the work. It's like OpenAI made an ODBC database connector and is saying "we created relational databases!"
    • paulgb 2y ago
      I think the only reason people think MCP is over-engineered is that people have been waiting for a way to expose remote tool calls in a client application, MCP came along and had that (among other things), and people assumed that that was all it was good for. But it's not! It's like saying a microwave is over-engineered because you only use the timer functionality.
  • Maxious 2y ago
    The google angle here isn't even so much on the LLM side but on Google Cloud See all those shiny badges for consulting firms? If you are a truely thought leadershiping executive, you should get one of them in ASAP to build you an A2A Registry [1] for your "Enterprise Agents" [2] to communicate via an A2A NotificationService [3] (brought to you by GCP!) Indicative that the blog post example isn't help book a holiday but help hire a software engineer 1: https://google.github.io/A2A/#/topics/agent_discovery https://google.github.io/A2A/#/topics/agent_discovery 2: https://google.github.io/A2A/#/topics/enterprise_ready https://google.github.io/A2A/#/topics/enterprise_ready 3: https://google.github.io/A2A/#/topics/push_notifications https://google.github.io/A2A/#/topics/push_notifications edit: > Updates to Agentspace make it easier for customers to discover, create and adopt AI agents. We're also growing the AI Agent Marketplace https://console.cloud.google.com/marketplace/browse?filter=category:ai-agent https://console.cloud.google.com/marketplace/browse?filter=c... , a dedicated section within Google Cloud Marketplace where customers can easily browse and purchase AI agents from partners. https://blog.google/products/google-cloud/next-2025/ https://blog.google/products/google-cloud/next-2025/
• bsenftner 2y ago
  [flagged]
  • itchyjunk 2y ago
    Did you watch the video? Do you have opinions on it? On MCP? On A2A? What is a title of youtube video and a link to it supposed to add here? Just start a new submission if you just want to link to it.
    • bsenftner 2y ago
      Yes, that is why I posted. The video summarizes a lengthy essay I'd have written less well than this communicates. Many of the same ideas are being echoed here as well.
• flakiness 2y ago
  > A2A is an open protocol that complements Anthropic's Model Context Protocol (MCP), which provides helpful tools and context to agents. A "server" sample: https://github.com/google/A2A/tree/main/samples/js/src/server https://github.com/google/A2A/tree/main/samples/js/src/serve... So it looks like the point is that it keeps the connection/context open for multiple interactions vs. MCP, which is more like pure request-response?
  • qntty 2y ago
    I don't know if it would be right to call MCP pure request/response, since unlike HTTP, it's a stateful protocol.
  • esafak 2y ago
    MCP is stateful. They are currently developing stateless support. https://github.com/modelcontextprotocol/modelcontextprotocol/discussions/102 https://github.com/modelcontextprotocol/modelcontextprotocol...
    • flakiness 2y ago
      Oh good to know, thanks for the clarification!
• mindcrime 2y ago
  Great, another Agent 2 Agent protocol. One more of those and we'll have a complete set! OK, I'm being a little bit facetious. But there has been an awful lot of work in this space (or closely related space). Going back to FIPA[1], KQML[2], DAML+OIL[3], etc., up through the more recent AGNTCY[4] and Agent Communication Protocol[5] stuff, there's a lot "out there". [1]: http://www.fipa.org/ http://www.fipa.org/ [2]: https://en.wikipedia.org/wiki/Knowledge_Query_and_Manipulation_Language https://en.wikipedia.org/wiki/Knowledge_Query_and_Manipulati... [3]: https://www.w3.org/TR/daml+oil-reference/ https://www.w3.org/TR/daml+oil-reference/ [4]: https://github.com/agntcy https://github.com/agntcy [5]: https://github.com/orgs/i-am-bee/discussions/284 https://github.com/orgs/i-am-bee/discussions/284
  • riku_iki 2y ago
    Now we can have 4 router startups on top of this
  • joezydeco 2y ago
    Wasn't XML supposed to be this holy grail of interop as well?
• devops000 2y ago
  Do you know real use cases of agents? Actually used and that have been using for a while. Not just for curiosity. I read about them only for hypothetical scenarios. Is it a real thing?
  • simonw 2y ago
    That depends very much on which of the dozen+ definitions of "agent" you are using.
    • knowaveragejoe 2y ago
      I think Anthropic does a good job of nailing it down to two definitions, one of which is very commonly referred to as agents but more appropriately called _workflows_, and this is the vast majority of what you'll see in the wild. https://www.anthropic.com/engineering/building-effective-agents https://www.anthropic.com/engineering/building-effective-age...
  • MajidManzarpour 2y ago
    [dead]
  • alittletooraph2 2y ago
    agents are just the rebranded version of automated workflows and sometimes its an LLM doing the validation
• frontalier 2y ago
  the protocol wars now available for agents
• owebmaster 2y ago
  The article mention MCP (once) as being complementary and not an alternative but it looks like Google intend to commodify the tools layer and monopolize the next layer, the agents using MCP.
• simonw 2y ago
  I just published some notes on MCP security and prompt injection. MCP doesn't have security flaws in the protocol itself, but the patterns it encourage (providing LLMs with access to tools that can act on the user's behalf while they also may be exposed to text from untrusted sources) are rife for prompt injection attacks: https://simonwillison.net/2025/Apr/9/mcp-prompt-injection/ https://simonwillison.net/2025/Apr/9/mcp-prompt-injection/
  • jsheard 2y ago
    Every decade or so we just forget that in-band signaling is a bad idea and make all the same mistakes again it seems. 1960s phone companies at least had the excuse of having to retrofit their control systems onto existing single-channel lines, and run the whole operation on roughly the processing power of a pocket calculator. What's our excuse?
    • mycall 2y ago
      Enterprise databases are filled with users usurping a field with pre/post-pending characters to mean something special to them. Even filenames have this problem due to limitations in directory trees. Inband signals will never go away.
      • delusional 2y ago
        At some level everything has to go in a single band. I don't have separate network connections to my house, I don't send separate TCP SYN packets for each "band". I don't have separate storage devices for each file on my harddrive. We multiplex the data somewhere. Yhe trick to it is that the multiplexer has to be a component, and not a distributed set of ad-hoc regexes.
        • fragmede 2y ago
          at some level, sure, but I can no longer put +++ATH0 into my comment and have it hang up your connection, so it's worth some effort to prevent the problem.
• dleeftink 2y ago
  > Hiring a software engineer can be significantly simplified with A2A collaboration Why not abstract away the applicant altogether, outsourcing the search for talent that make these very systems tick. Let the candidate microtrading really take off, there's always a better candidate in the pipeline after all
• rogerthis 2y ago
  Looking at partners of this effort, I wonder what problems does A2A create to serve as a solution.
  • candiddevmike 2y ago
    As I understand it, it enables SaaS for Agents, along with the associated consumption and billing. All of those partners are going to have some kind of agent subscription for you to plug into your enterprise LLM of choice. I see this as Slack bots 2.0. Maybe this will create real revenue opportunities where the original chatops didn't.
  • coredog64 2y ago
    Partner list includes Accenture, Capgemini, Cognizant, HCL, InfoSys, KPMG, and Wipro. I think it’s fair to say that the generative capability of A2A is the generation of billable hours.
    • atonse 2y ago
      Yeah seeing that list is a red flag for me. Seems like a vehicle to attach their names to so those companies can pretend that they’re actually innovating in this space, rather than the usual mediocre services offerings.
  • jillesvangurp 2y ago
    Adapting the capabilities of existing SAAS software for use by agentic AIs. This is not a small market. Anybody with any kind of software that does anything mildly valuable is going to look at ways to get in on the action via protocols like this. I know of several companies that have been exploring possibilities for this.
• AIorNot 2y ago
  Great Another acronym to put on your resume with 5 years of experience
• moralestapia 2y ago
  Always lagging, always late. Google is so lame these days. (I know, they still get billions in revenue, but maybe that's their curse, too comfy to take it seriously)
  • joezydeco 2y ago
    If A2A doesn't bring in ad revenue, it will be in the graveyard in a year or two.
• AndrewKemendo 2y ago
  These protocols are to put handlers between you and your own data so they can sell it back to you via “search.” Companies who are betting their future on LLMs realized a few years ago that the data they can legally use is the only long term difference between them, aka “moat.” Now that everyone has more or less the same public data access, and a thin compute moat is still there, the goal is to transfer your private textual data to them forever so they have an ever updating and tuned set of models for your data
  • ziddoap 2y ago
    >so they can sell it back to you via “search.” >transfer your private textual data to them Who is "they" (or "them") in these sentences? It's an open protocol with 50 partner companies, which can be used with AI agents from ~anyone on ~any framework. Presumably you can use this protocol in an air-gapped network, if you'd like. Which one of the 50 partner companies is taking my data and building the moat? Why would the other 49 companies agree to a partnership if they're helping build a moat that keeps them out?
    • delusional 2y ago
      I think the point the above poster is trying to make is that the point here is that they don't want to share the data. Instead google (and atlassian/SAP/whoever) would like to make an "open" but limiting interface mediated through their agents, such that you can never get actual access to the data, but only what they decide you get to have. To put it bluntly, the point of creating the open interface at this level, is that you get to close off everything else.
      • AndrewKemendo 2y ago
        Yes that’s exactly the point Open the interface publicly then monetize the I/O or storage or processing. Classic high margin SaaS approach with a veneer of “open.” You can look at it as a standards capture
  • niemandhier 2y ago
• pjmlp 2y ago
  With all this agents talks, maybe I should dust off my old Tcl books on Agent Tcl. https://digitalcommons.dartmouth.edu/dissertations/62/ https://digitalcommons.dartmouth.edu/dissertations/62/
  • srameshc 2y ago
    That looks interesting from abstract. Can you please explain how these two can be interconnected ?
    • pjmlp 2y ago
      Back in the late 90's, during one of the previous AI waves, there was this idea of autonomous agents, where one would communicate by sending code snippets or bytecode if using something like Java, which would trigger tasks on remote agents that would process those requests on their own somehow, and the transmited code snippets would be extensible logic. As far as I can remember, never really left the research lab, with a few books and papers published on the matter. Everything old is new again.
      • mindcrime 2y ago
        Later renamed as D'Agents[1]. Still never got any serious industry adoption as far as I know, but I guess the code is still out there if somebody wanted to do something with it. [1]: https://wiki.tcl-lang.org/page/D%27Agents+%28formerly+Agent+Tcl%29 https://wiki.tcl-lang.org/page/D%27Agents+%28formerly+Agent+...
        • rapjr9 2y ago
          I worked as a programmer for the D'Agents group at Dartmouth. The Tcl agent system was ported to Java and we did a variety of experiments with it, mostly centered around information retrieval. I built a Beowulf cluster which we populated with a distributed database of Usenet news. Agents could jump onto the cluster, do multistep queries, and then jump back with the condensed results. We did some work with the US Navy who had a problem with ship-to-shore networks; their network links to shore were T1 equivalents, which made it difficult to work interactively with large data sets for those on shore. We used agents to jump to the ships computer, do multistep queries and computations, and jump back to the shore with the results. This saved a lot of bandwidth. There were a few problems with agent systems. Letting untrusted code run on your server was a difficult security problem, though Java sandboxing helped. Also sending a trusted agent to run on a potentially compromised server was a difficult security problem, the agents might be carrying secrets. Another issue was that agents could use enormous resources, for example doing a database query for the word "the" would engage the entire cluster database. A single laptop sending an agent per second could overwhelm a computing cluster in minutes. We spent a fair amount of time implementing resource management, such as agent lifetime limits, but this was still an issue. What mostly ended the field of study at the time was probably that agents were a lot like computer worms, with difficult security issues, both for the agent and for the server. Also agents were somewhat uncontrollable, until you tried one you didn't know for sure what it might do, which made testing risky; agents could not only jump to and from the cluster, they could jump between machines on the cluster and fork themselves, so like a computer worm they could self-spread everywhere. Some later work seemed to find some solutions to those problems, but I don't know them in detail. Remote procedure calls were a possible alternative to agents, but didn't have as much versatility as sending your own custom code in an agent.
• jason-phillips 2y ago
  This doesn't say anything about the protocol other than what would be obvious (a JSON card describing the agent's schema) and that it will use http (such a safe, but low-effort bet). I was hoping for more, but with so many cooks in the kitchen, I guess I'm not surprised.
  • jason-phillips 2y ago
    The way they're framing this attempts to stave off disintermediation, which is the real threat.
    • ForHackernews 2y ago
      What do you mean? Who is the intermediary in this context? Google? The threat that people will use LLMs to get their fake information without needing to use google to find sites with fake reviews?
      • deleted 2y ago
        [deleted]
      • jason-phillips 2y ago
        Yes, to much of what you said.
• zb3 2y ago
  > Hiring a software engineer can be significantly simplified with A2A collaboration. Holy shit.. NO!
  • rvz 2y ago
    See how they didn't choose lawyers, bankers, or government civil servants? Analysts, digital artists, customer service support and journalists of all levels have already been replaced. Software engineers (of all levels) are the next knowledge workers to be replaced by agents.
    • zb3 2y ago
      I was actually more angered about the fact that the hiring process would be further automated, frustrating candidates even more.. Ultimately I see nothing wrong with replacing everyone, providing the newly generated wealth would be distributed to all, not just the select few "owners" of these things.. we'll see..
• humblyCrazy 2y ago
  i dont understand how it is different from mcp. The blog just says "A2A is an open protocol that complements Anthropic's Model Context Protocol (MCP), which provides helpful tools and context to agents." There is no example or anything on how does it complement it
  • varelaseb 2y ago
    It's not so much about what you _can do_ but about the messaging and posturing, which is what drives the adoption of standards as a social phenomenon. My team's been working on implementing MCP-agents and agents-as-tools and we consistently saw confusion from everyone we were selling this into (who were already bought in to hosting an MCP server for their API or SDK) for their agents because "that's not what it's for". Kinda weird, but kinda simple.
• LeonidBugaev 2y ago
  To put it simple: A2A is for communication between the agents. MCP is how agent communicate with its tools. Important aspect of A2A, is that it has a notion of tasks, task rediness, and etc. E.g. you can give it a task and expect completely in few days, and get notified via webhook or polling it. For the end users for sure A2A will cause a big confusing, and can replace a lot of current MCP usage.
  • NickNaraghi 2y ago
    If an agent could wrap itself in an MCP server, would that make A2A redundant?
    • tuananh 2y ago
      you mean wrap mcp server in itself?
    • fengkx 2y ago
      I have the same problem come out in my mind. What if I wrap the agent as a tool in MCP? Since the agents I got from the 'A2A' protocol is passed as tools to another Agent... https://github.com/google/A2A/blob/72a70c2f98ffdb9bd543a57c8de894fab96d3b85/samples/python/hosts/multiagent/host_agent.py#L81 https://github.com/google/A2A/blob/72a70c2f98ffdb9bd543a57c8...
• zurfer 2y ago
  My current understanding: MCP - exposes prompts, resources and tools to a host, who can do whatever they like A2A - exposes capability discovery, tasks, collaboration?/chat?, user experience discussions (can we embed an image or or a website?). High-level it makes sense to agree on these concepts. I just wonder if we really need a fully specified protocol? Can't we just have a set of best practices around API endpoints/functions? Like, imo we could just keep using Rest APIs and have a convention that an agent exposes endpoints like /capabilities, /task_status ... I have similar thoughts around MCP. We could just have the convention to have an API endpoint called /prompts and keep using rest apis? Not sure what I am missing.
  • daxfohl 2y ago
    That's the first step to creating a protocol. The next step is to formalize it, publish it, and get others to adopt it. That way, it's one less thing for LLMs to hallucinate on. Otherwise everyone has different conventions and LLMs start making stuff up. That's all these are.
  • MattDaEskimo 2y ago
    Eventually agents from different providers will come into play. It's important to agree on a standard for accurate interoperability. Ideally, the model providers would then build for the protocol, so the developers aren't writing spaghetti code for every small difference
  • nlarew 2y ago
    > Can't we just have a set of best practices around API endpoints/functions? Like, imo we could just keep using Rest APIs and have a convention that an agent exposes endpoints like /capabilities, /task_status ... To make this work at scale we all need to agree on the specific routes names, payloads, behaviors, etc. At that point we have defined a protocol (built on top of HTTP, itself a lower level protocol).
• rahulcap 2y ago
  From the blog post it’s hard to tell in which areas it’s better or worse than MCP. The one that will win — will be the one that gives devs the confidence to run in full “yolo/autonomous” mode. That’s the future.
• vessenes 2y ago
  OK, I’ve read the website, the spec, and JavaScript and python clients and servers. Here’s a quick initial reaction. 1. This is in the “embrace and extend” type area vis-a-vis MCP — if you implemented A2A for a project I don’t think you’d need to implement MCP. That said, if you have an MCP server, you could add a thin layer for A2A compliance. 2. This hits and improves on a bunch of pain points for MCP, with reasonable relatively light weight answers — it specs out how in-band and out-of-band data should get passed around, it has a sane (token based largely) approach to security for function calling, it has thought about discovery and security with a simple reliance on the DNS security layer, for instance. 3. The full UI demos imagine significantly more capable clients - ones that can at least implement Iframes - and reconnect to lost streaming connections, among other things. It’s not clear to me that there’s any UI negotiation baked into this right now, and it’s not clear to me what the vision is for non-HTML-capable clients. That said, they publish clients that are text-only in the example repo. It may be an area that isn’t fully fleshed out yet, or there may be a simple answer I didn’t see immediately. Upshot - if you’re building an MCP server right now, great —- you should read the A2A spec for a roadmap on some things you’ll care about at some point, like auth and out of band data delivery. If you’re thinking about building an MCP server, I’m not sure I’d move ahead on vanilla MCP - I think the A2A spec is better specified, and if for some reason A2A doesn’t take off, it will only be because MCP has added support for a couple of these key pain points — it should be relatively easy to migrate. I think any mid-size or better tool calling LLM should be able to get A2A capability json and figure out what tool to call, btw. One last thing - I appreciate the GOOG team here for their relatively clear documentation and explanation. The MCP site has always felt a little hard to understand. Second last thing: notably, no openAI or Anthropic support here. Let’s hope we’re not in xkcd 927 land. Upshot: I’d think of this as a sane superset of MCP and I will probably try it out for a project or two based on the documentation quality. Worst case, writing a shim for an exact MCP capable server is a) probably not a big deal, and b) will probably be on GitHub this week or so.
  • daxfohl 2y ago
    MCP docs say it's like USB for your AI model. A2A sounds more like a networking stack for multiple AI models.
  • 2y ago
• hliyan 2y ago
  Are we rediscovering SOA and WSDL, but this time for LLM interop instead of web services? I may be wrong, but I'm starting to wonder whether software engineering degrees should include a history subject about the rise and fall of various architectures, methodologies and patterns.
  • zubairq 2y ago
    haha, funny, I was thinking the same thing!
  • fedeb95 2y ago
    software engineering IS perpetual rediscovery of the Same.
  • Maxious 2y ago
    don't forget CORBA and OSGi
  • maxwellg 2y ago
    I wasn't around for WSDL so please correct me if I am wrong - but the main weakness of WSDL was that no applications were able to take advantage of dynamic service and method discovery? A service could broadcast a WSDL but something needed to make use of it, and if you're writing an application you might as well just write against a known API instead of an unknown one. LLMs promise to be the unstructured glue that can take advantage of newly-discovered methods and APIs at runtime.
    • zoogeny 2y ago
      I was unfortunate enough to work with SOAP and WSDL. There was a pipedream at the time of automatically configuring services based on WSDL but it never materialized. What it was very good at (and still has no equal to my mind) was allowing for quick implementation of API boilerplate. You could point a service at the WSDL endpoint (which generally always existed at a known relative URL) and it would scaffold an entire API client for whatever language you wanted. Sort of like JSON Schema but better. This also meant that you could do things like create diffs between your current service API client and an updated service API client from the broadcasting service. For example, if the service changed the parameters or data objects, deprecated or added functions then you could easily see how your client implementation differed from the service interface. It also provided some rudimentary versioning functionality, IIRC. Generally servers also made this information available with an HTML front-end for documentation purposes. So while the promise of one day services configuring themselves at runtime was there, it wasn't really ever an expectation. IMO, the reason WSDL failed is because XML is terrifically annoying to work with and SOAP is insanely complex. JSON and REST were much simpler in every way you can imagine and did the same job. They were also much more efficient to process and transmit over the network. Less cognitive load for the dev, less processor load, less network traffic. So the "runtime" explanation isn't really valid as an excuse for it's failure, since the discovery was really meant more in practice like "as a programmer you can know exactly what functions, parameters, data-objects any service has available by visiting a URL" and much less like "as a runtime client you can auto-configure a service call to a completely new and unknown service using WSDL". The second thing was a claim that one-day might be available but wasn't generally used in practice.
• johnnythunder 2y ago
  I can envision a future where we maintain a set of AI agent subscriptions that can perform tasks for us based on what we pay for, with the best models and agents costing much more that the freemium ones. This along with a heavily tweaked and customized open-source community that maintains their own non-subscription capabilities.
• peterjliu 2y ago
  From documentation: "TLDR; Agentic applications needs both A2A and MCP. We recommend MCP for tools and A2A for agents." Agents can just be viewed as tools, and vice versa. Is this an attempt to save the launch after getting scooped by MCP?
• rvz 2y ago
  This is disturbing and they are declaring war on you with too many red flags. > "Today, we’re launching a new, open protocol called Agent2Agent (A2A), with support and contributions from more than 50 technology partners" Why do you think the majority of the big consultancy firms like McKinsey, KPMG, PwC, Deloitte, Cognizant, Capgemini and Accenture are all here in this round table? You are on the menu when they arrive to replace you with an agent. Exhibit A: > Hiring a software engineer can be significantly simplified with A2A collaboration. Within a unified interface like Agentspace, a user (e.g., a hiring manager) can task their agent to find candidates matching a job listing, location, and skill set. The recruiter is now an "agent". Not a human. Don't think it isn't going to happen to you because that example targeted recruiters. The big consultancy firms already have tens of thousands of employees and are ready to try it on them first before recommending to businesses to replace.... you.
  • MattDaEskimo 2y ago
    This is the reality, unfortunately. Lots of jobs that focus on communication and data organization are out the window, including recruiters.
    • rapjr9 2y ago
      They do need to train the agents first though, so that is the other purpose of agents, to gather the training data to replace the people.
• smusamashah 2y ago
  In the video example, I am kind of baffled that LLM is being trusted to pick candidates for the role. How much guarantee does Google's LLM/agent provide that it didn't hallucinate (read wrong info) in any of the steps including parsing job description and than matching that with profile of candidates? I don't understand when these LLMs are presented to solve real life problems as if an LLM is like a sane person doing their job.
  • bryan_w 2y ago
    I'm glad someone else saw this. This is one of the few areas you wouldn't want to show off what you're doing with AI.
• alphazard 2y ago
  Can anyone comment on whether this or MCP are at all well designed? Is there any sort elegance to them? Or is it exactly what I would expect from a multi-corporation committee: lots of different ways to do the same thing, use case bloat, complicated to implement, complicated to test, etc.
• Flux159 2y ago
  Some very quick initial thoughts - the json spec has some similarities to mcp: https://google.github.io/A2A/#/documentation?id=agent-card https://google.github.io/A2A/#/documentation?id=agent-card - there's an agent card that describes capabilities that google wants websites to host at https://DOMAIN/.well-known/agent.json https://DOMAIN/.well-known/agent.json according to https://google.github.io/A2A/#/topics/agent_discovery https://google.github.io/A2A/#/topics/agent_discovery so crawlers can scrape to discover agents. The jsonrpc calls look similar-ish to mcp tool calls except the inputs and outputs look closer to the inputs/outputs from calling an LLM (ie messages, artifacts, etc.). The JS server example that they give is interesting https://github.com/google/A2A/tree/main/samples/js/src/server https://github.com/google/A2A/tree/main/samples/js/src/serve... - they're using a generator to send sse events back to the caller - a little weird to expose as the API instead of just doing what express allows you to do after setting up an sse connection (res.send / flush multiple times).
• cowpig 2y ago
  I don't totally understand why we need an additional layer of abstraction over MCP at this point. Why can't an agent just be an MCP server? What is the fundamental difference between an MCP server "tool" and an agent "capability"? This kind of feels to me like someone at google saw how successful MCP was becoming and said "we need something like that". I feel the same way about OpenAI's Agent SDK. I think the word "Agent" appearing in any engineering project is a tell that it's driven by marketing rather than engineers' needs.
  • Nav_Panel 2y ago
    A2A isn't a layer of abstraction over MCP, it functions in parallel and they complement each other. MCP addresses the Agent-to-Environment question, how can Agents "do things" on computers. A2A addresses the Agent-to-Agent question, how can Agents learn about other Agents and communicate with them. You need both. You CAN try and build "the one agent that does everything" but in scenarios where there's many simultaneous data streams, a better approach would be to have many stateful agents handling each stream via MCP, coupled with a single "executive" agent that calls on each of the stateful agents via A2A to get the high-level info it needs to make decisions on behalf of its user.
    • cowpig 2y ago
      What is an "agent"? To my understanding of this protocol it looks like it's an entity exposing a set of capabilities. Why is that different and complementary to an MCP server exposing tools? Why would you be limited to an "everything agent" in MCP? I am struggling to see the core problem that this protocol addresses.
      • Nav_Panel 2y ago
        Much debated question but if we run with your definition, then A2A adds communication capabilities alongside tool-calling, which is ultimately a set of programmatic hooks. Like "phone a friend" if you don't know the answer given what you have available directly (via MCP, training data, or context). My assumption is that the initial A2A implementation will be done with MCP, so the LLM can ask your AI directory or marketplace for help with a task via some kind of "phone a friend" tool call, and it'll be able to immediately interop and get the info it needs to complete the task.
• samuell 2y ago
  So now we are going towards using models to more efficiently store information, and let them talk to each other, instead of moving massive datasets around, as briefly outlined in 2023 in [1] & [2] (although I would anticipate that linked data might help here too)? [1] https://livingsystems.substack.com/p/the-future-of-data-less-data https://livingsystems.substack.com/p/the-future-of-data-less... [2] https://livingsystems.substack.com/p/will-data-served-as-language-models https://livingsystems.substack.com/p/will-data-served-as-lan...
• esafak 2y ago
  Can someone explain how this complements MCP? Is A2A for the case where you have multiple agents, rather than one agent with multiple tools?
• simonw 2y ago
  OK, I have to ask: isn't this agents to agents idea kind of Science Fiction? I absolutely get the value of LLMs calling tools and APIs. I still don't see much value in LLMs calling other LLMs. Everyone gets really excited about it - "langchain" named their whole company over the idea of chaining LLMs together - but aside from a few niche applications (Deep Research style tools presumably fire off a bunch of sub-prompts to summarize content they are crawling, Claude Code uses multiple prompts executions to edit files) is it really THAT useful? Worth building an entire new protocol with a flashy name and a bunch of marketing launch partners? LLMs are unreliable enough already without compounding their unreliability by chaining them together!
  • abshkbh 2y ago
    Morden software consists of separation of responsibilities between services and a higher plane orchestrating the data flow for business logic. If you believe there is value in fuzzy tasks being done by LLMs then from that it follows that having separate "agent" services with a higher order orchestrator would be required. Each calling LLMs on their own inside.
    • simonw 2y ago
      I don't buy it. Why would I want my LLM to talk to some other LLM and introduce even more space for weird, non-deterministic bugs when I could have my LLM call a deterministic API to achieve the same thing?
      • octopoc 2y ago
        Isn't an agent just a system prompt + specific tools? Why not just switch out the system prompt and tools in the same context?
        • IanCal 2y ago
          No. You have anything else that modifies the context, tools, model, and most importantly perhaps the iteration that controls what's going on with those other values.
• chipgap98 2y ago
  They are pitching this as complementary to the MCP [0], but I don't see it. What is the value in agents communicating in agents as opposed to just treating other agents as tools? [0]: https://google.github.io/A2A/#/topics/a2a_and_mcp https://google.github.io/A2A/#/topics/a2a_and_mcp
  • bryan_w 2y ago
    They are thinking about Enterprises. Shirley from accounting isn't going to install an mcp service to pull the receipt photos from Dropbox and upload them to SAP/Concur (expense reimbursement)
    • TS_Posts 2y ago
      Yes, that is our assumption. reposting from above: We are working with partners on very specific customer problems. Customers are building individual agents in different frameworks OR are purchasing agents from multiple vendors. Those agents are isolated and do not share tools, or memory, or context. For example, most companies have an internal directory and internal private APIs and tools. They can build an agent to help complete internal tasks. However, they also may purchase an "HR Agent" or "Travel Assistant Agent" or "Tax Preparation Agent" or "Facilities Control Agent". These agents aren't sharing their private APIs and data with each other. It's also difficult to model these agents as structured tools. For example, a "Tax Preparation Agent" may need to evaluate many different options and ask for specific different documents and information based on an individual users needs. Modeling this as 100s of tools isn't practical. That's where we see A2A helping. Talk to an agent as an agent. This lets a user talk to only their company agent and then have that agent work with the HR Agent or Travel Booking Agent to complete complex tasks when they cannot be modeled as tools.
    • chipgap98 2y ago
      I think that's true in the same way Shirley from accounting isn't going to setup an OAuth token to allow her productivity app to access her calendar. With the right abstractions she can do that without needing to understand what she is doing technically
  • 2y ago
• wooders 2y ago
  Agents are already usually deployed as an API service. You can have "agent-to-agent" communication by having agents call each others APIs. I don't understand what this protocol is for. MCP actually fills a gap since people don't normally expose things like writing to their local filesystem as a callable API.
• ramesh31 2y ago
  Big if true.
• caust1c 2y ago
  This Agent2Agent Protocol (a "compliment" to Anthropic's Model Context Protocol?) seems to me to just be an attempt at a land grab in the line-protocol AI communication ecosystem. If I'm reading it correctly, A2A is similar to MCP in that they both use JSONRPC but extends the capabilities for agents to be able to communicate with one another, potentially using separate backend models. MCP simply exposes applications data and workflows to a model itself and is not attempting to make agents communicate with one another. The fact that A2A wasn't proposed as an extension to MCP seems disingenuous at best. To me, it looks like Google (among the other AI giants) is trying to create their own repository of agents, controlling the protocol, thereby enabling them to become the de-facto source for finding trusted agents. Further, it comes off to me as a defense against the existential threat that AI poses to google's search and ads monopoly. The problem is, as a consumer of AI, I don't want multiple agents communicating with one another. What I want is one model that communicates with non-agentic services. Making AI work well and understanding what it's doing is hard enough. You now want to pull in multiple models and companies into the picture? Talk about a risk management nightmare. Shadow IT SaaS is already a massive problem for companies. Now imagine Shadow Agents doing work for your business using A2A to connect dozens of different unsupervised work for the company. No thanks! For the inevitable defense of A2A "But it's open source and Apache licensed!". That's just bait. If you control the protocol, you control the ecosystem. See: Android, VSCode, Chromium, Java, Kubernetes, etc. For me? I like my single-model audibility pulling in context using MCP. A2A just seems like an insane attempt at a land grab in the AI agent wars.
  • caust1c 2y ago
    Something else I just thought about: Agent2Agent in an unsupervised environment could easily lead to the first Agentic worms. It's not hard to imagine a few agents talking to one another with the right prompt injection attacks that could end up spreading to other agents via A2A. This is of course just speculation but I could definitely see this as being a big enabler of that possibility.
• matchagaucho 2y ago
  If robots.txt is an exclusion file, I can't help but wonder if we just need an agents.json inclusion file in the root to get a "standard" started. A2A looks like a typical enterprise, authenticated, strict DTD style spec. Agents acting on behalf of consumers need a simple file that describes: 1) What services are provided 2) What tools are available and how to use them Agent behavior and actions should happen in latent space. The format of any spec is almost meaningless, as long as it's self describing and conveys those 2 points.
• mellosouls 2y ago
  How it claims to complement/differentiate from MCP here: https://google.github.io/A2A/#/topics/a2a_and_mcp https://google.github.io/A2A/#/topics/a2a_and_mcp Basically (google claims): MCP enables agents to use resources in a standard way. A2A enables those agents to collaborate with each other.
  • a_wild_dandan 2y ago
    I suppose Google wants us to pretend that "agents" can't be "resources." MCP is already well established (Anthropic, OpenAI, Cursor, etc), so Google plastering their announcement with A2A endorsements just reeks of insecurity. I figure this A2A idea will wind up in the infamous Google graveyard within 8 months.
    • medbrane 2y ago
      But MCP doesn't claim to address agent to agent communication, right?
      • varelaseb 2y ago
        It's not so much about what you _can do_ but about the messaging and posturing, which is what drives the adoption of standards as a social phenomenon. My team's been working on implementing MCP-agents and agents-as-tools and we consistently saw confusion from everyone we were selling this into (who were already bought in to hosting an MCP server for their API or SDK) for their agents because "that's not what it's for". Kinda weird, but kinda simple.
    • thebytefairy 2y ago
      Creating new standards is not easy, largely because everyone has to agree that they will use this particular one. Plastering it with endorsements attempts to show that there is consensus and give confidence in adoption. If they didn't put them in, you'd instead say nobody is using or going to use this.
      • 2y ago
• justanotheratom 2y ago
  I thought English language was the Agent2Agent Protocol.
• deleted 2y ago
  [deleted]
• darepublic 2y ago
  Langchain is a technology partner? People just love bloat and abstraction for its own sake huh. Screw google and screw this protocol
  • mikehostetler 2y ago
    This is the type of comment that keeps me coming back to HN Well done sir
  • lta 2y ago
    Would have made a similar comment if I hadn't found yours. Google starts to inspire the same bloaty feeling as MS. I feel sad
• pea 2y ago
  I wonder if the name was inspired by the Gemini logo https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcThr7qrIazsvZwJuw-uZCtLzIjaAyVW_ZrlEQ&s https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcThr7qr...
• mindwok 2y ago
  The MCP announcement had me excited on day one. Compared to that, this is a miss for me. The capabilities it provides seem to be no more than a system prompt, which was already a mostly solved problem. What “agents” need is not a protocol for operating, they need a protocol for discovery and addressability. How do I find someone’s agent? How do I talk to it and verify its identity? Once I’ve done that, it can just be a normal chat interface for all I care.
  • medbrane 2y ago
    An endpoint implementing this protocol would describe the agent and its capabilities, including examples. So I guess you could index that and create a discovery service.
    • mindwok 2y ago
      That sounds like it could be the play. Quick, let’s apply to YC with it.
• Depurator 2y ago
  I started to work on a rust version, always thought more mcp / a2a plumbing should be done in rust instead of python/js. https://github.com/EmilLindfors/a2a-rs https://github.com/EmilLindfors/a2a-rs
• keithwhor 2y ago
  At least this uses existing standards, which was my biggest gripe with MCP. That said - protocol whiplash. And it might get worse.
  • zambachi 2y ago
    How does MCP not use existing standards when the reference transport is SSE on HTTP with a JSON RPC payload?
• bibryam 2y ago
  A Distributed Non-Deterministic Collaboration Protocol.
• low_tech_punk 2y ago
  But, why do they launch Firebase Studio (https://firebase.blog/posts/2025/04/introducing-firebase-studio/ https://firebase.blog/posts/2025/04/introducing-firebase-stu...) on the same day? I wonder if this is a timed.
  • low_tech_punk 2y ago
    Of course, there is Ironwood announce too: https://blog.google/products/google-cloud/ironwood-tpu-age-of-inference/ https://blog.google/products/google-cloud/ironwood-tpu-age-o...
• rukuu001 2y ago
  What’s really interesting about this is the broad support Google has drummed up among platforms. So it’s actually looks like a strategic focus, rather than just announcement for interest, relevance or whatever
• daxfohl 2y ago
  So we have MCP for USB, A2A for network. Next we'll need a protocol for nonvolatile storage, one for volatile storage that can be paged into context, interrupts or something for debugging. Definition of kernel/userland or rings. What else before an AI model can serve as a fuzzy CPU?
• phillipcarter 2y ago
  A key difference between MCP and A2A that is apparent to me after building with MCP and now reading the material on A2A: MCP is solving specific problems people have in practice today. LLMs need access to data that they weren't trained on, but that's really hard because there's a millions different ways you could RAG something. So MCP defines a standard by which LLMs can call APIs through clients. (and more). A2A solves a marketing problem that Google is chasing with technology partners. I think I can safely say which one will still be around in 6 months, and it's not the one whose contributors all work for the same company.
  • owebmaster 2y ago
    > I think I can safely say which one will still be around in 6 months LangChain is still around but that doesn't mean much. MCP isn't much better.
    • phillipcarter 2y ago
      Langchain has long solved (we can argue on if it's done it well, opinions vary) the problem of needing to orchestrate LLM calls into a coherent workflow. Plus it had a first mover advantage. MCP solves a data and API integration problem. Both are concrete things that people need to do today. AI agents talking to one another is not a concrete problem that organizations building features that integrate AI have today.
      • __loam 2y ago
        Langchain is one of the most hilarious libraries I've ever had the displeasure of looking through. Many of the abstractions look like they were written by a college student who took clean code way too literally. Many of the methods are so trivial and shallow that I'm shocked people use it in any serious capacity.
        • tomaskafka 2y ago
          This. I was amazed opening something like PagagraphLineReaderFactory, thinking it somehow deals smartly with paragraph boundaries and too long paragraphs etc., and finding a trivial single line regex wrapped in two screens of OOP boilerplate.
• aubanel 2y ago
  It seems to me that MCP alone could already allow the main use case claimed by A2A, which is an agent assigning a task to another agent: if you put an agent behind a MCP server, an agent can query it as if it was another tool, and voila, you don't need A2A. But maybe I miss other use cases.
  • varelaseb 2y ago
    It's not so much about what you _can do_ but about the messaging and posturing, which is what drives the adoption of standards as a social phenomenon. My team's been working on implementing MCP-agents and agents-as-tools and we consistently saw confusion from everyone we were selling this into (who were already bought in to hosting an MCP server for their API or SDK) for their agents because "that's not what it's for". Kinda weird, but kinda simple.
• tuananh 2y ago
  what areas you see A2A can potentially be useful for you? I'm curious to see answers, from indie builder perspective.
• standonopenstds 2y ago
  Can't we implement this with Actors framework
• bibryam 2y ago
  There is also https://agntcy.org/ https://agntcy.org/
• pseudoshikhar 2y ago
  I only see it as: Google way of rebranding MCP by calling it a open protocol.
• jorkim32 2y ago
  [dead]
• soccernee 2y ago
  This looks a lot like AGNTCY: https://agntcy.org/ https://agntcy.org/ A quick scan of the "partners" for A2A includes many of the same groups that helped launch AGNTCY. Either they jumped ship or they're teaming up with everyone. The Google announcement does read like marketing hype, though, so it remains to be seen how functional it is. Let the inter-agent standard wars begin.
• enso-labs 2y ago
  Example A2A Protocol built on top of LangGraph and Dockerized for deployments. If you find helpful drop a https://github.com/enso-labs/a2a-langgraph https://github.com/enso-labs/a2a-langgraph
• wushihong 2y ago
  Enabling seamless communication and collaboration between AI agents in a new era of agent interoperability. (https://a2aprotocol.xyz/ https://a2aprotocol.xyz/)
• lich-001 2y ago
  Another protocol... Fuck me.
• realsid 2y ago
  Reading through the documentation, I get a sense that the "agent" server could be any application that exposes an agent card and follows the protocol. Doesn't really have to be using LLM or be "agentic" (guess that's where the agent black box) comes in.
• benjamin_scott 2y ago
  [dead]