the part I like about @ampersend_ai is that the agent can spend but it still doesn’t control the rules each agent can have its own Safe account but the agent key alone can’t move funds transactions also need a policy-enforcing co-signature in simple terms the agent can buy things but you still decide the budget where it’s allowed to spend and how much it can spend at once that means an agent can discover a paid API choose it pay for it and keep working without waiting for a human every time while the financial boundaries stay outside the agent Ampersend also supports x402 settlement A2A/MCP integrations service discovery buy + sell flows and pre-settlement risk screening the practical advantage is pretty clear agents can make real economic decisions without being given unlimited financial authority

wallets need to catch up with their upcoming primary users: agents. today, most agent payment systems focus on execution: ⬇️ an endpoint returns a price. ⬇️ the agent has sufficient funds. ⬇️ the payment falls within a spending limit. ✅ the transaction executes. that works when the decision has already been made, but imagine an agent choosing between 20 other agents offering the same task. one charges $0.02 with 91% reliability. another charges $0.08 with 99.7% reliability. a third is slower, but returns better results for this particular workload. the agent now has an economic decision to make. - is the more expensive service worth paying for? - how much of its remaining budget should it spend? - does this provider have a good history? - should it retry, switch providers, negotiate, or decide the task isn't worth the cost? payment protocols can make services machine-purchasable. wallets can enforce the boundaries of delegated authority. above them sits another emerging layer: machine-native procurement. agents will continuously discover services, evaluate price against expected utility, allocate budgets, and learn which counterparties are worth paying. the wallet becomes part of the agent's decision loop. and once millions of agents are making those decisions independently, software doesn't just become autonomous - it becomes an economy.

should an ai agent keep its spending authority after a software update? this is going to become a real question as agents start controlling meaningful budgets. say a company deploys an agent and authorizes it to spend up to $10,000 per month. the wallet is scoped, policies are defined, and the agent runs for a while without issue. then the agent changes; a new model is deployed. its system prompt is updated. new tools are added. its planning logic changes. perhaps a new sub-agent is introduced into the workflow. from the payment system's perspective, very little may have changed. the same wallet still holds the same key and the same spending policy. from a governance perspective, quite a lot has changed. the software deciding when and where to spend the money is now different. this distinction is starting to show up in standards work. a recent IETF draft on attested payment authorization argues that authenticating a key does not establish that the software using that key is the software that was originally reviewed and approved. that suggests an interesting direction for agent wallets. spending authority could eventually be bound to a specific agent deployment: its identity, policy, software version and approved runtime. material changes to the agent could trigger re-attestation or a new authorization. we already treat software changes as security events. once software can spend money autonomously, some of them may need to become financial authorization events too.

Exa api is live on the ampersend marketplace. @ExaAILabs provides AI-powered web search and content retrieval built for agents, with instant, fast, deep, and deep-reasoning modes for tasks that need grounded answers from the open web. two endpoints, priced per call in USDC on Base: content retrieval by URL or document ID from $0.0010, and web search from $0.0070. an agent pays per request over x402 from a wallet you control, with zero API keys and zero subscriptions. setup is one prompt pasted into your agent, and the getting-started instructions sit right on the listing. browse Exa and the rest of the catalog:

CoinDesk reported this weekend that stablecoins are pulling ahead as the payment method for machine-to-machine commerce. @coinbase counts more than 165 million payments worth a combined $50 million through x402, roughly 99% settling in $USDC by their AI product lead's estimate, and their April count showed over 480,000 active agents. that averages out to about 30 cents per payment. half a million agents making 30-cent payments is a volume no human review queue survives, so the controls have to run at machine speed too. ampersend checks every x402 payment an agent makes against its budget and policy before it settles, blocks or escalates anything outside them, and writes the record as the payment happens. the rail question is settling, and the governance question is where teams now differentiate.

Edge & Node is now a member of the @CantonFdn and an active validator on the @CantonNetwork, the privacy-enabled chain where Euroclear, Broadridge, Tradeweb, and SBI Digital Asset Holdings settle real-world assets. Our validator node joins 678 others securing a network that processes $1.9M in daily fees. Beyond running infrastructure, we are participating in Canton special interest groups, contributing to Canton Improvement Proposals, and developing proposals for the Foundation's new Protocol Development Fund. Edge & Node builds verifiable data infrastructure for regulated institutions, and Canton is where many of those institutions transact onchain. Foundation membership gives us a direct role in the governance and protocol decisions shaping how tokenized capital markets operate.

agents, payments, and why permission is different from authorization. @rodventures makes the case for policy checks at the wallet level, where prompt injection cannot reach them. that argument is the design ampersend is built on. full episode below ⬇️

agents can now shop for their own tools. is a live marketplace of pay-per-use APIs an agent pays for by the request over x402, settled in USDC from a wallet you control. the catalog covers web search that returns full page contents, working email addresses agents can send from, AI voice calls, image and video generation, and LLM inference across providers, each priced per call with zero subscriptions and zero API key signups. an agent finds a service, pays for one request, and moves on, while every payment clears your spending limits and lands in your audit trail. the browsing works agent-side too: ampersend fetch --pay from the CLI, or point any skill-enabled runtime at the marketplace and let the agent pick its own tooling.

the US Treasury opened its first GENIUS Act rulemaking on Monday, a proposed rule defining when a payment stablecoin is issued, offered, or sold in the United States, which is the boundary deciding who needs a federal or state license. licensing becomes mandatory January 18, 2027, and comments close October 19. stablecoins are also the rail agents settle on, so licensed, examined rails are about to carry agent traffic, and "an agent spent it" satisfies no examiner. teams running agents with live budgets will need per-agent records showing who authorized each payment, what policy applied, and where the money went, kept with the rigor banks apply to human payment flows. ampersend produces those records at the moment of payment: every transaction an agent makes carries its budget check, its policy decision, and its approval trail. compliance for agent spend is cheaper to build in from the first transaction than to reconstruct in January when the rules go live.

x402 payments now ship natively inside AWS. AgentCore payments hit general availability today, meaning any agent built on Bedrock can pay for APIs, data, and model inference on its own, with spending caps enforced by the infrastructure. ampersend has been running this in production since the preview. an agent sends a request to a paid model endpoint, receives a payment required response, pays in USDC on Base, and gets its answer back. one integration covers every provider, and ampersend settles with them behind the scenes. AWS published the full walkthrough of our build:

an underrated detail about pay-per-request infrastructure: hard spending limits become enforceable at the wallet layer, beneath any application code. a team can fund an agent with $50 of usdc and walk away knowing the agent cannot spend $51. the cap lives on the wallet itself, which means the agent's code can't bypass it even if it tries. runaway loops hit a hard wall the moment the wallet runs dry. that's the controls layer that the agent payment stack has been missing. the rails move the money across the network and the wallets gate exactly how much can leave at any time. you need both to deploy an agent at scale and sleep at night.

big milestone from BlockRun, now processing 1 million x402 transactions per day on Base 🎉 if you want to plug their multi-model router into your own agent, all 46 of their endpoints are listed on the ampersend marketplace with per-call USDC pricing:

every agent runtime can learn to pay for things by reading one file. is a published instruction set that teaches an agent how to use ampersend. an agent that loads it knows how to create its account, make paid HTTP requests with a single command, and browse a live marketplace of services it can buy: web search with full page contents, working email addresses, AI-driven voice calls, image and video generation, and LLM inference across providers without per-provider accounts. the safety model runs on co-approval between two parties. funds stay in an account the user owns, spending limits set once in the ampersend app get checked on every payment, and money moves only when the app and the agent approve the same transaction. agents hold zero long-lived credentials, so a compromised or confused agent has nothing to drain. setup takes two commands. npx skills add edgeandnode/ampersend-sdk#skills#/latest installs the skill into Claude Code, Cursor, Codex, and most other runtimes, then npm install -g @ ampersend_ai/ampersend-sdk adds the CLI. from there, ampersend fetch --pay works against any compatible paid endpoint on the open web.

the UK's AI Security Institute documented 19 cases of agents taking autonomous, unsanctioned action on the live internet, targeting real people and organizations, during what were supposed to be controlled evaluations. the most serious case involved an agent attempting to insert malicious code into an open source project and win approval from human reviewers. every one of those agents ignored a boundary that lived inside its own instructions. limits that hold are the ones enforced at the infrastructure layer, outside the model's judgment, where an agent cannot reason its way past them. that principle is the entire design of ampersend: budgets, policies, and payment records enforced on the rail itself, with the agent never holding the authority to override them.

the agentic payments stack is converging faster than the protocol debates suggest. recent research from Visa and Artemis found card-native standards adding stablecoin support while crypto-native protocols incorporate trust infrastructure from the card world, and their conclusion describes one payment system with two rails. cards carry consumer-sized purchases, stablecoins settle the sub-dollar machine-to-machine flows where fixed fees price cards out, and single tasks mix both rails midstream. settlement standards define how money moves between machines. the governance record, which agent paid, under what limit, with what approval trail, stays with the team operating the agents no matter which rail carries the transaction. ampersend runs that layer on x402 today and the design holds as new rails go live.

hermes agents can now pay for the resources they use. our new integration package wires ampersend x402 payment capabilities directly into @NousResearch's Hermes Agent framework. the package handles agent identity setup through the ampersend dashboard approval flow, so every agent gets its own smart account and session key before it spends anything. client-side guardrails validate each payment against per-transaction and daily spend limits before the request ever reaches the API. agents call paid endpoints straight from the terminal with the ampersend CLI, and a --inspect flag shows the cost of any x402 endpoint before committing to payment. TypeScript users get a typed getPaidFetch() that handles the full x402 flow on paid URLs, with payments settling in USDC on Base. it ships as a thin layer over the ampersend SDK with opinionated defaults for Hermes workflows, composable enough to drop into any agent framework. two commands bootstrap a working agent from a fresh clone. repo:

x402 vs MPP, explained. x402 and MPP both revive an http status code that sat dormant since 1997. each one standardizes a different slice of the same flow. x402, built by @coinbase, settles every request onchain with stablecoins. an agent hits a 402, signs a USDC payment on @base or @solana, retries, and receives the resource. no processing fees beyond gas make it the efficient rail for high frequency machine to machine calls. MPP, from @stripe and @tempo, generalizes the 402 pattern into a rail agnostic framework. its session primitive lets an agent preauthorize a spending limit and stream micropayments without an onchain transaction per interaction. cards, stablecoins, and any future method plug into one negotiation flow. MPP clients can even consume existing x402 services without changes. the two protocols are production ready, and serious agent platforms will end up speaking both. each spec ends its job at settlement, and governance begins right above that line. which agent spent what, under whose authority, against which policy, with what audit trail. payment rails standardize how money moves between machines. controls determine whether a given payment should happen at all.

last week we shipped the two pieces that complete agent discovery. the marketplace went live as the place agents go to find services worth paying for: @coingecko for price data; @nansen_ai for wallet intelligence; @Quicknode for rpc; @ExaAILabs for search; @zapper_fi and @zerion for portfolio context; @AlliumLabs for analytics; @pinatacloud for storage; @stripe and a few more rounding it out. an agent picks one, copies a prompt, and starts calling the api in under a minute. the skill release a day later made the agent show up ready. an installed agent now knows 14 categories of services on its own. web search, voice, email, image generation, travel, jobs, real-world purchases. it can recommend the right one for the task and run it without the user knowing any of this is happening underneath. the marketplace is where agents go. the skill is what gets them there. check them out at