The Decision Layer for AI

AI is moving from writing answers to making decisions inside software. Decision engines — Jev, OpenAI's Decisions API, Laya — made the answer typed and measurable. We build what turns that answer into a decision a company can run, trust and audit.

1. 01

   Decisions are software, not prompts.

   A decision is a schema with typed questions, versioned and deployed like code — not a paragraph hidden in a prompt.

2. 02

   The engine is a choice, not a lock-in.

   Jev, OpenAI Decisions or Laya, per workspace or per decision. Engines improve every month; your decisions shouldn't have to be rewritten each time.

3. 03

   Every input deserves a decision.

   Text, JSON, images, voice notes and documents. The world doesn't arrive as clean text, so the decision layer shouldn't expect it.

4. 04

   An answer is not an action.

   A probability doesn't route a ticket. Policies turn answers into continue, block, escalate or fallback, and destinations carry them out.

5. 05

   Uncertainty is a feature.

   Confidence is part of every answer. When it's low, the decision says so and hands the case to a person or a bigger model — on purpose, not by accident.

6. 06

   Every decision leaves a trace.

   Input, answers, confidence, action, engine and version, for every run. What can't be audited can't be automated.

7. 07

   Machines decide first; people decide what matters.

   Millions of microdecisions run machine to machine, so people spend their time on the few that need judgment.

8. Engines answer. Dcision decides — and acts.

• Typed answers

  Dcision

  The same three on any engine, on one confidence scale

  Jev direct

  Choice, score, probability

  OpenAI Decisions direct

  Choice, score, predicate

  Laya direct

  Choice, score, probability

• Inputs

  Dcision

  Text, JSON, images, voice and documents — on every engine

  Jev direct

  Text and JSON

  OpenAI Decisions direct

  Text and images

  Laya direct

  Text (512–1,024 tokens)

• Engine choice

  Dcision

  Jev, OpenAI or Laya per workspace or per decision, compared side by side and in shadow mode before you switch

  Jev direct

  Jev only

  OpenAI Decisions direct

  gpt-6-luna only

  Laya direct

  Laya checkpoints

• Policies and fallback

  Dcision

  continue / block / escalate / fallback, minimum confidence per question, reserved "other"

  Jev direct

  You code thresholds and actions

  OpenAI Decisions direct

  You code thresholds and actions

  Laya direct

  You code thresholds and actions

• What happens next

  Dcision

  8 destination types: reply, JSON, LLM, agent, workflow, webhook, API request, function

  Jev direct

  You wire every system

  OpenAI Decisions direct

  You wire every system

  Laya direct

  You wire every system

• Versions and deploy

  Dcision

  Immutable versions; deploy without redeploying your app

  Jev direct

  Questions live in your code

  OpenAI Decisions direct

  Questions live in your code

  Laya direct

  Questions live in your code

• Build and test

  Dcision

  Visual builder, chat builder, Playground and templates

  Jev direct

  API only

  OpenAI Decisions direct

  Playground

  Laya direct

  Python library

• Logs and analytics

  Dcision

  Every run logged — input, answers, confidence, action, engine — with calibration hints

  Jev direct

  Provider usage only

  OpenAI Decisions direct

  Provider usage only

  Laya direct

  You build them

• Integrations

  Dcision

  REST, a webhook URL per decision (files included), MCP server, GPT-Live delegation, TS/Python SDKs and CLI

  Jev direct

  HTTP API

  OpenAI Decisions direct

  SDKs in 6 languages, GPT-Live voice

  Laya direct

  Python, your own server

• Where data runs

  Dcision

  On the engine you choose — with Laya, your server

  Jev direct

  TypeSafe's cloud

  OpenAI Decisions direct

  OpenAI's cloud (ZDR, US/EU residency)

  Laya direct

  Your server

• Engine price

  Dcision

  Per decision; Jev on Dcision's key included, or bring your own key

  Jev direct

  US$0.042 per 1M input tokens

  OpenAI Decisions direct

  US$0.10 per 1M input tokens

  Laya direct

  Your hardware

Engine facts as published by TypeSafe, OpenAI and Convai Innovations in October 2026. Dcision runs these engines — it doesn't replace them. TS/Python SDKs and the CLI are in the repository, not yet on npm/PyPI.

Even the most complex software is built from simple logic and layers. Decisions should be one of those layers: small, typed, inspectable, and trusted enough to run deep inside your systems.

1. 01

   Use before and after the LLM

   Before: Dcision classifies, scores and routes every event, so the expensive reasoning only runs where it is needed. After: it checks what an LLM or agent is about to send — grounded, safe, on policy — and blocks or escalates it before it reaches anyone.

2. 02

   Not everything needs an LLM

   Routing a ticket, scoring a lead or flagging a transaction is a microdecision, not an essay. Answer it with a typed decision instead of a prompt and free text.

3. 03

   Eliminate hallucinations

   Every answer must be one of the options, a score or a probability you declared in the schema, validated before it reaches your code. No invented labels, missing fields or text to parse — and when confidence is low, your policy blocks, escalates or falls back.

4. 04

   Faster than an LLM*

   Decision engines answer structured questions without generating long text, and every question in a decision is evaluated in a single call — extra questions add little latency.

5. 05

   Built for machine-to-machine

   Typed JSON in, typed JSON out, with a confidence and an action on every answer. It's the format APIs, agents, workflows and automations already speak — no human reading in between.

6. 06

   Managers in control

   Every run is logged with its version, confidence and action. Managers follow the indicators in the dashboard and adjust options, thresholds and destinations in the Decision Builder — each change becomes a new version, with full history.

LLMs reason. Agents act. Dcision decides — first.

* TypeSafe publishes up to 200× faster for Jev against frontier LLMs (an independent test by Every measured about 25×); OpenAI publishes about 10× faster than its Responses API for Decisions. Real gains depend on the case. On Dcision, a decision usually takes about 1–2 s end to end, network included.

• LLM calls

  −95%

• Output

  Typed JSON

• Integration

  1 API

* Illustrative example assuming 5% of decisions fall back to your own LLM — not a performance claim.

1. 01

   Send State

   Any event, message or JSON context from your app or agent.

2. 02

   Define Decisions

   Choice, Score and Probability questions in a versioned schema.

3. 03

   Execute

   The runtime validates the state and answers every question in one engine call, usually in about 1–2 seconds.

4. 04

   Act

   Get typed answers and an action — continue, block, escalate or fallback — plus the per-outcome actions you configure.

• continue
• block
• escalate
• fallback

{
  "stateSchema": {
    "kind": "object",
    "fields": [
      { "key": "message", "type": "string", "required": true },
      { "key": "company_size", "type": "number" },
      { "key": "source", "type": "string" }
    ]
  },
  "questions": [
    { "key": "purchase_intent", "type": "probability",
      "instructions": "Does this lead have real intent to buy in the next 30 days?" },
    { "key": "priority", "type": "score",
      "instructions": "How urgent is it to answer this lead?",
      "scale": ["low", "medium", "high", "critical"] },
    { "key": "route", "type": "choice",
      "instructions": "Which team should receive this lead?",
      "options": [{ "value": "sales" }, { "value": "sdr" },
                  { "value": "nurture" }, { "value": "spam" }] }
  ],
  "policies": [
    { "field": "route", "on": "output", "operator": "eq",
      "value": "spam", "action": "block" },
    { "field": "purchase_intent", "on": "confidence", "operator": "lt",
      "value": 0.6, "action": "escalate" }
  ]
}

curl https://api.dcision.io/v1/decisions/lead-qualification \
  -H "Authorization: Bearer $DCISION_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": {
      "message": "I need pricing for 500 users, ASAP. Can we do a call tomorrow?",
      "company_size": 500
    }
  }'

Press “Run decision” — the response below comes from the real Dcision API.

• Versioned Decision Schemas
• Idempotency-Key support
• Rate limits & standard errors
• OpenAPI 3.1 spec

Official TypeScript and Python SDKs are coming soon. Until then, call the API over plain HTTP, as above.

* Compared with integrating a decision engine's API — Jev, OpenAI Decisions or Laya — directly in your own code; features of each provider's own console or playground are not considered.

• AI Agents

  Which agent takes this task?

  ROUTE = research_agent

• Customer Support

  Department, urgency, human needed?

  ROUTE = BILLING

• Sales

  Purchase intent and priority.

  INTENT = 0.94

• Payments

  Fraud screening before execution.

  RISK = LOW

• Content

  Moderation before content goes live.

  ACTION = BLOCK

• RAG

  Is this chunk relevant to the query?

  RELEVANCE = 0.88

• LLM Routing

  Does this need a frontier model?

  ENGINE = small

• LLM Guardrail

  Is the agent's answer safe to send?

  GROUNDED = 0.12

• Decision Builder

  Form and visual editors, with a JSON preview.

• Decision Schemas

  JSON state schema + typed questions.

• Playground

  Test drafts with real data; runs are never billed.

• Engine adapters

  Jev, OpenAI Decisions and Laya — the engine is a choice, not the product.

• Decision Runtime

  Validation, IR, policies, execution logs.

• Observability

  Executions, p50/p95 latency, errors and cost.

• Versioning

  Immutable versions on every deploy, full history.

• Destinations

  Per-outcome actions: webhooks, API calls, workflows, LLM or agent replies, fixed replies, or functions in your code.

• Teams

  Roles, e-mail invitations and multiple workspaces.

• Proof of Decision

  Verifiable attestation (future).

• Genesis

  Early access

  Free

  $0 • past 1M, keeps running on prepaid credits

  Included

  1M / month

  Extra, with credits

  $12 / 1M

  • 2 decision schemas
  • Playground access
  • API keys + 7-day logs
  • Rate limit 60/min
  Join Genesis

  Beta • no credit card

• Developer

  For builders

  $29/mo + usage

  Included

  2.5M decisions

  Extra, with credits

  $12 / 1M

  • 10 decision schemas
  • 14-day logs
  • Rate limit 300/min
  • Credits with auto recharge and spend cap
  • Email support
  Start building

• Growth

  For production

  $199/mo + usage

  Included

  10M decisions

  Extra, with credits

  $9 / 1M

  • Unlimited decision schemas
  • 30-day logs
  • Rate limit 2000/min
  • Lower price per extra decision
  • Priority support
  Start Growth

  Extra decisions paid with prepaid credits

• Enterprise

  100M+ decisions

  Custom

  Committed volume, contracts

  Custom pricing • committed volume • invoicing

  • Committed volume from 100M decisions / month
  • Custom rate limits
  • Log retention up to 365 days
  • Contract, invoicing and DPA
  • Dedicated support
  Talk to founders

  Contracts • invoicing • DPA

• Prices in US$. Customers in Brazil pay in reais: Developer R$145/mo, Growth R$995/mo
• Annual plans are billed once a year
• Add a card and get $20 in free credits, valid for 90 days

1. 01Now

   Genesis

   Free early access and templates (Decision Points: planned)

2. 02Now

   Decision Cloud

   Builder, API, runtime, Destinations, teams

3. 03Now

   Multi-engine

   Jev, OpenAI Decisions and Laya today; rules and small models next

4. 04

   Marketplace

   Shared schemas and engines

5. 05

   Proof of Decision

   Verifiable, auditable decisions

6. 06

   Open Network

   Decentralized decision infrastructure