BlockRun
← All Services

PER CALL · JUDGMENT

Yes/no, choice and score decisions for agents, about a tenth of a cent each

About $0.0012 for a typical call: the input tokens at the model's own rate plus a $0.001 fee, and nothing for output. An agent that has to decide something usually asks a chat model and hopes the answer parses. Ask this instead: send the evidence and the questions, get one typed answer per question with a number beside it. It speaks OpenAI's Decisions API, request and response, so an OpenAI SDK works with our base URL.

Three question types, one request

Predicate: yes / no, with a probability
Not a bare boolean. You get how likely the condition is to hold, so an agent can set its own threshold instead of inheriting someone else's.
Choice: one of your values, every value scored
Route a ticket, pick a label, classify an intent. The winner comes back with the distribution behind it and a confidence.
Score: a position on a rubric you write
Describe the levels in words — no rush, this week, today, now — and get a weighted position across them plus the distribution behind it.

Ask several about the same evidence in a single call. The evidence can be text, or messages carrying text and inline images.

A judgment is not a short answer — it is a different kind of output

A chat model returns text and you hope it parses. This returns a value with a type, and a number beside it. Nothing is generated — the response reports output_tokens: 0 — so there is no field a sentence could come back in: you define the answer space, and the answer comes back inside it. One real customer message, three questions, one call, measured on 2026-10-07:

TypeThe question it answersYou defineYou got back
predicateIs this customer at risk of leaving?nothing — it holds or it does notprobability 0.95
choiceWhat part of the product is this about?checkout, search, delivery, account"checkout", confidence 1.0
scoreHow urgently does this need a reply?no rush, this week, today, now2.23 — past "today", short of "now"

The message: “Honestly the checkout flow is a disaster. Third time this week it timed out and I gave up. I have been a customer for six years and I am about done.” Sent three times, it returned the same numbers three times, in 0.28s to 0.38s.

Two ways to call it

PAY PER CALL · WALLET

POST https://blockrun.ai/api/v1/decisions, paid over x402 from the agent's own wallet. The 402 quotes the estimated input tokens at $0.10 per million plus the $0.001 transaction fee, and that quote is what settles. Output is not billed.

The estimate is an upper bound: it counts every English character as a token and any other character at up to three, so it errs high rather than low. Nothing is charged unless the model answers.

REGISTERED KEY · CREDIT

POST https://api.blockrun.ai/v1/decisions with Authorization: Bearer and a key from user.blockrun.ai, billed from your credit on the input tokens the model reports.

For teams that already run on a BlockRun key.

What the number is, and the failure we measured

The model reports a probability for a predicate and a distribution for a choice or a score, rounded to two places. We have not measured how well those probabilities line up with real outcomes, so we do not call them calibrated. Treat them as the model's stated confidence and pick a threshold from your own labelled examples.

Here is why that matters. Ask the support router — billing, shipping, technical — about “The mitochondria is the powerhouse of the cell.” It answers technical at 0.94, three times out of three. The answer is wrong and the number does not warn you: a choice question always picks one of the values you offered.

The fix is in the question, not the threshold. Add a value for “none of these” and the same sentence comes back none at 0.99; a predicate asking whether it is a support request at all returns 0.0. Give every choice somewhere to put the case that fits nothing.

One call: the evidence, the questions, the answers

curl https://api.blockrun.ai/v1/decisions \
  -H "authorization: Bearer $BLOCKRUN_API_KEY" \
  -H 'content-type: application/json' \
  -d '{
    "model": "gpt-6-luna",
    "input": "Help! My payouts have been failing for 3 days.",
    "questions": [
      { "type": "predicate", "name": "is_urgent",
        "instructions": "Does this convey urgency?" },
      { "type": "choice", "name": "department",
        "instructions": "Which team should handle this?",
        "choices": [ { "value": "billing",   "description": "Payments, refunds" },
                     { "value": "technical", "description": "Bugs, outages" },
                     { "value": "none",      "description": "Fits neither" } ] },
      { "type": "score", "name": "frustration",
        "instructions": "How frustrated is the customer?",
        "levels": [ { "label": "calm",       "description": "No frustration" },
                    { "label": "frustrated", "description": "Clearly annoyed" },
                    { "label": "very angry", "description": "Hostile" } ] }
    ]
  }'

# Billed from your key's credit. With the OpenAI SDK:
#   OpenAI(base_url="https://api.blockrun.ai/v1", api_key=BLOCKRUN_API_KEY)

The response is { model, answers: [...], usage }, one answer per question in the order you asked. The key comes from user.blockrun.ai . Without a key, send the same body to /v1/decisions on blockrun.ai and pay the 402 from a wallet.

Where a judgment sits in a real workflow

  1. Gather the evidence: the customer's message, the transactions it refers to, the policy that governs it.
  2. Ask the independent questions together in one call.
  3. Combine the answers with deterministic checks your code already has: the amount, the account age, prior refunds.
  4. Route. Act automatically where the answer is clear and the checks agree; send the rest to a person or a reasoning model.

For the slice that needs deliberation, a reasoning model is one endpoint over, on the same key.

OpenJev is retired

Until 2026-10-07 this endpoint was answered by OpenJev, an open-source natural-language-inference model we hosted ourselves. It is gone. Its numbers were entailment shares rather than probabilities, it read sarcasm as praise, and its first call after a quiet spell took about half a minute.

If you integrated against /v1/decide, it still answers: the old noul / choice / score request is translated to this one. New code should send the Decisions shape above. Jev, TypeSafe's model, is a different product that we never served; OpenJev vs Jev keeps the history.

What this is not

It does not write, summarise, or explain. If what you want is a typed value out of a chat model instead, that is a different problem with its own traps — what response_format actually does per provider has the measurements. If the job is sorting text into labels you can name up front, the text classification API is this endpoint written up for that one job. For prose, the chat models are next door.

It has no memory between calls and judges what you send rather than looking anything up. If the judgment needs a fact from the web, fetch it with search and pass it in as evidence.

What a call costs

The model bills input tokens only, and so do we: at its own rate, with no markup, plus a $0.001 fee per paid call that covers settling the payment. A one-question call on a short message comes to about $0.0012. A call at every limit on this page, in English, is under a cent.

Read the docs 

Decisions API questions: types, accuracy, pricing, OpenJev

What does the Decisions API actually return?
One typed answer per question: a predicate as a probability rather than a bare boolean, a choice with every value scored and a confidence, or a score positioned across levels you described in words. No free text and no output tokens, so nothing needs parsing.
Is this the same as OpenAI's Decisions API?
It speaks it. The request and response are OpenAI's Decisions API with gpt-6-luna, so an OpenAI SDK pointed at our base URL works unchanged. What we add is a pay-per-call rail an agent can use from its own wallet, and a keyed rail billed from credit.
How much does a decision cost?
Input tokens at the model's own rate with no markup, plus a flat transaction fee per paid call. The 402 quotes it before you pay, from an estimate that errs high: English is counted generously and any other character at up to three tokens. A one-question call on a short message costs about a tenth of a cent. Output is not billed, and a call the model never answered is not charged.
How accurate is the Decisions model?
We have not run a benchmark and will not invent one. What we did measure is on the page: plain routing and sarcasm came back right, and text that fits none of your values came back as one of them, confidently. Give every choice a none value, and test on your own data.
Are the probabilities calibrated?
We have not measured that, so we do not claim it. Treat them as the model's stated confidence, and pick any threshold from your own labelled examples rather than from the number's face value.
What happened to OpenJev?
We retired it on 2026-10-07. It was an open-source model we hosted ourselves, and it was never Jev, TypeSafe's model, which we do not resell. This endpoint now answers from gpt-6-luna; the old decide request with noul, choice and score still works and is translated.
Do I need an API key?
No. An agent with a wallet pays per call over x402. With a key from user.blockrun.ai the same request is billed from your credit instead; both rails take the same body.
Can the Decisions API judge images?
Yes. The evidence can be text, or messages carrying text and inline base64 images. Hosted image URLs are not accepted, so send the bytes.
Decisions API vs asking a chat model for JSON?
A chat model can be prompted into a label, but you pay for generated tokens, tune a prompt, police a schema and get a string back. This returns the type and the probability directly, generates nothing, and bills only the input.