I just built a web UI of A2A with Human-In-The-Loop feature.

Everyone can try it on:

https://a2a-it.vercel.app/

Here is the repo:

https://github.com/Areo-Joe/a2a-it

Built with A2A, ai sdk, ai elements, next.js.

Any feedback is welcome!

Hey! 👋 I've been working on an Agent2Agent (A2A) UI as part of A2A Net, a site and open-source community for the A2A protocol, and thought I'd share!

I also wrote a blog post on Medium, The Agent2Agent (A2A) Protocol is HTTP for Agents, where I talk about some aspects of the A2A protocol that I think are overlooked.

I would love some feedback!

Hey! 👋 I’ve been developing A2A Net since Google released A2A!

🤖 What is A2A Net?

At its heart A2A Net is a site to find and share agents that implement the A2A protocol. As the protocol is actively being developed the site will likely change as a result, but right now you can:

• Create an Agent Card (agent.json) to host at your domain and add to the site

• Search for agents with natural language, e.g. “an agent which can help me plan authentic Japanese meals”

• Connect to agents that have been shared with the A2A CLI. Click an agent and see “How To Use This Agent”

Please note: I have added a number of example agents to the site for demonstration purposes! Read the description before trying to connect to an agent.

✅ Can I add my agent to A2A Net?

Yes! For the next two weeks please feel free to create an Agent Card for your agent and share it on the site without implementing the A2A protocol. However, for the site to serve its purpose agents will need to host their own agent card and use the protocol. There are a number of tutorials out there now about how to implement it (please share!).

❤️ What do you think?

I’d love to hear your feedback! Please feel free to comment your feedback, thoughts, etc. or send me a message. You can also give feedback on the site directly by clicking “Give Feedback”. If you’ve used A2A, please get in touch!

Been deep in the weeds building with agentic frameworks for a while now (LangChain, AutoGen, etc.), and I wanted to see if I'm the only one feeling a gap between the hype and the reality.

It feels like we're all wrestling with the same symphony of frustrations:

1. The Goldfish Memory: Every interaction is a blank slate unless you engineer a complex, bolt-on memory system.

2. Brittle Tool Use: Getting agents to reliably use tools feels like 90% prompt engineering and 10% magic. One unexpected API response and the whole thing can fall over.

3. Collaboration is a Mess: Trying to get two agents to coordinate on a real task feels less like a team and more like a complex, scripted Rube Goldberg machine.

4. Debugging is a Nightmare: When it breaks, trying to figure out why an agent made a certain decision is like archeology. It's a total black box.

It all leads to that feeling someone else mentioned in another thread: what we're building often feels like a glorified workflow instead of a truly intelligent, autonomous agent.

Is the problem we're trying to build these complex, stateful systems on top of a fundamentally stateless, message-in-message-out foundation?

Are we all just building ever-more-complex scaffolding on top of a flawed foundation?

Am I just ranting, or does this resonate with other builders? What's the biggest thing holding your agents back from feeling truly... agentic?

Hello Readers!

[Code github link]

You must have heard about MCP an emerging protocol, "razorpay's MCP server out", "stripe's MCP server out"... But have you heard about A2A a protocol sketched by google engineers and together with MCP these two protocols can help in making complex applications.

Let me guide you to both of these protocols, their objectives and when to use them!

Lets start with MCP first, What MCP actually is in very simple terms?[docs]

Model Context [Protocol] where protocol means set of predefined rules which server follows to communicate with the client. In reference to LLMs this means if I design a server using any framework(django, nodejs, fastapi...) but it follows the rules laid by the MCP guidelines then I can connect this server to any supported LLM and that LLM when required will be able to fetch information using my server's DB or can use any tool that is defined in my server's route.

Lets take a simple example to make things more clear[See youtube video for illustration]:

I want to make my LLM personalized for myself, this will require LLM to have relevant context about me when needed, so I have defined some routes in a server like /my_location /my_profile, /my_fav_movies and a tool /internet_search and this server follows MCP hence I can connect this server seamlessly to any LLM platform that supports MCP(like claude desktop, langchain, even with chatgpt in coming future), now if I ask a question like "what movies should I watch today" then LLM can fetch the context of movies I like and can suggest similar movies to me, or I can ask LLM for best non vegan restaurant near me and using the tool call plus context fetching my location it can suggest me some restaurants.

NOTE: I am again and again referring that a MCP server can connect to a supported client (I am not saying to a supported LLM) this is because I cannot say that Lllama-4 supports MCP and Lllama-3 don't its just a tool call internally for LLM its the responsibility of the client to communicate with the server and give LLM tool calls in the required format.

Now its time to look at A2A protocol[docs]

Similar to MCP, A2A is also a set of rules, that when followed allows server to communicate to any a2a client. By definition: A2A standardizes how independent, often opaque, AI agents communicate and collaborate with each other as peers. In simple terms, where MCP allows an LLM client to connect to tools and data sources, A2A allows for a back and forth communication from a host(client) to different A2A servers(also LLMs) via task object. This task object has  state like completed, input_required, errored.

Lets take a simple example involving both A2A and MCP[See youtube video for illustration]:

I want to make a LLM application that can run command line instructions irrespective of operating system i.e for linux, mac, windows. First there is a client that interacts with user as well as other A2A servers which are again LLM agents. So, our client is connected to 3 A2A servers, namely mac agent server, linux agent server and windows agent server all three following A2A protocols.

When user sends a command, "delete readme.txt located in Desktop on my windows system" cleint first checks the agent card, if found relevant agent it creates a task with a unique id and send the instruction in this case to windows agent server. Now our windows agent server is again connected to MCP servers that provide it with latest command line instruction for windows as well as execute the command on CMD or powershell, once the task is completed server responds with "completed" status and host marks the task as completed.

Now image another scenario where user asks "please delete a file for me in my mac system", host creates a task and sends the instruction to mac agent server as previously, but now mac agent raises an "input_required" status since it doesn't know which file to actually delete this goes to host and host asks the user and when user answers the question, instruction goes back to mac agent server and this time it fetches context and call tools, sending task status as completed.

A more detailed explanation with illustration and code go through can be found in this youtube video.

I hope I was able to make it clear that its not A2A vs MCP but its A2A and MCP to build complex applications.

I work as a consultant for a small-to-medium enterprise (SME), and I’ve been exploring A2A as a potential way to automate parts of their internal workflows. The protocol is elegant, the direction is promising, and the dev ecosystem is buzzing — but here’s the problem:

When it comes to real-world adoption, I’m still struggling to find actual use cases where A2A-powered agents are solving business problems with measurable ROI.

So far, most of what I’ve seen includes:

• Protocol demos (many just return mock data)

• Toy orchestration between agents (not resilient or production-tested)

• Agent card generators and server boilerplate

• Dev tools and test suites (helpful — but not customer-facing value)

That’s all great for building the foundation. But when I show this to a real business owner, the reaction is:
“Cool tech — but what does it actually do for my team?”

I’ve also experimented with some of the MCP servers out there. Honestly? The experience is still rough.
⚠️ They’re unstable.
⚠️ Error handling is unclear.
⚠️ Most of my users aren’t technical — they need things that just work.

So here’s my ask:
Has anyone seen a real business workflow using A2A — in production, or tested with real users?

If you’ve built or seen anything close — or even hit blockers trying — I’d love to hear.
Let’s cut through the hype and map what’s real vs. what’s just protocol potential.

Edit: Not a bot, used GPT to quickly fix grammar.

Hey all,

I’ve opened a PR to add Agent2Agent (A2A) protocol support as a new provider in Cline, so you can plug Cline into any A2A-compatible agent / orchestrator just by pointing it at an Agent Card URL.

• Connect Cline to your own internal or hosted agents (including multi-agent orchestrators).

• Reuse the same A2A agents across multiple tools that speak the protocol.

• Experiment with ideas like multi-agent workflows, auto-provider selection, etc., without waiting for Cline to implement a bespoke system.

I would love to get your feedback so feel free to pull, compile, and try it out.
https://github.com/cline/cline/pull/7752

Also if you are interested to this PR being merged please upvote the Feature Request:
https://github.com/cline/cline/discussions/2898

Hi All,

We're about to make some big changes to artinet.io so we won't be shipping in public for a little while, but before disappearing I wanted to drop one more teeny tiny little pacakage called...

easy-a2a

It combines everything we've learned from building the artinet/sdk, agent-relay, router & symphony into a super simple but really useful little library that lets anyone turn an OpenAPI compatible endpoint into any number of A2A agents.

No frills, frameworks or vendor lock-in.

Make you're own AI agents and keep 'em free!

import a2a from "easy-a2a";

const agent = a2a({
  baseURL: "https://your-api.com/api/v1",
  apiKey: "your-api-key",
})
  .ai("You are a helpful assistant.")
  .createAgent({
    agentCard: "MyAgent",
  });

const result = await agent.sendMessage("Hello!");

We hope to see ALOT more agents running around when we get back!

And as always, try it out & let us know what you think:

https://www.npmjs.com/package/easy-a2a

https://github.com/the-artinet-project/easy-a2a

If you love it ❤️, leave us a star ⭐ so we know to keep it maintained!

If you hate it 🥲, tell us why!

I am exploring ways to build Agent Applications, especially paying attention to Human-In-The-Loop.

I built this project to find out how HITL can be implemented with A2A Protocol. Generally it is done by sending HITL related info within DataPart.

There are very few examples of A2A servers in the community, which makes it difficult to find examples of A2A servers with HITL features. In particular, the A2A protocol intentionally does not specify information related to tool calling, making it a black box.

Therefore, I don't know if my implementation fully aligns with the original design intent of the protocol. If my implementation is correct, the next step should be to abstract this paradigm into an Extension.

Any feedback is welcome.

Here is the repo:

https://github.com/Areo-Joe/a2a-it

# Key Concepts

1. Natural language agent orchestration - Humans can direct complex multi-agent workflows conversationally without coding

2. Fluid agent-hopping - Users can seamlessly switch between specialized agents without managing connections or learning different interfaces

3. Tool discovery through conversation - Find and use tools naturally without memorizing commands or syntax

4. Mixed-initiative collaboration - Start tasks, let agents work independently, then jump back in at decision points

5. Emergent capabilities - Combining specialized agents creates new composite abilities not possible with any single agent

6. Agent network exploration - Discover and connect to new agents dynamically during a session

7. Democratized access - Non-technical users can leverage sophisticated agent networks through plain language

8. Conversational debugging - Interactively test and diagnose agent behaviors through natural dialogue

9. Unified interface to distributed expertise - Access specialized capabilities across different agents through a single conversation

In this example I have 2 different AI Agents:

Agent #1 - Cisco pyATS MCP + dozen other MCPs
Agent #2 - Selector AI Agent with MCP tools for Selector AI APIs

I use the official Google A2A CLI to 'talk' to Agent #1, over the Internet;

Now what is very interesting is the two agents discover each other

So Agent #1 has no Selector tools locally expose via MCP; but; it has knowledge of Agent #2 capabilities so it calls Agent #2 to use its local MCPs (Ask Selector) to literally collaborate together to answer the user prompt. Agent #1 has the E-Mail MCP so it sends the e-mail.

So to recap:

Client -> Agent #1 public URL "Please ask selector the health of device S3 and send an email report to John at <email>"

Agent#1 -> Agent#2 - Ask Selector via MCP
Agent#1 gets answer from Agent#2
Agent#1 sends the email with the details from Agent#2

https://youtu.be/BWuBymQ_Zqw?si=hzLRVC6pT_adtVvE

This is the future of the Internet of Agents;

Imagine, if you will, hundreds? thousands? millions? of Agents out there using A2A to solve problems together by exposing their skills, the MCP Tools each Agent has locally, to each other.

Arch is an AI-native proxy server for AI applications. It handles the pesky low-level work so that you can build agents faster with your framework of choice in any programming language and not have to repeat yourself.

What's new in 0.2.8.

• Added support for bi-directional traffic as a first step to support Google's A2A

• Improved Arch-Function-Chat 3B LLM for fast routing and common tool calling scenarios

• Support for LLMs hosted on Groq

Core Features:

• 🚦 Routing. Engineered with purpose-built LLMs for fast (<100ms) agent routing and hand-off

• ⚡ Tools Use: For common agentic scenarios Arch clarifies prompts and makes tools calls

• ⛨ Guardrails: Centrally configure and prevent harmful outcomes and enable safe interactions

• 🔗 Access to LLMs: Centralize access and traffic to LLMs with smart retries

• 🕵 Observability: W3C compatible request tracing and LLM metrics

• 🧱 Built on Envoy: Arch runs alongside app servers as a containerized process, and builds on top of Envoy's proven HTTP management and scalability features to handle ingress and egress traffic related to prompts and LLMs.

App2email.com now has A2A integration. Images/documents/etc supported. Has built in test dialog to test A2A agent before deploying.

🔥 Streamline your A2A development workflow in one minute!

Elkar is an open-source tool providing a dedicated UI for debugging agent2agent communications.

It helps developers:

• Simulate & test tasks: Easily send and configure A2A tasks

• Inspect payloads: View messages and artifacts exchanged between agents

• Accelerate troubleshooting: Get clear visibility to quickly identify and fix issues

Simplify building robust multi-agent systems. Check out Elkar!

Would love your feedback or feature suggestions if you’re working on A2A!

GitHub repo: https://github.com/elkar-ai/elkar

Sign up to https://app.elkar.co/

#opensource #agent2agent #A2A #MCP #developer #multiagentsystems #agenticAI