How Much To Run AI

A budget for routing, scoring and yes/no decisions

Open-Source Decision Model Cost Calculator

Bring a latency measurement and an infrastructure quote. Compare a dedicated Clef, CLM or Laya endpoint with hosted API costs for the same assumed request volume.

What do you want to budget?

Your decision workload

Start with an hourly instance quote for a cloud budget, or a GPU/system quote and wall power for a local budget. Add measured latency and a setup note to see capacity and unit costs. All results are in USD.

About Laya

License summary

License:
Apache-2.0
Verified:
2026-09-29

License summaries link to the model repositories. Check the license for the exact version you plan to use.

Operating assumptions

Salary and electricity inputs use CNY, converted at your CNY-per-USD rate. Labor applies to both self-host deployment paths. PUE covers facility overhead beyond the measured system.

Cost assumptions

Export report:

Monthly budget and capacity

Laya English · 1 questions/request · 100,000 requests/month · 720 h/month

Add your measured latency and setup to estimate capacity and self-host unit costs. Fixed monthly budgets can still be estimated from your quotes.

Monthly cost (USD)USD / 1M requestsUSD / 1M decisions
Local endpointEnter a GPU/system purchase price and wall power (under Operating assumptions) to calculate the local budget.
Cloud endpointEnter a full instance hourly price to calculate the cloud budget.
Jev API$4.20$42.00$42.00
Decisions per month
100,000
Monthly operations labor
$312.50–$520.8333

Operating assumptions

Average API billed input tokens/request
1,000
Exchange rate (CNY/USD)
7.2
Electricity (CNY/kWh)
0.65
Ops salary min (CNY/mo)
15,000
Ops salary max (CNY/mo)
25,000
Ops FTE ratio
0.15
PUE
1.2
System multiplier
1.4
Depreciation (months)
36

Local monthly cost includes depreciation, electricity and labor. Cloud monthly cost includes provisioned compute and the same labor assumption. Jev shows API charges only. Storage, network, taxes, redundancy and application engineering are additional costs.

Measurements and infrastructure prices: supplied by you

Jev 1.13: $0.042 / 1M input tokens; output free. Rate checked 2026-09-29. TypeSafe

Compare accuracy and latency on the same labeled decisions before choosing a deployment.

API workload budget

Estimate metered usage in USD from the stored tariff. Include every attempt and retry. Taxes, credits, free allowances and fixed fees are separate. This is independent of the self-hosting capacity estimate.

For text-only decisions, this tool covers up to 32,000 input tokens per request, including state and every question. These endpoints do not charge output tokens. Media inputs and Clef-omni are not included.

Estimated usage cost: $0.042

Input: $0.042 · Output: $0.00 · $0.042 / $0.00 per 1M input / output tokens

Tariff source and verification date ·

When should you use a decision model?

Use a decision model when the answer is a finite label, a score or a yes/no judgment, and your program already knows what to do with it. Examples include ticket → billing, request → cheaper model, email → spam probability, or document → relevance score.

It can also be the first filter: reduce 100,000 documents to a shortlist for an LLM, send urgent tickets to a person, or escalate suspicious agent outputs for a more expensive review. Keep the accepted labels and the uncertain branch explicit.

Choose a generative model when the result itself is the product: an article, explanation, summary, research report, code or an open-ended plan. A decision model can route that work; it does not create the deliverable.

Keep arithmetic, dates, numeric thresholds and permission enforcement in code. Test confidence on representative cases instead of treating 0.8 as 80% accuracy. Define what happens when the model is uncertain, times out or returns an invalid answer.

Turn a workflow into explicit questions

Support triage: choose billing, technical support or account access; score urgency on a defined 1–5 scale; check whether a refund is requested. These are separate questions. Route the ticket or ask a person to review it; the model does not authorize the refund.

Review and guardrails: check whether an answer is grounded in supplied material, meets a rubric or needs human review. Calibrate review thresholds with false positives and missed violations. Use a generative model when you also need an explanation.

RAG filtering: score each candidate document against the request, shortlist the relevant material, then let a generative model read it. Validate recall so that a cheap first pass does not discard the evidence needed for the final answer.

Decision-model workflows for Jevmail email triage, HA-Jev Assist routing, guardrails and RAG filtering, and ComfyUI-Laya branch selection.
Each lane is a separate workflow. The community projects supply concrete integrations; guardrails and RAG show the general decision pattern described above.
See Laya’s hosted Gateway access

What are people building with decision models?

These projects show how a bounded judgment connects to working software. The results below are their authors’ reports, with the task and operating conditions kept alongside the numbers.

HA-Jev

AboveColin’s HA-Jev connects Jev to Home Assistant sensors, notifications and Assist routing. Low-confidence voice commands can go to a fallback conversation agent. The author reports warm calls of 250–580 ms from the Netherlands. Raw wattage judgments worked poorly; moving the numeric comparison into Jinja improved separation. The author avoids using it to control locks or heaters.

Jevmail

fazlerocks’ Jevmail assigns Gmail messages to five fixed trays, scores urgency from 1 to 5 and checks whether a human wrote them. It uses read-only Gmail permission and cannot send, archive or label mail. The README estimates about a minute and $0.03 for 1,000 emails on the paid Gateway tier; it does not publish a classification-accuracy table.

pi-jev-router

MejiasDev’s pi-jev-router chooses a coding model and reasoning setting, then pins the model for the session to preserve provider caches. Later monitoring can suggest a fork rather than silently switching models. Routing failures use the configured fallback. Compare routing quality, latency and completed-task cost on your own examples.

ComfyUI-Laya

jtydhr88’s ComfyUI-Laya chooses an image or video pipeline and skips unused branches; it does not speed up sampling. Its four-branch test ran only the selected branch after ComfyUI’s lazy-input fix in PR #16377. The author recommends explicit route criteria and the multilingual checkpoint for non-English prompts. Check that your ComfyUI build includes the fix, then evaluate your own routing examples.

pydecide / Laya

Gopalji Gaur’s pydecide supports local Laya and Laya-MLX, hosted decisions and confidence-based fallback. Its Apple Silicon Laya-MLX sample outputs show roughly 33–65 ms. Choice and Noul can be gated; Score is not. If all backends remain uncertain, the library can return a low-confidence result, so the calling application must decide whether to ask a person.

Published decision model latency references

The Laya project reports these Tesla T4 timings. The table does not pin a complete runtime/checkpoint revision and workload specification for every row. These are reference figures, not selectable measured profiles or results measured by this site.

Questions per requestEnglish (p50 ms/request)Multilingual (p50 ms/request)
139.532.8
584.540.1
10158.672.3
50771337

No Typed Decisions timing is inferred from the English checkpoint. CPU, ONNX, fast-path and other GPU setups need their own measurements. Parameter count and weight size do not determine request throughput.

Laya project benchmark source · 2026-09-29

How the decision model estimate works

One question produces one typed decision. Monthly decisions equal requests × questions per request. Several questions can share a state, but their measured latency need not scale linearly.

For sequential requests, capacity = provisioned hours × 3,600 ÷ measured latency in seconds. Active inference hours = requests × latency ÷ 3,600. Utilization is active hours divided by provisioned hours. This is average capacity, without burst, queueing or failover headroom.

Dedicated compute is billed for the time it stays provisioned, including idle time. Cloud compute = full instance hourly price × provisioned hours. Local electricity = wall kW × hours × electricity price × PUE. Local monthly TCO adds labor and system cost ÷ depreciation months.

Jev API cost = requests × average billed input tokens ÷ 1,000,000 × $0.042. The token input affects this comparison only; it never adjusts self-host latency. Use actual usage.input_tokens and include retries in request volume. Jev also requires state + longest question to fit 32k tokens within its 64k total request limit.

Payback divides the upfront system cost by Jev API charges minus local operating costs, excluding depreciation from the cash savings. It is shown only when savings stay positive across the labor range and one endpoint has enough average capacity.

How our cost assumptions work

Self-hosting or a decision API?

CLM / Laya

CLM and Laya provide open weights, local data handling and a fine-tuning path. CLM uses a frozen Qwen3-8B backbone with projection heads; Laya offers smaller specialized checkpoints. You own deployment, monitoring, capacity and calibration. Budget with measured latency and whole-system power.

Read the Laya guide and checkpoint comparisonRead the CLM-8B setup and scoring guide

Jev 1.13

Jev offers a managed decision API and a different context/choice budget. Low-volume requests can cost less than keeping an endpoint provisioned. The cost table does not include your application engineering for either path, and cannot decide whether a model meets your accuracy target.

Read the Jev 1.13 API and pricing guide

Decision calculator questions