BlockRun
Products

Three products, one loop.

Find out which AI actually works on your work, send every task to that one, and pay for what actually happened. Each answer feeds the next: measure the outcome and the evaluation runs again.

  1. Evaluate
  2. Route
  3. Measure the outcome
  4. Re-evaluate
01VERIFIED EVAL

Evaluate

Know which AI actually works on your workload

A public benchmark tells you which model is good at a public benchmark. Give us two hundred to five hundred cases out of your production and we measure which model and configuration completes your workload, and what each one costs per task that actually finished.

How it is delivered today
  • Scored program-verifiably: tests pass, exact match, correct end state. Never a model grading a model.
  • We are the gateway the calls run through, so the cost in the report is what was charged, not a rate card times a token count.
  • You get the numbers, where the failures cluster, and a policy you can deploy or ignore.

Not yet: We measure it for you. We do not yet tell you what usually wins — that answer needs many comparable workloads behind it, and saying it early is how you get caught by the customer whose result disagrees.

02OPEN SOURCE

Route

Send every task to the system that wins it

Everyone else picks on price and latency. A finding says which configuration completes the work, and ClawRouter is what turns that finding into the choice your agent makes on every call — over 105 models reachable from one endpoint.

How it is delivered today
  • ClawRouter — MIT, on npm, runs on your side. Plugins for DeepSeek Harness, Hermes and OpenAI Codex.
  • Franklin — our own agent, running the same policy end to end.
  • The gateway — one OpenAI-compatible endpoint, 78 chat models from 13 providers, plus image, video, music and speech.

Not yet: The gateway does not pick models for you. It calls the model you asked for, allow_fallback is off by default, and every substitution it does make is disclosed in the response headers. Selection is ClawRouter's job, on your side of the wire.

03LIVE

Settle

Pay for what actually happened

Per call, at the provider's published rate plus a fixed fee. No subscription, no seat, no minimum, and no invoice for capacity you did not use.

How it is delivered today
  • USDC on Base and Solana, settled per call — no account, no API key, no card.
  • Every paid call returns a receipt and an id you can join to your own records one to one.
  • Enterprise pays by monthly invoice against the same per-call numbers.

Not yet: Outcome-based settlement — paying for the result rather than the call — is where this goes next. It is not running today, and nothing on this page should be read as if it were.

One endpoint, whichever product you came for.

Evaluation runs through it, ClawRouter calls it, and settlement happens on it. It is OpenAI-compatible, so pointing an existing SDK at it is a base URL change.

Point an OpenAI client at one base URL. Every model, one wire format.

POST /v1/chat/completions

{
  "model": "openai/gpt-5.6-luna",
  "messages": [
    { "role": "user",
      "content": "In one sentence: what does a routing layer do?" }
  ],
  "max_tokens": 120
}
Response
{
  "model": "openai/gpt-5.6-luna",
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "A routing layer directs incoming requests or data
                  to the appropriate destination, service, or
                  processing path."
    },
    "finish_reason": "stop"
  }],
  "usage": { "prompt_tokens": 17, "completion_tokens": 23,
             "total_tokens": 40 }
}

Real responses, captured from the gateway — not illustrative.

What delivers them

Five pieces of software, all of them shipping, plus the endpoint above. None of them is the product on its own — they are how the three above reach your stack.

Franklin

Our own agent with a wallet, running evaluate → route → settle end to end.

ClawRouter

The router itself. MIT, installed from npm, with three harness plugins.

BlockRun MCP

19 tools inside Claude Code, Cursor and ChatGPT — chat, media, search, markets, RPC.

Data and runtime services

Neural search, prediction markets, equity tickers, multi-chain RPC, sandboxed compute, voice — priced per call like the models.

SDKs

Python, TypeScript and Go. MIT, on the public registries, payment signing handled for you.

Start with the measurement.

The loop only has one honest entry point. Send us one workflow that already runs and we will tell you what completes it and what that costs — then routing and settlement are decisions you make with a number in hand.