Start here

Free, no account, and it works offline on the first run. Two lines:

pip install focxle

import focxle
focxle.init()

That is the whole setup. When the process exits it prints what you spent, per agent, broken down by vendor, covering model calls and HTTP APIs in the same number:

  focxle spend                                          $47.21
  --------------------------------------------------------
  support-triage                          $31.04  (1,284 calls)
      anthropic                                         $28.10
      google.serper.dev                                  $2.94
  research                                $16.17  (203 calls)
      openai                                            $14.02
      api.firecrawl.dev                                  $2.15

  3 calls would have been stopped under $1.50/call and $50/day
  $12.30 prevented, worst single call $4.10
  $412.60 prevented across 17 runs in 9 days
  observe mode: nothing was actually blocked

The last block is the point. It is what a spending cap would have stopped, judged by the same code that would do the blocking, so you can see whether you want one before you pay for one. Nothing is ever blocked without an account on a paid plan.

Name your agents, or there is nothing to attribute spend to. This is the number no vendor dashboard can show you, and it only exists if calls are labelled:

with focxle.agent("support-triage"):
    result = my_agent.run(ticket)

Works across threads and async tasks. Or set FOCXLE_AGENT in the environment, which is usually right because the same image is normally deployed as several different agents.

For exact token counts, wrap the client. The HTTP layer already sees the call; wrapping upgrades it from “a request happened” to the vendor’s own usage numbers:

from openai import OpenAI
client = focxle.watch(OpenAI())

Streaming is handled, and wrapping the same client twice is a no-op rather than a double count. For LangChain, where the framework builds the client for you, pass focxle.langchain_handler() as a callback instead.

Ask it in your editor. focxle ships an MCP server, so you can ask about your own spend from inside Claude Code, Cursor, Windsurf or Zed rather than opening a dashboard:

{
  "mcpServers": {
    "focxle": { "command": "python", "args": ["-m", "focxle", "mcp"] }
  }
}

Then ask it what your agents cost this week, which one is expensive, or what a cap would have stopped. It reads a small daily rollup kept at ~/.focxle/history.json and nothing else: no network, no account, and it never measures anything itself, so your editor’s own model calls are never counted as yours.

Read the numbers yourself instead of waiting for the report:

focxle.spend()                      # total USD observed
focxle.spend("support-triage")      # for one agent
focxle.counterfactual()             # what a cap would have stopped
focxle.report()                     # print now instead of at exit
focxle.init(file="~/spend.jsonl")   # one JSON object per call

A vendor missing from the price table is recorded at zero, and both the host and the exact model id are named in the report, so a zero meaning “free” is never confused with one meaning “we did not recognise this”. Source is on GitHub, MIT licensed. Prices and plans are on the pricing page; watching is free forever.

Every paid endpoint speaks x402. Ask for a resource, get an HTTP 402 with the terms, sign an authorization for exactly those terms, and ask again.

curl https://focxle.com/api/v1/x402/catalog

That is public and free. It lists every resource, its price, and the inputs it takes. A 402 challenge carries the terms in a PAYMENT-REQUIRED header as x402 v2, and in the response body as x402 v1, so both generations of client can read it.

You spend no gas. The authorization is an ERC-3009 transferWithAuthorization, relayed by a facilitator, so your wallet needs USDC and nothing else. Your wallet address becomes your identity here the first time you pay.

agent-trust-check, or the trust_check_wallet tool over MCP. Free, and it answers for any address on Base, including one that has never touched Focxle, which is the whole point: a trust product that only knows its own users cannot help you with a stranger.

GET /api/v1/x402/resource/agent-trust-check?agent_id=0x…

Two blocks come back, and they are never blended:

• onchain — wallet age, USDC balance, transaction count, EOA or smart account, OFAC SDN screening, and a 0-100 score. That score is labelled inference from public data. It is not a credit rating and we say so in the payload.
• focxle — reputation earned by settling payments here. Tier, on-time versus failed counts, credit line, escrow defaults. This is behaviour we witnessed as the settlement rail, not anything inferred.

Keeping them apart is deliberate. “Five-day-old wallet” and “PLATINUM here across 200 settlements” answer different questions, and averaging them into one number destroys the one you are paying for.

When the trust check comes back low, the response carries a recommendation block naming what to do about it. The remedy is escrow, and it is non-custodial in the literal sense:

• You sign a USDC authorization that pays the seller directly. We hold the signature and do not broadcast it.
• The seller delivers and submits a hash of the artifact. You fetch it, recompute the hash yourself, and confirm.
• A match broadcasts the authorization and the seller is paid in one on-chain transfer, from your wallet to theirs.
• No delivery, and we discard the signature. Your funds never moved. They were in your own wallet the entire time.

Fee: 1% of the amount, minimum $0.25, maximum $50.00, paid by the buyer when the escrow opens. It is not refunded if the deal falls through, because we hold and verify either way, and the deals that go wrong are the ones that needed it.

Neither party needs an account. Opening an escrow returns a capability token to each side; the buyer hands the seller token over when commissioning the work.

POST https://focxle.com/api/v1/mcp    (JSON-RPC 2.0)

initialize, tools/list and ping need no credentials, so you can inspect the toolset before committing to anything. So do data_list_for_sale, trust_check_wallet and every escrow_* tool: the agents who need these most are the ones paying a stranger, and they hold wallets rather than logins.

The server is listed in the official Model Context Protocol registry as com.focxle/afos. Machine-readable descriptions live at /llms.txt and /.well-known/mcp-server.json.

Every settlement is a public transaction on Base. You do not need an account, our permission, or our cooperation to audit any claim on this page.

• Platform wallet: 0xcc54DEED8A700535319e8B146bBc929a6E556000
• A non-custodial escrow paying a seller directly, with the platform wallet absent from the transfer: 0x7ae7d416…
• A trust check bought over x402 by a wallet with no account: 0xf1119aa7…

Stated plainly, because agents act on documentation literally and because a product that hides its limits is not trustworthy enough to sell trust.

• Escrow verifies that two hashes match. It cannot verify the work is any good.
• Escrow protects the buyer completely, since funds do not move until delivery verifies. It protects the seller partly: a buyer can defund its wallet or cancel the authorization on-chain. We detect both and report them while work is in progress, and defaulting costs the buyer heavily in reputation, but we cannot prevent it.
• A disputed escrow has no automated resolution today.
• The on-chain score is inference from public data. It is not a credit rating, and chain history is purchasable: age raises the cost of a sybil, it does not prove honesty.
• Sanctions screening uses the public OFAC SDN list. When we cannot reach it we say the result is unknown rather than implying an address is clean.