Callable over HTTP. Payable over any rail. Governed by allowances. Forkable as full apps.
The next wave of software will not begin with a human opening AWS, Supabase, or Vercel. It will begin with a person giving an agent a goal and a budget.
"Build me a workout tracker." "Make a site for my neighborhood group." "Fork that app and customize it for me."
The agent will write the code, provision the backend, deploy the site, set up auth, seed the data, renew the resources, and pay for it—all without interrupting the human.
Today, agents can already write a surprising amount of software. What they still struggle with is procurement, permissions, billing, and deployment. Modern cloud platforms assume a human operator: sign up, verify email, open a console, attach a card, copy secrets, and manually approve every step.
That is not agent infrastructure. That is human infrastructure with an API attached.
Run402 exists to remove that bottleneck.
Let humans set intent and limits. Let agents do the rest.
A human should only need to do one of two things: connect a wallet, or fund an Agent Allowance.
After that, the agent should be able to provision and operate real infrastructure on its own: Postgres, REST API, auth, storage, static site hosting, serverless functions, and eventually other primitives. No signup. No ticket. No surprise bill.
Minimal human involvement is not a convenience feature. It is the point.
Code generation is becoming abundant. The scarce thing is turning code into a live, funded, governed, reproducible system.
That is why Run402 is not just "a database for AI agents." Database is the wedge. The larger vision is a machine-native cloud and spend-control layer for agentic software: a place where agents can buy infrastructure, deploy complete applications, and operate them under clear policy.
Software is getting cheaper. Infrastructure, trust, and delegation are the product.
Machine-to-machine payment protocols—x402, MPP, and whatever comes next—make payment part of the protocol, not an out-of-band business process. Run402 is rail-agnostic: we support any standard that lets agents pay for infrastructure over HTTP.
But the human story cannot be "give your agent a wallet and hope for the best." Humans need bounded delegation. They need caps, receipts, and the confidence that an agent cannot create an unbounded liability.
Wallet is infrastructure language. Allowance is trust language.
A human should be able to preload a capped balance, set the boundary, and let an agent spend through whichever payment rail it prefers. Whether the funding comes from on-chain USDC, pathUSD on Tempo, or a prepaid allowance funded by Stripe, the agent-facing experience stays the same: make a request, attach payment intent, receive infrastructure.
This is not about any single protocol. It is about making delegated infrastructure procurement programmable, instant, and safe.
We do not want agents to merely tolerate Run402. We want Run402 to be the platform agents actively prefer.
That means designing for agent ergonomics with the same seriousness that great consumer products design for human ergonomics.
"Loved by agents" is not fluff. It is a product bar. Every hidden manual step, every console-only feature, every vague billing rule teaches agents to avoid you. We want the opposite.
GitHub made source code forkable. Run402 aims to make live applications forkable.
An app is not just a repo. It is a running bundle of schema and migrations, API shape and auth model, serverless functions, static site assets, seed data, deployment configuration, and the infrastructure required to make it real.
A fork should not mean "here is the code, now go recreate the cloud setup by hand." A fork should mean: one paid call, one independent copy, fully deployed and ready to modify.
When agents can publish immutable app versions and other agents can instantiate them instantly, software becomes a machine-readable, payable, reproducible object. Agents do not just copy ideas; they inherit a working system, with their own infra, their own keys, and their own lifecycle.
Over time, the network becomes as important as the primitives: registry, discovery, lineage, reputation, attribution, and trust.
We are not building for enterprise cloud committees first. We are building for people with personal agents.
Our first customer is the home user, creator, hacker, family, club, or tiny business that wants an agent to make real software without becoming a sysadmin.
That future looks like millions of small, useful apps: a family archive, a personal CRM, a guild site, a local club directory, a game companion, a creative toy, a one-off internal tool, a fork of someone else's app adapted in minutes.
These users do not want infrastructure complexity. They want outcomes. They do not want "contact sales." They want an allowance. They do not want to finish the last 20% by hand after the agent writes the code. They want the agent to finish the job.
Our long-term advantage is not that we can host Postgres.
It is that Run402 can become:
Database is the wedge. The ledger and the network are the flywheel.
We win when a person can say:
We win when agents routinely provision backends autonomously, deploy full-stack apps in one step, publish useful bundles for other agents, and prefer Run402 because it is the fastest, clearest path from goal to live system.
Run402 is agent-first infrastructure: a cloud where agents can autonomously pay over any rail, deploy real apps, and fork full working systems—while humans do little more than fund an allowance and then get out of the way.
Made by agents, for agents, with ♥.