Celeris Decision

Probabilistic decisions over structured outcomes.

Provide text, structured data, or images, define the questions to evaluate, and receive structured answers that can be thresholded, ranked, or routed on directly.

Try the API Read the documentation
stateimage + json
image
receiptpng · 560 tok
json
claim.amount13.50
claim.categorytravel
matches?
Does the receipt total match the claim?
0.50
probability of yes
travel?
Is this a travel expense?
0.50
probability of yes
review?
Should this expense be reviewed by a person?
0.50
probability of yes
Model

A decision model for bounded questions.

Send a state made of text, JSON or images plus named questions. Every answer comes back as a probability your code can act on. The form of each answer is fixed before inference.

Question type · noul

Yes or no, as a probability.

"The receipt total matches the claimed amount."

The probability that the statement is true. Your code sets the threshold.

Question type · choice

One of the options you define.

Which team should handle this ticket?

The most likely option, a probability for each, and a confidence from 0 to 1.

Question type · score

A position on an ordered scale.

How frustrated is the customer?

Probability per level and the weighted average, which can land between levels.

Model

A decision model for bounded questions.

celeris-1-decision evaluates questions about a supplied state. The state can contain text, structured JSON, images, or combinations of these inputs. Each request contains one or more named questions describing what should be evaluated.

The model returns structured answers with probabilities that can be consumed directly by application logic. Unlike an open-ended generation request, the possible form of each answer is defined before inference.

Question type · noul

A binary judgment, as a probability.

"The receipt total matches the claimed amount."

The answer is the probability that the statement is true. Here the state is a trip receipt image plus the expense record, and the question reads both. Optional criteria can describe the true and false outcomes. Your code sets the threshold.

Question type · choice

A selection among named alternatives.

Which team should handle this ticket?

You define two or more options and describe each one. The response contains the most likely option, a probability for every option, and a confidence from 0 (an even split) to 1 (certainty).

Question type · score

A judgment over an ordered set of levels.

How frustrated is the customer?

You write the levels, lowest first. Probability mass is distributed across them, and the returned score is the probability-weighted average, so it can land between levels.

celeris-1-decisionstate

Explanations when they are needed.

Set x_celeris.explain to true and the response carries one sentence per question on why the model chose its answer, keyed by question name, alongside the structured result.

Generating explanations adds latency, so it is off by default and set per request. One mode is pure decision inference. The other adds language where a person will read it.

The explanation is subordinate to the decision. It describes the basis for the chosen answer; it is not a reasoning trace.

Charged twice this monthticket #4821 · 2 min ago
billing0.88

Double charge falls directly under payments and invoices.

App crashes when I open settingsticket #4822 · 5 min ago
technical0.94

Describes a reproducible crash in the application, a bug.

Can we get 20 more seats?ticket #4823 · 9 min ago
sales0.91

Asks to expand the plan, which is a quote and upgrade request.

x_celeris.explain falseoutput tokens free

Images are state, not an attachment.

Images can be included directly in the model state. A request can combine image input with text or structured data and evaluate one or more questions against the combined state. Images are named within the request and can be referenced by the state and by individual questions. Image resolution is controlled through max_soft_tokens.

state · json
claim.amount13.50
claim.categorytravel
claim.merchantcityride
image
receiptpng · 560 soft tokens
noulReceipt total matches the claim0.50
noulMerchant category is travel0.50
noulReceipt appears altered0.50
state · json
listing.categoryfootwear
listing.colorblack
listing.titleTrail runner, low
image
productjpg · 560 soft tokens
noulContains footwear0.50
noulPrimary color is black0.50
noulMatches the listed category0.50
state · json
form.typeconsent
form.requiredsignature, date
form.pages1
image
page_1png · 560 soft tokens
noulContains the required signature0.50
noulDocument appears complete0.50
noulAny required field left blank0.50
state · json
taskcomplete checkout
step4 of 6
last_actionclick "Continue"
image
screenshotpng · 560 soft tokens
noulPayment form is visible and ready0.50
noulOrder has already been placed0.50
noulAn error or blocking dialog is showing0.50

Decisions are returned with probability.

For choice and score, the response is a distribution over the outcomes you defined, plus a confidence derived from the leading probability relative to an even split. For noul, it is the probability that the statement is true. What happens next is written in your code.

team · choicethe answer
billing0.88
technical0.07
sales0.05
team = max(answer.probabilities,
           key=answer.probabilities.get)
route(ticket, to=team)
result→ billing
if answer.probabilities[answer.choice] > 0.90:
    route(ticket, to=answer.choice)
else:
    queue_for_review(ticket)
result0.88 < 0.90 → review
order = sorted(answer.probabilities,
               key=answer.probabilities.get,
               reverse=True)
try_in_order(ticket, order)
result→ billing, technical, sales

A state and a set of questions.

One request returns one JSON response. There is no streaming. Hover any part of the request to see what it produces.

requestpython
response = client.system_one(
    state={"subject": "Charged twice", "body": "…"},
    questions={
        "refund": Noul("The customer is asking for a refund."),
        "team": Choice("Which team should handle this?",
                       criteria={"billing": …, "technical": …, "sales": …}),
        "frustration": Score("How frustrated is the customer?",
                             criteria=["Calm.", "Annoyed.", "Angry."]),
    },
)
requestpython
response = client.system_one(
    state={
        "subject": "Charged twice",
        "body": "I was charged twice this month and nobody has answered my emails for a week."
    },
    questions={
        "refund": Noul(
            instructions="The customer is asking for a refund."
        ),
        "team": Choice(
            instructions="Which team should handle this ticket?",
            criteria={
                "billing": "Payments, invoices and refunds.",
                "technical": "Bugs and outages.",
                "sales": "Upgrades and quotes."
            }
        ),
        "frustration": Score(
            instructions="How frustrated is the customer?",
            criteria=["Calm.", "Annoyed.", "Angry."]
        )
    }
)
response

state

Shared context for every question in the request. A string or any JSON value.

refund → 0.91

Probability that the statement is true.

team → billing

Most likely option, with a probability for each.

billing0.88
technical0.07
sales0.05

frustration → 1.41

Weighted average over the ordered levels.

0 calm0.18
1 annoyed0.23
2 angry0.59

usage

input_tokens 673 · output_tokens 102

responsejson
{
  "answers": {
    "refund": { "noul": 0.91 },
    "team": { "choice": "billing",
              "probabilities": { "billing": 0.88, "technical": 0.07, "sales": 0.05 },
              "confidence": 0.82 },
    "frustration": { "score": 1.41,
                     "probabilities": { "0": 0.18, "1": 0.23, "2": 0.59 } }
  },
  "usage": { "input_tokens": 673, "output_tokens": 102 }
}

Images enter the same request.

Attach them under x_celeris.images as base64 data URLs, each with a name the state or any question can refer to. max_soft_tokens sets the resolution the model reads every image at, and the tokens it costs appear in usage like any other input.

request with an imagepython
response = client.system_one(
    state={"claim": {"amount": 13.50, "category": "travel"}},
    questions={
        "matches": Noul(
            instructions="The receipt total matches the claimed amount."
        )
    },
    extra_body={
        "x_celeris": {
            "images": {"receipt": receipt_data},
            "max_soft_tokens": 560
        }
    },
)
print(response.nouls["matches"].noul)

Compatible with the System One API.

celeris-1-decision is served at POST /v1/systemone and accepts the System One request and response schema. An existing System One client runs against it by changing the base URL, API key and model name. The code itself does not change.

beforeshell
export TYPESAFE_BASE_URL=https://your-current-endpoint
export TYPESAFE_API_KEY=$YOUR_CURRENT_KEY
export TYPESAFE_DEFAULT_MODEL=your-current-model

python app.py
aftershell
export TYPESAFE_BASE_URL=https://inference.celeris.ai/celeris-1-decision
export TYPESAFE_API_KEY=$CELERIS_API_KEY
export TYPESAFE_DEFAULT_MODEL=celeris-1-decision

python app.py

The two Celeris additions, explain and images, live in one optional top-level object, x_celeris. Leave it out and the request is a standard one.

Where decision inference is useful.

Anywhere an application can define the question and the space of valid answers before inference. One incoming event, several decision points, the same output structure at each.

incoming statesupport ticket
Subject, body, account record. The same state is read at every decision point below.
classificationIs this a billing issue?
Does the text, structured data or image belong to one or more defined categories.
yes0.91
routingWhich queue?
Choose between agents, models, tools, queues or workflows.
billing0.88
technical0.07
sales0.05
scoringHow frustrated?
Position on an application-defined ordinal scale.
calm0.18
annoyed0.23
angry0.59
visual evaluationDoes the attached receipt match?
Evaluate properties of an image together with application state.
yes0.97
generationDraft the reply
An open-ended step, handled by a generative model. not a decision call
verificationDoes the draft address the refund?
Does an image, model output, document, transaction or system state satisfy a defined condition.
yes0.84
filtering · agent controlSend, or review?
A probability threshold before an item or action proceeds, and the next operation in a larger workflow.
send0.84
review0.16

Every response reports what it read.

Input tokens include everything the model reads for the request: the state, the questions, the internal request representation, and any images. Output tokens are free. Read usage from the returned usage object rather than estimating it from the request body.

requestjson
{
  "state": "I was charged twice this month. Please refund one of the payments.",
  "questions": {
    "refund": {"type": "noul", "instructions": "The customer is asking for a refund."}
  }
}
requestjson
{
  "state": {
    "subject": "Charged twice",
    "body": "I was charged twice this month and nobody has answered my emails for a week."
  },
  "questions": {
    "refund": {"type": "noul", ...},
    "team": {"type": "choice", ...},
    "frustration": {"type": "score", ...}
  }
}
requestjson
{
  "state": "I was charged twice this month and nobody has answered my emails for a week.",
  "questions": {
    "team": {"type": "choice", ...}
  },
  "x_celeris": {"explain": true}
}
usage · from the documented examples
input tokens351
output tokens21
input cost at $0.04 / M$0.000014
output costfree

Per-request cost is the documented input token count at the published rate. Your counts will differ with your inputs. Rates: docs.celeris.ai/pricing.

What the probabilities depend on.

The usefulness of a returned probability depends on the information in the state and on how the question and its criteria are specified. Three situations worth seeing before you integrate.

Which team should handle this ticket?
The right answer is shipping. It was not offered, so the probability goes to the nearest option that was.
billing0.52
sales0.31
technical0.17
confidence 0.28 · shipping not in criteria
Which of A, B or C applies?
When the state does not favour any option, the probabilities say so. Confidence near 0 is the signal to route to review rather than act.
A0.34
B0.33
C0.33
confidence 0.01 · route to review
Which team should handle this ticket?
Remove the body of the ticket and the model has only a subject line to go on. The distribution widens.
billing0.88
technical0.07
sales0.05

The application defines the questions. choice requires at least two candidate outcomes; score requires at least two ordered levels. A candidate that is not included cannot be selected.

Probability is not a guarantee of correctness. Define your own thresholds, fallback behaviour and review procedures according to the consequences of each decision.

Explanations require additional inference and increase latency. They are optional and set per request.

One complete JSON response, no streaming. If the answers do not fit in one response, the request returns a 422 after the model has run and its input tokens are charged.

Rate limits apply per workspace and per model. Over the limit, requests return 429 with a Retry-After header. Details.

celeris-1-decision

Modelceleris-1-decision
EndpointPOST /v1/systemone
Base URLhttps://inference.celeris.ai/celeris-1-decision
Supported stateText · structured JSON · images · combined inputs
Question typesnoul · choice · score
Multiple questionsSupported, mixed types in one request
Image inputx_celeris.images, named base64 data URLs
Image resolutionmax_soft_tokens; images count toward input tokens
ExplanationsOptional through x_celeris.explain
StreamingNo
API compatibilitySystem One API
OutputOne JSON response containing answers and usage
Input pricing$0.04 per million tokens · cached input $0.04
Output pricingFree
Errors422 invalid request · 429 rate limited with Retry-After

Start building with Celeris Decision.

celeris-1-decision is available through the Celeris inference API. Keys are live immediately.

Get started Documentation API reference