Belajar A2A - Ecosystem: A2A x402 & Commerce

#Pendahuluan

Episode 18 membawa kalian ke level performa: task dalam ribuan per detik dengan pooling, caching, load balancing, dan gRPC. Sekarang pertanyaannya berubah — bukan lagi "bagaimana melayani lebih cepat", melainkan "apakah agent ini boleh dilayani sama sekali". Di dunia nyata, layanan berharga, dan agent yang melakukan pekerjaan berhak dibayar.

Episode 19 memperkenalkan lapisan commerce dari ekosistem A2A. Kita akan membahas ekstensi x402 yang membuat agent bisa meminta pembayaran lewat kode HTTP 402, konsep mandate dan approval yang menjaga otorisasi transaksi, lalu interop dengan UCP dan AP2 sebagai peta besar agentic commerce — termasuk trust rails dari Visa dan Mastercard yang menopang kepercayaan di belakang layar.

#HTTP 402: Kode Status untuk Pembayaran

Sebagian besar kode HTTP sudah akrab: 200 sukses, 404 tidak ditemukan, 500 error server. Ada satu kode yang lama menganggur sejak 1998: 402 Payment Required. Kode ini tidak pernah punya semantik baku — sampai ekosistem x402 memberinya arti: "pekerjaan ini bisa dilakukan, tapi harus dibayar dulu."

Ketika client agent mengirim task ke remote agent yang berbayar, remote agent tidak langsung menolak. Ia menjawab dengan status 402 dan menyertakan payment request — deskripsi harga, denominasi, penerima, dan instruksi bagaimana membayar:

curl -s -o /dev/null -w "%{http_code}" -X POST \
  https://agent-premium.example.com/ \
  -d '{"jsonrpc":"2.0","id":1,"method":"tasks/send","params":{...}}'

{
  "payments": [
    {
      "id": "pay_abc123",
      "description": "Analisis kredit 10 dokumen",
      "amount": "250",
      "currency": "usd",
      "receiver": "https://wallet.agent-premium.example.com",
      "network": "ethereum"
    }
  ]
}

Klien membaca respons ini, lalu memutuskan: bayar sekarang, atau tolak. Ini mengubah pola interaksi agent dari "semua gratis" menjadi layanan bernilai dengan harga transparan. Kunci pentingnya: x402 bukan mata uang baru — ia adalah lapisan instruksi pembayaran di atas jaringan yang sudah ada, jadi agent tidak perlu memahami detail blockchain untuk meminta bayaran.

#Ekstensi A2A-x402: Menggabungkan Task dan Pembayaran

Ekstensi x402 berjalan di atas HTTP binding A2A. Alurnya seperti negosiasi yang berurutan:

1. Client mengirim tasks/send ke remote agent.
2. Remote agent membalas status 402 Payment Required dengan payment request (seperti di atas).
3. Client membuat payment, mendapat bukti transaksi, lalu mengirim ulang task dengan payment proof sebagai bagian dari request.
4. Remote agent memverifikasi bukti, menjalankan task, dan mengembalikan hasil seperti biasa.

send-task-berbayar.py

import httpx
 
async def send_paid_task(url: str, task: dict) -> dict:
    async with httpx.AsyncClient() as client:
        resp = await client.post(url, json={"task": task})
        if resp.status_code != 402:
            return resp.json()
 
        payment_request = resp.json()["payments"][0]
        proof = await settle_payment(payment_request)
 
        final = await client.post(
            url,
            json={"task": task, "payment_proof": proof},
        )
        return final.json()

Perhatikan dua hal penting dalam contoh ini. Pertama, task tetap satu kesatuan — yang ditambahkan hanyalah bukti pembayaran, bukan struktur task yang berbeda. Kedua, settle_payment bisa berupa apa saja: memanggil wallet agent, meminta persetujuan user, atau mengeksekusi kontrak di jaringan pembayaran. Fleksibilitas inilah yang membuat x402 lintas-domain.

#Mandate dan Approval: Siapa yang Menyetujui Pengeluaran

Jika setiap transaksi harus minta persetujuan penuh kepada user, agent akan macet. Solusinya ada dua kata kunci: mandate dan approval.

• Mandate adalah otorisasi yang diberikan sekali dan berulang: "agent ini boleh membelanjakan hingga 50 dolar per hari untuk layanan analisis, tanpa bertanya lagi."
• Approval adalah persetujuan satu kali yang diminta untuk transaksi di luar batas mandate — jumlah besar, penerima baru, atau kategor baru.

mandate-approval.py

class PaymentPolicy:
    def __init__(self):
        self.mandates = {
            "agent-analisis": {"limit_daily": 50.0, "spent": 0.0},
        }
 
    async def authorize(self, payer: str, amount: float, receiver: str) -> str:
        mandate = self.mandates.get(payer)
        if mandate and mandate["spent"] + amount <= mandate["limit_daily"]:
            mandate["spent"] += amount
            return "approved-by-mandate"
        return await self.request_approval(payer, amount, receiver)

Pola ini menjaga keseimbangan antara kecepatan dan kontrol: transaksi rutin berjalan tanpa friksi, sedangkan transaksi mencurigakan atau besar masih lewat jalur manusia. Di deployment nyata, mandate disimpan di sisi wallet atau policy service, bukan di kode agent — supaya keputusan keuangan bisa diaudit secara terpisah dari logika agent.

#UCP dan AP2: Peta Besar Agentic Commerce

x402 adalah protokol pembayaran langsung antar agent. Di atasnya, ada dua inisiatif yang menyusun agentic commerce secara lebih utuh:

• UCP (Universal Commerce Protocol) — standar yang menormalisasi siklus hidup transaksi komersial: penawaran, kesepakatan, pembayaran, dan penyelesaian. UCP memberi bahasa yang sama untuk barang, jasa, dan kewajiban antar pihak.
• AP2 (Agentic Payments Protocol) — fokus pada relasi agent-to-wallet: bagaimana agent mewakili kepentingan finansial pemiliknya, menegosiasikan harga, dan memindahkan nilai antar wallet tanpa manusia mengetik detail kartu.

Keduanya komplementer dengan A2A: A2A mengurus "bagaimana agent meminta pekerjaan dilakukan", UCP mengurus "apa nilai transaksinya", dan AP2 mengurus "bagaimana nilai itu berpindah dari wallet agent A ke wallet agent B". Kalian bisa membayangkan tumpukan ini seperti lapisan-lapisan di jaringan OSI — masing-masing berurusan dengan masalahnya sendiri dan tidak peduli dengan lapisan di bawahnya.

#Trust Rails: Visa TAP dan Mastercard Agent Pay

Semua protokol di atas hanya bermakna jika ada trust rails — jalur kepercayaan yang menjamin uang benar-benar berpindah. Di sinilah institusi pembayaran tradisional masuk ke dunia agent. Visa TAP (Tokenized Agent Payments) dan Mastercard Agent Pay adalah dua inisiatif yang menghubungkan agent ke jaringan pembayaran kartu:

• Identity agent yang dipercaya: merchant dan penyedia pembayaran bisa memverifikasi bahwa agent tersebut dijalankan oleh entitas terdaftar — bukan bot nakal.
• Limit dan kontrol risiko: transaksi agent diatur dengan batas yang jelas dan bisa diaudit, meniru kontrol yang sudah ada di kartu kredit.
• Settlement di dunia nyata: hasil akhir transaksi agent tetap masuk ke rekening bank atau ledger yang diakui regulasi.

agent:
  name: "payment-processor-agent"
  description: "Menerima task berbayar dengan x402"
  capabilities:
    - streaming
    - push
  payment:
    methods:
      - x402
      - visa-tap
      - mastercard-agent-pay
    default_currency: usd
    max_amount_per_task: 1000

Di ekosistem nyata, remote agent tidak perlu memilih salah satu — ia bisa menerbitkan agent card dengan daftar metode pembayaran dan membiarkan client memilih jalur yang paling nyaman. Inilah kekuatan desain berbasis kartu: kemampuan dipublikasikan, keputusan diserahkan ke pihak lawan.

#Penutup

Episode 19 menempatkan A2A dalam konteks ekonomi agent: HTTP 402 menjadi sinyal "bayar dulu, kerja kemudian", ekstensi x402 membungkus bukti pembayaran ke dalam alur task yang sudah kalian kenal, mandate dan approval menjaga kontrol pengeluaran, dan UCP plus AP2 memberi peta besar agentic commerce — sementara trust rails dari Visa dan Mastercard memastikan nilai benar-benar berpindah di dunia nyata.

Inti yang harus dibawa pulang:

• HTTP 402 adalah jembatan antara task agent dan pembayaran; responsnya berisi payment request yang terstruktur.
• Ekstensi x402 menempel pada alur A2A yang ada — client cukup menambahkan bukti pembayaran saat mengirim ulang task.
• Mandate untuk transaksi rutin, approval untuk yang besar atau asing — keduanya harus diaudit terpisah.
• UCP menormalisasi transaksi, AP2 menghubungkan agent ke wallet, A2A menghubungkan agent ke agent.
• Trust rails dari Visa dan Mastercard membawa identitas dan settlement dari dunia pembayaran tradisional ke ekosistem agent.

Di episode 20 kita berbalik dari urusan uang ke urusan operasional: policy-as-code dan automation — men-deploy agent dengan CI/CD, menguji sistem multi-agent di pipeline, contract testing untuk agent card, dan governance versi serta SLA. Sampai jumpa!