Implementing Trusted AI Transactions: A Guide to Intent Contracts and Single-Use Tokens in Agentic Commerce

Introduction

As artificial intelligence agents become capable of shopping and making payments on behalf of users, ensuring trust, security, and accountability becomes paramount. American Express (Amex) has pioneered a system—the Agentic Commerce Experiences (ACE) developer kit—that leverages intent contracts and single-use tokens to enforce AI transactions within its closed-loop payment network. This guide walks you through the key steps to implement a similar agentic commerce stack, focusing on how to validate agent intentions and secure transactions using these mechanisms. While the system is not fully transparent, it represents a critical step toward building the trust needed for widespread agentic commerce adoption.

What You Need

• Understanding of agentic commerce – Familiarity with how AI agents perform tasks like shopping on behalf of users.
• Payment network infrastructure – A closed-loop system (like Amex’s own network) where you act as both card issuer and payment network, or an equivalent intermediary that can control transaction flow.
• Intent contracts framework – A mechanism to capture and verify the agent’s original shopping goal (e.g., buy a specific item at a given price).
• Single-use token generation – Capability to generate unique, one-time tokens that authorize a specific transaction and expire immediately after use.
• Agent identity verification system – Tools to authenticate the agent’s identity and ensure it is authorized to act on behalf of the user.
• Compliance and audit tools – Systems to log transactions and allow post-hoc validation, even if the validation process is not entirely transparent.

Step-by-Step Guide

Step 1: Define and Capture the Agent’s Intent

The foundation of a trusted agentic transaction is a clear intent contract. This contract outlines what the agent is permitted to do—for example, “purchase a flight ticket under $500 for a specific date.” As Amex does, encode this intent into a machine-readable format that can be verified later. Use a semantic evaluation layer to match the final shopping cart against the original intent. This ensures the agent does not deviate from its instructions.

Step 2: Authenticate the Agent’s Identity

Before allowing any transaction, verify that the agent is genuine and authorized. Use cryptographic signatures or digital certificates issued by a trusted authority. Amex’s ACE kit integrates identity verification at the payment layer, ensuring only approved agents can initiate purchases. Implement a multi-factor authentication check: agent identity, user authorization, and merchant validation.

Step 3: Issue a Single-Use Token for the Transaction

Once intent and identity are confirmed, generate a single-use token that is linked to the specific transaction details (amount, merchant, item). This token acts as a one-time authorization code. It prevents replay attacks and ensures that even if an agent is compromised, the token cannot be reused. Amex’s approach uses such tokens to enforce transaction control within its network. The token should encapsulate the intent contract hash for later validation.

Step 4: Execute the Transaction in a Closed-Loop Network

Route the transaction through a controlled environment where you have full visibility—such as Amex’s own payment network. This closed-loop system allows you to validate the token, check the merchant’s credentials, and confirm that the transaction matches the original intent contract. Because you act as both issuer and network, you can enforce rules at every step. This reduces the risk of fraud and chargebacks.

Step 5: Validate the Transaction Against Intent

After the agent submits the shopping cart, compare the final items and price against the original intent contract. Use a mix of deterministic checks (e.g., price limits) and flexible semantic evaluation (e.g., whether the item name matches). Amex claims this validation step, though the exact algorithm remains a black box. For your implementation, ensure that the validation logic is auditable—even if not fully public—to build trust with merchants and users.

Step 6: Enforce Post-Transaction Accountability

Log every transaction with the intent contract, single-use token, and outcome. Provide merchants and users with a verification receipt that includes a cryptographic proof of validation. This creates an immutable audit trail. Amex’s system still has opaque elements, but you can increase transparency by opening the validation process to third-party auditors. This step is crucial for gaining the trust needed for agentic commerce to scale.

Tips for Success

• Embrace transparency to counter black-box concerns – While Amex keeps some validation details secret, consider publishing a high-level overview of your validation logic to reassure stakeholders. The industry needs more openness to achieve widespread adoption.
• Plan for interoperability – Amex participates in Google’s Agent Pay Protocol (AP2) to ensure compatibility with other systems. Design your tokens and contracts to be usable across different networks in the future.
• Test with realistic agent scenarios – Simulate rogue agents attempting to overspend or modify orders. Ensure your intent contracts and single-use tokens can handle edge cases like partial refunds or multi-item carts.
• Prioritize user control – Allow users to set spending limits and approve high-value transactions interactively, even if the agent initiates the process. This builds user confidence.
• Audit continuously – Regularly review logs to detect anomalies. The closed-loop nature gives you unique oversight, but only if you actively monitor the data.

By following these steps, you can build an agentic commerce stack that enforces trust through intent contracts and single-use tokens—mirroring the innovative work of American Express while addressing the transparency gaps that still challenge the field.