O problema que o AgentCore Payments veio resolver
O mundo dos agentes de Inteligência Artificial (IA) está evoluindo rapidamente. A expectativa é que bilhões de agentes de IA generativa operem de forma autônoma, tomando decisões e executando tarefas sem intervenção humana. Para suportar esse cenário, a AWS desenvolveu o Amazon Bedrock AgentCore, uma plataforma modular e totalmente gerenciada para construir, implantar e operar agentes de IA em escala.
Nesse novo contexto, um obstáculo concreto surge quando esses agentes precisam acessar serviços pagos: APIs com cobrança por uso, conteúdo premium e ferramentas que exigem assinatura. O problema se desdobra em várias camadas:
- Integrar carteiras de pagamento de terceiros exige gerenciar autenticação, controle de acesso e segurança das credenciais.
- A maioria das transações vale centavos, mas métodos tradicionais como cartão de crédito cobram taxas fixas por transação (por exemplo, USD $0,30), tornando micropagamentos economicamente inviáveis.
- Protocolos de pagamento para agentes, como o x402 — um dos protocolos populares de pagamento máquina a máquina — têm variações de versão e complexidades que demandam meses de trabalho para integrar corretamente.
- Sem guardrails de orçamento, um agente autônomo pode gastar além do limite previsto, especialmente quando múltiplos pagamentos ocorrem em paralelo.
É exatamente para resolver esse conjunto de desafios que a AWS lançou o Amazon Bedrock AgentCore Payments, disponível em preview. O serviço promete reduzir o esforço de integração de meses para dias.
O que é o AgentCore Payments
O AgentCore Payments é o primeiro serviço gerenciado dentro do Amazon Bedrock AgentCore focado em pagamentos. Ele permite que agentes de IA executem micropagamentos de forma autônoma para APIs pagas, servidores MCP (Protocolo de Contexto de Modelo) e conteúdo, com poucas linhas de código.
Os principais recursos oferecidos são:
- Pagamentos instantâneos para serviços externos pagos, sem necessidade de configuração manual de cobrança por provedor.
- Suporte a stablecoins para micropagamentos economicamente viáveis, incluindo transações abaixo de um centavo.
- Guardrails de gastos configuráveis para controle granular de orçamento e limites de transação por agente ou sessão.
Como o serviço resolve cada desafio técnico
Autenticação segura de carteiras de pagamento
Para autenticar carteiras de pagamento com segurança, o AgentCore Payments utiliza o AgentCore Identity. O desenvolvedor cria um payment connector — um recurso de integração específico por provedor de pagamento. Esse conector provisiona automaticamente um provedor de credenciais no AgentCore Identity, que armazena as credenciais em um cofre seguro de tokens e emite tokens de acesso tokenizados sem expor as credenciais brutas.
O serviço suporta assinaturas criptográficas EdDSA, ECDSA e ES256 para operações com carteiras. O material criptográfico fica armazenado no AWS Secrets Manager e nunca é retornado pelas APIs. Na camada de entrada, o serviço impõe autenticação dupla — OAuth e AWS SigV4 — no mesmo pipeline de requisição.
Orquestração de protocolos de pagamento
O cenário de protocolos de pagamento agênticos é fragmentado, com múltiplos padrões competindo entre si. Para resolver isso, o AgentCore Payments oferece um motor de orquestração de pagamentos que fica entre o agente e os provedores de pagamento, expondo uma única interface processPayment.
Essa interface recebe uma requisição de pagamento e retorna uma prova de pagamento que o agente pode apresentar para acessar o serviço pago. O orquestrador gerencia automaticamente fluxos de pagamento em múltiplas etapas, tentativas e casos extremos para protocolos como o x402 (incluindo as versões 1 e 2, que diferem na estrutura dos campos exigidos). O modelo é plugável: adicionar suporte a um novo protocolo não exige mudanças na lógica central nem na API exposta ao desenvolvedor.
Controle de orçamento em tempo real
Agentes são autônomos por natureza, o que torna o controle de gastos um requisito crítico de infraestrutura. O AgentCore Payments implementa limites de gasto na camada de infraestrutura por meio de um fluxo transacional de três fases:
- Fase 1 — Reserva: o valor solicitado é deduzido atomicamente do saldo disponível antes de qualquer processamento.
- Fase 2 — Processamento: o pagamento é processado pelo provedor.
- Fase 3 — Confirmação ou rollback: em caso de sucesso, a transação é confirmada; em caso de falha, o valor reservado é restaurado ao saldo disponível.
Esse protocolo garante que, mesmo com múltiplos agentes transacionando simultaneamente contra o mesmo orçamento, não haja leituras desatualizadas, sobrescritas ou gastos além do limite.
Observabilidade completa dos pagamentos
Para agentes que transacionam de forma autônoma, visibilidade total é indispensável. O AgentCore Payments entrega um sistema de observabilidade em três pilares, publicado diretamente na conta AWS do desenvolvedor, sem necessidade de instrumentação de código:
- Métricas no Amazon CloudWatch: contagens de sucesso, falha e latência por operação. A operação
processPaymenttambém emite o valor gasto por tipo de token. - Logs estruturados entregues via pipeline assíncrono e em lote, com contexto do recurso de pagamento e ID de requisição para correlação.
- Rastreamento distribuído baseado em propagação de contexto W3C com spans compatíveis com OpenTelemetry, enriquecidos com atributos de pagamento como valor gasto, orçamento restante e telemetria da cadeia de assinatura.
Como começar a usar o AgentCore Payments
Para começar, a AWS recomenda verificar os pré-requisitos na documentação. O serviço pode ser configurado por múltiplas interfaces: AWS SDK para Python (Boto3), Console de Gerenciamento AWS, Amazon Bedrock AgentCore SDK e Strands Agents com plugin nativo para integração com hooks x402.
Configuração inicial (uma única vez)
Antes de registrar no AgentCore Payments, é necessário obter credenciais de API do provedor de pagamento escolhido. Para Stripe, utiliza-se a chave secreta de API do Stripe Dashboard. Para Coinbase, cria-se uma chave de API na Coinbase Developer Platform, que emite um par de nome de chave e chave privada.
O código abaixo, usando o AgentCore SDK, realiza toda a configuração inicial em uma única chamada:
from bedrock_agentcore.payments import PaymentClient
# Create PaymentClient
payment_client = PaymentClient(region_name="us-west-2")
# Create payment manager with connector and credential provider
response = payment_client.create_payment_manager_with_connector(
payment_manager_name="myPaymentManager",
payment_manager_description="myPaymentManager description",
authorizer_type="AWS_IAM",
role_arn=ROLE_ARN,
payment_connector_config={
"name": "myPaymentConnector",
"description": "myPaymentConnector description",
"payment_credential_provider_config": {
"name": "myCoinbasePaymentCredential",
"credential_provider_vendor": "<PROVIDER>",
"credentials": {
"api_key_id": API_KEY,
"api_key_secret": API_KEY_SECRET,
"wallet_secret": WALLET_SECRET,
},
},
}
)
# Extract details from response
payment_manager_arn = response["paymentManager"]["paymentManagerArn"]
payment_connector_id = response["paymentManager"]["paymentConnectorId"]Criando o instrumento de pagamento
Com o payment manager configurado, o próximo passo é criar um instrumento de pagamento referenciando o manager e o conector. O instrumento é essencialmente uma carteira embarcada — um endereço de carteira autocustodial gerenciado pelo usuário final. Após a criação, o instrumento precisa ser financiado e a autorização de assinatura deve ser concedida antes que o agente possa transacionar.
from bedrock_agentcore.payments import PaymentManager
# Initialize manager
manager = PaymentManager(
payment_manager_arn=payment_manager_arn,
region_name="us-west-2"
)
instrument = manager.create_payment_instrument(
user_id="test-user-123",
payment_connector_id="codeverifymycoinbaseconnector-sfp0lynfjc",
payment_instrument_type="EMBEDDED_CRYPTO_WALLET",
payment_instrument_details={
"embeddedCryptoWallet": {
"network": "ETHEREUM",
"linkedAccounts": [{
"email": {
"emailAddress": "test@example.com"
}
}]
}
},
)Criando uma sessão de pagamento
A sessão de pagamento define o limite financeiro do agente: quanto pode ser gasto e por quanto tempo. O ID da sessão e o ID do instrumento são passados ao agente quando sua tarefa começa. O agente não pode estender sua sessão nem gastar além dos limites configurados.
# Create a payment session
session_response = manager.create_payment_session(
user_id="test-user-123",
limits={
"maxSpendAmount": {
"value": "100.00",
"currency": "USD"
}
},
expiry_time_in_minutes=60
)Processando pagamentos de forma autônoma
Quando o agente chama um endpoint pago e recebe uma resposta HTTP 402 Payment Required, o AgentCore Payments entende o protocolo x402 e sabe exatamente como gerar a prova de pagamento necessária para desbloquear o serviço:
payment_response = manager.process_payment(
user_id="user-123",
payment_session_id=PAYMENT_SESSION_ID,
payment_instrument_id=PAYMENT_INSTRUMENT_ID,
payment_input={
"cryptoX402": {
"version": "1",
"payload": {
"scheme": "exact",
"network": "base-sepolia",
"maxAmountRequired": "5000",
"resource": "https://premiousEndpoint",
"description": "Premium AI joke generation",
"mimeType": "application/json",
"payTo": PAY_TO_ADDRESS,
"maxTimeoutSeconds": 300,
"asset": "0xxxxxxxxxxxxxxxxxxxxxxxx",
"extra": {"name": "USDC", "version": "2"},
},
}
}
)Caso de uso: agente de pesquisa financeira
Para ilustrar o funcionamento na prática, imagine um analista financeiro que pede ao seu agente de IA: “Analise as ações da Amazon e compare com benchmarks do setor.” O agente precisa de três fontes pagas: uma API de dados financeiros (USD $0,50 por consulta), um fornecedor de análise de cadeia de suprimentos (USD $1,20 por relatório) e uma base de dados de benchmarks (USD $0,80 por dataset).
O backend da aplicação cria uma sessão com orçamento de USD $10,00 e passa o ID da sessão e o ID do instrumento ao agente. O agente chama cada serviço, recebe HTTP 402 de cada um, e o AgentCore Payments verifica o orçamento atomicamente, assina a transação pelo provedor de carteira configurado e retorna a prova criptográfica. O agente faz a tentativa novamente com a prova e recebe o conteúdo pago.
Três fornecedores, três pagamentos, uma chamada de API cada. Gasto total: USD $2,50 de um orçamento de USD $10,00. O analista recebe a análise completa sem intervenção manual.
O mesmo fluxo funciona independentemente do framework de agente utilizado (Strands Agents, LangChain, etc.) e do modelo de linguagem escolhido — seja Claude da Anthropic, GPT da OpenAI, Gemini do Google ou Llama da Meta.
Integração com outros serviços do AgentCore
Como os pagamentos operam na camada de chamada de ferramentas, eles funcionam naturalmente com outros serviços do AgentCore:
- AgentCore Gateway — descobre ferramentas MCP pagas no Coinbase x402 Bazaar sem registro por provedor. Uma única stack de pagamento dá acesso a mais de 10.000 endpoints.
- AgentCore Memory — armazena resultados de pesquisas entre sessões. Se o agente já comprou um relatório anteriormente, a memória recupera o resultado sem novo pagamento.
- AgentCore Tools — ferramentas gerenciadas como Browser e Code Interpreter funcionam no mesmo fluxo. O Browser navega em sites com paywall e paga pelo conteúdo inline.
- AgentCore Runtime — ao implantar o agente com
agentcore deploy, o papelProcessPaymentRoleé aplicado no nível de infraestrutura.
Recursos para começar
- Documentação do AgentCore Payments
- Keynote do AgentCore Payments no FSI Symposium
- Repositório de exemplos do AgentCore Payments — tutoriais e padrões de casos de uso completos
- Documentação do Amazon Bedrock AgentCore — para explorar Gateway, Memory, Tools e Runtime
- Preços do AgentCore
O AgentCore Payments está disponível em preview. Após os testes, lembre-se de limpar os recursos criados para evitar cobranças desnecessárias.
Fonte
Technical deep dive: AgentCore payments and innovation in agentic commerce (https://aws.amazon.com/blogs/machine-learning/technical-deep-dive-agentcore-payments-and-innovation-in-agentic-commerce/)
Leave a Reply