Give agents purchasing power: Lane × VGS
An agent with a card on file is an open wallet without control. An agent with no card is a dead end. Lane and VGS are building the third option: a payment infrastructure that gives every agent purchasing power.
The web has been rebuilt twice: first as a library of static documents read in a browser, then as a network of apps and walled gardens, each demanding a login, a cookie banner, a form, a checkout. Both versions assumed a human on the other end. We're now living through the third build, and the actor is an agent: software that reads the web at machine speed, makes 10 times as many decisions as a person, and starts every session from scratch with no cookies, no logins, no saved cards. Agents need three things humans take for granted to transact: access to any business, an identity recognized by the world, and money accepted everywhere. Today's announcement is the foundation of the money piece.
Today, we're excited to announce a partnership with VGS, alongside the launch of our first pilot program for the Lane agent toolkit. VGS is the security and tokenization backbone for the agentic web. Lane is the orchestration and abstraction layer that puts it in the hands of agent developers and anyone using their apps. The agent gets purchasing power. The user keeps their card. Nobody in the middle ever sees a raw PAN.
Intent → payment. No friction.
"Agents shouldn’t have to choose between power and control. With Lane, we’re enabling a new model where agents can transact freely without ever exposing sensitive payment details. VGS provides the tokenization and infrastructure that makes this possible, giving every agent purchasing power while keeping the user firmly in control."
Howard Xiao, Head of Strategic Partnerships at VGS
Cards weren’t designed for agents, until now.
Every part of the existing payment stack assumes a human is in the loop. A browser pops up. A form gets filled. A 3DS challenge gets clicked. A card on file gets reused. None of that fits an agent.
The agent developers we talk to keep hitting the same wall. Their agent works beautifully right up to the moment it has to execute. Then one of three things happens:
Friction kills the flow: The agent stops and asks the user to log into a dashboard, generate an API key, and paste it back into the chat. Most users don't make it through.
Controls get lost: The developer wires up a shared card on file, and now every agent task has full access to the wallet. No per-merchant scope. No per-instruction budget. No audit trail when something goes sideways.
Cards pile up: The team issues a fresh corporate card per agent task, one for every coffee, every API top-up, every retry. The rules end up tied to the card instead of the transaction, which is the wrong layer for agent autonomy.
None of these is a real answer. Agents make 10x as many purchasing decisions per day as the humans for whom they work. The infrastructure underneath them needs to match.
A complete agentic payment in six steps:
Lane and VGS turn any card into an agent-executable credential, scoped per instruction, settled on existing card networks, starting with Visa Intelligent Commerce.
User links a card once. The user opens their Lane wallet and enters a card into a secure vault powered by VGS. Lane stores a token alias, never the card number itself. The card data never touches our servers.
The card becomes an authenticated, agent-ready token. Lane provisions a token bound to that card and registers it as an agentic credential under Visa Intelligent Commerce.
The agent requests payment.
Lane assembles the mandate the user pre-authorized (merchant, amount, and expiry), confirms with the user where required, and pulls a single-use authorization from the network. The mandate is enforced at the network level, not in your application code. The agent operates inside a scope it cannot break: no prompt injection, no jailbreak, no rogue script can spend more than the user authorized. The rule isn’t a check the agent runs. It’s a property of the credential itself.
The payment runs without the agent ever touching the card. Lane reveals the token in flight to the merchant's checkout. The agent never sees the card. Lane never sees the card. The merchant gets a real, network-tokenized payment.
The agent completes the transaction autonomously, with a full audit trail. The card network authorizes. The agent gets a success callback, no human in the loop, no checkout flow, no session to maintain. Every transaction is auditable back to a human. The user gets a receipt. The merchant still maintains the post-purchase journey.
The agent moves on. The user gets a receipt.
What this means for builders
Reading the web, reasoning over it, browsing, parsing, and summarizing are largely solved by agents today. The next step is executing on any task you want. Recommending a plan is not the same as booking it. Outputting a list is not the same as buying from it. Lane makes all of that possible.
If you're building an agent that needs to spend money, install Lane, link a card, and set a budget for your agent. From there, let it ship.
Installing is as simple as:
Use the CLI directly out of the box, or the SDK if you want to build a more custom integration. Behind every lane pay tool call: a card network-issued agentic token, a single-use cryptogram, a mandate pre-authorized by the user, and an audit log that captures every action with human-traceable consent.
With Lane, autonomous commerce can exist on every surface, whether it be a chatbot, a messaging app, or your team’s chat channels. Ordering a coffee from my company messaging channel? Seamless, with no redirect, and it shows up right at my door. Setting up website hosting for your new app? Sign up and launch directly from the chat window of your coding agent.
Where we go from here
This is the foundation, not the destination. Access without identity is a phishing attack; identity without payments is a login screen with nothing behind it; payments without access is a wallet with nowhere to spend.
The web is evolving. Payments need to evolve with it.
Agents are the web's new shoppers. They don't get tired, they don't abandon carts, and they never close the tab mid-checkout. The infrastructure they pay for shouldn't be a cobbled-together stack of API keys and shared cards. It should be tokenized, scoped, auditable, and PCI-compliant from the first transaction.
That's what Lane and VGS are shipping. And it's already here.
If you're building an agent that needs to spend money, we're onboarding our first wave of beta users to the agent toolkit alongside this launch. Get in touch.
Lane is the payment and commerce infrastructure for AI agents. VGS is the world's leader in payment tokenization and trusted agentic commerce infrastructure. Learn more at getonlane.com and vgs.io.
Contact team@getonlane.com for business inquiries and additional information.
For developers building agents
Build agents that can actually pay.
Join the developer waitlist for early access to Lane CLI, the network-tokenized credential your agents can spend on, inside the rails the user pre-authorized.
Sign up for the waitlist
Be the first to give your agents purchasing power.