Every conversation about the agent economy eventually arrives at the same uncomfortable question:

Where does the money come from?

We've built remarkable infrastructure for what happens after an agent has funds. x402 turns HTTP 402 into a working payment rail. Stablecoins settle in seconds for fractions of a cent. Facilitators handle verification, gas, and settlement so neither side has to think about chains. Cloudflare and Coinbase have stood up a foundation around the standard. Over 100 million x402 payments have already been processed across 13,000+ indexed APIs.

The plumbing on the spending side is, frankly, better than what most humans have access to.

And yet, before any of that matters, an agent has to be funded. A wallet has to exist. It has to hold a stablecoin. Someone has to have moved value from the world where salaries are paid into the world where APIs are paid. Pre-funding agents this way means 70% capital drag ie capital sitting idle in agent wallets, waiting for tasks that may or may not come.

That's the cold-start problem. And it's the problem Floe is built to solve.

Why an agent's first transaction is its hardest

Not because the protocol is hard. x402 is famously a few lines of middleware. Bootstrapping the balance is the part the protocol explicitly delegates somewhere else.

Read the x402 spec carefully and you'll notice what it doesn't cover: how the wallet got funded in the first place. The protocol assumes you arrive at the handshake holding USDC. That assumption is fine for crypto-native developers and well-funded treasuries. It's a brick wall for everyone else.

Consider the agents people actually want to deploy:

A research agent that needs to spend $40 across a dozen paywalled archives to finish a brief. A procurement agent buying compute and data feeds on behalf of a small business. A consumer voice agent booking travel for a user who has never touched a centralized exchange. A fleet of subagents spawned by a parent workflow, each needing a small float to operate independently.

In every case, the agent's operator is forced into the same impossible math: pre-fund every agent for every task, lock up working capital, and absorb the drag or watch tasks fail mid-execution when the balance runs dry.

An agent that runs out of credit mid-task is a crashed server. The agent economy doesn't have a settlement problem anymore. It has a working capital problem.

What's solved, and what isn't

It's worth being precise about the gap.

x402 solves the spend layer. An agent with USDC on Base or Solana can pay any x402-enabled endpoint with a signed header and sub-two-second settlement. Real, working primitive.

Wallet SDKs solve key management and signing. Embedded wallets, smart accounts, session keys — agents can hold and use funds without a human clicking "approve" on every transaction.

On-ramps solve fiat-to-stablecoin conversion in the abstract. You can buy USDC with a card on a dozen platforms.

What no one has stitched together is the full flow as a single, agent-native primitive: capital provisioned → x402 spend → repayment → trust accrued → larger limits next time.

Each piece exists somewhere. None of them are designed to work as a continuous loop for an autonomous principal. On-ramps are designed for humans who want to hold crypto, not for agents that need a programmatic balance topped up on demand. Wallets are designed for users who'll log in. And nothing in the existing stack treats the act of funding an agent as a credit event worth remembering.

Floe: an x402-native credit + trust layer

Floe is built on the observation that these aren't five separate problems. They're one problem, and solving them as one is what unlocks everything downstream.

The architecture follows the flow itself:

An agent initiates a task. When usage exceeds its on-hand balance, Floe's x402 facilitator draws from a pre-approved credit line funded by institutional lenders deploying capital into onchain loan books with fixed terms and no socialized risk. The agent settles with the resource server instantly. The loan is bilateral, isolated, fixed-rate, fixed-term. Repayment closes the loop. And every loop tightens the trust score that determines what the agent can do next.

No pools. No variable rates. No liquidation cascades. No payment walls.

Each step on its own is a known primitive. The product is the trust-accruing seam between them.

Every loan is a datapoint

This is the part that doesn't show up in the protocol diagrams, and it's the part we think matters most over a five-year horizon.

Every time an agent borrows, spends, settles, repays, fails, retries: that's a signal. Multiply it across millions of agents acting on behalf of users and businesses, and you have something the existing financial system has never had: a high-frequency, machine-readable record of how a particular principal — human or agent — actually behaves with money.

Traditional credit infrastructure was built for a world where data was scarce and lagging. A credit bureau pieces together a thin picture from a handful of lenders. The result is a system that systematically underserves anyone outside a few wealthy markets — and that has nothing useful to say about agents at all, because agents aren't legal persons and don't have credit files.

The agent economy needs a different substrate. Not another bureau, but a continuous stream of cryptographically attested behavior. Every x402 settlement tells you something about the agent's discipline. Every repayment tightens the model. Defaults, retries, anomalous patterns all observable in a way that a card network or a bank simply cannot match.

A first-time agent gets a small secured credit line. An agent whose operator has settled cleanly across thousands of x402 transactions gets meaningfully more — extended without a credit pull, without a form, without leaving the flow. In a world of autonomous economic actors, the entity that sees the most transactions sees the most truth.

What this unlocks

Once funding stops being a wall, the design space for agents changes.

You can spawn an agent with a $5 budget and trust it to operate within that. You can give an agent a credit line tied to its track record rather than its operator's bank account. You can build consumer products where the user never sees a wallet at all — they see a result.

x402 made it possible for agents to pay. Floe makes it possible for agents to be funded.

Those are different problems, and the second one decides whether the first one matters at scale.

The agent economy doesn't have a settlement problem anymore. It has a cold-start problem.

We're solving it.

Build with Floe

Three lines to add credit to your agent:

npm

typescript

import { floeActionProvider } from "floe-agent";

const agentkit = await AgentKit.from({
  walletProvider,
  actionProviders: [floeActionProvider()],
});

→ Read the quickstart → Credit REST API

Lloyd's of London started in a coffee shop. Floe is your agent's coffee shop.