Engines and BYOK

EnginesCopy Anchor Link

Dcision runs decisions on two engines. Both are decision models — trained to return decisions and calibrated probabilities instead of generated text — and both speak the same System One contract: choice, score and probability questions answered with a probability distribution, which Dcision turns into typed answers, confidence and weighted levels.

Responses report the engine in metrics.engine and the exact model that answered in metrics.model.

The decision schema doesn't depend on the engine: Dcision compiles it into an engine-neutral representation and only the engine adapter speaks to the model. The state, the decision's context and the questions — text or structured JSON — are sent in the engine's native shapes, and all the questions of a decision go in one request.

Which engine runs a decisionCopy Anchor Link

Settings → Engine sets the workspace's default engine. A decision can pick its own in Engine & runtime → Engine (settings.engine); without it, it follows the default. Each engine keeps its own credential and model, so a workspace can run most decisions on Jev and one on Laya.

Jev: who runs the engine callCopy Anchor Link

Choose it in Settings → Engine (Admins and the Owner). The choice applies immediately to every Jev decision of the workspace — Playground and API.

Models on Dcision's keyCopy Anchor Link

Aliases move when TypeSafe ships a new release, so the answers behind them can change without a change on your side. metrics.model and the execution log always record the exact version that answered — jev-1.13.0 even when you selected jev-latest.

ProvidersCopy Anchor Link

All three expose the same System One contract:

LayaCopy Anchor Link

Laya is an open-source System One model: no per-token price, and it runs where you run it — your data never leaves your server. Its laya-serve server exposes the same /v1/systemone contract as Jev, so Dcision calls it with the same questions.

Run your Laya serverCopy Anchor Link

pip install "laya[serve]"
LAYA_API_KEY=<a long random secret> LAYA_PRELOAD=1 laya-serve   # listens on :8000

Shorter context than Jev. Laya reads up to 512 tokens (english) or 1,024 (multilingual, typed-decisions) of state and question; longer inputs are truncated by the server. For long states, prefer multilingual or keep Jev. Re-test thresholds (minConfidence, policy ranges) in the Playground when moving a decision to Laya: each model has its own confidence profile.

Bring your own keyCopy Anchor Link

If you select My own provider key without saving a key for that provider, every run fails with 424 ENGINE_NOT_CONFIGURED.

How keys are protectedCopy Anchor Link

• Encrypted at rest with AES-256-GCM; the API never returns them — only the last 4 characters are shown.
• Never written to logs and never sent anywhere but the provider's endpoint.
• Only Admins and the Owner can add, replace, test or remove them; everyone else in the workspace sees which providers have a key, with its last 4 characters.
• Removing a key deletes it. Save a new key to rotate.

Keys for LLM destinationsCopy Anchor Link

The OpenRouter and Vercel AI Gateway keys saved here also power LLM destinations — the answers a decision can generate for a route. They are used for those answers even when the engine runs on Dcision's key, and the provider bills their tokens to your account. Dcision's engine key never runs LLM destinations.

Limits of the engineCopy Anchor Link

• Token budget. Jev reads the state once and evaluates every question against it: about 32,000 tokens for the state plus the longest question and 64,000 for the state plus all questions. Dcision checks both before the call and answers 422 INVALID_STATE when a state doesn't fit — see Limits.
• Throughput. TypeSafe limits each account in requests and tokens per second. On Dcision's key, the limit is shared by all workspaces, so Dcision smooths bursts: a call waits for a free slot within its deadline instead of failing at once. With your own key, your provider account's limits apply.
• Text only. The state must be text or JSON; convert images, audio or files to text first.

CostCopy Anchor Link

On Laya the engine cost is the server you run: Dcision estimates estimated_cost_usd: 0 for Laya calls. A successful API run still counts as a billable decision.

On Jev, each response includes metrics.input_tokens, metrics.output_tokens and metrics.estimated_cost_usd: the input tokens of the call times the model's price. Jev is priced at US$0.042 per 1M input tokens and doesn't bill output tokens — they are reported for observability only — so a decision of 375 input tokens is estimated at 0.00001575. This is an estimate of the engine cost — useful to compare decisions — not your Dcision invoice.

All the questions of a decision share one call, so adding a question adds its own tokens to the call, not another request.

With your own key, the provider bills the engine call. The call still counts as a billable decision on your Dcision plan when it succeeds through the API.

Engine errorsCopy Anchor Link

Within the decision's timeoutMs, Dcision makes up to 2 retries on network errors, 429/503/529 and other 5xx answers, honoring the provider's Retry-After — see timeoutMs. Failed runs are recorded as executions with status Error and are not billed. With onEngineError: "fallback", every error of this table except ENGINE_NOT_CONFIGURED becomes a 200 with the decision's fallback action. See Errors.