A2A (Agent-to-Agent) Protocol vs MCP: Bagaimana Cara Kerja Standar Komunikasi Antar AI Agent di 2026?

A2A vs MCP, apa bedanya? Penjelasan cara kerja Agent Card, task, tools, dan transportnya, plus kapan memakai keduanya dalam satu arsitektur agent.

A2a vs mcp featured - A2A (Agent-to-Agent) Protocol vs MCP: Bagaimana Cara Kerja Standar Komunikasi Antar AI Agent di 2026?
A2A (Agent-to-Agent) Protocol vs MCP: Bagaimana Cara Kerja Standar Komunikasi Antar AI Agent di 2026?

Di Artikel Ini

TL;DR: MCP dan A2A bukan saingan โ€” mereka menyelesaikan dua masalah berbeda di dua lapisan berbeda. MCP menyambungkan satu agent ke tools dan data (vertikal), sementara A2A menyambungkan satu agent ke agent lain sebagai rekan sejawat (horizontal). Per November 2026, keduanya hidup di bawah yayasan yang sama, Agentic AI Foundation, dan arsitektur multi-agent yang serius biasanya memakai keduanya sekaligus: delegasi antar-agent lewat A2A, eksekusi tools lewat MCP.

๐Ÿ’ก Key Takeaway

  • MCP itu vertikal, A2A itu horizontal. MCP memperdalam satu agent dengan tools, resources, dan prompts; A2A menghubungkan agent lintas tim, vendor, dan framework.
  • A2A bekerja lewat Agent Card dan task. Setiap agent mempublikasikan kartu JSON berisi skill dan endpoint-nya, lalu pekerjaan yang didelegasikan dilacak sebagai task dengan lifecycle yang jelas.
  • Versi yang berlaku sekarang: A2A 1.0 dan MCP 2026-07-28. A2A 1.0 (Maret 2026) membawa Agent Card bertanda tangan dan tiga binding; MCP 2026-07-28 (Juli 2026) menghapus handshake dan session. Tutorial lama yang masih menulis pola 2025 sudah kedaluwarsa.
  • Kepercayaan tidak datang gratis dari protokolnya. A2A tidak punya registry pusat maupun framework otorisasi bawaan โ€” siapa boleh memanggil agent siapa tetap harus kamu atur sendiri.

Agent kamu sudah pintar sendiri. Masalahnya mulai waktu dia harus kerja bareng agent lain

Bayangin kamu punya agent customer service yang sudah jalan bagus. Dia bisa jawab pertanyaan produk, cek status pesanan, dan bikin tiket komplain. Suatu hari, tim lain membangun agent gudang โ€” beda framework, beda vendor model, beda tim yang merawatnya. Agent CS kamu perlu tanya ke agent gudang: stok varian ini tinggal berapa, dan kapan restock-nya?

Di sinilah kebanyakan tim mentok. Agent CS kamu tidak bisa sekadar “memanggil function” agent gudang, karena agent gudang bukan function โ€” dia punya state sendiri, tools sendiri, dan cara berpikir sendiri. Kamu butuh bahasa bersama supaya dua agent yang tidak saling kenal ini bisa menemukan satu sama lain, sepakat soal format pesan, dan melacak pekerjaan yang sedang berjalan.

Nah, di titik inilah dua nama selalu muncul berbarengan: MCP dan A2A. Dan di titik ini juga kebanyakan orang salah paham, mengira keduanya bersaing dan kamu harus memilih salah satu. Padahal tidak. Artikel ini membahas cara kerja masing-masing, bedanya di mana, dan bagaimana keduanya dipakai bersama dalam satu arsitektur.

MCP dulu: colokan standar antara agent dan tools

Model Context Protocol, atau MCP, adalah protokol terbuka yang menstandarkan cara aplikasi LLM terhubung ke tools dan sumber data luar lewat satu antarmuka yang sama. Anthropic memperkenalkannya pada 25 November 2024, dan sejak 9 Desember 2025 protokol ini dikelola Agentic AI Foundation di bawah Linux Foundation โ€” bukan lagi proyek satu vendor.

Arsitekturnya punya tiga peran. Host adalah aplikasi AI-nya, misalnya IDE atau aplikasi desktop. Client adalah konektor di dalam host yang menjaga satu koneksi ke satu server. Server adalah program yang menyediakan konteks dan kemampuan. Satu host bisa menjalankan banyak client, masing-masing terhubung ke server yang berbeda, dan semua pesannya memakai JSON-RPC 2.0.

Server MCP mengekspos tiga primitif:

Primitif Artinya Contoh
Tools Fungsi yang bisa dieksekusi model, dengan argumen bertipe Cari di database, kirim pesan, hitung total
Resources Data dan konteks yang bisa dibaca Isi file, baris database, dokumen kebijakan
Prompts Template pesan dan alur kerja buat user Template rekap laporan, template review kode

Transportnya ada dua. stdio buat server lokal yang jalan sebagai subprocess di mesin yang sama โ€” pola klasik di desktop dan CLI. Streamable HTTP buat server remote: setiap pesan JSON-RPC dikirim sebagai satu POST HTTP ke satu endpoint, dan jawabannya kembali sebagai JSON atau aliran SSE yang terikat ke request itu. Transport HTTP+SSE yang lama sudah deprecated sejak Maret 2025, jadi kalau kamu masih menemukan URL berakhiran /sse, itu pola lama.

Yang paling penting buat kamu yang belajar dari tutorial lama: revisi spesifikasi 2026-07-28, yang rilis 28 Juli 2026, mengubah inti protokol menjadi stateless. Handshake initialize dan header session Mcp-Session-Id dihapus; setiap request sekarang membawa sendiri versi protokol dan kapabilitas client di field _meta, sehingga server MCP remote bisa jalan di belakang load balancer biasa seperti web service pada umumnya. Server juga wajib mengimplementasikan server/discover buat mengumumkan versi dan kemampuannya, dan pekerjaan panjang dipindahkan ke ekstensi Tasks yang opsional. Kalau tutorial yang kamu ikuti masih menulis handshake dan session id, tutorial itu mendeskripsikan MCP 2025, bukan yang sekarang.

Satu hal yang sering ketukar: MCP menyambungkan agent ke alat dan data, bukan mengajari agent cara mengerjakan sesuatu. Alur kerja yang berulang โ€” langkah-langkah baku yang harus diikuti agent โ€” biasanya dibungkus sebagai skill, paket instruksi yang bisa dipakai ulang dan distandarkan lewat format Agent Skills yang dibaca banyak agent berbeda. Keduanya sering dipakai bersama: skill memberi tahu kapan dan bagaimana memakai alat yang disediakan MCP.

A2A: kartu nama, pesan, dan task antar-agent

Agent2Agent, atau A2A, adalah protokol terbuka buat komunikasi antar-agent yang independen โ€” agent yang dibangun dengan framework, bahasa, atau vendor berbeda. Google mengumumkannya pada 9 April 2025 bersama lebih dari 50 partner teknologi, lalu menyumbangkannya ke Linux Foundation pada Juni 2025. Spesifikasi stabil pertamanya, versi 1.0.0, rilis pada 12 Maret 2026, dan pada Agustus 2026 proyek ini bergabung ke Agentic AI Foundation, yayasan yang sama dengan MCP.

Prinsip desainnya satu dan penting: agent di ujung sana itu opaque. Kamu tidak bisa mengintip model, prompt, memori, atau tools-nya. Yang kamu dapatkan cuma kartu yang menjelaskan kemampuannya, ID task buat melacak pekerjaan, dan state yang dilewatinya. Itu disengaja โ€” justru karena itulah agent dari vendor berbeda bisa bekerja sama tanpa membongkar dapur masing-masing.

Spesifikasinya mendefinisikan lima objek inti:

Objek Artinya Contoh
Agent Card Dokumen JSON berisi identitas, skill, endpoint, dan syarat keamanan agent Kartu agent gudang di domainnya sendiri
Message Satu giliran komunikasi, dengan role user atau agent, berisi satu atau lebih Part “Cek stok varian biru ukuran M”
Part Unit konten terkecil di dalam Message atau Artifact Teks, file, URL, atau data JSON terstruktur
Task Unit pekerjaan yang dilacak, dengan ID, status, histori, dan artifact Permintaan pengecekan stok yang sedang diproses
Artifact Output yang dihasilkan task, tersusun dari Part Laporan stok dalam bentuk JSON

Discovery berjalan lewat Agent Card: dokumen JSON yang wajib dipublikasikan agent di alamat /.well-known/agent-card.json di domainnya sendiri. Kartu ini berisi nama dan deskripsi agent, daftar skill โ€” masing-masing dengan id, nama, deskripsi, tag, dan contoh โ€” interface yang dilayani, kapabilitas seperti dukungan streaming dan push notification, serta skema keamanan yang diterima. Sejak v1.0, kartu bisa ditandatangani secara kriptografis dengan JSON Web Signature, supaya client bisa memverifikasi bahwa kartu itu memang berasal dari domain yang diklaimnya.

Supaya kebayang bentuknya, ini contoh kartu yang dipangkas:

{
  "name": "Agent Gudang",
  "description": "Mengecek stok dan jadwal restock.",
  "version": "1.0.0",
  "supportedInterfaces": [
    {
      "protocolBinding": "JSONRPC",
      "url": "https://gudang.contoh.id/a2a",
      "protocolVersion": "1.0"
    }
  ],
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {
      "id": "cek-stok",
      "name": "Cek Stok",
      "description": "Mengembalikan jumlah stok per varian produk.",
      "tags": ["stok", "gudang"]
    }
  ]
}

Setelah membaca kartu, client mengirim pesan lewat operasi SendMessage. Jawabannya bisa berupa pesan langsung, buat interaksi sederhana, atau sebuah task yang melacak pekerjaan yang berjalan. Task bergerak lewat state yang didefinisikan: submitted dan working di awal, bisa berhenti di input-required kalau agent butuh informasi tambahan atau auth-required kalau butuh otorisasi, dan berakhir di salah satu state terminal โ€” completed, failed, canceled, atau rejected. Hasilnya dikembalikan sebagai artifact, dan buat pekerjaan panjang, client bisa memantau lewat streaming, polling GetTask, atau push notification ke webhook yang disiapkan client.

Yang perlu dicatat: A2A bukan framework. Framework yang membangun agent-nya tetap framework multi-agent seperti LangGraph dan CrewAI, ADK, atau SDK agent lainnya โ€” A2A cuma bahasa yang dipakai agent-agent itu buat ngobrol satu sama lain. Dan satu spesifikasi, tiga cara kirim: operasi yang sama dipetakan ke tiga binding โ€” JSON-RPC 2.0, gRPC, dan HTTP+JSON (REST) โ€” dengan definisi data yang sama dari file a2a.proto sebagai sumber kebenaran tunggal. Pilihan binding jadi keputusan infrastruktur, bukan keputusan fitur.

Bedanya di mana? Ini tabel jujurnya

Kalau diringkas satu kalimat: MCP menjawab “bagaimana agent ini mengakses kemampuan?”, A2A menjawab “bagaimana agent ini bekerja sama dengan agent lain?” Dokumentasi A2A sendiri menyatakan keduanya sangat komplementer dan dirancang buat dipakai bersama. Model mental yang paling gampang diingat: MCP itu vertikal, A2A itu horizontal.

Dimensi MCP A2A
Tujuan utama Menyambungkan agent ke tools, data, dan prompts Menyambungkan satu agent ke agent lain
Yang di ujung sana Tool atau sumber data yang kamu kendalikan Agent otonom yang punya state dan rencananya sendiri
Arah Vertikal: memperdalam satu agent Horizontal: menghubungkan agent lintas tim dan vendor
Discovery Server yang sudah dikonfigurasi; daftar tools, resources, dan prompts; plus server/discover Agent Card di /.well-known/agent-card.json
Model interaksi Client memanggil tool bernama dengan argumen bertipe, lalu menerima hasil Client mengirim pesan; agent remote merencanakan, memakai tools-nya sendiri, lalu membalas
Penanganan task Ekstensi Tasks yang opsional buat operasi panjang Lifecycle task bawaan, plus streaming dan push notification
Transport JSON-RPC 2.0 lewat stdio atau Streamable HTTP JSON-RPC 2.0, gRPC, atau HTTP+JSON lewat HTTP(S)
Tata kelola Anthropic, lalu Agentic AI Foundation (Des 2025) Google, lalu Linux Foundation (Jun 2025) dan Agentic AI Foundation (Agu 2026)
Versi terkini Revisi 2026-07-28 (stateless) 1.0.0 (12 Maret 2026), patch 1.0.1 (28 Mei 2026)
Unit kegagalan Tool call yang gagal Task yang didelegasikan dan gagal

Satu baris yang sering luput dari tabel perbandingan: siapa yang menafsirkan hasil. Di MCP, yang menafsirkan hasil tool call adalah agent pemanggil itu sendiri. Di A2A, yang menafsirkan adalah agent remote โ€” dia yang merencanakan langkahnya, memakai tools-nya sendiri, dan mengembalikan hasil yang sudah jadi. Itu sebabnya kegagalan di MCP berbentuk “tool call gagal”, sementara kegagalan di A2A berbentuk “task yang didelegasikan gagal” โ€” dua jenis kegagalan yang cara debugging-nya beda.

Cara kerja bareng: satu arsitektur, dua protokol

Di sistem produksi yang beneran, keduanya hampir selalu muncul bersamaan, di lapisan yang berbeda. Bayangin arsitekturnya begini:

1. User bicara ke satu agent orkestrator. Agent ini yang menerima permintaan, memecahnya jadi sub-tugas, dan bertanggung jawab atas jawaban akhirnya.

2. Orkestrator mendelegasikan lewat A2A. Buat tiap sub-tugas, orkestrator membaca Agent Card agent yang relevan, mengirim pesan, dan melacak task-nya sampai selesai. Dia tidak tahu โ€” dan tidak perlu tahu โ€” framework apa yang dipakai agent di ujung sana.

3. Setiap agent mengeksekusi lewat MCP. Di dalam batasnya sendiri, tiap agent memanggil tools dan membaca data lewat MCP server: API booking, database harga, dokumen kebijakan. MCP-lah yang menyeragamkan akses ke semua sistem itu.

4. Hasil kembali sebagai artifact. Tiap agent mengembalikan artifact-nya, orkestrator merangkainya jadi satu jawaban, dan user cuma melihat hasil akhirnya.

Contoh konkretnya: agent perencana perjalanan menerima permintaan “buatkan itinerary 3 hari ke Yogyakarta”. Dia mendelegasikan pencarian hotel ke agent akomodasi dan pencarian tiket ke agent transportasi lewat A2A โ€” dua agent yang mungkin dibangun tim berbeda dengan stack berbeda. Masing-masing agent lalu memakai MCP buat mengakses API booking, database harga, dan dokumen kebijakan. Orkestrator tidak pernah tahu tools apa yang dipakai di dalam; dia cuma menerima artifact berupa daftar hotel dan jadwal penerbangan.

Pola yang disarankan dokumentasi A2A sendiri kurang lebih begitu: bangun agent dengan framework apa pun, lengkapi dengan MCP, dan komunikasikan dengan A2A. Begitu arsitektur seperti ini jalan di produksi, pertanyaan berikutnya bukan lagi “protokolnya apa”, tapi “waktu ada yang salah, langkah mana yang salah?” Delegasi antar-agent dan panggilan tools yang bersarang bikin debugging buta kalau tidak ada rekaman. Di sinilah cara melacak log, latensi, dan debugging AI agent di produksi jadi fondasi โ€” setiap hop A2A dan setiap tool call MCP perlu tercatat sebagai trace yang bisa dibuka langkah demi langkah.

Status 2026: siapa yang megang, dan apa yang masih bolong

Timeline singkatnya, supaya kebayang seberapa cepat ruang ini bergerak:

Tanggal Kejadian
25 November 2024 Anthropic memperkenalkan MCP
9 April 2025 Google mengumumkan A2A bersama 50+ partner
23 Juni 2025 Linux Foundation meluncurkan proyek Agent2Agent
9 Desember 2025 MCP disumbangkan ke Agentic AI Foundation
12 Maret 2026 A2A 1.0.0, spesifikasi stabil pertama
28 Juli 2026 MCP revisi 2026-07-28, inti stateless
27 Agustus 2026 A2A diterima sebagai proyek Agentic AI Foundation

Dari sisi adopsi, Linux Foundation melaporkan lebih dari 150 organisasi pendukung A2A pada April 2026 dan menyebut protokol ini sudah dipakai di deployment produksi. SDK resmi tersedia untuk Python dan JavaScript/TypeScript, dan implementasi dari berbagai vendor sudah mulai bermunculan. Tapi jujur saja: ini masih wilayah yang bergerak cepat, dan ada beberapa hal yang belum beres.

Tidak ada registry pusat buat Agent Card. Spesifikasi tidak mendefinisikan katalog global tempat client mencari agent; discovery berjalan lewat alamat well-known yang sudah diketahui, konfigurasi, atau registry pihak ketiga. Artinya, “menemukan” agent masih lebih banyak urusan operasional daripada urusan protokol.

Tidak ada framework otorisasi bawaan. Kartu boleh mendeklarasikan skema keamanan โ€” API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS โ€” tapi siapa boleh memanggil siapa, dan dengan hak apa, tetap keputusan implementasi kamu. Kartu yang ditandatangani membantu memverifikasi keaslian kartu, tapi tidak membuktikan agent di baliknya bisa dipercaya.

Perbedaan versi itu nyata. A2A 1.0 mengubah nama operasi dan detail encoding dari v0.3, jadi client dan server harus sepakat soal versi yang dipakai โ€” header A2A-Version ada buat itu. Di sisi MCP, client yang dibangun buat revisi 2026-07-28 tidak otomatis cocok dengan server era 2025-11-25 ke bawah. Uji interop sebelum berasumsi.

Jadi, kamu pakai yang mana?

Pakai kerangka keputusan sederhana ini:

Pakai MCP kalau yang di ujung sana adalah tool atau data yang kamu kendalikan: database, API internal, file, atau template prompt. Satu agent, banyak kemampuan, satu antarmuka yang sama.

Pakai A2A kalau yang di ujung sana adalah agent lain yang punya state dan otonominya sendiri โ€” apalagi kalau beda tim, beda vendor, atau beda organisasi. Kamu mendelegasikan hasil, bukan memanggil function.

Pakai keduanya kalau kamu membangun sistem multi-agent yang serius: A2A di lapisan koordinasi, MCP di lapisan eksekusi. Ini pola yang dipakai arsitektur produksi pada umumnya di 2026.

Tidak perlu A2A kalau agent-agentmu masih hidup dalam satu codebase dan satu tim. Buat sub-agent dalam satu framework, primitif bawaan framework-mu โ€” atau MCP โ€” biasanya sudah cukup, dan dokumentasi A2A sendiri bilang begitu. A2A baru sepadan waktu ada batas kepemilikan yang dilewati.

Pertanyaan yang sering ditanya soal ini

Apakah A2A menggantikan MCP?

Tidak. A2A menghubungkan agent ke agent lain, MCP menghubungkan agent ke tools dan data. Keduanya dirancang buat dipakai bersama: agent yang menerima delegasi lewat A2A biasanya memakai MCP buat mengeksekusi pekerjaannya.

Apakah A2A cuma bisa dipakai dengan agent Google?

Tidak. Google yang memperkenalkannya, tapi sejak Juni 2025 proyek ini dikelola Linux Foundation, dan sejak Agustus 2026 berada di Agentic AI Foundation bersama MCP. Spesifikasinya terbuka dengan lisensi Apache 2.0, dan implementasinya tidak terikat ke framework atau vendor mana pun.

Apakah MCP cuma bisa dipakai dengan Claude?

Tidak. Anthropic yang memperkenalkannya, tapi MCP adalah standar terbuka yang didukung banyak aplikasi AI dan tools pengembangan. Server yang dibangun sekali bisa dipakai dari banyak client yang patuh pada spesifikasi yang sama.

Apa bedanya Agent Card dengan discovery di MCP?

Agent Card adalah dokumen discovery antar-agent: client membaca kartu buat tahu skill, endpoint, dan syarat keamanan sebuah agent sebelum memanggilnya. Di MCP, discovery berjalan di dalam koneksi yang sudah dikonfigurasi โ€” client menanyakan daftar tools, resources, dan prompts ke server, dan sejak revisi 2026-07-28 server mengumumkan kemampuannya lewat server/discover.

Apakah saya harus migrasi ke MCP revisi 2026-07-28?

Untuk implementasi baru, ya โ€” itu revisi yang berlaku sekarang, dan tutorial era handshake sudah kedaluwarsa. Buat sistem yang sudah jalan, perhatikan kompatibilitasnya: revisi ini mengubah inti protokol jadi stateless, jadi client dan server dari era berbeda tidak otomatis cocok. Rencanakan migrasi dengan menguji kedua sisi, bukan sekadar menaikkan versi SDK.

Apakah A2A aman dipakai antar-perusahaan?

Protokolnya menyediakan fondasi โ€” kartu yang bisa ditandatangani, skema keamanan yang dideklarasikan, dan dukungan otorisasi di dalam task โ€” tapi tidak menyediakan framework otorisasi maupun registry tepercaya bawaan. Kepercayaan antar-organisasi harus dibangun di luar protokol: verifikasi tanda tangan kartu, autentikasi yang kuat, dan kebijakan siapa boleh memanggil siapa. Jangan berasumsi agent remote itu jinak cuma karena kartunya valid.

Penutup: dua protokol, satu sistem yang bisa saling ngerti

Lima tahun lalu, integrasi antar-sistem AI berarti menulis konektor khusus buat tiap pasangan aplikasi. MCP dan A2A memecah masalah itu jadi dua lapisan yang masing-masing punya standar terbuka: satu buat kemampuan, satu buat kolaborasi. Hasilnya, agent yang dibangun tim berbeda, dengan framework berbeda, akhirnya bisa saling menemukan, saling mendelegasikan, dan saling mengerti โ€” tanpa harus membongkar dapur masing-masing.

Yang perlu kamu ingat cuma satu kalimat: MCP memperdalam satu agent, A2A menghubungkan banyak agent. Kalau kamu cuma ingat itu, kamu sudah lebih paham dari kebanyakan debat “A2A vs MCP” di luar sana.

Kamu sendiri gimana? Sudah pernah membangun sistem yang memakai MCP, A2A, atau keduanya? Ceritain di kolom komentar โ€” aku pengin tahu bagian mana yang paling bikin pusing waktu pertama kali menghubungkan agent ke agent lain.

Sumber dan bacaan lanjutan

Avatar Priyo Harjiyono

Workshop ยท Batch 12

2 jam bikin AI Agent pertamamu

Minggu, 18 Okt 2026 ยท 20.00 WIB

Rp399.000 Rp1.800.000

Modul Gratis

Modul intro Karyawan AI

Tiga bab video + worksheet + grup Telegram. Gratis.

Tinggalkan Balasan

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *