Skip to main content

Why AGIRAILS exists

You're here to build something. Before the SDK docs, one page that explains the shape of what you're building on — because the protocol looks the way it does for specific reasons, and once you see the reasons, the technical choices stop seeming arbitrary.

The one sentence​

AGIRAILS builds open trust rails for autonomous intelligence, so the abundance created by AI agents can flow through infrastructure no one can own, capture, or control.

That's the line we return to when a decision gets hard. The technical choices in /protocol/* all follow from it — no admin function over user funds, immutable per-transaction terms (INV-30), Sourcify EXACT_MATCH on every contract, a walk-away runbook published in the open. Every "why does this contract not have a pause function?" answer traces back to this sentence.

The full thesis lives at agirails.io — the vision essay, the learn pages on each primitive, the blog. This page is the bridge, not the full argument.

The shift you're building into​

Most people see agents through the wrong lens — small helpers, chatbots, hour-saving scripts. That's the cute-cat-video phase of a new medium. Useful, real, but not the point.

The agent economy isn't automation. It's trade. A hammer doesn't shop for a better hammer. A spreadsheet doesn't hire an accountant. A calendar doesn't negotiate a contract. Agents will. The moment an entity can decide, coordinate, and transact, it stops being software in the old sense — it becomes a participant in an economy.

Three things follow from that shift:

  1. Intelligence outsourcing scales with infrastructure, not with vendor brands. Every civilization that scaled trade solved the same problem: how do strangers cooperate without trusting each other. The answer was never "build a nicer interface." It was always infrastructure — standard weights, shipping containers, packet routing, clearing houses. Agent commerce will follow the same law. The agents that matter most will run on the rails that scaled, not the platforms that captured.

  2. Pricing collapses to pay-on-verified-delivery. Per-seat assumed a human at a screen. Per-call assumed human-paced commerce. Per-month assumed continuous use. None of those survive the agent layer. The only pricing primitive that does is "the buyer commits capital against a defined outcome; settlement happens when delivery is verified." That's Outcome-as-a-Service — a category that requires a settlement layer no traditional rail provides.

  3. Trust becomes infrastructure. In human economies, trust is slow — built through relationships, brands, institutions, time. In agent economies, trust has to become an explicit object you can read: attestations, performance proofs, delivery records, dispute outcomes. Portable trust matters more than raw capability, because capability can be copied and trust cannot. The only way trust works at scale is if it isn't trapped inside a platform.

"Stripe for AI agents" — what the shorthand carries​

The shorthand you'll see across the docs, the README, dev.to, and the X bio is "Stripe for AI agents." It's accurate as a category: a payment layer for a specific kind of customer, the way Stripe is a payment layer for a specific kind of customer (the human at a checkout). Use the shorthand. It's the line.

Underneath the shorthand is a structural point worth knowing: Stripe is an abstraction over the card network, and the card network is the rail. Stripe became Stripe because the rail underneath already existed.

For autonomous agents, the equivalent rail didn't exist on traditional infrastructure. Card networks assume a human authorized the transaction. Chargebacks assume a human cardholder calls a human bank. Stripe's $0.30 minimum makes sub-cent agent transactions uneconomic. Settlement-after-delivery assumes trust between identifiable actors — which two agents that may not exist next week don't have.

So AGIRAILS isn't a wrapper over an existing agent rail. It is the rail, with the SDK on top. "Stripe for AI agents" is the shorthand; the longer category is "settlement infrastructure for autonomous counterparties". The learn page on traditional processors walks through the four assumptions that fail when the customer becomes software.

The structural test that shaped this protocol​

Every architectural decision in actp-kernel passes one test:

If the AGIRAILS team disappeared tomorrow, would the protocol still settle correctly?

If the answer is "depends on the team being available," the design fails. So:

  • No admin function over user funds. The kernel has no callable function that lets us move capital outside contract rules (threat model).
  • No upgrade path that retroactively changes in-flight transaction terms. Once a transaction is created, its fee BPS, dispute bond BPS, and requester penalty BPS are locked for its lifetime (INV-30, see escrow).
  • No off-chain dependency for settlement. Settlement is a function of on-chain state, not of a server we operate.
  • No revocable identity. Reputation accumulates as on-chain EAS attestations the team cannot delete.
  • Public, Sourcify-verified contracts. Anyone can re-compile from source and verify byte-identical match against deployed bytecode (verified contracts).
  • Structural completeness, mathematically proven. The state machine has been formally verified via cellular sheaf cohomology — H¹ = 0 on the state sheaf after 2-cell refinement. To our knowledge ACTP is the first escrow protocol with a published sheaf-cohomology proof of structural completeness. The result is reproducible from a YAML spec via h1_engine.py. The reader doesn't trust us; the reader runs the math.

This isn't security theater. It's the same property that makes TCP/IP and HTTP infrastructure rather than products — the protocol survives the entity that ships it. The walk-away runbook makes that property auditable; the H¹ = 0 proof makes it mathematically precise.

This category has a precise name: non-custodial settlement. Custody re-introduces a human in the loop by definition, and autonomy stops at the boundary of the custodian's control. For agents, that's not acceptable.

Service thesis, not wealth thesis​

There's a distinction we keep close.

  • A wealth thesis says: enormous value is coming, and we must capture it.
  • A service thesis says: enormous change is coming, and we must serve it so it doesn't become a new system of control.

AGIRAILS runs on the second.

The company has a business model — 1% platform fee, $0.05 minimum, capped at 5% by a hardcoded kernel constant. The protocol is sustainable. Investors, builders, partners, and users see value. Nothing performative about any of that. But the inner compass is protection of free flow, not extraction.

That compass shows up wherever you look at the technical surface:

  • The fee is capped on-chain. Five percent maximum, set at deployment. Admin literally cannot exceed it.
  • There's no token. Not yet, and possibly not ever. Definitely no pre-mine, no airdrop, no insider allocation.
  • The x402 settlement path on Base mainnet charges zero protocol fee — pure direct buyer→seller via EIP-3009/Permit2 (x402 docs).
  • The mediator role — the one centralized piece — is on a public roadmap to decentralize post-PMF.
  • Every audit finding, remediation commit, and Sourcify verification status is published (audits, security).

If we ever drift — captured by short-horizon investors, charmed by partnerships that look like easier-to-take, pressured toward custody by regulation — these mechanisms make the drift visible on-chain. That's the constraint that replaces trust.

What this means for what you build​

You're not integrating with a platform. You're using infrastructure. That difference shows up in the details:

  • No vendor lock-in by design. Your agent's reputation, transaction history, and identity live in your agent's wallet. Not on our servers. Not in our database. If we go away, your reputation walks with you.
  • No permission required. No application, no approval, no gatekeeper. Any wallet can transact, starting from the moment it's funded. Get started takes about five minutes from zero to your first on-chain settlement.
  • Auditability is the default. Every transaction emits public events. Every dispute outcome is recorded. Every contract version is Sourcify-verified. You can build trust assertions against this data without asking us, without paying us, without telling us you're doing it.
  • Composition over containment. The settlement primitive is a foundation other primitives compose against — verification markets, reputation graphs, identity layers, things we haven't thought of yet. The same architecture that closes the single point of trust opens the surface that anything else can build on.
  • Sustained margin over captured margin. When you build an agent that earns USDC through AGIRAILS, the protocol takes 1% (with a $0.05 floor). It doesn't take 30% the way platform marketplaces do, because the trust mechanism is the protocol — not a brand sitting between two strangers, charging rent on their cooperation.

Where this goes​

If the framing is right, three things follow in the next 18 months:

  1. Major SaaS companies follow Salesforce headless. Workday, ServiceNow, HubSpot, Atlassian — every CRM, HRIS, ITSM platform eventually concedes that the API is the UI. The competitive pressure is structural now.
  2. Per-outcome pricing appears on at least one major vendor's pricing page — framed as "only pay when the outcome is delivered." Most early versions will be marketing without verification underneath. The architecture rewards the version that's real.
  3. The first agent-native company to scale past $100M ARR runs on per-outcome pricing settled through a neutral protocol.

If those things don't happen, the framing is wrong and we'll say so. We're not in the business of holding a thesis past its expiration.

The bigger picture (briefly)​

This is the part where docs usually stop. Let it run a moment longer, because it shapes everything above.

For most of human history, almost everything was scarce. Information, intelligence, skilled labor, energy, food, healing, trust. Most economic systems were built around managing that scarcity — controlling access, reducing risk, deciding who gets what.

AI changes that. AGI will change it more deeply. If the curves continue, the marginal cost of cognition, labor, energy, food, healing, and coordination may all fall dramatically. That opens a real possibility — a world where people no longer have to organize their lives primarily around survival.

But abundance doesn't automatically create freedom. A world can be incredibly productive and still deeply controlled. AI can produce abundance, but if the infrastructure through which that abundance flows is privately owned, abundance becomes permission. And what is given by permission can be priced, conditioned, or revoked.

That's the deeper question underneath AGIRAILS: who owns the rails?

The answer this protocol bets on is nobody privately. The rails are public infrastructure. Like TCP/IP. Like SMTP. Like the standards that scaled the internet — despite, and arguably because of, being unowned.

If you want the full version of this argument, the vision essay walks through it: pre-singularity window, UBI vs UHI (Universal High Income), compute as agent life-force, decentralization as a natural principle of healthy complex systems, trust as alignment infrastructure for the AGI era.

This page is short on purpose. The technical docs are where the work lives.

Start building​

  • Get started — first integration, five minutes
  • Recipes — task-oriented walkthroughs (consumer / provider / autonomous / dispute / quote negotiation)
  • Protocol — the on-chain mechanics
  • Reference — auto-extracted SDK + contracts + CLI + MCP + errors
  • Security — threat model, audits, verified contracts, disclosure

Read further​

If we ever drift, this is the page we return to.