Hiring is slow. Payroll is expensive. Compliance is a maze. Yet software companies still spend most of their time coordinating people to push buttons that software could make itself. The next generation of breakout companies will flip that model on its head. They will be small founding teams with fleets of on-chain AI agents that negotiate, buy, sell, route orders, pay vendors, file receipts, and even hire other agents. Revenue scales without headcount. Operations run at block time. And the paper trail is on-chain by default.
This is not sci-fi. The rails for autonomous commerce are arriving fast: agent payment standards, intent-based execution across chains, account-abstraction wallets, and marketplaces where you can spin up task-specific agents and meter them like cloud services. Below is a grounded tour of the stack, the early playbooks, the risks, and a 90-day plan to build an “almost-no-employees” company from day one.
Why does this flip the startup org chart?
1) Payments designed for software workers.
Google’s Agent Payments Protocol (AP2) gives AI agents a standard to spend on your behalf using cryptographically signed mandates. One mandate can cap spend, set duration, and define which merchants or blockchains the agent may use. AP2 supports cards, real-time bank rails, and stablecoins, and it ships with hooks to popular agent-to-agent protocols so bots can pay each other without sharing raw keys.
2) Intent rails replace click-by-click workflows.
Cross-chain “intents” let you describe the outcome, not the steps. A standard, co-authored by Uniswap Labs and Across (ERC-7683), defines how a user or agent can post an intent, such as “bridge 1 ETH from chain A to at least X USDC on chain B,” while competing solvers handle routing and settlement. That is precisely the abstraction autonomous agents need to do complex work safely.
3) Accounts that enforce policy, not just signatures.
Account abstraction turned wallets into programmable accounts. With ERC-4337 widely deployed and Ethereum’s 2025 upgrade adding EIP-7702 capabilities, you can delegate specific actions to smart-contract logic while keeping ultimate control of the key. That means daily spend limits, session keys, and recovery baked into the wallet, which is ideal when software, not employees, is doing the clicking.
4) A labor market for agents.
Olas (Autonolas) runs a bazaar where developers publish agent apps, stake them, earn fees, and even let agents hire other agents for specialized tasks, such as prediction-market trading. It looks like an app store, except the “apps” can run unattended and settle on-chain.
5) Verifiable AI in the loop.
Heavy models will not live on an L1, but they do not have to. Ritual’s Infernet lets smart contracts request off-chain inference and write back proofs and outputs that other contracts can verify. That gives your company an auditable record of “the model ran, here is the result we paid for.”
Put these together, and you get a company where the unit of work is an on-chain transaction produced by an agent with a budget, a mandate, and a receipt.
What these “agent-first” companies actually do
Here are early jobs that are practical today and compound value fast:
-
DeFi operations. Agents rebalance inventory as markets drift, claim and restake rewards when fees are low, and route swaps through intent auctions for better execution. ERC-7683-style flows let a single instruction handle bridge, swap, and settlement atomically.
-
Procurement and subscriptions. Agents maintain credits for API calls, GPU time, and SaaS seats. They pay through AP2 mandates with daily caps and instant revocation, including stablecoin rails for micro-purchases.
-
Market making for long-tail assets. Small pools need constant quoting and hedging. Agents can split coverage by hour or pair and hand receipts to your books in real time.
-
Cross-chain errands. Bridge, swap, stake, and move revenue to the proper chain based on fee and slippage budgets, all with one intent. This removes a whole class of brittle ops scripts.
-
Meta-work: hiring other agents. Your treasury agent can post a bounty to a marketplace, hire a “swap agent” for one job, and settle automatically when the job is proven. Olas explicitly supports agent-to-agent marketplaces for this pattern.
“No employees” sounds cute. What about the business plumbing?
Payments and accounting.
AP2’s mandates give you SOC-friendly controls: who authorized the spend, the limit, and the audit trail. Cloudflare is even launching a dollar-backed NET Dollar stablecoin and a machine-to-machine payments foundation with Coinbase to make agent commerce cheap and global. Expect more vendors to accept agent-originated payments as these rails spread.
Custody and risk.
Account-abstraction wallets enforce limits in code. Pair that with role-scoped keys and time-locked actions for anything high impact. The 2025 Ethereum upgrade made it easier to delegate logic to contracts while retaining key control, which reduces the “agent ran away with funds” fear.
Vendor management.
In an agent app store, your “vendors” are agent services with staking, SLAs, and on-chain reputation. Poor performance gets slashed. Good performance climbs the rankings. Olas and similar networks are leaning into this model.
Data provenance.
Ritual’s approach ties inference outputs to on-chain receipts, so you can prove the model execution that drove a trade or purchase. That reduces disputes and makes audits sane.
The competitive angle: why the agent-first company wins
-
Speed. Intents settle in minutes across chains. An agent can rebalance at 3 a.m., wait until gas is cheap, and never forget to revoke a stale approval.
-
Cost. You pay per outcome. AP2 and solver auctions compress overhead by funding only successful fills or policy-compliant purchases.
-
Coverage. A small team can orchestrate hundreds of micro-decisions daily. That is impossible with a human-only ops desk.
-
Proof. Every action has a receipt. That makes governance, compliance, and investor reporting easier, not harder.
No surprise, then, that investors are pouring money into agent infrastructure, and usage is climbing. Industry tallies in 2025 put AI-agent-focused raises into the billions and show double-digit growth in on-chain agent activity.
What an “agent workforce” looks like in practice
Picture a dashboard with five tiles:
-
Treasury Rebalancer
Mandate: keep 12–18 months of stablecoin runway, cap vendor concentration at 7 percent, and respect a daily spend cap. Inputs: prices, fees, payables. Actions: small rebalances via intents, approvals via AP2, receipts on-chain. -
Revenue Router
Mandate: bridge and swap weekly revenue to the target chain and asset with a max 0.3 percent slippage and gas under a threshold. Uses ERC-7683 flows to combine steps. -
Procurement Agent
Mandate: maintain GPU credits and SaaS seats with a rolling buffer, shop across providers, and never exceed the daily mandate. Pays vendors through AP2. -
Risk Sentinel
Mandate: alert and throttle if fees spike, if an exchange route degrades, or if a vendor’s SLA drops. Kick non-performing agents and re-hire from the marketplace. -
Inference Broker
Mandate: send jobs to verifiable runtimes and archive outputs plus proofs for audits. Ritual-style receipts anchor the trail.
Five boxes, zero payroll. You still have humans for strategy, BD, and product, but the “back office” is code.
Risks and how to keep them small
-
Runaway spend. Never give blanket keys. Use mandate caps, allow-lists, short durations, and session keys. Revoke on the first anomaly. AP2 bakes this in.
-
Fragile integrations. Favor standards. ERC-7683 for intents, ERC-4337/EIP-7702 for accounts, and marketplaces that stake agents for quality.
-
Opaque models. Tie inference to verifiable runtimes and require a human-readable rationale in every receipt.
-
Payment acceptance. Some vendors are not ready for payments originating from bots. The gap is closing fast as AP2 rolls out support for card networks, PayPal, and crypto.
-
Liquidity and MEV. Use private or auctioned flows via intent solvers to reduce predatory execution during volatile periods.
A 90-day plan to build an agent-heavy startup
Days 1–15: Write the rules down
Define three policies you already follow: runway months, daily spend cap, and max slippage. Choose an account-abstraction wallet and set per-agent permissions with short session durations.
Days 16–30: Wire payments and intents
Register AP2 mandates for “Ops Purchases” and “Compute Credits.” Add an intents router that supports ERC-7683 so your agents can bridge and swap in a single step. Dry-run flows on testnets.
Days 31–60: Hire your first two agents
From an agent marketplace, launch a Procurement Agent and a Revenue Router with tight caps. Require receipts that show “policy met” and cost vs. alternatives.
Days 61–90: Close the loop
Add a Risk Sentinel and move model-based decisions to a verifiable AI runtime with on-chain proofs. Start measuring four KPIs: spend within mandate, prevented slippage vs. naive route, failed transactions, and time-to-settlement.
By the end of the quarter, routine ops should run without tickets or headcount.
How does this change fundraising and metrics
Investors will start asking a different set of questions:
-
Agent efficiency: dollars of gross margin per dollar of agent spend
-
Intent fill quality: average slippage vs. RFQ quotes across chains
-
Autonomy ratio: percent of ops executed by agents vs. humans
-
MTTR for incidents: blocks from anomaly to mitigation
-
Receipt coverage: share of revenue and costs with verifiable on-chain proofs of action
If your numbers look good, your company scales like software, not services.
The bigger picture: from apps to an agentic internet
Analysts are calling this shift the agentic internet. Instead of users clicking through apps, agents talk to other agents, buy things through shared protocols, and settle money instantly. Whoever controls the standards for communication and payments will shape the next decade. Google is pushing AP2, A2A, and MCP integrations with major payment firms. Cloudflare is shipping a stablecoin and a foundation for machine-to-machine payments. The race to define the rails is on.
Bottom line
The next unicorns will not employ thousands of people. They will orchestrate thousands of agents. Payments are catching up. Intents are standardizing. Wallets enforce policy in code. Marketplaces let you hire software like contractors. And every step can be verified on-chain.
If you are starting today, do not hire for manual workflows that you can express as a mandate and an intent. Hire a small team to write the rules, wire the rails, and pick the agents. Let software handle the rest, and keep the receipts.