Dcision
Docs
Genesis Program — now open

The Decision Layer for AI

Millions of decisions. Milliseconds. One infrastructure.

Build applications and AI agents that make fast, structured decisions without invoking a large language model for every event.

Start buildingSee the API

Built for developers. Designed for billions of decisions.

LLMs reason. Agents act. Dcision decides what happens next.

The problem

Not every decision needs an LLM.

AI applications are using large models for small decisions. The result: high cost, latency, low predictability and unnecessary reasoning.

Without a Decision Layer

10,000,000 events

10,000,000 LLM calls

With Dcision

10,000,000 events

500,000 LLM calls

  • LLM calls

    −95%

  • Output

    Typed JSON

  • Integration

    1 API

LLM vs Dcision for micro-decisions
CapabilityLLMDcision
LatencySecondsMilliseconds
Cost / 1M decisions$300 and up~$24 incl. fallback
OutputUnstructured textTyped JSON Schema
DeterminismNon-deterministicDeterministic + auditable
RoutingPromptedPolicy engine

* Illustrative example — not a performance claim.

How it works

Decide before you reason.

  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 routes each decision to the right engine in milliseconds.

  4. 04

    Act

    Get typed results: ALLOW, BLOCK, ROUTE, SCORE or ESCALATE.

  • ALLOW
  • BLOCK
  • ROUTE
  • SCORE
  • ESCALATE

Decision Schema • lead-quality.dc.json

{
  "id": "lead-quality",
  "state": {
    "type": "object",
    "properties": {
      "message": { "type": "string" },
      "company_size": { "type": "number" },
      "source": { "type": "string" }
    }
  },
  "decisions": {
    "purchase_intent": { "type": "score", "range": [0, 1] },
    "priority": { "type": "choice", "values": ["low", "medium", "high"] },
    "route": { "type": "choice", "values": ["sales", "sdr", "nurture", "spam"] }
  },
  "engine": { "type": "auto" },
  "policy": { "block_if": "purchase_intent < 0.1 && route == spam" }
}

What you get

  • Schema-validated inputs
  • Deterministic scoring
  • Policy & guardrails
  • Versioned + observable
  • Engine auto-routing

Decision API

One endpoint. Typed answers.

Publish a decision and call it like any other API. Stable contract, versioned schemas, idempotency and standardized errors.

State inputeditable • live
source
chat_widget
intent
0.94
priority
high
route
sales

Illustrative demo — computed in your browser, nothing is sent.

POST /v1/decisions/{slug}
curl https://api.dcision.io/v1/decisions/lead-quality \
  -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
    }
  }'
200 OK · 41ms
{
  "decision_id": "dec_123",
  "schema": "lead-quality",
  "version": 3,
  "result": {
    "route": "sales",
    "priority": "high",
    "purchase_intent": 0.94
  },
  "metrics": {
    "latency_ms": 41,
    "engine": "jev"
  }
}
  • Versioned Decision Schemas
  • Idempotency-Key support
  • Rate limits & standard errors
  • OpenAPI 3.1 spec

Engine routing

Spend intelligence where it matters.

Dcision is engine-agnostic. Every decision is routed to the cheapest engine that can answer it — and escalates only when complexity requires it.

  • Rules

    Deterministic, ~1ms

  • System One

    Jev and decision models

  • Small models

    Classifiers, local models

  • LLMs

    Reasoning, when needed

  • Human

    Review & escalation

Dcision is not a Jev wrapper.

Jev is the first engine. The core is Decision Schema + Decision IR + Runtime + Multi-Engine Routing + Observability: the layer that makes decisions portable, auditable and cheap.

  • Decision Schema

    JSON Schema for state + questions DSL. Not prompts.

  • Decision IR

    Intermediate Representation. Portable across engines.

  • Runtime + Policy

    Validation, routing, allow / block / escalate, telemetry.

Use cases

One API for millions of microdecisions.

  • 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 at stream speed.

    ACTION = BLOCK

  • RAG

    Is this chunk relevant to the query?

    RELEVANCE = 0.88

  • LLM Routing

    Does this need a frontier model?

    ENGINE = small

  • Event Filtering

    Ignore, act or escalate?

    ESCALATE = NO

Platform

Everything you need for Decision as a Service.

  • Decision Builder

    Visual + code editor for schemas.

  • Decision Schemas

    JSON Schema + questions DSL.

  • Playground

    Test with real data, evals inline.

  • Jev Adapter

    The first engine, not the product.

  • Decision Runtime

    Validation, IR, routing, policy.

  • Observability

    Traces, latency, confusion matrix.

  • Versioning

    Git-like history, shadow deploys.

  • Multi-Engine Routing

    Cost / latency / accuracy tradeoff.

  • Evaluation Suite

    Datasets, metrics, regression alerts.

  • Proof of Decision

    Verifiable attestation (future).

Observability

Every decision, measured.

Volume, latency, confidence, errors and estimated cost — per decision, per version, per engine.

Decisions / 24h
2.41M
p50 latency
38ms
Escalated to LLM
4.7%
Est. cost saved
$1,284
Live executionsDemo data
  • lead-qualityROUTE=sales41ms
  • support-routerROUTE=billing33ms
  • fraud-screenRISK=low12ms
  • rag-relevanceSCORE=0.8829ms
  • agent-routerESCALATE=llm52ms

Pricing • US$ per 1M decisions

Pay for decisions. Not tokens.

A flat price per decision, with fallback cost visible in your logs. No token billing, no hidden fallback costs, no “unlimited” without limits.

Base price −20% on annual • Overages unchanged

  • Genesis

    Limited cohort

    Free

    $0 base • $0 overage during beta

    Included
    1M / month
    • 2 decision schemas
    • Playground access
    • API keys + 7-day logs
    • Rate limit 60/min
    • Decision Points + leaderboard
    • Community support
    Join Genesis

    Beta • no credit card

  • Developer

    For builders

    $29/mo + usage

    Included
    2.5M decisions
    Overages
    $12 / 1M
    • 10 decision schemas
    • 3 envs: dev / staging / prod
    • 14-day logs
    • Rate limit 300/min
    • Standard observability
    • Email support
    Start building

  • Growth

    Most popular

    $199/mo + usage

    Included
    10M decisions
    Overages
    $9 / 1M
    • Unlimited decision schemas
    • Unlimited environments
    • 30-day logs
    • Rate limit 2000/min
    • Observability p50 / p95 / p99
    • Confidence + fallback tracking
    • Fallback LLM routing
    • Webhooks
    • 5 team seats
    • Priority support
    Start Growth

    Volume discounts on overages

  • Enterprise

    100M+ decisions

    Custom

    Committed volume, contracts

    Volume discounts • committed use • invoicing

    • SLA 99.9%
    • SSO / SAML
    • VPC / private deploy
    • Dedicated support
    • Audit trail + retention controls
    • On-prem engine option
    • Custom engine mix
    Talk to founders

    Contracts • DPA • SOC 2 on roadmap

Comparison • 100% LLM vs Dcision

Live calculator

See your savings at scale

10M decisions

100% LLM (mini-class)

$3,000

$300 / 1M

Dcision + 5% fallback

$240

$9 engine + fallback at LLM price

92% saving

You save $2,760 / month at 10M decisions

Usage cost only (plan base fee excluded). Dcision = $9 per 1M on Growth + 5% of decisions falling back to the LLM at $300 per 1M ≈ $24 per 1M. Estimates for binary classification; actual cost varies with complexity.

Included in every plan

  • No token billing

    Flat $ per decision, not per token

  • Fallback tracked

    Visible in logs • shown in the savings estimate

  • Typed JSON

    Schema enforced, no parse failures

  • Observability

    p50 / p95 / p99 + confidence + fallback_rate

FAQ

What counts as a decision?

One POST /v1/decisions/:id call that returns typed JSON. Batches count per item. Playground runs don't count during Genesis.

What is fallback?

When confidence is below your threshold, Dcision routes the request to your configured LLM. fallback_rate × LLM cost is tracked per decision and shown next to the savings vs a 100% LLM setup. The estimate assumes a 5% fallback rate.

How is pricing sustainable?

Engine cost, infrastructure and variable support are our cost of goods. We price per decision — never per token — and target healthy margins on mature workloads without hiding fallback cost.

  • All prices in USD
  • Illustrative pricing during Genesis

Roadmap

From Genesis to an open decision network.

  1. 01Now

    Genesis

    Early access, templates, Decision Points

  2. 02

    Decision Cloud

    Builder, API, runtime, analytics

  3. 03

    Multi-Engine

    Rules, small models, LLM fallback

  4. 04

    Marketplace

    Shared schemas and engines

  5. 05

    Proof of Decision

    Verifiable, auditable decisions

  6. 06

    Open Network

    Decentralized decision infrastructure

Genesis Program

Create your first Decision in under 5 minutes.

Join the first builders of the Decision Layer. Free credits, 1M decisions a month and early access.

  • 1M free decisions / month
  • Genesis access
  • Early Decision Points
  • Direct founder support

No spam. Early access, docs and community.

Decision Points are not tokens, have no monetary value and are not transferable. Eligibility for future ecosystem rewards is not guaranteed and criteria may change.