That story captures something important happening across the web right now. Discovery is being restructured. The customer journey increasingly runs through AI systems, and those systems have their own requirements for who they can see and recommend.

Burns got lucky: his content made it into the training data, and the model knew he existed. But many businesses aren’t so fortunate. And the unlucky ones often don’t even know they’re invisible.

The Shift (Almost) Nobody Prepared For

For twenty years, the web security playbook has been straightforward: humans good, bots bad. Build walls. Check CAPTCHAs. Rate-limit aggressively. Block anything that doesn’t look like a person clicking around.

That made sense when “bot” meant scrapers, spammers, and credential stuffers. But the category has fractured. Today, automated traffic includes:

Training crawlers harvesting content for AI model development (Common Crawl, GPTBot, ClaudeBot). These are extractive and periodic with no user behind them, just dataset assembly.

Retrieval bots fetching real-time information to augment AI responses (Perplexity, ChatGPT with browsing). These surface your content in AI-synthesized answers.

Transaction agents acting on direct behalf of users to accomplish specific goals: book a flight, compare insurance quotes, place an order, schedule an appointment.

That third category is the one that should keep business leaders up at night, not because it’s dangerous, but because it’s valuable, and we’re systematically blocking it.

When a user tells their AI assistant “find me a hotel in Lisbon under €200 with good reviews and book it,” that agent is a customer. It has intent, a task, and (via the user) a credit card. If your site can’t accommodate it - or worse, actively blocks it - you’ve lost a sale to a competitor whose infrastructure was ready.

Consider Children’s Hospital of Los Angeles, one of the top pediatric cancer centers in the United States. It’s effectively invisible to AI assistants. When parents ask Gemini or ChatGPT where to take a child with leukemia in LA, CHLA doesn’t appear, not because the hospital opted out, but because their CDN’s default settings block AI crawlers. Families may be unable to find potentially life-saving care because of a configuration choice the hospital may not even know was made.

That’s the current state: valuable, legitimate discovery and transaction pathways being severed by infrastructure designed for a different threat model.

Three Properties Your Web Presence Now Needs

I’ve been working on identity and authorization infrastructure for AI agents with colleagues across the industry, including co-authoring a recent whitepaper on the topic. We keep returning to the same framework. For your web presence to function in an agent-mediated world, it needs three properties:

Accessible: The agent can actually reach your content and services. Not blocked by CDN defaults, overzealous bot detection, or blanket crawler bans.

Legible: The agent can understand what it finds. Structured data, semantic markup, machine-readable formats. Not just pretty HTML that requires a human eye to interpret.

Actionable: The agent can do something. Complete a transaction, submit an inquiry, access a service. Not just read, but also act.

If any layer is missing, whether accessibility, legibility, or actionability, your web presence is invisible or inert to the fastest-growing discovery and transaction channel emerging today. Even if your site is live but not properly indexed for agent retrieval or omitted from the training corpus, you may still be invisible.

Most organizations have focused their AI strategy on the first category, namely training data accessibility, being “in the model.” That matters. But it’s table stakes. The real opportunity (and the real risk of missing out) is in the third category: enabling legitimate agents to transact on behalf of real users.

The Verification Problem (And Why It’s Being Solved)

The obvious objection: “How do I tell a legitimate agent from a malicious bot? They look the same at the firewall.”

Fair point. Today, they often do look the same. User-agent strings are trivially spoofable. Traffic patterns can be mimicked. This is a real problem.

But it’s being actively solved. The IETF is developing Web Bot Auth, a protocol that allows agents to cryptographically prove their identity within HTTP requests, essentially a passport for responsible agents. Major players like Cloudflare and Vercel are involved in the effort. AWS Bedrock AgentCore already supports Web Bot Auth to reduce CAPTCHAs when its agents browse protected sites. This isn’t speculative; it’s shipping.

On the authorization side, OAuth 2.1 extensions are being developed to support explicit delegated authority, a formal “on-behalf-of” flow where the agent’s access token contains two distinct identifiers: the user who granted permission and the agent performing the action. This is critically different from impersonation. It creates a clear, auditable link: you can see both who authorized the action and what performed it.

The infrastructure is coming. The question is whether you’ll be ready for it, or scrambling to catch up while your competitors capture the agent-mediated market.

What “Agent Optimization” Actually Means

We’ve spent two decades optimizing for search engines. Keywords, backlinks, page speed, mobile responsiveness, the whole SEO apparatus. Now a new optimization target is emerging: AI agents.

Agent Optimization means:

• Structured data that agents can parse: Schema.org markup, JSON-LD, clear semantic HTML. If an agent can’t extract your pricing, availability, or booking endpoint programmatically, you don’t exist to it.

• APIs and action endpoints: Not just content to read, but services to invoke. Can an agent place an order? Submit an inquiry? Check inventory? If the only path is clicking through a JavaScript-heavy checkout flow, you’re invisible to agent-mediated commerce.

• Authentication infrastructure that distinguishes agent types: Allow legitimate agents through while maintaining security. This requires moving beyond binary “human or bot” detection to nuanced policies based on verified identity and delegated scope.

• Consent and governance frameworks: When an agent accesses your systems on behalf of a user, what are the terms? What data can it retrieve? What actions can it perform? Clear policies, machine-readable where possible.

The organizations that build this infrastructure now will have a significant advantage as agent-mediated interaction becomes mainstream. Those that don’t will find themselves optimized out of an increasingly important channel.

The Stakes Are Higher Than You Think

Scenario 1: E-commerce. A user asks their AI assistant to “order more of that coffee I liked from last month.” The agent needs to access the user’s order history (with permission), find the product, check availability, and complete a purchase. If your site can’t support this flow, the agent will find a competitor who sells similar coffee and can support it. You didn’t lose a customer to a better product. You lost them to better infrastructure.

Scenario 2: Professional services. A business user tells their agent to “schedule a consultation with a commercial real estate attorney in Denver for next week.” The agent needs to find appropriate providers, check availability, and book an appointment. If your law firm’s website is a brochure with a “Contact Us” form and no structured data, the agent can’t engage. You don’t get the lead.

Scenario 3: B2B procurement. A procurement agent is tasked with “find three suppliers for industrial adhesives that meet our specs and request quotes.” The agent needs to query product databases, compare specifications, and initiate RFQ processes. If your supplier portal requires human navigation through nested menus, you’re not in the consideration set.

In each case, the failure isn’t about the quality of your product or service. It’s about the accessibility, legibility, and actionability of your web presence to AI agents acting as legitimate proxies for potential customers.

What You Should Do Now

1. Audit your current accessibility. Are AI crawlers being blocked by your CDN? Check your Cloudflare settings, your robots.txt, your rate-limiting rules. Tools like CanAISeeIt can analyze which known AI bots can access your site and how you’re showing up in AI-generated citations.

2. Assess your legibility. Can a machine parse your key information? Do you have structured data for products, services, pricing, availability, locations? Run your pages through schema validators. If an agent can’t extract the basics, you have work to do.

3. Evaluate your actionability. What can an agent actually do on your site? If the answer is “read content,” you’re only halfway there. Consider APIs, booking integrations, programmatic inquiry endpoints. What would it take for an agent to complete a transaction?

4. Develop agent access policies. Not all automated access is equal. Define what types of agents you want to support, under what conditions, with what verification. This is a policy decision, not just a technical one.

5. Watch the standards landscape. Web Bot Auth, OAuth for AI agents, MCP (Model Context Protocol), A2A (Agent-to-Agent protocol, and the related Agent Payment Protocol), these are developing rapidly. You don’t need to implement everything today, but you should understand what’s coming. To get started, check out this webinar I hosted last week discussing the emerging AI Agents standards race, with senior representatives from Visa, Stripe, Skyfire, and Consumer Reports.

6. Reframe the conversation internally. If your security team’s mandate is “block bots,” you have a framing problem. The mandate should be “enable legitimate access while blocking malicious actors.” Those are different objectives with different implementations.

7. Think in two layers: live retrieval and foundational memory. Your site must both be live-index-ready and training-corpus-visible.

For purposes of being open for business by AI Agents, your current site needs to be discoverable and indexable now by whatever live web feeds support retrieval-augmented generation (RAG) and AI-agent search. That means ensuring your content is live, indexed, updated, structured, and accessible.

But there’s a second, equally strategic layer: ensuring your content is included in the training data of large language models. Being in the training corpus doesn’t guarantee retrieval, but being absent from it dramatically lowers your odds of ever being surfaced.

Treat properly identified AI crawlers (like Common Crawl’s CCBot) as strategic stakeholders, not threats. Allow appropriate access. Mark your content as machine-readable. Opt in rather than blocking by default.

The formula: live indexing + training corpus inclusion = dual-path visibility in the era of agent-mediated discovery.

Practical Standards: What’s Working Now

The strategic framework matters, but so does implementation. Here’s what’s emerging as practical infrastructure for agent-readiness.

For Accessibility

robots.txt is getting AI-specific extensions. The Robots Exclusion Protocol (now RFC 9309) remains the baseline, but an IETF draft proposes syntax to distinguish AI training from inference, letting you permit RAG-style answers while blocking training ingestion, or vice versa. AI crawlers like GPTBot, ClaudeBot, and Google-Extended already check robots.txt.

Cloudflare now blocks AI crawlers by default for new customers. If you’re on Cloudflare, check your settings. Their AI Crawl Control features let you make nuanced decisions. Be intentional about your access policy rather than accepting defaults that may be making you invisible.

For Legibility

llms.txt is the clearest practical step you can take today. It’s a simple Markdown file at /llms.txt that provides a curated map of your most important content for AI systems: key docs, FAQs, policies, pricing, with links to clean Markdown versions where possible.

Here’s what a basic llms.txt file looks like:

# YourCompany.com

> Brief description of what your company does and what this site offers.

## Key Pages
- [Product Overview](/docs/product-overview.md): What we offer and how it works
- [Pricing](/pricing.md): Current plans and pricing
- [API Documentation](/docs/api.md): Full API reference for developers

## Support & Policies
- [FAQ](/faq.md): Common questions answered
- [Terms of Service](/legal/terms.md)
- [Contact](/contact.md): How to reach us

Adoption is growing. Directories like llmstxt.site and directory.llmstxt.cloud track hundreds of implementations. GitBook has published tutorials. CMS platforms are building auto-generation features.

I’ve implemented llms.txt on several of my own sites, and I plan to expand this significantly, adding Markdown versions of key content and keeping the files current. It’s one of the most concrete things you can do right now.

Structured data (JSON-LD / Schema.org) remains non-negotiable. Products, organizations, FAQs, events, locations, schema markup gives agents a machine-readable knowledge graph of your key entities.

For Actionability

Expose your services as tools, not just pages. If you have APIs, document them with OpenAPI/Swagger specs. Agents can ingest these and treat your API as a callable tool, placing orders, checking inventory, submitting inquiries, rather than screen-scraping checkout flows.

Consider MCP (Model Context Protocol). If you want agents to act on your services, exposing an MCP-compatible endpoint is increasingly the path. Your booking system, inventory lookup, or quote generator can become a tool that agents call directly, with proper authentication and scoping.

The /ask endpoint pattern is emerging. A Microsoft-Cloudflare collaboration is pushing a model where sites expose conversational interfaces: /ask for human Q&A, /mcp for agent tool calls, both backed by the same retrieval infrastructure. Forward-looking, but being built now.

For Diagnostics

Check where you stand. CanAISeeIt scores sites on AI visibility, crawler accessibility, and protocol compliance. Your server logs show which AI user-agents are visiting. If you’re not seeing CCBot, GPTBot, or ClaudeBot, find out why.

The Web Is Being Rebuilt. Quietly.

What I’m describing isn’t a distant future. It’s happening now, mostly invisibly. Every major AI lab is building agent capabilities. Every major identity vendor is developing agent-specific IAM. Standards bodies are actively drafting protocols for agent authentication, authorization, and payment.

The shift from search engine optimization to AI optimization is directionally right as a framing, but it undersells the magnitude. SEO was about being found. Agent optimization is about being found and being usable by non-human actors who represent real human intent.

The web was built for human browsers, then retrofitted for search engine crawlers. Now it’s being rebuilt again, this time for AI agents that act as legitimate proxies for human users.

The organizations that recognize this shift and prepare for it will capture a new channel of demand. Those that don’t will watch that demand flow to competitors who were paying attention.

Your next customer might arrive via an AI agent. The question is whether you’ll recognize them as a customer, or lock them out as a bot.

If you’re investing in, building, or deploying AI agents, there’s a foundational problem you need to understand: identity, authentication, and authorization for autonomous agents is fundamentally different from traditional software, and many current implementations are getting it wrong.

Today, I’m excited to share a comprehensive whitepaper I co-authored for the OpenID Foundation: “Identity Management for Agentic AI: The New Frontier of Authorization, Authentication, and Security for an AI Agent World.”

Why This Matters Now

As AI agents rapidly move from proof-of-concept to pilot and now to production, they’re creating urgent security and accountability challenges:

• User impersonation is masking accountability. Most agents today act indistinguishably from their users, creating dangerous gaps in audit trails and accountability when things go wrong.

• Consent fatigue is inevitable. As agents proliferate, users will face thousands of authorization requests, leading to reflexive approval and security risks.

• Recursive delegation is uncharted territory. When agents spawn sub-agents or delegate tasks across organizational boundaries, we lack clear mechanisms for scope attenuation and attributable transitive trust.

• Cross-domain operations break current models. OAuth 2.1 works well within anchored trust domains, but agents operating more fluidly across organizational boundaries need something more robust.

What’s Already Working (and What Isn’t)

The good news: we’re not starting from scratch. Current OAuth 2.1 frameworks, when properly implemented with protocols like MCP (Model Context Protocol), provide a starting point for enterprise agents accessing internal tools within a single trust domain.

The challenge: this only solves the simplest use cases. The moment agents need greater autonomy, asynchronous execution, or cross-domain delegation, existing patterns reveal significant gaps. We identify several issues, options, and future opportunities in the whitepaper that I hope will provide a sound approach supporting everyone seeking to span that gap!

A Huge Thanks to the Team

I want to especially thank Tobin South for his incredible, energetic leadership as the primary author and editor who wrangled this entire effort together. His vision and persistence made this comprehensive work possible. I’m also thrilled that the Stanford & Consumer Reports Loyal Agents Initiative (where both Tobin and I are active) was able to collaborate on this project. This cross-institutional collaboration reflects the urgency and importance of getting agent identity right, especially for ensuring AI agents are safe and effective for consumers to use and rely upon, particularly when conducting e-commerce transactions and making binding commitments on behalf of users.

What’s in the Paper

The whitepaper provides both immediate, practical guidance and a strategic roadmap:

• Section 2 outlines current best practices using existing standards (OAuth 2.1, SCIM, SSO, CIBA) for today’s agent implementations

• Section 3 tackles future challenges: delegated authority models, recursive delegation, scope attenuation, scalable consent mechanisms, and the economic layer (payments and financial transactions)

• Real-world use cases demonstrating where traditional IAM fails and what’s needed for high-velocity, asynchronous, and cross-domain agent operations

What’s Coming Next

This whitepaper is just the beginning of a deeper exploration I’ll be sharing:

Agent Protocols: I’ve already started with my recent post on Agent Payments Protocol (AP2) last month, with more protocol deep-dives to follow.

Legal Dimensions: Building on my previous work on AI agents conducting transactions, UETA and LLM agents, and recent agent legal frameworks, I’ll be diving deeper into the legal infrastructure needed for increasingly autonomous agent transactions.

Evals for AI Agents: Following up on my initial exploration beyond AI benchmarks, I’ll be sharing frameworks for properly evaluating agent capabilities, safety, and reliability.

High-Value Use Cases: Identifying and unpacking the specific scenarios where proper identity capabilities unlock significant new value and reduces risk.

Agents Accelerating Research and Science: Exploring how properly governed agents can transform scientific discovery and research methodologies to spur innovation.

Looking Forward with Clear Eyes

I’m genuinely optimistic about the transformative potential of AI agents to augment human capabilities, empower consumers, and create new forms of value. The technical foundations exist, brilliant people across industry and academia are collaborating, and momentum is building toward interoperable standards.

But let’s be clear: many hard challenges remain. We need to move from impersonation to true delegation, build scalable governance mechanisms that respect user autonomy, create robust cross-domain trust fabrics, and ensure agents serve their users’ interests loyally. The work of building safe, trustworthy, and effective agent systems is just beginning.

For those investing in AI agents: ignoring these identity and authorization challenges doesn’t make them go away, it just means you’ll hit them unexpectedly in production. This whitepaper aims to be your starting point for understanding what’s required and building responsibly from the ground up.

Read the full paper: Identity Management for Agentic AI

Let’s build the future of autonomous agents together, securely, responsibly, accountably, and successfully!

Yesterday, Google announced the Agent Payments Protocol (AP2), a new, open standard designed to solve the fundamental question of trust in AI-driven payments in commerce. Today’s payment systems assume a human is clicking "buy." AP2 creates the framework for a world where autonomous AI agents can securely and verifiably transact on behalf of users and businesses.

It achieves this by introducing a system of Verifiable Credentials called "Mandates," which serve as cryptographically signed, auditable proof of authority and intent for every transaction. AP2 is not a new payment network; it is a data protocol that layers on top of the Agent2Agent (A2A) protocol, ensuring it can work with any payment method—from credit cards to real-time bank transfers. I previously wrote about A2A here in the" Agents Talking to Agents (A2A): Reshaping the Marketplace and Your Power" section.

Deep Dive: The Intent Mandate - The "Digital Power of Attorney"

The Intent Mandate is the most critical innovation for business and legal purposes. It is the core instrument of delegation for any transaction where the user is not present to give final approval (a "Human-Not-Present" scenario).

• What it is: A legally and technically significant "delegation contract" that a user signs to grant an AI agent specific, constrained purchasing authority. It formally translates a user's goal (e.g., "Buy this item if the price drops below $100") into a set of enforceable rules.

• Legal Significance: It serves as non-repudiable proof that the user authorized the agent's action, providing a powerful evidentiary anchor for assigning liability and resolving disputes. It answers the question: "Who told the agent to do that?"

• Business Significance: It unlocks automated and conditional commerce. Businesses can empower agents to execute procurement strategies, manage subscriptions, or react to market opportunities autonomously, all while operating within pre-approved boundaries.

Deep Dive: The Other Mandates - The "Evidentiary Chain"

Two other mandates complete the transaction's auditable trail:

• The Cart Mandate: This is the "notarized purchase order" for Human-Present transactions. The merchant generates it to lock in the final terms (items, price, shipping), and the user signs it on a trusted device surface. It provides definitive proof of what was agreed upon at the moment of purchase.

• The Payment Mandate: This is the "transaction manifest" sent to the payment network (e.g., Visa, Mastercard). Its primary purpose is to signal that an AI agent was involved and whether a human was present. This allows issuers and networks to apply appropriate risk models and provides critical data for the financial ecosystem.

Examples and Use Cases for Consumers and Businesses

AP2 creates powerful new capabilities for both B2C and B2B commerce by providing a secure framework for delegation.

Consumer Use Cases: Convenience and Automation with Guardrails

Deal Hunting
A user wants to buy a specific gaming console but only if it drops below $400 before the holidays.
The user signs an Intent Mandate with the SKU, a price ceiling of $400, and an expiry date. The agent monitors prices and executes the purchase automatically when the condition is met.

Time-Sensitive Purchases
A user wants to buy tickets for a popular concert the moment they go on sale.
The user signs an Intent Mandate specifying the event, a seating preference (e.g., "front section"), and a maximum budget. The agent is pre-authorized to act instantly.

Complex Travel Planning
A user asks their agent: "Book me a round-trip flight and a 4-star hotel in London for the first week of December, total budget $1500."
The agent holds a signed Intent Mandate. It interacts with airline and hotel agents simultaneously. Once it finds a combination that fits the budget and criteria, it can execute both bookings.

Subscription Management
"Renew my streaming subscription, but only if the price doesn't increase by more than 10%."
An Intent Mandate governs the renewal. The agent verifies the price each cycle and either proceeds or pauses for user instruction if the price hike exceeds the limit.

On-the-Go Purchases
While driving, a user tells their voice assistant to order and pay for coffee from a nearby shop.
This is a Human-Present flow. The coffee shop's agent returns a Cart Mandate. The user provides a quick biometric approval on their phone or car's infotainment screen, signing the Cart Mandate to complete the payment.

Business Use Cases: Auditable Automation and Control

AP2 is transformative for B2B transactions, providing the auditable trail necessary for corporate governance and financial controls.

Automated Procurement
A procurement manager authorizes an agent to re-order lab supplies from approved vendors whenever inventory drops below a threshold, provided the price per unit has not increased by more than 5% since the last order.
The manager signs an Intent Mandate that is cryptographically linked to their corporate identity. The mandate specifies the SKUs, the approved vendor list, and the 5% price variance rule. Every purchase is auditable and tied back to this specific, standing authorization.

Contractor & Field Operations
A construction firm authorizes a site foreman's agent to purchase up to $5,000 in materials from Home Depot or Lowe's for a specific project.
The project manager issues a time-bound Intent Mandate linked to the foreman's identity and the project's budget code. The mandate limits the merchant category and total spend. The trail proves the expense was authorized for that project, streamlining reconciliation.

Dynamic Cloud Resource Scaling
An IT department authorizes an agent to scale cloud computing resources based on real-time demand, with a hard budget cap of $10,000/month.
The CIO signs an Intent Mandate allowing the agent to interact with the cloud provider's agent. The mandate contains the budget cap and service-level rules. This prevents runaway costs while enabling automation.

Travel & Expense Management
An employee uses their corporate travel agent to book a trip. The company's policy (e.g., "economy class only, hotel under $300/night") is encoded into the agent's instructions.
The employee's request generates an Intent Mandate that also reflects corporate policy constraints. The auditable trail shows the booking was compliant, simplifying expense reporting. The employee's identity is tied to the authorization.

Structuring the Corresponding Legal Framework: The Letter of Authorization

It stands to reason that the technical IntentMandate must be backed by a formal legal agreement, a Letter of Authorization (LoA) of some kind, between the User (or User Organization) and the AI Agent Provider, unless the user is operating the AI Agent infrastructure themself. This agreement defines the legal rights and responsibilities of each party. Below are three potential models for structuring this relationship.

I am focused primarily on option 1 below as a conceptual approach to such authorization, and also actively developing other options given this early stage of implementation.

OPTION 1: The Principal-Agent Model (User as Authorizer, Provider as Enforcer)

This model establishes a classic principal-agent relationship where the user provides explicit instructions and the provider must execute them faithfully.

• User Responsibilities: The user is the source of authority and is responsible for clearly articulating their intent. Their primary responsibilities include:

  • Delegating Authority: The user initiates the entire process by appointing the provider to operate the agent on their behalf, often memorialized through an agreement like a DocuSign.

  • Defining Authorization (The "What"): The user must specify exactly what the agent is allowed to do. This includes defining the scope (check_balance), the target resource (account GH-1234), and any constraints (data_minimization, purpose_binding).

  • Defining Autonomy (The "How"): The user sets the rules for how the agent carries out its tasks, such as when it can act silently ("auto-ok") versus when it must get explicit, real-time confirmation ("always-ask").

  • Assuming Consequences: The user is ultimately responsible for the consequences of the agent's properly authorized actions.

• AI Agent Provider Responsibilities 🤖: The AI Agent Provider is responsible for the technical and operational infrastructure that brings the user's instructions to life safely and reliably. Their key responsibilities are:

  • Operating Secure Infrastructure: The provider must maintain the underlying service, network, and security controls to run the agent reliably.

  • Enforcing User Grants: The provider's core duty is to honor and strictly enforce the authorization and autonomy rules defined by the user. The agent must not exceed its granted authority.

  • Managing Authentication & Credentials: The provider is responsible for presenting the correct credentials (e.g., short-lived, purpose-bound tokens) to third parties like the bank.

  • Enforcing Revocation: When a user revokes permission, the provider must ensure that access is terminated promptly, meeting the stated Service-Level Objective (SLO) of ≤60 seconds.

  • Providing Evidence: The provider must generate and deliver auditable proof of the agent's actions, such as signed receipts, to create a clear evidence trail for all parties.

  • Upholding a Duty of Care: A central point of the exercise is to determine the nature of the provider's duty—whether they are simply a neutral "tool provider" or hold a higher, fiduciary-like "duty of loyalty" to act in the user's best interest and avoid conflicts.

OPTION 2: The Managed Platform Model (Template-Based Delegation)

This model positions the AI Agent Provider as a platform offering pre-defined, vetted "skills" or "playbooks." The user's role is to configure and authorize these templates rather than defining instructions from scratch. This is analogous to using a marketplace of trusted apps with pre-set permissions.

• User Responsibilities:

  • Selecting and Configuring Templates: The user browses a library of pre-built "Mandate Templates" (e.g., "Auto-Book Travel," "Monitor and Buy Stock") and configures key parameters (e.g., budget, dates, vendors).

  • Authorizing the Configured Template: The user signs the finalized template, which becomes the active Intent Mandate.

  • Monitoring and Revoking: The user is responsible for monitoring the agent's actions against the template's goals and revoking authorization if needed.

• AI Agent Provider Responsibilities 🤖:

  • Curating a Safe and Secure Template Library: The provider is responsible for the safety, security, and clarity of the templates it offers. This includes vetting them for common exploits or ambiguous language.

  • Strict Parameter Enforcement: The provider must ensure the agent operates strictly within the user-configured parameters of the chosen template.

  • Transparency and Disclosure: The provider must clearly disclose the capabilities and limitations of each template.

  • Liability for Template Flaws: The provider may assume a greater share of liability if a loss occurs due to a flaw or vulnerability in the template itself, rather than user error in configuration.

OPTION 3: The Certified Fiduciary Model (Role-Based Trust & Duty of Care)

This model envisions an ecosystem where AI agents can be independently certified for specific, high-stakes roles (e.g., "Certified Corporate Procurement Agent," "Certified Financial Advisor Agent"). The legal framework is tied to the agent's certified capabilities and implies a higher standard of care.

• User/User Organization Responsibilities:

  • Due Diligence in Agent Selection: The user is responsible for selecting an agent with the appropriate certification for the task at hand. Using a non-certified agent for a high-stakes financial task would place more liability on the user.

  • Providing Clear Objectives: The user must still provide the high-level goals and constraints for the Intent Mandate.

  • Cooperation in Audits: The user must cooperate in providing information if a certified agent's actions are audited.

• AI Agent Provider Responsibilities 🤖:

  • Achieving and Maintaining Certification: The provider must meet the rigorous technical, security, and ethical standards required by a third-party certifying body.

  • Upholding a Fiduciary Duty: For certified financial roles, the agent must legally and technically operate under a fiduciary duty, meaning it must act in the user's absolute best financial interest, avoiding conflicts of interest (e.g., it cannot favor a merchant who pays a higher commission).

  • Proactive Risk Mitigation: A certified agent is expected to go beyond simple instruction-following and proactively identify and flag potential risks to the user (e.g., "Warning: This purchase is non-refundable and the merchant has a poor rating. Do you still wish to proceed?").

  • Submitting to Audits: The provider must agree to be audited by the certifying body to ensure continued compliance.

I’m working on some other potential options as well, but nothing quite ready to share yet. And as always, if you have other ideas about how this could play out, I’m all ears!

Remaining Work and Strategic Next Steps

AP2 provides the technical foundation, but significant work remains to build the business and legal ecosystems around it.

For Businesses and Consumers (as Users):

1. Develop Internal Governance and Delegation Policies: Businesses must create clear policies defining who can authorize agents, for what purposes, and under what financial limits. This includes establishing evaluations for adherence to adopted practices and policies.

2. Integrate with Procurement and ERP Systems: The true power of B2B automation will be realized when agents can read from and write to existing systems of record, like SAP or Oracle, governed by AP2 mandates.

3. User Education and Training: Both consumers and employees will need to be educated on how to safely and effectively delegate authority to AI agents, including how to craft clear, unambiguous intents.

For AI Agent Providers:

1. Build User-Friendly Mandate Creation Tools: The process of creating and signing an Intent Mandate must be simple, transparent, and secure. This is a critical UX/UI challenge.

2. Develop Legal Frameworks and LoAs: Providers must work with their legal teams to develop the "Letter of Authorization" agreements based on one of the models above, clearly defining responsibilities and liabilities.

3. Engage with the Ecosystem on Certification: For the Fiduciary Model to work, providers should begin conversations with industry bodies and regulators to define what "certification" means for different agent roles. Evals and benchmarks developed by users could be a strategic basis for some such certifications or trust marks.

For the AP2 Standard and the Intent Mandate:

1. Evolve the Intent Mandate Schema: The current v0.1 schema is designed for common commerce. Future versions will need to support more complex business logic, such as:

   • Conditional Logic: "Buy item A only if item B is also available."

   • Multi-Party Approvals: Requiring signatures from multiple individuals (e.g., a manager and finance) for high-value corporate purchases.

   • Richer Constraint Language: Moving beyond simple price ceilings to more complex rules (e.g., "quality benchmarks," "ratings and rankings," "total cost of ownership," "vendor performance scores," etc.).

2. Formalize the Cryptographic Profile: As discussed, a formal specification for the signature and verification process is the top technical priority for moving from alpha to a production-ready standard.

AP2 addresses a fundamental challenge that will only grow more pressing as AI agents become routine participants in commerce: establishing verifiable authority and accountability for autonomous transactions. While still in early stages, the protocol provides a practical framework for businesses and developers to begin experimenting with trusted agent delegation. The business, legal and technical foundations outlined here represent necessary infrastructure for scaling AI commerce effectively and responsibly. In future posts, I'll be sharing working examples and implementation patterns for those interested in testing these concepts in practice. For organizations considering how agent-mediated transactions might fit their operations, now is an appropriate time to begin exploring the possibilities.

Reach out to me directly here if you’d like to discuss opportunities to work together on these and related opportunities.

This kickoff workshop, co-presented by Stanford CodeX, MIT Computational Law Report, Stanford HAI Digital Economy Lab, and Consumer Reports Innovation Lab, began a crucial conversation about the legal dimensions and innovative applications of AI Agents.

April 8th, 2025 Inauguraal Workshop Program

Introductions

• Speaker: Dazza Greenwood

Welcome Remarks

• Speaker: Sandy Pentland

Setting the Context for AI Agents x Law

• Speaker: Dazza Greenwood

Legal Issues and Options for AI Agents Conducting Transactions

• Speaker: Diana Stern

Legal Practice and Innovating Law with AI Agents

• Speaker: Damien Riehl

Open Source Demo Example of Legal Error Handling for AI Agent

• Speaker: Andor Kesselman

Authenticated Delegation of Authority for AI Agents

• Speaker: Tobin South

You can view the session recording here and embedded above, and learn more or share your insights via this feedback form at https://computationallaw.org

Here’s a demo of the first version of my project working with the SDK from last week, presented to the OpenAI Agent team, thanks to early access with AgentOps!

My Journey from Straight Python to the OpenAI Agents SDK

Previously, I built autonomous AI agents using pure Python—a powerful but intricate process. But I found it better to do it that way than using any of the available agent frameworks. Check out my original project here. It demanded meticulous orchestration and heavy coding to handle multi-agent workflows. The OpenAI Agents SDK slashed that complexity, letting me reimagine and rebuild my project into a streamlined, modular, and far more powerful system.

Introducing "Agento": A Modular AI Planning System

My new "Agento" project showcases how the OpenAI Agents SDK can be used to turn broad goals into structured, actionable plans with iterative polish. Literally, you can start this sucker off with ANY goal or idea you can think of and it will go to work on it for you. Here’s the breakdown:

1. Criteria Generation: Iteratively identifies and select custom success metrics, grounded in full web search to ensure they are relevant and actionable.

2. Plan Generation: Crafts detailed goal-achievement strategies and a plan outline.

3. Plan Expansion and Evaluation: Expands and critiques each plan outline into a full draft.

4. Revision Identification: Spots needed improvements based on your original goal and, critically, on the success criteria.

5. Revision Implementation: Applies and tests revisions for a solid and well-aligned draft.

6. There is also a module to export your final plan as easy to read markdown (with MS Word, PDF, and other formats depending on the plan content coming soon)

Each module is independent and interchangeable, linked by standard JSON interfaces for flexibility across agent frameworks. This means you can take any module and re-create it in whatever agent framework you prefer (LangGraph, Crew, AutoGen, etc, etc) and everything will still work. It’s just JSON in and JSON out. Dive into the details and grab the starter code here.

Making Your Life Easier with a Ready-to-Go Single File

To get you started fast, I’ve packed all of the OpenAI Agent SDK code and docs into one ready-to-use file. Just add or attach it to your LLM prompts for a seamless custom-agent-building experience. Grab the total Agent SDK in one file right here!

A Deeper Dive into OpenAI Agents SDK

The OpenAI Agents SDK, a versatile open-source tool, orchestrates complex multi-agent workflows with ease. It outshines earlier frameworks like Swarm, boosting productivity and simplicity. Key features:

• Agent Configuration: Equip agents with built-in or custom tools effortlessly.

• Smart Handoffs: Delegate tasks between agents seamlessly.

• Guardrails: Enforce safety and other priorities with input/output validation.

• Tracing & Observability: Debug and optimize with clear execution insights.

Dig into the details of the new SDK at these links

• OpenAI Announcement: https://openai.com/index/new-tools-for-building-agents/

• Documentation: https://platform.openai.com/docs/guides/agents

• SDK docs: https://openai.github.io/openai-agents-python/

• GitHub repo: https://github.com/openai/openai-agents-python

• SDK walkthrough: https://x.com/OpenAIDevs/status/1899531225468969240?t=617

Try it Out!

Whether you’re building a breakthrough or simplifying daily tasks, the OpenAI Agents SDK supercharges your work. Dive into the docs, try my "Agento" example, and see how it can lift your projects to new heights. Let’s innovate together, just grab the code, start fast, and unlock endless possibilities with OpenAI’s latest gem!

In previous explorations of UETA and LLM agents, we established that the law’s broad applicability extends to modern AI-powered transactions. In this deep dive, we focus on error handling—the critical yet often neglected factor that determines both user trust and system resilience.

Have you ever been stuck in a frustrating loop with an automated system, unable to fix a simple mistake? In AI-driven commerce, every transaction intermediated by an LLM agent is a moment of truth. Section 10 of the Uniform Electronic Transactions Act (UETA) provides a clear legal framework for error correction and prevention—yet it remains largely ignored in AI-powered transactions.

Without these safeguards, your transactions may not be final—leaving businesses exposed to transaction reversals, liability disputes, and operational uncertainty. But by building in error prevention, correction, and auditability, AI agent systems can establish true finality—where transactions are legally binding, disputes are minimized, and fairness is ensured for consumers.

It’s time to bring this critical legal requirement into the light—to protect businesses from liability, give consumers trustworthy digital transactions, and ensure AI-driven commerce operates with certainty and integrity.

To get into this topic, I’ll spotlight this passage from a recent post I co-authored with Diana Stern published by Stanford CodeX:

By implementing a user interface and process flow that enables customers to review and correct transactions before they are finalized, providers not only comply with UETA but also establish a strong argument for ratification. If a customer has the opportunity to correct an error but chooses not to, they have arguably adopted the transaction as final. Moreover, this provision of UETA cannot be varied by contract, which means this rule allowing customers to reverse transactions will apply even if providers insert disclaimers or other contract terms insisting the customer holds all responsibility and liability for mistakes and errors committed by the Transactional Agent.

Given this is the law of the land in the U.S., with UETA enacted in 49 states, it is prudent to take these rules seriously. This design pattern – proactively building in error prevention and correction mechanisms – is therefore not just about legal compliance; it’s a fundamental aspect of responsible Transactional Agent development that helps define the point of finality and clarify the allocation of risk. But it’s also just good practice and a fair rule. By implementing these mechanisms, providers can significantly reduce their risk of liability. By embracing error avoidance and corrections protocols in the design and deployment of Transactional Agents, perhaps the most valuable benefit will not be avoiding liability for reversed transactions but legitimately earning Transactional Agent customers’ trust and reliance upon this new technology and way of doing business.

With that context, let’s dive in!

Why Error Handling Matters Now More Than Ever

For business and technology leaders, error handling might seem like a technical detail best left to development teams. For legal and risk management professionals, it may appear as just another compliance checkbox. Both perspectives, however, overlook the larger strategic importance of robust error handling.

Every transaction your LLM agent handles is a moment of truth. When transactions proceed flawlessly, interactions feel seamless. But when errors occur, the system faces a critical choice:

- Leave users stranded: Failing to offer correction options can trap users in a rigid, automated process.

- Empower users: Providing clear, transparent paths for error correction builds trust and long-term loyalty.

This distinction not only affects user satisfaction but also lays the groundwork for sustainable, scalable automated commerce.

The Business Case for Robust Error Handling

Implementing strong error handling capabilities is an investment—not merely an added cost. Consider the following benefits:

Beyond these immediate advantages, robust error handling lays the foundation for the future of automated commerce.

UETA Section 10: A Framework for Fair Automation

UETA’s Section 10 provides a forward-thinking framework for error handling in electronic transactions. Its key principles include:

1. User Agency: Systems must offer meaningful opportunities for error prevention and correction.

2. Mutual Responsibility: Both parties should adhere to agreed-upon security procedures.

3. Clear Communication: Prompt notifications and clear procedures are essential when errors occur.

4. Fair Resolution: The system must ensure that users have a path to avoid being bound by erroneous transactions.

These principles serve not only as legal requirements but also as best practices that reinforce user trust and system reliability.

Implementation Requirements: Bridging Legal Theory and Technical Practice

For both business leaders and legal teams, meeting UETA compliance while optimizing user experience demands that error handling systems deliver on two fronts: legal integrity and technical robustness. Achieving this balance requires that your LLM-based system be designed around four core capabilities:

Here are the four points in narrative form, combining the business and legal/risk values for each capability:

• Error Prevention serves dual purposes: it reduces support costs and drives higher user satisfaction on the business side, while proactively mitigating risks from a legal perspective. This capability helps organizations stay ahead of potential issues before they materialize.

• Error Detection capabilities enable quick identification and resolution of issues, supporting operational efficiency. From a legal standpoint, this capability ensures proper evidence preservation and enables ongoing compliance monitoring, providing organizations with real-time insights into their regulatory adherence.

• Error Correction enhances the user experience and helps retain customers by smoothly resolving issues when they occur. Legally, it provides clear demonstration of UETA (Uniform Electronic Transactions Act) compliance, showing that the organization maintains appropriate error handling procedures.

• Record Keeping delivers valuable business intelligence and supports process improvement initiatives by maintaining comprehensive transaction data. On the legal side, it ensures audit readiness and provides robust documentation for dispute resolution, helping organizations maintain defensible positions in potential conflicts.

Practical UETA Compliance Strategies for LLM Agents

To translate these capabilities into a compliant and user-friendly system, consider the following actionable strategies:

• Establish Clear Security Procedures:
  Design your system with automated prompts or multi-factor confirmations for high-value or unusual transactions. For example, if an order exceeds a certain threshold, trigger an additional verification step. Document these procedures in your terms of service as evidence of adherence to UETA §10(1).

• Provide a Human-in-the-Loop or Escalation Path:
  Even though LLM agents operate autonomously, allow for an optional human review on transactions deemed high-risk. This extra layer ensures users have the opportunity to detect and correct errors—fulfilling UETA §10(2).

• Implement Transparent, Actionable Prompts:
  For every critical step, display clear, unambiguous prompts. For example, before finalizing a high-value transaction, show:
  “You are about to purchase 100 self-heating mugs. Confirm or Cancel?”
  This confirms that users have a genuine opportunity to reconsider their actions.

• Maintain Comprehensive Audit Trails:
  Record all user interactions and system responses—including timestamps, unique identifiers, and the exact text of prompts. This not only supports attribution under UETA §9 but also provides critical evidence during dispute resolution.

• Highlight Error-Correction Procedures in Your Terms:
  While UETA does not allow for waivers of mandatory error correction rights, you can clearly outline the process for reporting and remedying errors. For example:
  “If you notice an unintended transaction, please contact us at [Contact Info] within 48 hours. We will investigate and provide instructions for returning goods or funds.”

• Stay Vigilant for Regulatory Changes:
  Build a modular system that can adapt quickly to evolving legal and regulatory standards. This future-proofs your error handling architecture against potential AI-specific guidelines or enhanced transparency requirements.

Building Error Prevention into LLM Agent Systems

Error prevention is about striking the right balance—ensuring that safeguards are strong enough to prevent mistakes without impeding efficiency. A robust prevention strategy operates on three levels:

The Three Layers of Error Prevention

Pre-Transaction Validation

Pre-transaction validation is the first line of defense. This step ensures that the data input into the system is accurate and that the transaction parameters are valid. Key capabilities include:

• Input validation with clear user feedback

• Identity and authorization verification

• Parameter consistency checks

• Contextual consistency assessments

UETA Compliance Note:
UETA Section 10(2) requires that electronic agents offer a genuine opportunity to prevent or correct errors. Robust pre-transaction validation is your first opportunity to satisfy this requirement.

Contextual Analysis

Contextual analysis involves verifying the transaction’s context to ensure it reflects the user’s true intent. For example, consider factors such as: - Transaction timing and sequence
- User history and behavioral patterns
- Environmental or situational factors (e.g., a purchase attempt at an unusual time)
- Cross-transaction dependencies

Example:
If a user typically makes purchases during business hours, a transaction attempted at 3 a.m. might be flagged as unusual. This not only protects the user from unintended transactions but also reinforces that the system is capturing the true intent—an essential element in meeting UETA requirements.

Progressive Confirmation

As transaction complexity increases, so does the need for confirmation. The system should adjust its verification process based on the transaction’s risk level:

This tiered approach ensures that: - Low-risk transactions proceed efficiently. - Higher-risk transactions receive additional scrutiny. - A comprehensive audit trail is maintained for all confirmations.

Error Detection: When Prevention Isn’t Enough

Despite robust prevention measures, errors may still occur. Rapid and accurate detection is essential for mitigating negative impacts.

Detection Mechanisms

Your system should incorporate multiple detection methods to catch errors as soon as they occur:

• Rule-Based Detection: Utilizes predefined rules to catch common error patterns.

• Anomaly Detection: Uses statistical models or machine learning to identify deviations from typical transaction behavior.

• User Feedback: Enables users to quickly report errors when they notice discrepancies.

• LLM Validation: Involves cross-checking responses for internal consistency and alignment with the user’s initial intent.
  Example: If the agent’s response contradicts earlier confirmations, the system can flag this for review.

Measuring Detection Effectiveness

To ensure your error detection methods are working as intended, monitor these key metrics:

For example, “Detection Speed” can be measured by tracking the time elapsed from when an error occurs to when it is detected.

Designing Effective Error Correction Interfaces for LLM Agents

When errors occur in transactions managed by LLM agents, the correction interface becomes the system’s moment of truth. It must balance ease of use with rigorous compliance. An effective error correction interface should enable users to quickly understand the error, explore correction options, and confirm that the intended changes have been made—all while maintaining detailed records for audit purposes.

The Anatomy of Effective Error Correction

Effective error correction requires a multi-layered approach:

• Error Communication: Use plain language to explain what went wrong. For example, rather than showing a cryptic error code, the system might state, “It appears that there was a typo in your credit card number. Please review and correct the digits.”

• Correction Options: Offer users clear, actionable choices. For instance, a simple data error (such as an incorrect shipping address) can be corrected via a direct form, while more complex process errors (such as insufficient funds) might trigger a guided workflow.

• Verification Steps: Confirm that the corrected information is accurate. This could involve a two-step process or multi-factor verification for high-value transactions.

• Resolution Recording: Automatically log the correction process to create an audit trail that demonstrates compliance with UETA’s requirements and ensures transaction finality.

Three Levels of Error Correction

Different types of errors require tailored approaches:

This tiered approach ensures that:

- Simple Data Errors are quickly resolved, keeping the user experience smooth.

- Process Errors are handled with sufficient oversight through guided workflows.

- Complex Errors involving system integration benefit from human intervention, ensuring full documentation and resolution.

LLM-Enhanced Error Correction

LLM agents can improve the error correction process by:

- Generating plain-language explanations to help users understand the error.

- Suggesting likely corrections based on the transaction context.

- Guiding users through multi-step correction workflows.

- Maintaining contextual continuity so that corrections are appropriately applied.

For example, rather than simply alerting the user to an error, the agent might say, “We noticed a potential mismatch in your order details. Would you like to review your shipping address or update your payment method?” Such tailored prompts help ensure that the user can effectively resolve issues while the system logs every step for compliance purposes.

Measuring Correction Effectiveness

To ensure the correction interface works as intended, monitor these key performance metrics:

For example, tracking the “Time to Resolution” metric can help determine whether the correction process is efficient enough to maintain user confidence while providing timely compliance evidence.

Record Keeping: The Foundation of Trust and Compliance

Robust record keeping is critical—not only does it support business process improvements, but it is also essential for meeting legal requirements under UETA. In LLM agent systems, where transactions can be highly dynamic, comprehensive records serve as the backbone for transparency and accountability.

Essential Record Types

Different types of records are necessary to cover all aspects of a transaction:

Each record type provides a unique layer of insight:

- Transaction Records document the details of every interaction.

- Error Logs capture any discrepancies or issues that occur.

- Correction Trails offer a step-by-step account of how errors were resolved.

- System States track the performance and contextual environment at the time of the transaction.

Record Keeping Architecture

A robust record keeping system should incorporate:

1. Data Integrity:

   1. Immutable storage (e.g., any write-once-read-many database will do, or blockchain if you really feel that need)

   2. Version control and change tracking

   3. Strict access controls

2. Accessibility:

   1. Quick retrieval and searchable archives

   2. Support for data export in standardized formats

   3. Consistent format preservation to maintain context

3. Context Preservation:

   1. Detailed logs of transaction states, user decisions, and system configurations

   2. Mechanisms for preserving the intent behind changes or corrections

Future-Proofing Your Records

As LLM agent systems evolve, record keeping systems must adapt to emerging challenges:

To address these challenges, consider the following best practices:

• Record Organization:
  Develop clear classification systems, retention policies, and disposal procedures. Regular audits can help ensure that records remain accurate and accessible.

• Context Management:
  Track decisions, preserve user intent, and document all system changes to create an effective historical record that supports dispute resolution.

• Access Control:
  Implement role-based permissions, audit trails, and robust security protocols to protect sensitive data and ensure that records can be retrieved efficiently in the event of an audit or legal dispute.

Best Practices for LLM Agent Systems: Beyond Basic Compliance

While UETA provides the legal framework for error handling, truly effective LLM agent systems go well beyond minimal compliance. A robust system not only satisfies legal requirements but also drives business value through superior user experience and operational excellence.

System Design Principles

Adopt these design principles to ensure your LLM agent system remains resilient and adaptable:

• Transparency: Ensure that all system processes are visible to users, including error handling and confirmation steps. This not only builds trust but also simplifies regulatory audits.

• Predictability: Design processes that behave consistently under similar conditions, reducing unexpected errors.

• Adaptability: Build modular architectures that can incorporate new technologies or comply with updated legal standards as they emerge.

• Accountability: Maintain thorough records and audit trails to support both internal review and external regulatory scrutiny.

Measuring Success in LLM Agent Systems

Quantitative metrics are essential for evaluating system performance over time:

For instance, a high adoption rate coupled with low dispute frequency suggests that the system is both efficient and legally robust.

Advanced Use Cases and Future Considerations

As LLM agent systems continue to evolve, new challenges and opportunities will emerge. Understanding these future trends is key to staying ahead in the rapidly evolving landscape of automated commerce.

Agent-to-Agent Interactions

The future of automated commerce increasingly involves interactions between autonomous agents. This introduces new technical and legal complexities:

• Protocol Standards: Establish clear, standardized protocols for agent-to-agent interactions to ensure smooth operations.

• Error Propagation: Implement safeguards that prevent errors from cascading between systems.

• Intent Preservation: Use contextual analysis to track and maintain the original intent behind transactions.

• Conflict Resolution: Develop frameworks for resolving disputes between agents, thereby minimizing business interruptions.

Evolution of User Intent

Over time, user preferences and behaviors may evolve as use and reliance upon AI agent systems deepens and becomes more complex and integrated. An effective system must adapt without compromising compliance or operational efficiency:

• Basic example: An LLM agent that tracks previous purchase behaviors might proactively suggest complementary products. However, it must also ensure that any changes in user intent are clearly documented to avoid misinterpretation of transactions.

Emerging Standards and Future Readiness

To prepare for the evolving landscape of automated transactions, it is essential to monitor emerging standards and align your system accordingly:

• Preparing for the Future:

  • Design for Evolution: Adopt modular architectures and extensible protocols that can quickly adapt to new standards.

  • Plan for Complexity: Incorporate advanced analytics and comprehensive logging to manage increasing transaction volumes.

  • Maintain Transparency: Keep detailed, traceable records to support compliance with evolving regulations.

If your organization has the resources and talent to actively participate in relevant standards development, being part of such processes can both ensure awareness/readiness as well as offer the opportunity to help shape future standards.

The Future of Transaction Finality in Agent Systems

A critical challenge for LLM agent systems is ensuring true transaction finality—where errors are not only prevented or corrected but also the final state of a transaction is clearly established and legally binding.

Transaction Finality: The Path Through Error Handling

The challenge of establishing transaction finality in AI agent systems reveals a critical business reality: without proper error handling, there can be no true finality. This isn’t just about good practice—it’s about legal certainty under UETA.

Key Relationships and Roles

Note: In some arrangements, the Third Party may also serve as the Agent Provider, offering an agent for users to interact with their own services.

The Legal Framework for Finality

UETA Section 10(2) provides a crucial right: users can “avoid the effect” of electronic records (essentially reverse transactions) if they weren’t given proper opportunity to prevent or correct errors. This means:

1. Without robust error handling, there is no true transaction finality

2. Users retain a statutory right to reverse transactions if proper error prevention/correction wasn’t available

3. This right cannot be waived by contract or agreement

Practical Implications

For businesses deploying AI agents, this creates a clear imperative. Organizations must first implement strong error prevention mechanisms throughout their transaction flows. They need to provide and document clear error correction pathways that users can easily access and understand. Importantly, they must maintain records of when and how these capabilities were made available to users during each transaction. Only after meeting these requirements can a business confidently establish transaction finality. These aren’t optional best practices—they’re essential steps for achieving legally defensible completion of transactions.

Two Implementation Models

1. Three-Party Arrangement:

   1. User engages with Third Party merchant through Agent Provider’s system

   2. Agent Provider implements error handling for both parties

   3. Clear documentation of error prevention/correction opportunities

2. Two-Party Arrangement:

   1. Merchant provides agent for users to interact with their own services

   2. Merchant directly responsible for error handling

   3. Simplified implementation but same legal requirements

The Business Value of True Finality

Implementing proper error handling delivers concrete business value beyond mere legal compliance. When organizations build robust error prevention and correction capabilities into their agent systems, they establish legally defensible transaction finality that protects all parties. This approach significantly reduces the risk of statutory transaction reversals, providing the certainty needed for efficient business operations. It creates clear, documented completion points that support reliable accounting and fulfillment processes. Perhaps most importantly, this framework builds genuine user confidence in automated transactions, paving the way for broader adoption of AI agent systems in commerce.

Understanding Practical Finality

While we speak of achieving “transaction finality” through proper error handling, it’s worth noting that finality in digital transactions is more of a practical business construct than an absolute state. As Patrick McKenzie expertly explains in his analysis of payment systems, true finality is more of a “probability distribution” influenced by technical infrastructure, relationships between parties, and governing laws rather than an absolute condition. For the purposes of AI agent transactions, we’re focused on reaching a clear point where all parties can confidently treat the transaction as complete for practical business purposes—whether that’s booking revenue, initiating fulfillment, or closing the accounting period. This framework of error prevention and correction helps establish that practical finality, even if philosophical arguments about absolute finality remain.

For a fascinating deeper dive into the broader concept of finality in payment systems, see McKenzie’s “Finality does not exist in payments” and I thank Alex Reibman of AgentOps for his feedback on this larger point. While absolute finality in transactions is philosophically complex, for business and legal purposes, the goal is to establish practical finality where transactions are recognized as complete and legally binding. Achieving that practical goal, and adding deeper context on the road ahead, is the purpose of this piece.

A Trust Protocol Stack

This notional “Trust Protocol Stack,” is a way to approaching assurance of transaction finality by integrating multiple layers of assurance:

This layered approach not only enhances confidence in the system but also opens new business models around premium, verified transaction services.

Protocol Standards for the Future

Developing and implementing standardized protocols is essential for future-proofing automated transactions:

• Implementation Challenge: Achieving consensus or working agreed practices among stakeholders to ensure business and technical interoperability among different agent platforms, frameworks, or services will be critical in the agent-to-agent transactional context.

Bringing It All Together: A Call to Action

The evolution of LLM agent systems demands that businesses and legal professionals alike view error handling as a strategic investment rather than a regulatory checkbox. The following steps provide a roadmap for organizations looking to lead in this new era of automated commerce:

Key Takeaways

1. For Business Leaders:

2. Strategic Investment: Robust error handling drives user trust and creates competitive differentiation.

3. Innovative Opportunities: Premium verification and advanced correction capabilities open new revenue streams.

4. Market Leadership: Early adoption of best practices positions your organization at the forefront of automated commerce.

5. For Legal/Risk Professionals:

6. Defensible Processes: UETA compliance is a baseline that can be enhanced through transparent, robust error handling.

7. Clear Documentation: Detailed audit trails and correction records provide strong evidence in dispute resolution.

8. Regulatory Readiness: A future-proof system is essential for adapting to evolving legal and technological landscapes.

Strategic Implementation Path

• Action Steps:

  • Assess Your Current State: Conduct a thorough review of your existing error handling capabilities.

  • Plan Your Evolution: Identify key enhancement opportunities and set a timeline for implementation (e.g., assess within 30 days, plan within 90 days).

  • Implement Changes: Roll out modular improvements, starting with high-risk areas.

  • Lead the Change: Engage with industry bodies to help shape future protocol standards.

The Opportunity Ahead

The future of automated commerce hinges on our ability to build transparent, trustworthy systems. By integrating robust error prevention, detection, correction, and record keeping, you not only comply with UETA’s mandatory requirements but also drive user confidence and operational excellence. The time to act is now—embrace these practices and lead the way in a new era of automated transactions.

I’m excited to share a sneak peek of a project I’ve been deeply involved in – a multi-agent system designed to unlock autonomous innovation. I’ll be demonstrating this system at Davos later this month, and I’m thrilled to give you, my cherished subscribers, an early look!

Before we dive in, I want to extend a huge thank you to everyone who responded to my call on LinkedIn for feedback on this demo. Your insights were invaluable in refining the presentation.

Live Demo from Earlier Today:

What is Agento and GenSpring?

This system, which I’m calling Agento, is all about harnessing the power of AI agents to not just chat, but to actually bring those ideas to life. It’s built on three core innovations:

1. Modular Architecture: This allows for rapid experimentation and seamless integration of new technologies. Think of it like building with LEGOs – you can easily swap out parts and add new ones without rebuilding the entire structure.

2. Deep Agent Collaboration: The agents in this system are designed to work together in a way that mirrors successful human collaboration. They can reason deeply about complex problems, provide constructive criticism, and iterate towards a high-quality solution.

3. GenSpring - The Idea Engine: This is where things get really exciting. The most innovative modules is called GenSpring, which is designed to continuously generate new ideas, evaluates them, and feed the most promising ones into the development pipeline through all the other modules. It’s like having a perpetual brainstorming machine!

Why This Matters

I believe this technology has the potential to revolutionize how we innovate across a wide range of fields. Imagine a future where:

• AI agents can autonomously generate and develop solutions to complex problems, like disaster response or affordable housing.

• New products and services can be brought to market faster than ever before, thanks to the accelerated innovation cycles enabled by this system.

• Organizations can become more agile and adaptable, thanks to the modular architecture and the ability to integrate new technologies seamlessly.

Demo in Action

To complement the conceptual design above, here are key moments from the actual system demonstration. In this practice run, you’ll see:

• A slide deck and key talking points outlining this approach to using AI agents.

• A demo of the system taking a user-defined goal and breaking it down into an actionable plan.

• Multiple agents, powered by models like GPT–4o, Claude 3.5 and Gemini 1.5, working together to refine the plan through a process of revision requests and evaluations.

• The importance of clear communication and well-defined evaluation criteria for successful agent collaboration.

• The final output in both JSON and Markdown formats, demonstrating the system’s ability to produce structured, machine-readable, and human-readable results.

• The role of GenSpring is as a kind of initialization module that can be swapped in instead of the user-defined goal input, so as to enable a fully autonomous general purpose innovation pipeline prototype.

Presentation Deck & Key Moments

These slides and talking points form the foundation of how I am currently communicating the system’s capabilities, novel design, and broader potential:

“What innovative challenges can we solve together?”

"What if AI agents could continuously generate breakthrough ideas AND autonomously develop them into real solutions? I've created a system that does exactly that through three key innovations: First, a modular architecture that enables rapid experimentation and seamless integration of new technologies without disrupting the whole system. Second, a sophisticated approach to AI agent collaboration that enables deep reasoning and effective handling of complex challenges. And third - perhaps most exciting - GenSpring, an 'idea engine' that constantly generates and evaluates new opportunities, feeding promising innovations directly into development."

"This modular architecture isn't just about flexibility - it's about enabling a new paradigm for AI innovation. Each module accepts structured inputs and produces structured outputs, creating clear interfaces where teams can plug in their preferred approaches. This means you can rapidly experiment with different technologies, frameworks, or entirely new approaches without rebuilding the whole system.

But here's where it gets interesting: this modularity ALSO opens the door to something bigger. Any team that believes they have superior agent technology can prove it by taking standard inputs from one module and showing they can produce better outputs. It's an open invitation to demonstrate real capabilities rather than just talk assert the superiority of a given implementation or approach."

"What makes this system unique is how it orchestrates AI conversations in a way that mirrors successful human-AI collaboration patterns. The agents can guide each other back to relevant topics, seek revision of outputs that don't meet quality benchmarks, and engage in deeper reasoning about complex challenges. By finding that crucial balance between steering and enabling, these agent conversations can adapt to tackle virtually any problem. Think of it as creating the conditions for AI creativity to flourish while ensuring the results remain practical and focused.

The power isn't in controlling every interaction, but in establishing the right design patterns for productive collaboration. Think of it as creating the conditions for AI creativity to flourish while ensuring the results remain practical and focused.”

"GenSpring is where this system truly breaks new ground. Imagine having access to a perpetual wellspring of innovative ideas - not just random concepts, but carefully validated opportunities that are novel, useful, and crucially, achievable. This isn't just an idea generator - it's a complete pipeline that continuously identifies promising innovations and filters them through sophisticated analysis to ensure real-world value creation.

What makes GenSpring transformative is its seamless integration with our modular architecture. Each idea is structured precisely to flow into subsequent modules - from detailed planning to implementation, testing, and eventual deployment. As the system runs, successful innovations feed back into the process, creating an ever-evolving fountain of refined, practical solutions."

"The implications of this modular, agent-driven approach extend far beyond any single organization or industry. By establishing clear interfaces for AI systems to exchange value - whether that's ideas, services, or solutions - we're laying the groundwork for an entirely new kind of innovation economy.

Imagine a future where AI-driven companies can seamlessly exchange specialized capabilities, where breakthrough ideas can flow freely between organizations, and where innovation isn't limited by organizational boundaries. This isn't just about accelerating R&D or reducing costs - it's about creating the fundamental infrastructure for a new era of open, collaborative innovation. Just as standardized shipping containers revolutionized global trade, standardized AI interfaces could transform how we create and exchange value in the digital age."

“What innovative challenges can we solve together?”

I’d Love Your Feedback!

This is just a first glimpse, and I’m eager to hear your thoughts. What aspects of the system are most exciting to you? What questions do you have? What potential applications do you see? Let me know in the comments.

Want a One-on-One Demo and Chat?

If you’re a paid subscriber and would like a personalized demo and a chance to discuss this technology further, I’d love to connect! I’d be happy to answer any questions and talk through how these approaches to AI agents could be useful in your contexts. Please reach out to me using this form, https://forms.gle/8LnVNGEs6u9n5UGT6, and be sure to use the same email and name you use for your Substack subscription so I know it’s you.

Looking Ahead

I believe that multi-agent systems like Agento and components like GenSpring have the potential to transform the way we approach innovation. By combining the creative power of AI agents with the structure and rigor of modular design, we can unlock new levels of productivity, problem-solving, and even new value creation. I’m excited to continue developing this technology and exploring its possibilities with you.

Thanks for being a part of this journey!

Best,

Dazza Greenwood

P.S. For a deeper dive into the legal aspects of LLM-powered agents, check out my Stanford CodeX project site: https://law.stanford.edu/codex-the-stanford-center-for-legal-informatics/projects/agentic-genai-transaction-systems/ and the first of three blog posts as part of that research on issues and opportunities for transactional AI Agents is now live at: https://law.stanford.edu/2025/01/14/from-fine-print-to-machine-code-how-ai-agents-are-rewriting-the-rules-of-engagement.

And for insights on empowering consumers with personal AI agents, see these posts I wrote with Consumer Reports Innovation Lab: https://innovation.consumerreports.org/empowering-consumers-with-personal-ai-agents-legal-foundations-and-design-considerations/ and https://innovation.consumerreports.org/engineering-loyalty-by-design-in-agentic-systems/.

Also, earlier today, some MIT colleagues and I published a pre-print of a new research paper on a potential way to use and extend OAuth 2 and OpenID Connect technical specifications to enable “Authenticated Delegation and Authorized AI Agents”. You can learn about that here: https://arxiv.org/abs/2501.09674

Key Terms and Definitions

Before diving into the infrastructure and frameworks that enable AI agent transactions, it’s essential to understand a few key terms and concepts:

Core Concepts

• AI Agent: The technology program that autonomously performs tasks and interacts with third parties, in this context, including use of Large Language Models (LLMs)

• AI Agent System: The AI agent technology plus the technology provider who operates the agent and acts as an intermediary, forming a legal agency relationship with the user

• Agent (Legal): A person or entity authorized to act on behalf of another (the principal)

• Principal (Legal): The person or entity for whom an agent acts and who exercises principal authority, some of which can be delegated to the agent

• Third Party (Legal): Any person who is a counter-party in a transaction with the agent who is acting on behalf of the principal

• Contract: A legally binding agreement between two or more parties

• Electronic Contract (UETA): A contract formed through electronic means

• Human: A natural person

• Organization: A legal entity, such as a corporation, business, or government agency (also known legally as an “artificial person”)

Legal Definitions from UETA

• Transaction: “‘Transaction’ means an action or set of actions occurring between two or more persons relating to the conduct of business, commercial, or governmental affairs.” (UETA § 2(16))

• Person: “‘Person’ means an individual, corporation, business trust, estate, trust, partnership, limited liability company, association, joint venture, governmental agency, public corporation, or any other legal or commercial entity.” (UETA § 2(12))

• Electronic Signature: “‘Electronic signature’ means an electronic sound, symbol, or process attached to or logically associated with a record and executed or adopted by a person with the intent to sign the record.” (UETA § 2(8))

• Automated Transaction: (Defined in detail in Legal Framework section below)

• Electronic Agent: (Defined in detail in Legal Framework section below)

Digital Identity Concepts

• Digital Identity (Wyoming): The intangible digital representation of, by and for a person, over which they have principal authority and through which they intentionally communicate or act. Can be:

  • Personal Digital Identity: For individuals

  • Organizational Digital Identity: For legal entities (See WY Stat. § 8-1-102(a)(xviii-xix) (2022))

• Attribution: The process of establishing that an action or communication originated from a specific person or entity

• Impersonation: The act of falsely representing oneself as another person or entity, especially in a digital context. Doing so to commit a crime or fraud carries specific penalties.

Building the Legal Infrastructure: A Bridge to the Future

While use of AI agents is undeniably a novel situation for almost all people at this moment in history, there is an all-but-forgotten existing legal framework that nicely supports and reflects use of this technology, including for transactions.

Back in the late 1990s, I spent nearly two years in drafting meetings for Uniform Electronic Transactions Act (UETA), attending every session but one. During this time, we were grappling with how to create a legal framework that could adapt to the rapid evolution of technology and support the rise of e-commerce. I also co-chaired the American Bar Association group that advised on electronic agents provisions and later testified before Congress on related federal legislation (the E-SIGN Act).

The legal infrastructure we built—UETA and the federal Electronic Signatures in Global and National Commerce Act (E-SIGN)—is like a massive, invisible 50-lane highway bridge supporting today’s digital economy. We designed it with the future in mind, anticipating “lanes” for autonomous agents long before the technology existed. Those seemingly excessive “lanes” are now proving essential.

Well, we suddenly need that bridge to traverse a slightly different type of traffic. Now that we finally have tons of autonomous agents and many people want to deploy them, UETA is like that bridge with perfectly suited lanes for autonomous traffic. Those wide shoulder lanes that have been gathering dust for 25 years are exactly what we need for LLM agents conducting transactions for people and organizations. They just didn’t know it!

The Legal Framework: UETA and Electronic Agents

UETA provides explicit provisions for electronic agents to conduct transactions autonomously. The law defines several key concepts that are remarkably relevant to today’s AI landscape:

Core Definitions

Electronic Agent: “‘Electronic agent’ means a computer program or an electronic or other automated means used independently to initiate an action or respond to electronic records or performances in whole or in part, without review or action by an individual.” (UETA § 2(6))

Automated Transaction: “‘Automated transaction’ means a transaction conducted or performed, in whole or in part, by electronic means or electronic records, in which the acts or records of one or both parties are not reviewed by an individual in the ordinary course in forming a contract, performing under an existing contract, or fulfilling an obligation required by the transaction.” (UETA § 2(2))

Attribution and Legal Effect

The most important concept from these frameworks is attribution. Automated systems that ensure clear attribution to responsible legal persons help avoid an accountability gap for potential harm and damage these systems could cause. The federal ESIGN Act states that electronic agent actions are legally valid “so long as the action of any such electronic agent is legally attributable to the person to be bound.” UETA offers further guidance:

“An electronic record or electronic signature is attributable to a person if it was the act of the person. The act of the person may be shown in any manner, including a showing of the efficacy of any security procedure applied to determine the person to which the electronic record or electronic signature was attributable.” (UETA § 9)

Just as vehicles are required to have clearly visible license plates when they enter upon public roads, we need appropriate measures for attribution of the acts of automated and autonomous systems back to responsible parties.

The Iron Triangle: Principal, Agent, and Third Party

The relationships between users and their AI agents and external parties forms what I call the “iron triangle” of roles:

1. The Principal (the user/consumer/employee)

2. The Agent (the intermediary providing the AI agent tech for the Principal/user)

3. Third Parties (companies or other entities the AI agent interacts with)

The term “agent” itself can cause confusion, holding different meanings in the realms of software development and law. In software, it broadly refers to systems that perform tasks on behalf of users. However, the legal definition is much more specific, encompassing obligations that AI systems alone cannot fulfill. According to the Restatement (Second) of Agency § 1(1) (1958), agency is defined as “the fiduciary relation which results from the manifestation of consent by one person to another that the other shall act on his behalf and subject to his control, and consent by the other so to act.”

That definition might leave you scratching your head! Let’s break it down. In simpler terms, ‘agency’ means one person agrees to act for another, like a personal assistant handling tasks for their boss. It’s about a relationship built on trust, where the ‘agent’ is loyal to the ‘principal’ and follows their instructions. The three fundamental roles, legally, are the principal, the agent, and third parties, with whom the agent interacts on behalf of the principal to get tasks done. You can think of these three roles as a kind of iron triangle. Fiduciary duties owed by agents to principals, like the duty of loyalty, ensure the agent is legally obligated to act in the principal’s best interests. I want to emphasize that both individuals (like in our role as consumers) as well as organizations (operating through employees) using AI agent systems would be wise to prioritize working with fiduciary providers and operators of AI Agent Systems.

Now, consider this legal concept in the context of today’s rapidly evolving AI landscape. AI agents, particularly those powered by large language models (LLMs), are quickly becoming more sophisticated and widely deployed. They’re handling increasingly complex tasks for their users, including making purchases, managing finances, and even making significant decisions with real-world consequences. However, the current models governing these AI-powered interactions are often murky and lack clarity regarding the roles, responsibilities, and legal relationships between all the players involved. This lack of clarity creates uncertainty and potential risks for both consumers and businesses, hindering the widespread adoption and beneficial potential of these powerful tools.

When you rely upon an AI Agent to conduct transactions for you which involve your duty to pay and that form other legal obligations, you should confirm that you are in fact the principal and the provider of the technology has not arrogated the role of principal to itself, leaving you as a user of their system who is relegated to operate under their principal authority. Arguably, the entire framework of hundreds of years of agency law and practice exists to support and advance precisely such relationships of trust and reliance. It is not only reasonable, but recommended, that these frameworks be applied to AI agent intermediated transactons as well, in order to ensure alignment with the user’s interests and expected legal and business relationships and results.

To address this challenge, we can apply the robust legal framework of agency to structure the unique context of AI Agent Systems. By clarifying the roles and relationships of each party involved – the consumer or employee as principal, the intermediary that provides the AI as a tool as Agent– we can create a model that fosters trust, predictability, and accountability. The role of the intermediary combined with the AI Agent can be called an “AI Agent System.” This allows us to build on the iron triangle of agency, leveraging hundreds of years of well-understood precedent. This approach not only provides principals with greater certainty but also empowers third-parties to engage in AI-powered interactions with greater confidence and clarity, unlocking the tremendous benefits of this technology for all.

This structure should be supported by five critical levels of system design:

1. Governance: Rules and bylaws ensuring transparency and accountability

2. Data Stewardship: Protection and ethical use of consumer data

3. Instructions & Tooling: Mechanisms to control and direct agent actions

4. Agent-to-Agent Communication: Secure interaction protocols (mostly coming soon)

5. Identity & Payments: Secure verification and transaction processing

Key Considerations for Agent Transactions

Confidentiality and Data Protection

Within the fiduciary model, robust data protection is paramount. The AI Agent System provider has a high duty of care and loyalty to the user, which includes maintaining strict confidentiality of their private information and commercial transactions. This reinforces the trust essential for users to reasonably rely upon AI agents to manage sensitive tasks.

Security and Error Prevention

LLM agents may make unexpected errors when conducting automated transactions. UETA provides a framework for addressing these very issues through specific mechanisms for error prevention and correction. For example:

• Security procedures can establish spending limits

• Error detection mechanisms can trigger alerts

• Failed security procedures may provide grounds for transaction reversal

Fiduciary Duty and Trust

The most compelling use case for AI Agent Systems is their ability to act as fiduciaries, prioritizing user interests above all else. The party providing the AI Agent technology to users, in this context, also forms a legal principal-agent relationship with that user. These agents can be bound by a “duty of loyalty” to their users, creating a trustworthy foundation for autonomous transactions. This fiduciary approach is especially important in the context of transactions, where financial and legal ramifications can be significant.

Parallel Tracks: Individuals and Organizations

These principles apply equally to individuals and organizations using LLM agents. The Wyoming Digital Identity Act provides a framework for recognizing and managing digital identities, further strengthening the legal foundation for AI agent transactions. The Act recognizes this duality:

Personal Digital Identity: “the intangible digital representation of, by and for a natural person…over which he has principal authority” (WY Stat. § 8-1-102(a)(xviii) (2022))

Organizational Digital Identity: “the intangible digital representation of, by and for a corporation, business trust…or any other legal or commercial entity…over which it has principal authority” (WY Stat. § 8-1-102(a)(xix) (2022))

The Act provides strong protections against impersonation, including injunctive relief and the potential for triple damages:

“Any person with a personal or organizational digital identity may proceed by suit to enjoin the use of any impersonations…and may require the defendants to pay to such person all profits derived from or all damages suffered by reason of such wrongful use…the court, in its discretion, may enter judgment for an amount not to exceed three (3) times any profits or damages and reasonable attorneys’ fees…” (WY Stat. § 40-30-103 (2022))

Wyoming statute provides crisp clarity on these specific points, but every state of the US has legal frameworks that can be used in combinations to achieve the same results. While the legal foundations are in place, the field of AI agent transactions is rapidly evolving. Recent developments highlight the growing momentum and practical applications of this technology.

Recent Developments in Agent Transactions: The Stripe Agent Toolkit

The landscape of agent transactions has shifted dramatically with the recent release of Stripe’s Agent Toolkit. This development, from the dominant player in online payments, is poised to accelerate the adoption of AI agents for real-world commerce. This isn’t a future prediction; it’s happening right now. Stripe’s massive reach means this technology will quickly become embedded within the core transactional fabric of the digital economy.

The Stripe Agent Toolkit enables developers to integrate Stripe’s powerful financial services directly into agentic workflows, empowering agents to not just facilitate transactions but to actively participate in them through secure, controlled mechanisms built on Stripe’s robust financial infrastructure.

Key Capabilities

1. Creating and Managing Stripe Objects
   Agents can now programmatically create payment links, manage products and prices, generate invoices, and handle other essential Stripe objects. This streamlines payment workflows and automates key business processes.

   Use Cases:

   • Generating dynamic payment links for e-commerce purchases

   • Creating and managing invoices for freelancers

   • Automating product catalog management

   • Streamlining customer support workflows

2. Metered Billing (Usage-Based Billing)
   Businesses can easily implement usage-based pricing for their agent services, tracking and charging customers based on metrics like token counts or execution time. This opens up new possibilities for monetizing AI agent platforms.

   Use Cases:

   • Billing for chatbot usage (messages or tokens)

   • Charging for API calls

   • Tracking and billing agent execution time

   • Usage-based pricing for AI services

3. Online Purchasing with Stripe Issuing
   Perhaps the most transformative capability, agents can now generate single-use virtual cards to make purchases online. This eliminates the need for consumers to share their primary card details with multiple merchants, significantly enhancing security while streamlining procurement processes.

   Use Cases:

   • Automating travel booking with controlled spending limits

   • Managing company expenses through virtual cards

   • Dynamically managing ad campaign budgets

   • Secure online purchasing with transaction-specific cards

Technical Implementation

The toolkit is designed for broad compatibility and ease of integration:

• Framework Support: Native support for popular agent frameworks including LangChain, CrewAI, and Vercel’s AI SDK

• Language Options: Available in both Python and TypeScript

• LLM Compatibility: Works with any LLM provider that supports function calling

• Security Controls: Fine-grained access control through configurable actions

• Error Prevention: Built-in safeguards and monitoring capabilities

Stripe is known for its excellent developer documentation and support, making the integration process even smoother. For detailed implementation guidance, the Stripe documentation provides comprehensive examples and best practices.

Integration Examples

Here are two practical examples of how the Stripe Agent Toolkit enables sophisticated transaction scenarios:

Consumer Purchase via Intermediary Service

A consumer uses a shopping agent service to find and purchase products. The agent searches for the best deals, and upon consumer approval, completes the purchase using a virtual card issued by Stripe through the intermediary service.

Key Components:

• Consumer-facing interface (app/website)

• AI shopping agent powered by LLMs

• Stripe Agent Toolkit integration

• Virtual card issuance for secure purchases

• Order tracking and fulfillment

Employee Procurement System

An employee uses a company-provided procurement tool (powered by an LLM agent) to purchase office supplies. The agent identifies approved vendors and products, and after employee confirmation, completes the purchase using a virtual card issued by Stripe.

Key Components:

• Company intranet/procurement portal

• AI procurement agent with policy enforcement

• Stripe Agent Toolkit integration

• Automated budget tracking and reporting

• Integration with accounting systems

These developments represent a significant step forward in making agent transactions practical and secure for both consumers and businesses. The Stripe Agent Toolkit provides the crucial infrastructure needed to bridge the gap between AI agents and real-world financial transactions.

Perplexity’s Direct-to-Consumer Shopping Agent

Just days after Stripe’s announcement, Perplexity introduced a new AI-powered ecommerce feature called “Buy with Pro,” marking another significant milestone in agent transactions. While Stripe enables developers to build agent-powered commerce solutions, Perplexity is taking a direct-to-consumer approach, offering U.S. Pro users the ability to purchase items through their AI agent without visiting retailer websites.

Key Features of “Buy with Pro”

• One-Click Checkout: Users can store their billing and shipping information securely within Perplexity, enabling them to complete purchases with a single click. This streamlined process includes automatic tax calculations based on the user’s address. Unlike the Stripe agent API, this new Perplexity shopping agent is provided direct-to-consumer by Perplexity itself, and it will conduct the transaction on behalf of the user including handling payment.

Here are the key business components of this new agent transaction service:

• Free Shipping: Pro subscribers benefit from free shipping on all purchases made through the “Buy with Pro” feature.

• Visual Product Cards: For shopping-related queries, Perplexity displays visual cards that provide detailed product information, including pricing, seller details, and pros and cons. These cards are designed to offer unbiased recommendations without sponsored content.

• Snap to Shop: This visual search tool allows users to upload a photo of a product they are interested in. Perplexity then identifies and displays similar items available for purchase, enhancing the shopping experience even when users lack specific product names or descriptions.

• Integration with Shopify: By integrating Shopify’s API, Perplexity gains access to a wide range of products and merchants, allowing it to provide comprehensive shopping options directly within its platform.

This new feature positions Perplexity as a competitor to major ecommerce platforms like Amazon and Google Shopping by offering a seamless shopping experience directly through its AI search engine. The company is currently focusing on growing its search query volume rather than monetizing this feature immediately, with advertising business remaining the primary revenue stream focus.

The Inflection Point

Between the Stripe Agent API and Perplexity’s shopping agent both launching within the last week (as of November 20, 2024), it is clear that transactional AI agents are no longer a future possibility but have reached broad scale availability. These complementary approaches - Stripe’s developer toolkit and Perplexity’s direct-to-consumer service - demonstrate how quickly this technology is being commercialized and made available at population-scale.

The Future of Agent Transactions

As transactional AI agent technology matures, two key areas (among others) that will shape its evolution are:

1. The development of common protocols for agent-to-agent communication, enabling seamless and efficient automated transactions

2. Sophisticated mechanisms for managing the delegation of authority from the principal user to the AI agent, balancing automation with user control

This will ensure that agents act within clearly defined boundaries while maximizing their utility. The foundation we laid with UETA has proven remarkably prescient, providing crucial guardrails for responsible innovation while protecting user interests. The challenge now is to build upon this foundation, creating systems that maintain trust while unleashing the transformative potential of autonomous agents.

Note: This is a beta version preview of materials that will be released shortly on my new site OnAgents.org site, so check there for the most up to date versions of this and other AI Agent topics.

Also: For more detailed discussion, including the role of zero-knowledge proofs and other emerging legal considerations for transactional AI agents, standby for an upcoming white paper I’m co-authoring with the ever-awesome Diana Stern, titled: “From Fine Print to Machine Code: How AI Agents are Rewriting the Rules of Engagement”. I’ll post a link to it here in the OnAgents section of DazzaGreenwood.com.