Common Misunderstandings about the A2A Protocol

A2A Agents are not automatically autonomous

You might get the impression from the official documentation that exposing your agents via the A2A protocol makes them automatically able to work together on their own:

A2A allows agents to [...] act as autonomous entities while collaborating with other agents.

[A2A] enables complex, multi-turn interactions where agents reason, plan, and delegate tasks to other agents. For example, this facilitates multi-turn interactions, such as those involving negotiation or clarification when placing an order.

But to be clear: A2A is just a protocol that in theory enables autonomous agent-to-agent communication.

If you look at the official A2A python sdk, you won't find any code that actually makes your agent autonomous. The A2A protocol just gives you the tools to build these autonomous systems. It ensures all agents use the same "language", but it doesn’t deliver a ready-made autonomous system.

"Fully autonomous agents are a myth for now"

Listening to big tech marketing, you might think AI Agents are already capable of very complex tasks and multi-agent systems can solve almost anything.

Some agentic systems are impressive. For example, the Vibe Coding industry shows that AI Agents can create prototypes without software engineers.

But in practice, most agents being built and deployed in companies aren’t that advanced, at least from my experience. Other AI developers on social media have noticed the same:

Fully autonomous agents are a myth for now.

I think most of what we call agents are workflows that use llm for doing some work. Anything you can draw as a flow diagram usually falls into this.

Does A2A make sense if your agents aren't autonomous yet?

In my opinion, yes. I explain why in my blog article The Potential of the A2A Protocol in large Enterprises.

A2A isn't only relevant for agent to agent communication

Most of the time, agentic systems only work well if they have a good user interface. The Human in the loop concept is very important here. Agents are not perfect and make mistakes all the time. Humans play a key role in observing, guiding and being part of the agent's decision making process. For this, a good user interface is essential.

Reusability matters. Why should each agent have a different user interface? Many agents have very similar requirements for a UI.

I'm not the first one who sees the need for a standard here:

AG-UI is an open, lightweight, event-based protocol that standardizes how AI agents connect to user-facing applications.

Built for simplicity and flexibility, it standardizes how agent state, UI intents, and user interactions flow between your model/agent runtime and user-facing frontend applications—to allow application developers to ship reliable, debuggable, user‑friendly agentic features fast while focusing on application needs and avoiding complex ad-hoc wiring.

Why a separate protocol like AG-UI?

Why do we need a separate protocol for user-to-agent and agent-to-agent interaction? Sure, both have different requirements. But I think they can be solved with the same protocol.

In my opinion, user-to-agent interaction can be handled well using the A2A protocol. For more advanced requirements, it can be solved using an A2A Extension.

Reduce number of standards

Let's try to reduce the number of standards. Maybe an agent should be used by both other agents and users directly. Should the agent support both the AG-UI and A2A protocol? That sounds like a lot of development effort.

Let's keep things simple. In my opinion, A2A works well for user-to-agent interaction too.

Feedback?

Did I miss a common misunderstanding, make a mistake or do you see things differently? Maybe you’re building your own agentic system and want to chat? Just send me a message at [email protected].

Always happy to hear your thoughts or help out.