Agentic Commerce Protocol na Prática: Quando Agentes de IA Compram e Vendem

MCP conecta agentes a ferramentas. A2A conecta agentes a agentes. ACP conecta agentes ao dinheiro. Em 2026, a conversa sobre IA deixou de ser "o que ela pode gerar" e passou a ser "o que ela pode comprar". Agentes autônomos já reservam voos, reabastecem estoque, contratam freelancers e pagam por APIs — tudo sem um humano no meio.

O Agentic Commerce Protocol (ACP) é o padrão aberto que torna isso seguro: uma linguagem comum para que agentes de IA descubram produtos, iniciem checkout e compartilhem credenciais de pagamento sem expor dados sensíveis. Desenvolvido pela Stripe em parceria com a OpenAI, o ACP já é usado pelo ChatGPT Instant Checkout e por dezenas de merchants como Kate Spade, Best Buy e Coach.

Este guia cobre:

• O que é ACP e por que ele não compete com A2A nem MCP — completa ambos
• A diferença entre ACP (padrão aberto) e UCP (ecossistema Google)
• Como funciona um checkout agent-ready: do descobrimento à confirmação
• Código real: expondo um endpoint ACP com REST e MCP
• Segurança: Shared Payment Tokens, escopo de permissão e compliance PCI
• Quando usar ACP vs. MPP vs. x402 — o mapa de decisão

O Problema: Agentes Compram, Mas Não Sabem Como Pagar

Imagine um agente de viagem autônomo. Ele pesquisa voos, compara hotéis, monta um itinerário completo. Chega na hora de reservar... e trava. Por quê?

1. Não tem cartão de crédito. Agentes não são pessoas. Não podem abrir conta em banco.
2. Não pode usar o seu cartão. Mesmo que você autorize, passar credenciais reais para um agente é violação de PCI DSS e um convite a fraudes.
3. O site de checkout não foi feito para máquinas. Botões, CAPTCHAs, JavaScript dinâmico — tudo assume um humano com mouse e tela.

A analogia real: é como tentar fazer um pedido no iFood usando apenas um assistente de voz. A infraestrutura de pagamentos foi construída para humanos clicando em interfaces. Agentes precisam de uma nova camada — e é aí que entra o ACP.

O Que é o Agentic Commerce Protocol

ACP é um padrão aberto (Apache 2.0) que define como agentes de IA descobrem produtos, iniciam checkout e transacionam com segurança. Ele não substitui o Stripe, o PayPal ou o cartão de crédito. Ele traduz entre o mundo dos agentes e o mundo dos pagamentos.

Desenvolvido pela Stripe em colaboração com a OpenAI e lançado em 2025, o ACP é mantido como projeto open source com contribuições da comunidade. Em maio de 2026, o Stripe anunciou que o Agentic Commerce Suite já integrava 288 funcionalidades novas, incluindo parceria com Google para checkout dentro do AI Mode e do Gemini app.

"AI is the biggest platform shift for the economy since the internet, and in the not-too-distant future agents will account for most transactions online." — Patrick Collison, CEO do Stripe, Sessions 2026

Os Três Pilares do ACP

O Stack de Protocolos: Onde o ACP se Encaixa

Para entender o ACP, você precisa ver a pilha completa. Nenhum protocolo trabalha sozinho.

A regra é simples:

• MCP = "agente, aqui estão suas ferramentas" (acesso a dados)
• A2A = "agente A, delegue para o agente B" (coordenação)
• ACP = "agente, aqui está o checkout — pague com segurança" (comércio)
• AGNTCY = "quem é você, onde está, e posso confiar?" (infraestrutura)

Fonte: Digital Applied, AI Agent Protocol Ecosystem Map 2026 (março 2026); Ry Walker Research, Agent Coordination Protocols Compared (junho 2026).

ACP vs. UCP: Dois Protocolos, Dois Propósitos

Aqui mora a maior confusão do ecossistema. Existem dois protocolos de comércio agentic, e eles não competem — servem contextos diferentes.

Fonte: Stripe Documentation, Agentic Commerce (docs.stripe.com/agentic-commerce); Stripe Blog, Everything we announced at Sessions 2026 (maio 2026); Google I/O 2026 Keynote.

Quando usar qual:

• Use ACP se você quer que seu produto seja vendido por qualquer agente (ChatGPT, Claude, agentes customizados)
• Use UCP se seu foco é o ecossistema Google (AI Mode, Gemini, Google Shopping)
• Os dois podem coexistir — um merchant pode implementar ambos

Como Funciona: O Fluxo de Checkout ACP

O ACP define três momentos em uma transação agentic: descobrimento, checkout e confirmação. Vamos ver cada um.

1. Descobrimento

O agente precisa saber o que está disponível para compra. O merchant expõe um catálogo de produtos via API REST ou MCP server.

// Resposta do endpoint /products do merchant
{
  "products": [
    {
      "id": "shirt-001",
      "name": "Deluxe Shirt",
      "variants": [
        { "color": "Black", "size": "Large", "price": { "amount": 2600, "currency": "USD" } }
      ],
      "acp_checkout_url": "https://loja.exemplo.com/acp/checkout"
    }
  ]
}

O agente filtra, compara e seleciona — tudo sem interface humana.

Fonte: Agentic Commerce Protocol, agenticcommerce.dev (especificação oficial).

2. Checkout

O agente envia uma requisição para o endpoint ACP do merchant com o produto selecionado e um Shared Payment Token (token de pagamento compartilhado).

// Requisição POST para /acp/checkout
{
  "product_id": "shirt-001",
  "variant": { "color": "Black", "size": "Large" },
  "payment_token": "ptok_stripe_shared_xxx",
  "buyer_consent": {
    "max_amount": 5000,
    "currency": "USD",
    "expires_at": "2026-06-22T23:59:59Z"
  }
}

O Shared Payment Token é a inovação de segurança central do ACP. Em vez de passar o número do cartão, o agente recebe um token escopado do Stripe Link (ou outro processor compatível). Esse token:

• Tem valor máximo definido ($50 no exemplo)
• Expira em horas ou dias
• Só funciona para aquele merchant específico
• Nunca expõe o número real do cartão

Fonte: Stripe Documentation, Shared Payment Tokens (docs.stripe.com/agentic-commerce/concepts/shared-payment-tokens); Stripe Blog, Agentic Commerce Suite (2025).

3. Confirmação

O merchant usa o token para criar um PaymentIntent no Stripe. A transação é processada sem o agente (ou o merchant) nunca ter acesso aos dados reais do cartão.

// Resposta de confirmação
{
  "status": "completed",
  "order_id": "order_abc123",
  "payment_intent": "pi_xyz789",
  "receipt_url": "https://pay.stripe.com/receipts/..."
}

O agente reporta o sucesso ao usuário. O ciclo está completo.

Código na Prática: Expondo um Endpoint ACP

Vamos implementar um checkout ACP minimalista em Python. O merchant expõe um endpoint que qualquer agente pode chamar.

from flask import Flask, request, jsonify
from datetime import datetime, timedelta
import stripe

app = Flask(__name__)
stripe.api_key = "sk_test_..."  # sua chave Stripe

# Catálogo de produtos (em produção, viria do banco de dados)
PRODUCTS = {
    "shirt-001": {
        "name": "Deluxe Shirt",
        "base_price": 2600,  # cents
        "variants": {
            "black-large": { "color": "Black", "size": "Large", "price": 2600 }
        }
    }
}

@app.route("/acp/products", methods=["GET"])
def list_products():
    """Endpoint de descobrimento — agentes buscam produtos disponíveis."""
    return jsonify({
        "products": [
            {
                "id": pid,
                "name": p["name"],
                "variants": list(p["variants"].values()),
                "acp_checkout_url": f"https://loja.exemplo.com/acp/checkout"
            }
            for pid, p in PRODUCTS.items()
        ]
    })

@app.route("/acp/checkout", methods=["POST"])
def acp_checkout():
    """Endpoint de checkout — agente envia token e recebe confirmação."""
    data = request.get_json()
    
    product_id = data.get("product_id")
    variant_key = data.get("variant_key", "black-large")
    payment_token = data.get("payment_token")
    buyer_consent = data.get("buyer_consent", {})
    
    # Validação básica
    if product_id not in PRODUCTS:
        return jsonify({"error": "Produto não encontrado"}), 404
    
    product = PRODUCTS[product_id]
    variant = product["variants"].get(variant_key)
    if not variant:
        return jsonify({"error": "Variante não encontrada"}), 404
    
    # Verifica consentimento do comprador (valor máximo, expiração)
    max_amount = buyer_consent.get("max_amount", 0)
    if variant["price"] > max_amount:
        return jsonify({"error": "Valor excede o consentimento do comprador"}), 403
    
    # Cria PaymentIntent usando o Shared Payment Token
    try:
        intent = stripe.PaymentIntent.create(
            amount=variant["price"],
            currency=buyer_consent.get("currency", "usd").lower(),
            payment_method_data={
                "type": "link",
                "link": {"payment_details_token": payment_token}
            },
            confirmation_method="manual",
            confirm=True,
            metadata={
                "acp_order": "true",
                "product_id": product_id,
                "variant": variant_key
            }
        )
        
        return jsonify({
            "status": "completed" if intent.status == "succeeded" else "requires_action",
            "order_id": f"order_{intent.id}",
            "payment_intent": intent.id,
            "receipt_url": intent.charges.data[0].receipt_url if intent.charges.data else None
        })
        
    except stripe.error.CardError as e:
        return jsonify({"error": "Pagamento recusado", "details": str(e)}), 402
    except Exception as e:
        return jsonify({"error": "Erro no processamento", "details": str(e)}), 500

if __name__ == "__main__":
    app.run(port=5000, debug=True)

O que esse código faz:

1. /acp/products — Qualquer agente pode listar produtos e saber o que está disponível
2. /acp/checkout — Recebe um Shared Payment Token, valida consentimento e processa via Stripe
3. Validação de consentimento — O agente não pode gastar mais do que o usuário autorizou
4. Sem cartão exposto — O token é opaco; nem o agente nem o merchant vê o número real

Nota: Este é um exemplo educacional. Em produção, adicione rate limiting, idempotência, webhooks para confirmação assíncrona e logs de auditoria.

ACP como MCP Server: Duas Formas de Expor

O ACP é agnóstico de transporte. Você pode expor checkout via REST tradicional ou como um MCP server — o que permite que agentes compatíveis com MCP (Claude Desktop, Cursor, Windsurf) descubram e usem seu checkout nativamente.

# mcp_server_acp.py — MCP server que expõe checkout ACP
from mcp.server import Server
from mcp.types import Tool, TextContent
import stripe

server = Server("acp-merchant-server")

@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="list_products",
            description="Lista produtos disponíveis para compra",
            inputSchema={"type": "object", "properties": {}}
        ),
        Tool(
            name="checkout",
            description="Inicia checkout ACP para um produto",
            inputSchema={
                "type": "object",
                "properties": {
                    "product_id": {"type": "string"},
                    "variant_key": {"type": "string"},
                    "payment_token": {"type": "string"},
                    "max_amount": {"type": "integer"}
                },
                "required": ["product_id", "payment_token", "max_amount"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name, arguments):
    if name == "list_products":
        return [TextContent(type="text", text=str(PRODUCTS))]
    elif name == "checkout":
        # Mesma lógica do endpoint REST, mas via MCP
        result = await process_acp_checkout(arguments)
        return [TextContent(type="text", text=str(result))]

# O agente MCP descobre essas tools automaticamente e pode chamar checkout
# sem saber que é ACP por baixo — o MCP abstrai o protocolo

Fonte: Stripe Documentation, Agentic Commerce — seção "REST and MCP compatible" (docs.stripe.com/agentic-commerce).

Segurança: O Que ACP Garante (e O Que Não Garante)

A segurança do ACP é projetada em camadas. Entender o que cada camada protege é essencial antes de colocar em produção.

O Que ACP Protege

O Que ACP Não Protege (Você Precisa Cuidar)

Fonte: Stripe Documentation, Security and PCI compliance (docs.stripe.com/agentic-commerce); Worldpay, Agentic Commerce (worldpay.com/en/agentic-commerce); PayAI Network, Agentic Payments (blog.payai.network).

MPP e x402: Quando ACP Não é Suficiente

O ACP resolve comércio tradicional (produtos, carrinho, checkout). Mas nem toda transação agentic é uma compra de camiseta. Às vezes, um agente precisa pagar por uma API call, um serviço de processamento, ou um micro-serviço. Para isso, existem outros protocolos.

Machine Payments Protocol (MPP)

O MPP é um protocolo de pagamento máquina-a-máquina desenvolvido pelo Stripe. Em vez de um checkout com carrinho, o MPP embute o pagamento na própria requisição HTTP.

POST /api/process-data HTTP/1.1
Host: api.servico.com
Content-Type: application/json
X-Payment-Token: ptok_mpp_xxx

{"data": "...", "max_charge": 50}

O servidor processa os dados e cobra automaticamente. Sem carrinho, sem checkout, sem interface.

x402 (Payment Required)

O x402 reutiliza o status HTTP 402 (Payment Required) — um código que existia desde 1992 mas nunca foi amplamente usado. A ideia é simples:

1. Agente faz uma requisição a um recurso pago
2. Servidor responde com 402 Payment Required + valor necessário
3. Agente reenvia a requisição com proof-of-payment
4. Servidor processa e entrega o recurso

GET /api/expensive-analysis HTTP/1.1
Host: api.analytics.com

# Resposta:
HTTP/1.1 402 Payment Required
X-Payment-Amount: 0.05
X-Payment-Currency: USD

# Agente reenvia:
GET /api/expensive-analysis HTTP/1.1
X-Payment-Proof: proof_x402_xxx

Fonte: Stripe Documentation, Machine Payments (docs.stripe.com/payments/machine); PayAI Network, x402 Overview (blog.payai.network); Solana, x402 Protocol (solana.com/x402).

Mapa de Decisão: Qual Protocolo Usar

┌─────────────────────────────────────────────────────────────┐
│  O agente precisa comprar um produto físico/digital?        │
│                    ↓ SIM                                    │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  Use ACP (Agentic Commerce Protocol)                │    │
│  │  → Checkout, catálogo, Shared Payment Tokens        │    │
│  └─────────────────────────────────────────────────────┘    │
│                    ↓ NÃO                                    │
│  O agente precisa pagar por uma API/serviço?                │
│                    ↓ SIM                                    │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  Use MPP (Machine Payments Protocol)                │    │
│  │  → Pagamento embutido na requisição HTTP            │    │
│  └─────────────────────────────────────────────────────┘    │
│                    ↓ NÃO                                    │
│  O agente precisa de micropagamentos (<$1)?                 │
│                    ↓ SIM                                    │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  Use x402 (HTTP 402 Payment Required)               │    │
│  │  → Pay-per-request, APIs, stablecoins               │    │
│  └─────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────┘

O Estado do Ecossistema (Junho 2026)

O agentic commerce deixou de ser promessa e virou infraestrutura. Aqui está o panorama atual.

Quem Já Está Usando

Números que Importam

• 97 milhões de downloads do MCP (março 2026) — a base de ferramentas que ACP usa
• 50+ parceiros de lançamento do A2A — a coordenação que ACP assume
• 288 funcionalidades novas no Stripe Sessions 2026 — incluindo agentic commerce
• $17,5 trilhões — projeção da Deloitte para agentic commerce global até 2030
• 40% dos projetos agentic serão cancelados até 2027 (Gartner) — por falta de infraestrutura como ACP

Fontes: Digital Applied, AI Agent Protocol Ecosystem Map 2026; Ry Walker Research, Agent Coordination Protocols Compared (junho 2026); Gartner, Predicts 2026; Deloitte, Agentic Commerce Forecast (2026); E-Commerce Brasil, IA Agêntica e o E-commerce Brasileiro em 2026.

Conclusão: O Dinheiro Agora Fala MCP

O Agentic Commerce Protocol não é apenas mais um acrônimo no ecossistema de IA. Ele é a camada que transforma agentes de "conversadores inteligentes" em "participantes da economia". Sem ACP, um agente pode pesquisar, comparar e recomendar — mas não pode agir. Com ACP, ele compra, paga e transaciona com a mesma segurança que um humano, sem nunca expor dados sensíveis.

A pilha de protocolos está completa: MCP para ferramentas, A2A para coordenação, ACP para comércio, AGNTCY para infraestrutura. Em 2026, construir um agente que não transaciona é como construir um navegador que não acessa a internet — tecnicamente possível, mas economicamente irrelevante.

O que fazer agora:

1. Se você é merchant, implemente um endpoint ACP. Comece com /acp/products e /acp/checkout. Use o Shared Payment Token do Stripe.
2. Se você é desenvolvedor de agentes, adicione suporte a ACP no seu orquestrador. Um agente que não pode pagar é um agente que não pode terminar a tarefa.
3. Se você é arquiteto de segurança, audite seus tokens. Shared Payment Tokens são seguros, mas só se o escopo for rigoroso.

O futuro do comércio não é humano vs. máquina. É humano com máquina — e o ACP é o tradutor que torna essa colaboração possível.

Publicado em andrecosta.ia.br. Atualizado em junho de 2026 com dados do Stripe Sessions 2026, Google I/O 2026 e Linux Foundation.

Referências

1. Stripe Documentation — Agentic Commerce. docs.stripe.com/agentic-commerce. Acesso em junho 2026.
2. Stripe Blog — Introducing the Agentic Commerce Suite. stripe.com/blog/agentic-commerce-suite. 2025.
3. Stripe Blog — Everything we announced at Sessions 2026. stripe.com/blog/everything-we-announced-at-sessions-2026. Maio 2026.
4. Stripe Newsroom — Stripe builds out the economic infrastructure for AI with 288 launches. stripe.com/newsroom/news/sessions-2026. Maio 2026.
5. Agentic Commerce Protocol — agenticcommerce.dev. Especificação oficial open source (Apache 2.0).
6. Digital Applied — AI Agent Protocol Ecosystem Map 2026: MCP, A2A, ACP, UCP. digitalapplied.com. Março 2026.
7. Ry Walker Research — Agent Coordination Protocols Compared. rywalker.com. Fevereiro 2026, atualizado junho 2026.
8. Google Developers Blog — Announcing the Agent2Agent Protocol (A2A). developers.googleblog.com. Abril 2025.
9. A2A Protocol — a2a-protocol.org/latest. Documentação oficial, governança Linux Foundation.
10. LF AI & Data — ACP Joins Forces with A2A. lfaidata.foundation. Agosto 2025.
11. TechCrunch — OpenAI, Anthropic, and Block join new Linux Foundation effort. techcrunch.com. Dezembro 2025.
12. AGNTCY — agntcy.org. Infraestrutura Internet of Agents, Linux Foundation.
13. PayAI Network — Agentic Payments: How AI Agents Pay, Transact, and Power the Economy. blog.payai.network. 2026.
14. Worldpay — Agentic Commerce. worldpay.com/en/agentic-commerce. 2026.
15. Mastercard — Mastercard Agent Pay. mastercard.com. Abril 2025.
16. Dodo Payments — Billing Infrastructure in the Age of AI Agents. dodopayments.com. Julho 2025.
17. E-Commerce Brasil — IA Agêntica e o E-commerce Brasileiro em 2026. ecommercebrasil.com.br. 2026.
18. Deloitte — Agentic Commerce Forecast 2030. Projeção: $17,5 trilhões globais.
19. Gartner — Predicts 2026: 40% of agentic AI projects canceled by 2027. gartner.com.
20. OpenAI — Buy it in ChatGPT. openai.com. 2025.