· ·

The spend layer for AI agents — TypeScript SDK. Pay any of 2,000+ vendor API services through one endpoint, with budgets your agent can reason about. Walletless. No crypto required.

Website · Docs · Dashboard · Python SDK

Your agent calls paid APIs — LLMs, voice, search, data. Floe is the spend layer in front of those calls:

• One endpoint, many vendors. Pay any x402 API through the Floe facilitator. No per-vendor accounts or keys.
• Budgets the agent can reason about. Ask "do I have budget? is this call worth it?" before paying.
• Programmable spend controls. Per-call caps, daily limits, allowed destinations, session ceilings — enforced server-side, before money moves.
• Walletless. Email + a funding source. Floe provisions wallets in the background — no MetaMask, no seed phrase, no gas. The stablecoin rails are invisible.
• Real-time visibility. Every call is a typed receipt: target, amount, status, time.

Two layers in one package:

FloeAgent (the runtime client) can be used standalone:

npm install floe-agent

The AgentKit action providers need @coinbase/agentkit and its peers:

npm install floe-agent @coinbase/agentkit viem zod

No wallet, no chain. Your agent pays for an API and stays inside its budget.

import { FloeAgent } from "floe-agent";

const agent = new FloeAgent({ apiKey: process.env.FLOE_API_KEY });

// Check budget before spending. `balance()` returns a plain number.
const available = await agent.balance();   // dollars available to spend
// For active loans, pending settlements, and raw units, use:
//   const detail = await agent.balanceDetails(); // BalanceResult

// Pay any x402 API. The agent never touches the payment layer.
const res = await agent.fetch({
  url: "https://api.exa.ai/search",
  method: "POST",
  body: JSON.stringify({ query: "AI agent frameworks" }),
});
// res is a FetchResult: res.body (string), res.cost (USDC dollars), res.status

Fund with fiat: operators fund the wallet with USDC via Coinbase — card, bank transfer, Apple Pay, Google Pay — directly from the dashboard. No crypto on-ramp.

Get an agent key: dashboard → connect → Create an agent → copy the floe_<hex> key (shown once).

Most SDKs let an agent spend. Floe lets an agent reason about spend before it commits, then stops it before it overruns.

// 1. Preflight the cost against your balance — no payment is made.
const estimate = await agent.estimateCost("https://api.example.com/premium");
// estimate => { cost: number; canAfford: boolean; isPaid: boolean }

// 2. Only pay if the agent can afford it.
if (estimate.canAfford) {
  await agent.fetch({
    url: "https://api.example.com/premium",
    method: "POST",
    body: JSON.stringify({ prompt: "..." }),
  });
}

This is the "answer the three rational-agent questions in one round-trip" workflow: Do I have budget? Is this call worth it? Where am I in my spend?

The lower-level x402ActionProvider action estimate_x402_cost is a separate API that returns a richer reflection (willExceedAvailable / willExceedSpendLimit) for AgentKit tool calls — see the Advanced section.

// Vercel AI SDK (requires: npm install floe-agent @coinbase/agentkit viem zod)
import { AgentKit } from "@coinbase/agentkit";
import { getVercelAITools } from "@coinbase/agentkit-vercel-ai-sdk";
import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";
import { floeActionProvider, x402ActionProvider } from "floe-agent";

const agentkit = await AgentKit.from({
  walletProvider,
  actionProviders: [
    floeActionProvider(),
    x402ActionProvider({ facilitatorApiKey: process.env.FLOE_FACILITATOR_API_KEY }),
  ],
});

const tools = await getVercelAITools(agentkit);
const { text } = await generateText({
  model: openai("gpt-4o"),
  tools,
  maxSteps: 10,
  prompt: "What did my agent spend today?",
});

// MCP (Claude Desktop / Claude Code / Cursor) — zero install
{ "mcpServers": { "floe": {
  "url": "https://mcp.floelabs.xyz/mcp",
  "transport": "streamable-http"
} } }

npm install floe-agent @coinbase/agentkit viem zod

import { AgentKit } from "@coinbase/agentkit";
import { floeActionProvider, x402ActionProvider } from "floe-agent";

const agentkit = await AgentKit.from({
  walletProvider,
  actionProviders: [
    floeActionProvider({ knownMarketIds: ["0x..."] }),
    x402ActionProvider({ facilitatorApiKey: process.env.FLOE_FACILITATOR_API_KEY }),
  ],
});

// Borrow against on-chain collateral. marketId is required — fetch via get_markets.
await agentkit.run("instant_borrow", {
  marketId: "0x...",
  borrowAmount: "9500000000",
  collateralAmount: "10000000000",
  maxInterestRateBps: "800",
  duration: "1209600",
});

import { AgentKit } from "@coinbase/agentkit";
import { floeActionProvider, x402ActionProvider } from "floe-agent";

const agentkit = await AgentKit.from({
  walletProvider,
  actionProviders: [
    floeActionProvider(),
    x402ActionProvider({ facilitatorApiKey: process.env.FLOE_FACILITATOR_API_KEY }),
  ],
});

npm install -g floe-agent
floe-agent

Interactive conversational agent for testing the full action surface. Prompts for wallet provider (Private Key or CDP MPC), AI provider (OpenAI / Anthropic / Ollama), and Base RPC URL. Config saved to .floe-agent.json; API keys are never cached.

See floe-examples for end-to-end multi-framework agents. The examples/ directory here has a Vercel AI SDK chatbot (chatbot.ts) and a no-framework standalone script (standalone.ts).

# npm link (live symlink)
npm run build && npm link        # then `npm link floe-agent` in your project

# npm pack (simulates a real publish — safest validation)
npm run build && npm pack        # creates floe-agent-<version>.tgz
npm pack --dry-run               # should include only dist/, README.md, package.json

Floe ships the spend layer first and builds credit on top of it.

• Working capital / credit lines — in development.
• Unsecured / receivables-backed credit — in development. Email hello@floelabs.xyz for the design-partner program.
• Portable ERC-8004 credit record — in development.

Website · Docs · Python SDK · MCP server · Examples

MIT