Stop paying LLM prices for every decision.

Let LLMs reason. Let Sieve decide.

This is not a replacement for the model you already run. Reasoning, planning and conversation are what large models are good at, and you should keep paying for them where they earn it. What they should not be doing is answering the same four-option question eight thousand times a day at a cent a go. Give that work to something built for it, and let your software do what software has always done: act.

1. LLM agents Reason, plan, converse.
2. Sieve Decide: approve, route, flag, score.
3. Your software Act: update, pay, notify.
4. Sieve Assurance A governance plane across all three: calibration, drift and a per-decision audit log.

Every number here is published.

We know what a benchmark score is worth, because ours was wrong once. Our 27B model scored 68.02 on the public test suite and 59.89 when the maintainers ran their private one. We had taught it the test. The rebuild took three weeks and changed how we train and how we select weights, and the model below now scores higher on tasks from domains it has never seen than on the skills it was trained for. That is the number we would check if we were you.

Decision Index 0.4.1, board data of 28 October 2026. The Full score is 60% private tests of the same skills and 40% private tasks from new domains; public benchmarks are displayed on the board and carry no weight. Leaderboard positions move as models are added.

Five offerings, one decision stack you own.

Nobody buys a decision stack. They buy one decision that stopped costing them money, and then another. These five exist because that is the order the problem arrives in: prove it works, get it past InfoSec, teach it your policies, satisfy the examiner, then do it again for the next twenty decisions without starting over.

Each one stands alone. Most teams start with a Foundry model running on Vault, governed by Assurance, then add decisions from their industry canvas.

Six decisions to start with.

Every one of these is a decision somebody on your team makes a few hundred times a day, from a policy they could recite in their sleep, and gets right almost every time. That is what makes them worth automating and also what makes them easy to measure: you already know the right answer for the last two thousand cases.

Pick one decision with history and a clear owner.

Twelve open decision models, from 0.8B to 31B.

The model you need is probably smaller than the one you are using. A 9B model answers a yes/no judgement in 50 milliseconds for a fifth of a cent, and on the kind of question your software actually asks, it is not meaningfully worse than something forty times its size. Start small, and move up only where the decision is genuinely hard.

See all Sieve models on Hugging Face. Model cards credit every base model and open-source component. Two vision models are also published and are not counted here.

Same kind of model, a different deal.

Jev made this category real, and it is a good hosted API. The question is not which model is better on a given Tuesday, because that will change. The question is what you are left holding in two years. With a hosted API you are renting one shared model over the internet, and the terms, the price and the roadmap belong to somebody else. With Sieve the weights are yours, the adapter trained on your decisions is yours, and it runs where your data already lives.

Jev is a product of TypeSafe. Comparison based on TypeSafe documentation and public sources, October 2026.

Three lines to the first decision.

There is no prompt to write. No output schema to specify, no retry loop, no parser to maintain when somebody adds a sixth queue. You pass the case and the answers you will accept, and you get a number back for each one.

$ pip install "sieve-decisions[cuda,serve] @ git+https://github.com/sthanika-ai/Sieve"

from sieve import load_sieve
model = load_sieve("sthanika-ai/Sieve-9B-v2")
model.choice(state=ticket,
             question="Which team should handle this?",
             options=["billing", "technical", "account", "other"])

# POST /v1/systemone
{
  "model": "sieve-latest",
  "state": { "claim": "Rear-end collision, police report, estimate $3,850" },
  "questions": {
    "route": {
      "type": "choice",
      "instructions": "Where should this claim go?",
      "criteria": { "fast_track": null, "standard": null, "investigate": null }
    }
  }
}

# response
{ "route": { "choice": "fast_track", "confidence": 0.73,
  "probabilities": { "fast_track": 0.82, "standard": 0.15, "investigate": 0.03 } } }

From one decision to production.

You have been through a pilot that went sideways and could not be stopped without someone losing face. So every stage here has a written exit that you control, agreed before the work starts. If the benchmark is unconvincing, that is the end of it and it cost you nothing. If the pilot misses the criteria we set together on day one, there is no fee.

1. 01

   Benchmark

   When

   Weeks 0 to 2

   Cost

   Free

   One decision, up to 2,000 past cases, scored against your current model

   Exit: Your call on a pilot

2. 02

   Pilot

   When

   Weeks 3 to 8

   Cost

   $40,000, credited

   Up to five decisions, in your cloud or on redacted samples

   Exit: Agreed criteria met, or no fee

3. 03

   Production

   When

   Weeks 9 to 16

   Cost

   Licence

   Vault in your environment, a Foundry model on your logs

   Exit: Model-risk sign-off, live

4. 04

   Scale

   When

   Quarter 2 onward

   Cost

   Expand

   Canvas decisions added, quarterly retraining, monthly drift and calibration reports

Bring us one decision.

The benchmark is free because arguing about this in a meeting is slower than measuring it. Send one decision and two thousand past cases, and in ten business days you will know what Sieve costs, how fast it runs and how often it is right, next to whatever you use today. If the answer is that your current setup is fine, that is a useful thing to find out for nothing.

Questions buyers ask