Decisions API

Structured decisions for software teams · Decisions API

Try Decisions API free online

Turn application state and typed questions into structured choices, scores, and probability signals your code can use. Test a real workflow in the Decisions API playground, then connect the REST API.

Start with $10Run a free test
Clear output shapeMultiple questions at onceProbabilities included
Decision preview
Illustrative example

01 / Input state

state
A rollout of release 4.8.1 is producing elevated checkout errors in us-east-1. The error budget is nearly exhausted.

02 / Decision

choice
Should the rollout be paused and escalated for review?
Output
response
✓Pause the rollout and review the latest deployment metrics.
Continue the rollout and monitor error rates
Not a chat transcript—a usable resulttyped response

Online playground

Playground

Test application state and typed questions online, then inspect the structured JSON result.

Sign in to use the playground free with unlimited runs.

1. State

Give the same context to every question.

1/15

All questions share this context and are answered independently.

2. Questions

Define up to eight typed questions for the same state.

3 / 8

3. Run decision

Run the decision request.

Results

Click “Generate decisions” to see typed output with probabilities.

4. API request

Preview or copy the JSON shape to call the same endpoint from your app.

Results are returned in a structured format so you can connect them to your application logic.

Decisions API for developers

A three-step integration

Test typed questions against real application state, then connect structured results to your product.

01

Give it state

Use a ticket, message, form fields, or the structured context your agent already sees.

state = ticket.text
02

Ask the question

Describe the decision with choice, score, or noul. Ask multiple questions in one request.

questions = { intent, urgent }
03

Let code act

Use the result and its probability to queue, route, block, or request review. Your system keeps control.

if result.urgent: escalate()

A decision layer for applications

Give software an answer it can act on

Decisions API is for product logic that needs a bounded answer, a probability signal, and a clear handoff back to code.

Choose the answer space

Name the allowed outcomes first, so downstream code receives a value it can validate and route.

Evaluate related questions together

Use one shared state to classify intent, measure urgency, and check policy without assembling a chain of separate prompts.

Set an uncertainty boundary

Read the probability distribution with the decision and send ambiguous or high-impact cases to review.

Keep execution in your product

Map the result to your own functions, queues, approval rules, and audit trail.

One request shape for the workflow

Send state and typed questions to the REST endpoint; receive answers keyed to your question IDs.

Build from a real request

The docs cover request fields, answer types, response handling, and the limits to account for before production.

Decisions in production systems

Turn an uncertain input into a defined next step

Use Decisions API at the point where product code needs a judgment. Your application still owns model selection, permissions, retries, and execution.

01

Choose a route from a fixed set

Classify an incoming task against your approved destinations, then let deterministic code dispatch it.

02

Check an action before execution

Evaluate whether a requested tool action fits the policy and route uncertain or sensitive cases for approval.

03

Prioritize the right cases

Evaluate intent, urgency, and review needs from the same ticket state before assigning queue priority.

04

Keep facts in long sessions

Decide which tool results still matter and preserve source details when context is compressed.

Decisions API

Get started with the REST API

Try the API free online, then create an API key and connect structured decisions to your product.

Explore API docs
REST-ready
Typed schema
Manageable API keys

What a request looks like

Drop the decision into an existing service

POST /v1/systemone
from typesafe_sdk import Choice, Noul

response = client.system_one(
    state=ticket,
    questions={
        "intent": Choice(criteria={...}),
        "needs_human": Noul(
            instructions="Does this need a person?"
        ),
    },
)

# response.answers["intent"].choice

Pricing for structured decision workloads

Start by testing one Decisions API request. Choose a credit package for the concurrency and volume your application needs, then scale as usage grows.

One-time $10, $100, and $1,000 packages do not renew automatically. Purchased credits remain available without an expiration date.

No auto-renewal
Credits do not expire
Playground + API access

Starter

$10

For a first integration: validate a small workflow in the playground and send its first server-side request.

  • 100,000 credits, no expiry
  • 1 workspace
  • 3 concurrent requests
  • Standard speed
  • Choice, score, and noul questions
  • Typed decision output
  • Probability and confidence results
  • Online playground
  • API key management
  • Email support
Recommended

Pro

$100

For products that need steady classification, scoring, and policy checks across active workflows.

  • 1,000,000 credits, no expiry
  • Unlimited workspaces
  • 10 concurrent requests
  • Fast lane
  • Choice, score, and noul questions
  • Typed decision output
  • Parallel questions per request
  • API access
  • Usage and request history
  • Priority support

Enterprise

$1,000

For teams operating multiple workspaces or custom production integrations, with 10% additional credits.

  • 11,000,000 credits (10% extra included)
  • Everything in Pro
  • Unlimited concurrency
  • Dedicated fast lane
  • Team workspaces and collaboration
  • Custom integration support
  • Security and permission guidance
  • Dedicated support
  • Priority production processing
  • Product roadmap feedback

Agent integration

Give your agent a typed decision layer

Call the Decisions API endpoint from your existing coding-agent workflow for bounded classification, routing, and safety checks. Your application continues to control tools and permissions.

Read the agent guide

Connect the API

Create a Decisions API key and configure the endpoint in your agent or application environment.

Configure once

Keep the API key in a server-side environment variable, outside source code and agent transcripts.

Ask for a judgment

Give the agent a bounded question; it returns a choice, score, or yes probability that code can use.

API environment setup

Use the API from your existing agent workflow

export DECISIONS_API_KEY="sk_your_key_here"
export DECISIONS_API_BASE_URL="https://decisions-api.pro"

The agent still keeps control

The API evaluates a decision. Your agent, application permissions, deterministic rules, and human approvals still control the final action.

Decisions API documentation

Integration docs for structured decisions

Follow a practical path: define typed questions, send application state, and use structured results in code.

Open full docs

Quickstart

Create an account, prepare your first state and questions, and inspect the typed decision in the response.

Define questions

Use choice, score, and noul for classification, continuous scoring, and yes-or-no decisions. Ask multiple questions in one request.

Integrate

Create an API key, follow the SDK or REST example, and use probabilities and confidence to drive your application logic.

Know the boundaries

The API accepts text, JSON objects, and arrays of text. Images, audio, and video are not supported yet; validate accuracy separately for non-English inputs.

Explore the Decisions API

Go from the core definition to provider-specific integration notes and copyable examples.

What is a Decisions API?Learn how state, typed questions, and structured answers fit together.Jev API guideSee how the Jev decision model is exposed through this hosted endpoint.OpenRouter integration guideCompare direct OpenRouter calls with the Decisions API hosted route.Decisions API examplesReview Choice, Noul, and Score patterns for product workflows.

Questions, answered

Practical answers about inputs, response signals, model access, and integration boundaries.

Start with one decision your product already makes

Try a representative case in the playground, inspect the JSON response, and connect the result to your own application logic.

Test a decision