Što je A2A protokol i zašto bi vas trebao zanimati?
A2A (Agent2Agent) protokol otvoreni je standard za komunikaciju između AI agenata koji je Google objavio u travnju 2025., a već u lipnju iste godine donirao Linux Foundation pod okrilje Agentic AI Foundation (AAIF). Do travnja 2026., preko 150 organizacija — uključujući Google, Microsoft, AWS, Salesforce, SAP i IBM — aktivno podržava ovaj protokol. Službeni GitHub repozitorij ima više od 22.000 zvjezdica, što govori samo za sebe.
Ali zašto je to uopće bitno?
Pa, u svijetu gdje se AI agenti sve češće koriste u produkciji, neizbježno je da više agenata — često izrađenih različitim alatima i od različitih dobavljača — mora surađivati. A2A protokol rješava upravo taj problem: omogućuje horizontalnu komunikaciju između agenata, neovisno o jeziku, okviru ili platformi na kojoj su izgrađeni. Dakle, vaš Python agent može bez problema razgovarati s agentom napisanim u Javi ili Go-u.
Ako ste već upoznati s MCP-om (Model Context Protocol), koji povezuje agente s alatima i izvorima podataka (vertikalna integracija), A2A je njegov prirodni komplement — povezuje agente međusobno. Zajedno, ova dva protokola čine temelj interoperabilnog agentičkog ekosustava.
Temeljni koncepti A2A protokola
A2A protokol koristi HTTP(S) s JSON-RPC 2.0 formatom poruka, uz podršku za gRPC (od verzije 0.3) i streaming putem Server-Sent Events (SSE). Specifikacija je trenutno na verziji 0.3 (stabilna), dok je v1.0 u fazi RC kandidata. Ajmo razložiti ključne koncepte.
Agent Card — digitalna posjetnica agenta
Svaki A2A agent objavljuje svoju Agent Card — JSON dokument dostupan na /.well-known/agent-card.json. Zamislite to kao digitalni CV vašeg agenta koji opisuje što zna i kako mu pristupiti:
- Ime i opis — što agent radi
- URL servisa — gdje agent prima zahtjeve
- Vještine (skills) — popis specifičnih zadataka koje agent može obaviti
- Mogućnosti (capabilities) — podržava li streaming, push obavijesti itd.
- Autentifikacija — koji sigurnosni mehanizmi su potrebni
Ono što je ovdje stvarno elegantno jest automatsko otkrivanje — klijentski agent može dohvatiti Agent Card udaljenog agenta i na temelju vještina sam odlučiti s kojim agentom komunicirati. Nema ručnog konfiguriranja endpointova.
Message — jedinica komunikacije
Poruka (Message) predstavlja jednu komunikacijsku razmjenu između klijenta i agenta. Svaka poruka ima ulogu (role): "user" (klijent) ili "agent" (agent koji odgovara), te sadrži jedan ili više dijelova (Part):
- TextPart — obični tekst
- FilePart — datoteka (inline ili putem URI-ja)
- DataPart — strukturirani JSON podaci
Jednostavno i čisto — ništa komplicirano tu nema.
Task — jedinica rada
Zadatak (Task) je temeljni radni element u A2A protokolu. Svaki zadatak ima jedinstveni ID i prolazi kroz životni ciklus koji je zapravo prilično intuitivan:
submitted→ zadatak je poslanworking→ agent obrađuje zadatakcompleted→ uspješno završeninput_required→ agent čeka dodatni unos klijentafailed/canceled/rejected→ terminalna stanja
Artifact — izlazni proizvod
Artefakt (Artifact) je rezultat koji agent generira po završetku zadatka — dokument, slika, strukturirani podaci. Artefakti se mogu slati inkrementalno putem streaminga, što je posebno korisno za velike izlaze.
JSON-RPC metode
A2A definira pregršt metoda za interakciju:
message/send— slanje poruke agentumessage/stream— slanje s real-time streamingom odgovoratasks/get— dohvat statusa zadatkatasks/cancel— otkazivanje zadatkatasks/pushNotificationConfig/create— konfiguracija push obavijesti
A2A vs MCP: Dva komplementarna protokola
Iskreno, jedno od najčešćih pitanja koje se čuje u agentičkom ekosustavu 2026. glasi: „Trebam li A2A ili MCP?" Odgovor je — gotovo sigurno oboje. Ova dva protokola rješavaju različite probleme i dizajnirana su da rade zajedno.
| Dimenzija | A2A (Agent2Agent) | MCP (Model Context Protocol) |
|---|---|---|
| Svrha | Agent ↔ Agent (horizontalna) | Agent → Alat (vertikalna) |
| Tvorac | Google (travanj 2025.) | Anthropic (krajem 2024.) |
| Upravljanje | Linux Foundation / AAIF | Linux Foundation / AAIF |
| Transport | HTTP/JSON-RPC 2.0, gRPC, SSE | JSON-RPC 2.0 / stdio / SSE |
| Otkrivanje | Agent Card na /.well-known/ | Registracija MCP servera |
| Apstrakcija | Neprozirni agenti s vještinama | Alati, resursi, promptovi |
| Asinkrona podrška | Nativna (push, dugotrajni zadaci) | Pretežno sinkrona |
Praktični primjer koji ovo pojašnjava: Zamislite maloprodajni AI sustav. Agent za inventar koristi MCP za pristup bazi podataka proizvoda (vertikalna veza s alatom). Kada otkrije da je zaliha niska, koristi A2A za komunikaciju s eksternim agentom dobavljača kako bi pokrenuo narudžbu dopune. MCP za podatke, A2A za koordinaciju.
Ima tu i jedna stvar koja se često previdi — ključna razlika u skalabilnosti. MCP alatni opisi mogu zauzeti cijeli kontekstni prozor LLM-a kako broj alata raste. A2A zaobilazi taj problem korištenjem Agent Cardova visokog nivoa apstrakcije umjesto detaljnih specifikacija alata. U praksi, to znači da možete imati stotine agenata a da ne „zatrpate" kontekst.
Postavljanje A2A servera u Pythonu — korak po korak
Dosta teorije — idemo konačno kodirati. Izgradit ćemo potpuno funkcionalan A2A sustav: agent koji analizira tekst i klijent koji s njim komunicira. Koristit ćemo službeni a2a-sdk paket.
Preduvjeti i instalacija
Trebate Python 3.10+ i sljedeće pakete:
pip install "a2a-sdk[http-server]" uvicorn httpxSlužbeni SDK (a2a-sdk) održava Google pod Apache 2.0 licencom. Trenutno stabilna verzija je 0.3.x koja implementira A2A specifikaciju v0.3.
Kreiranje A2A agenta (server)
Kreirajte datoteku text_stats_agent.py. Krenimo od importova i pomoćne funkcije:
import uvicorn
from a2a.server.apps import A2AStarletteApplication
from a2a.server.agent_execution import AgentExecutor, RequestContext
from a2a.server.events import EventQueue
from a2a.server.request_handlers import DefaultRequestHandler
from a2a.server.tasks import InMemoryTaskStore, TaskUpdater
from a2a.types import AgentCapabilities, AgentCard, AgentSkill
from a2a.utils import new_agent_text_message
def analyze_text(text: str) -> str:
"""Analizira tekst i vraća statistiku."""
words = text.split()
word_count = len(words)
if word_count == 0:
return "Prazan unos — nema teksta za analizu."
cleaned = [w.strip(".,!?;:\"'\u2018\u2019\u201c\u201d") for w in words]
avg_word_len = sum(len(w) for w in cleaned) / word_count
reading_time_sec = (word_count / 238) * 60
freq: dict[str, int] = {}
for w in cleaned:
key = w.lower()
freq[key] = freq.get(key, 0) + 1
most_common = max(freq, key=lambda w: freq[w])
return (
f"Broj riječi: {word_count}\n"
f"Prosječna duljina riječi: {avg_word_len:.1f} znakova\n"
f"Procijenjeno vrijeme čitanja: {reading_time_sec:.0f} sekundi\n"
f"Najčešća riječ: '{most_common}' ({freq[most_common]}x)"
)
class TextStatsExecutor(AgentExecutor):
"""Izvršitelj koji analizira tekst i vraća statistiku."""
async def execute(
self, context: RequestContext, event_queue: EventQueue
) -> None:
updater = TaskUpdater(
event_queue=event_queue,
task_id=context.task_id,
context_id=context.context_id,
)
# Označi da agent radi na zadatku
await updater.start_work()
# Dohvati korisnički unos i analiziraj
user_input = context.get_user_input()
result = analyze_text(user_input)
# Pošalji rezultat i označi zadatak kao završen
await event_queue.enqueue_event(new_agent_text_message(result))
await updater.complete()
async def cancel(
self, context: RequestContext, event_queue: EventQueue
) -> None:
raise NotImplementedError("Otkazivanje nije podržano")
# Definicija vještine agenta
skill = AgentSkill(
id="text_stats",
name="Statistika teksta",
description="Analizira tekst i vraća broj riječi, prosječnu duljinu i vrijeme čitanja.",
tags=["text", "analysis", "nlp"],
examples=[
"Analiziraj ovaj tekst.",
"Koliko riječi ima u ovom odlomku?",
],
)
# Agent Card — opis agenta za otkrivanje
agent_card = AgentCard(
name="Text Stats Agent",
description="Agent specijalist za izračun statistike tekstualnog sadržaja.",
url="http://localhost:9999/",
version="1.0.0",
default_input_modes=["text"],
default_output_modes=["text"],
capabilities=AgentCapabilities(streaming=False),
skills=[skill],
)
# Kreiranje A2A aplikacije
app = A2AStarletteApplication(
agent_card=agent_card,
http_handler=DefaultRequestHandler(
agent_executor=TextStatsExecutor(),
task_store=InMemoryTaskStore(),
),
)
if __name__ == "__main__":
uvicorn.run(app.build(), host="0.0.0.0", port=9999)
Pokrenite server:
python text_stats_agent.pyAgent je sada dostupan na http://localhost:9999, a njegova Agent Card na http://localhost:9999/.well-known/agent-card.json. Možete to brzo provjeriti curl-om ako želite vidjeti kako Agent Card izgleda u praksi.
Kreiranje A2A klijenta
Sad dolazi zabavni dio — klijent koji automatski otkriva agenta i komunicira s njim. Kreirajte datoteku client.py:
import asyncio
import httpx
from a2a.client import A2ACardResolver, ClientFactory, ClientConfig
from a2a.client import create_text_message_object
SAMPLE_TEXT = """
A2A protokol omogućuje AI agentima međusobnu komunikaciju
neovisno o okviru ili platformi na kojoj su izgrađeni.
Ovo je revolucionaran korak prema interoperabilnom
agentičkom ekosustavu.
"""
async def main():
base_url = "http://localhost:9999"
async with httpx.AsyncClient() as http:
# 1. Otkrivanje agenta putem Agent Card
resolver = A2ACardResolver(httpx_client=http, base_url=base_url)
card = await resolver.get_agent_card()
print(f"Otkriven agent: {card.name}")
print(f"Vještine: {[s.name for s in card.skills]}\n")
# 2. Kreiranje klijenta i slanje poruke
factory = ClientFactory(config=ClientConfig(httpx_client=http))
client = factory.create(card)
message = create_text_message_object(
content=SAMPLE_TEXT.strip()
)
# 3. Obrada odgovora
async for event in client.send_message(message):
if isinstance(event, tuple):
task, _ = event
if task.history:
for msg in task.history:
if msg.role.value == "agent":
for part in msg.parts:
if hasattr(part.root, "text"):
print("Rezultat od agenta:")
print(part.root.text)
asyncio.run(main())
U drugom terminalu pokrenite klijenta:
python client.pyKlijent će automatski otkriti agenta putem Agent Card, poslati tekst na analizu i ispisati rezultat. Cijeli proces — otkrivanje, slanje, primanje — odvija se u svega par sekundi.
Integracija s okvirima: Google ADK i FastA2A
Ručno korištenje SDK-a korisno je za razumijevanje protokola, ali realno — u praksi ćete vjerojatno posegnuti za jednim od okvira s ugrađenom A2A podrškom. I tu stvari postaju stvarno jednostavne.
Google ADK (Agent Development Kit)
Google ADK nudi najjednostavniji put do A2A servera. Doslovno jedna funkcija pretvara bilo kojeg ADK agenta u A2A kompatibilan servis:
pip install "google-adk[a2a]"from google.adk.a2a.utils.agent_to_a2a import to_a2a
from google.adk import Agent
# Definirajte ADK agenta
root_agent = Agent(
model="gemini-flash-latest",
name="helper_agent",
instruction="Ti si koristan asistent koji odgovara na pitanja.",
)
# Jedna linija ga pretvara u A2A server
a2a_app = to_a2a(root_agent, port=8001)
Funkcija to_a2a() automatski konfigurira AgentExecutor, InMemoryTaskStore, DefaultRequestHandler i generira Agent Card putem AgentCardBuilder. ADK v1.0.0 je stabilan i spreman za produkciju — tako da ne morate brinuti o „beta" problemima.
Pydantic FastA2A
Pydantic tim nudi fasta2a — ASGI baziranu A2A implementaciju koja se besprijekorno integrira s Pydantic AI. Ako ste fan Pydantica (a tko nije?), ovo će vam se svidjeti:
pip install fasta2afrom pydantic_ai import Agent
agent = Agent("openai:gpt-4", instructions="Budi koncizan i precizan.")
# Jedna linija — A2A server spreman
app = agent.to_a2a()
Pokrenite s uvicorn module:app --host 0.0.0.0 --port 8000. FastA2A koristi tri zamjenjive komponente: Storage (pohrana zadataka), Broker (raspoređivanje) i Worker (izvršavanje), što omogućuje razdvajanje web servera i radnog procesa na različite strojeve. Za ozbiljnije deploymente, to je jako praktično.
Podrška u drugim okvirima
Ekosustav raste brzo:
- CrewAI — nativna podrška od verzije 1.10.1 (45.900+ zvjezdica na GitHubu)
- LangChain — integracija putem
langchain-adki A2A endpoint podrške - OpenAgents — nativna podrška za MCP + A2A
Produkcijske razmatranja
Sve ovo lijepo funkcionira lokalno, ali prije nego stavite A2A agente u produkciju, postoji par stvari koje morate riješiti. Evo najvažnijih.
Autentifikacija i sigurnost
A2A podržava deklaraciju sigurnosnih zahtjeva izravno u Agent Card koristeći OpenAPI kompatibilne sigurnosne sheme:
- OAuth 2.0 — preporučeni pristup za produkciju (koristite client credentials flow s kratkoživućim tokenima)
- OpenID Connect — za scenarije koji zahtijevaju CIBA tok za autonomne agente
- API ključevi — za jednostavnije scenarije
- Mutual TLS (mTLS) — za visokosigurnosna okruženja
U produkciji obavezno koristite HTTPS s TLS 1.3+. A2A v1.0 RC uvodi i potpisane Agent Cardove putem JWS-a za kriptografsku verifikaciju identiteta — što je posebno važno ako agenti komuniciraju preko javnog interneta.
Streaming i dugotrajni zadaci
Nisu svi zadaci gotovi za par sekundi. Za one koji traju minutama, satima (ili čak danima), A2A nudi solidne mehanizme:
- SSE streaming — real-time ažuriranja putem
TaskStatusUpdateEventiTaskArtifactUpdateEvent - Ponovno povezivanje — klijent se može odspojiti i ponovno spojiti, provjeravajući status putem
tasks/get - Push obavijesti — server šalje HTTP POST na webhook URL klijenta kada se status promijeni
Jedna napomena o push obavijestima — implementirajte SSRF zaštitu: validirajte webhook URL-ove, koristite challenge-response verifikaciju i jedinstvene event ID-jeve (JWT jti) za sprječavanje duplikata. Ovo se lako previdi, ali je ključno za sigurnost.
Skaliranje i perzistencija
Za produkcijske scenarije, InMemoryTaskStore zamijenite trajnom pohranom. SDK nudi gotove implementacije:
# PostgreSQL backend za perzistenciju zadataka
pip install "a2a-sdk[postgresql]"Dodatne produkcijske mogućnosti u v1.0 RC uključuju:
- Multi-tenancy podrška — izolacija podataka između korisnika
- OpenTelemetry integracija — putem
a2a-sdk[telemetry] - Technology Compatibility Kit (TCK) — za testiranje usklađenosti implementacije
Arhitekturni obrazac: A2A + MCP u praksi
Najmoćniji scenarij koristi oba protokola zajedno. Evo jedne arhitekture za sustav korisničke podrške koja odlično ilustrira sinergiju:
┌─────────────────────────────────────────────────┐
│ Orchestrator Agent │
│ (prima korisničke upite) │
└──────┬──────────────┬──────────────┬─────────────┘
│ A2A │ A2A │ A2A
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ Agent za │ │ Agent za │ │ Agent za │
│ naplatu │ │ tech. │ │ povrate │
│ │ │ podršku │ │ │
└────┬─────┘ └────┬─────┘ └────┬─────┘
│ MCP │ MCP │ MCP
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ Stripe │ │ Knowledge│ │ ERP │
│ API │ │ Base │ │ sustav │
└──────────┘ └──────────┘ └──────────┘U ovoj arhitekturi:
- Orchestrator koristi A2A za delegiranje zadataka specijaliziranim agentima ovisno o vrsti upita
- Svaki specijalizirani agent koristi MCP za pristup svojim specifičnim alatima i izvorima podataka
- Agenti mogu biti izgrađeni različitim okvirima (ADK, LangChain, CrewAI) i komunicirati bez problema zahvaljujući A2A standardu
Ljepota ovog pristupa je u tome što možete zamijeniti bilo kojeg agenta novom implementacijom bez da išta drugo mijenjate — dokle god poštuje A2A specifikaciju, ostali agenti neće ni primijetiti razliku.
Ekosustav i budućnost A2A protokola
A2A protokol doživio je eksplozivan rast u prvoj godini postojanja. Gartner izvještava o porastu od 1.445% u upitima o višeagentnim sustavima od Q1 2024. do Q2 2025., a prema njihovim predviđanjima, 40% poslovnih aplikacija uključivat će AI agente specifične za zadatke do kraja 2026.
Službeni SDK-ovi dostupni su za pet jezika: Python, JavaScript, Java, Go i .NET. Protokol je pod upravljanjem Linux Foundation s 146 članova u AAIF-u (stanje: ožujak 2026.), a stabilna verzija 1.0 očekuje se u svibnju–lipnju 2026.
Uz A2A raste i ekosustav pratećih protokola poput AP2 (Agent Payments Protocol) za sigurno procesiranje plaćanja između agenata. To je zanimljiv signal — ne gradi se samo komunikacijska infrastruktura, već potpuna infrastruktura za autonomnu međuagentsku ekonomiju. Uzbudljiva vremena, bez sumnje.
Često postavljana pitanja (FAQ)
Koja je razlika između A2A i MCP protokola?
A2A (Agent2Agent) omogućuje horizontalnu komunikaciju između AI agenata — agent s agentom. MCP (Model Context Protocol) omogućuje vertikalnu integraciju — agent s alatima, bazama podataka i API-jima. Ukratko: koristite MCP za pristup resursima, a A2A za koordinaciju između agenata. Oba protokola su sada pod upravljanjem Linux Foundation.
Kako izgraditi A2A agenta u Pythonu?
Instalirajte a2a-sdk[http-server], implementirajte AgentExecutor klasu s metodom execute(), definirajte AgentCard s vještinama i mogućnostima, te kreirajte A2AStarletteApplication. Pokrenite server s Uvicornom. Za brži pristup, koristite Google ADK ili Pydantic FastA2A koji nude jednolinjsku integraciju.
Što je Agent Card i kako funkcionira?
Agent Card je JSON dokument koji agent objavljuje na /.well-known/agent-card.json. Sadrži ime, opis, URL, vještine, mogućnosti i sigurnosne zahtjeve agenta. Drugi agenti koriste Agent Card za automatsko otkrivanje i odlučivanje s kojim agentom komunicirati — slično tome kako web servisi koriste OpenAPI specifikacije.
Podržava li A2A protokol streaming i dugotrajne zadatke?
Da, A2A ima nativnu podršku za oboje. Streaming koristi Server-Sent Events (SSE) za real-time ažuriranja statusa i artefakata. Za dugotrajne zadatke, klijent se može odspojiti i ponovno povezati, provjeriti status putem tasks/get, ili konfigurirati push obavijesti putem webhookova.
Koji okviri podržavaju A2A protokol u 2026.?
Google ADK ima nativnu A2A podršku (google-adk[a2a]), Pydantic AI nudi FastA2A integraciju, CrewAI podržava A2A od verzije 1.10.1, a LangChain pruža integraciju putem langchain-adk. Službeni Python SDK (a2a-sdk) omogućuje izgradnju A2A agenata bez ovisnosti o specifičnom okviru.