stripeJun 11, 2026

Stripe Projects adds new agent integrations, more providers, and custom developer controls (opens in new tab)

Agent traffic now exceeds human internet traffic, driven largely by agents independently building software and integrating APIs. Stripe reports that agents account for nearly 40% of its documentation traffic and 70% of API-resource requests through the Stripe CLI. Stripe Projects is expanding to help agents handle the infrastructure, credentials, services, and operational controls surrounding software development. ## Agent Integrations - Stripe Projects is available as a skill in Hermes, an open-source AI agent from Nous Research. - Hermes can retain context across sessions, allowing it to collaborate on complex projects over days or weeks. - Factory Droids and Warp have integrated the Projects CLI into their coding workflows. ## Expanded Provider Support - Projects now supports 49 providers, adding 16 new integrations. - New providers include: - Metronome for usage-based billing - Wix for storefronts - ClickHouse for LLM observability - Agents can provision applications, billing, storefront, monitoring, and other services without manually navigating provider dashboards. ## Controls for Safe Agent Provisioning Stripe is adding guardrails similar to those used for agent-driven purchases: - **Unified cost visibility:** Developers can view current and historical spending across providers for each project. - **Per-provider spending limits:** Teams can set different caps for services such as AI models, hosting, and databases. - **Named environments:** Isolated credentials can be created for development, staging, production, or custom environments. Agents default to development, reducing the risk of affecting production. - **Platform delegation:** Platforms can provision services for users using scoped credentials and white-labeling, keeping developers inside the platform’s environment. ## Future Direction Stripe plans to extend Projects across the full lifecycle of agent-built software, including operations and security. Planned additions include stronger security primitives for autonomous agents and a data layer that lets providers meter and bill for software created by agents. Stripe’s broader recommendation is to use Projects as an agent-accessible way to provision infrastructure—for example, asking an agent to add a Prisma database.

api-integrationai-agentclickhousehermes+4

stripeMar 12, 2026

10 things we learned building for the first generation of agentic commerce (opens in new tab)

AI-driven commerce is emerging quickly, but making it reliable requires much more than adding an AI checkout button. Sellers must manage fragmented catalog integrations, real-time inventory and variant data, evolving protocols, secure payment tokens, fraud detection, fulfillment, and post-purchase operations. The central recommendation is to use adaptable infrastructure and begin with a limited, measurable product selection rather than launching an entire catalog at once. ## Catalog Integration and Data Quality - Product catalogs are the entry point for AI agents, but each agent may require a different format, such as: - SFTP file drops - Custom APIs - Agent-specific feed specifications - Reformatting the same catalog for multiple agents creates a costly maintenance burden. - Reliable “ingestion-ready” data determines whether products appear consistently across AI shopping surfaces. - A shared commerce layer can syndicate one catalog across supported agents and eliminate duplicate integrations. ## Real-Time Inventory and Product Variants - Agents need to verify current availability immediately before presenting checkout options. - Inventory becomes harder to manage when products include combinations of: - Sizes - Colors - Customizations - Variant-specific availability - Checkout APIs must support real-time availability checks and alternative recommendations when a particular configuration is unavailable. - Real-time accuracy is essential for customer trust and brand reputation. ## Protocol Evolution and Compatibility - Agentic commerce protocols are changing rapidly, with new releases adding payment handlers, scoped tokens, discounts, buyer authentication, and transport methods. - Sellers risk creating “zombie integrations” that become obsolete when an AI platform changes direction. - A protocol-agnostic commerce layer can help businesses support standards such as ACP and Google’s UCP without rebuilding their systems for every change. ## Secure Payments Through Shared Payment Tokens - Shared Payment Tokens allow agents to initiate payments with a buyer’s permission without exposing payment credentials. - The token layer connects AI agents to existing payment rails while limiting transaction scope. - Agentic commerce requires more than payment authorization; systems must also support: - Product discovery - Checkout state management - Shipping - Returns and refunds - The broader infrastructure must cover the full transaction lifecycle. ## Fraud Detection Without Human Browser Signals - Traditional fraud tools often depend on signals such as mouse movements, browser fingerprints, device details, and window size. - Those signals disappear when an AI agent performs the transaction. - Network-level payment history can provide risk context even when a purchase is new to a particular seller. - Shared Payment Tokens allow fraud systems such as Radar to evaluate agentic purchases similarly to traditional checkout transactions. - Early deployments with major retailers reportedly experienced fraud rates near zero. ## Start with a Focused Product Selection - Sellers should avoid enabling their entire catalog immediately. - A practical launch strategy is to: - Select a small group of high-conversion SKUs - Use simple products with direct-to-home fulfillment - Monitor conversion, inventory behavior, payment methods, and fulfillment issues - URBN initially focused on popular categories such as dresses and denim rather than its full range, which also includes complex products like plants and custom furniture. - Early launches should function as controlled experiments that produce data for broader expansion. ## A Strategic Shift in Retail Discovery - Agentic commerce moves buying intent from stores, websites, and branded mobile apps onto AI platforms. - This changes how sellers must approach: - Product discovery - Brand control - Trust - Dispute resolution - The relationship between the seller and customer - Agents increasingly mediate product selection and purchase decisions, requiring sellers to adapt their commerce strategy beyond the traditional storefront. Sellers should treat agentic commerce as an evolving channel rather than a one-time integration. Start with reliable data, a narrow product scope, secure tokenized payments, and infrastructure that can absorb protocol changes before scaling to more products and complex fulfillment scenarios.

api-integrationstripeagentic-commercefraud-detection+4

stripeMar 2, 2026

Can AI agents build real Stripe integrations? We built a benchmark to find out (opens in new tab)

State-of-the-art LLM agents can complete many scoped coding tasks, but fully autonomous software engineering remains difficult because real projects require long-term planning, persistent state, debugging, and end-to-end validation. Stripe evaluated this gap through a benchmark of realistic backend, frontend, database, and browser-based integration tasks. The results were stronger than expected: agents demonstrated substantial full-stack capability, but still struggled with ambiguity and the judgment required to distinguish genuine failures from bad test inputs. ## Building the Stripe Integration Benchmark - Stripe created 11 environments based on real integration challenges, including Checkout migrations and Billing API modeling. - Each environment included: - A complete codebase, database, scripts, and test Stripe credentials. - Deterministic graders using API calls, automated browser tests, or inspection of Stripe objects. - A consistent agent harness with terminal, browser, and Stripe-specific search tools through MCP. - Challenges were divided into: - **Backend-only tasks:** SDK upgrades, API changes, and database migrations. - **Full-stack tasks:** Coordinated server and client changes requiring browser verification. - **Gym problem sets:** Focused exercises testing deep knowledge of features such as Checkout and subscriptions. ## Stronger-than-Expected Agent Performance - The benchmark intentionally used fewer, harder tasks designed to expose weaknesses. - Agents successfully: - Navigated browser interfaces. - Debugged live issues. - Worked with underdocumented API behavior. - Continued productively across long interactions, with top runs averaging 63 turns. - Claude Opus 4.5 achieved a 92% average score across four full-stack tasks. - GPT-5.2 achieved a 73% average score across two gym problem sets. - In a migration from Card Element to Checkout, an agent completed and verified a test purchase using Link, despite no payment method being specified. ## Reverse-Engineering Checkout Configurations - A Checkout gym task required agents to infer API parameters from 20 prebuilt Checkout UIs. - Agents had to: - Inspect products and quantities shown in each session. - Locate matching product IDs through the Products API. - Identify shipping costs, custom fields, tax settings, and other customizations. - Translate those details into valid Checkout Session parameters. - Agents provided more than 80% of the correct parameters. - The best-performing agent recognized that one UI’s color options were hidden behind an interactive dropdown, explored the control, and included the missing values. ## Remaining Challenges with Ambiguity - Agents struggled when evaluation situations required judgment rather than straightforward implementation. - In SDK upgrade tasks, some agents supplied nonexistent Stripe data, received expected 400 errors, and treated those responses as evidence that their implementation was broken. - This illustrates a broader limitation: successful autonomous engineering requires not only writing code, but also designing meaningful tests, interpreting failures correctly, and validating behavior against realistic system state. The benchmark suggests that agents are increasingly capable of substantial Stripe integration work, including full-stack implementation and browser-based verification. However, reliable autonomy will require better handling of ambiguity, realistic test data, persistent project state, and rigorous end-to-end validation.

api-integrationstate-managementllm-evaluationdatabase-migrations+4