Skip to content

Build Independently confirmed3 publishers 3 min read Published

llama.cpp brings TypeSafe's typed-decision format to five open model families on local hardware

llama.cpp merged a /v1/systemone endpoint on October 2 that returns typed answers with probabilities from five open model families running locally. Whether it can replace hosted classification calls depends on calibration that each team has to measure on its own data.

The Engineer · Build desk

Send a correction

Illustration accompanying llama.cpp brings TypeSafe's typed-decision format to five open model families on local hardware
Generated illustration

What happened

  • TypeSafe AI introduced the /v1/systemone format with its hosted Jev model on September 15, as a way to return typed decisions to software workflows.
  • The llama.cpp pull request names Laya, Julia-1, Lev, OpenJev and Kev as the supported model families.
  • Xuan-Son Nguyen authored the change, and Georgi Gerganov reviewed and approved it and announced the endpoint on X.
  • Nguyen wrote on X that the feature should ship in llama.cpp v0.6.0 "early next week", with development builds usable until then.
  • OpenAI put its own Decisions API, built on its small Luna model, into limited preview, with broad release planned within days.

Why it matters

  • What's now possible capability Teams using a supported family can keep classification and routing requests on their own hardware without sending each one through a hosted service.
  • What it limits constraint A team whose preferred open model is outside the five families cannot use the endpoint until someone writes that model's conversion, metadata and server handling.
  • Who's exposed exposure Where a score decides whether a human looks at a moderation or escalation case, a miscalibrated probability sends cases past review, and only a team's own labeled cases can show it.

A call to /v1/systemone sends one shared state and several questions about it. In the pull request's example, the state holds a customer's message and order details [11]. The questions ask whether the customer wants a refund, which team should take the case, and how urgent or frustrating it is [11]. Each question declares an answer type: yes-or-no (`noul`), a choice among labels, or a score on an ordered scale [10]. The server returns a typed answer for each question with a probability distribution attached [11].

According to The New Stack, most teams handle this today by prompting a chat model to pick from a list and, with luck, reading token probabilities as a rough confidence score [16]. The other route is a small classifier. It is fast and cheap, but it needs labeled data and a retrain every time the label set changes [16]. A decision model takes new labels in the prompt and still returns a score a program can act on [17].

Support is per model. The pull request describes model-specific conversion, metadata and server handling, so loading some other open model does not give it the endpoint [18]. A community discussion had already sketched a wrapper built from existing llama-server features [13]. I think per-model conversion code belongs next to the server it has to track. The merged change puts it in the runtime, where conversion and server support are maintained alongside the project [13]. Nguyen wrote in the author disclosure that most of the code was AI-written and that he owned the design [14].

I'd treat the endpoint as ready to evaluate, but not yet as a proven replacement for hosted calls. The pull request compares llama.cpp outputs with reference outputs on example inputs [5]. A parity check is the right first test for a port. It shows the port reproduces the reference model on those cases [5]. It cannot show whether a 0.9 on the urgency question is right nine times in ten on a particular support queue [5]. Teams still have to run supported models on their own cases and check that reported confidence matches observed accuracy [6]. In practice that means holding out labeled real cases, grouping the endpoint's predictions by reported probability, and comparing each group's accuracy with its stated confidence.

OpenAI says its Luna-based decision model returns results in 150 milliseconds, against 1.6 seconds for GPT-6 Luna [1][15]. That works out to roughly 10.7 to 1 [19]. Both figures describe OpenAI's own models. They become a target for a local deployment only after a team times its own hardware on its own requests. The New Stack lists the per-call price, the number of candidate answers one request can carry, and whether developers can tune the model on their own data as still unclear [3]. An OpenAI spokesperson told the publication the company plans to share more "at broad rollout" [2].

What to watch

  • Whether llama.cpp v0.6.0 ships with /v1/systemone on the timeline Nguyen gave, or the feature stays on development builds.
  • Calibration results for any of the five families on real routing or moderation data, evidence beyond the pull request's parity checks.
  • OpenAI's per-call price and candidate-answer limit for the Decisions API at broad rollout, the figures a local-versus-hosted cost comparison needs.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence50
Adoption15
Hype gap+5
Incentives55
Confidence55

Perspective Coverage

3 publishers
Builder
Builder 48%
Operator
Operator 29%
Investor
Investor 23%
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    OpenAI's new Decisions API is based on its Luna model, the smallest and most affordable in its lineup; it is in limited preview with broad release planned for the coming days.

    Reported Supported Source: The New StackView cited source
  2. [2]

    An OpenAI spokesperson told The New Stack the company plans to share more "at broad rollout."

    Reported Supported Source: OpenAI spokesperson, via The New StackView cited source
  3. [3]

    The New Stack says it is still unclear what the Decision API costs per call, how many candidate answers a single request can handle, and whether developers can tune it on their own data.

    Reported Supported Source: The New StackView cited source
  4. [4]

    TypeSafe AI introduced hosted model Jev on September 15th, describing its /v1/systemone format as a way to return typed decisions for software workflows.

    Reported Supported Source: runtimewire.comView cited source
  5. [5]

    The pull request includes comparisons between reference outputs and llama.cpp outputs for example inputs; those checks show implementation agreement on the tested cases and are not a broad evaluation of decision quality across real customer data.

    Reported Supported Source: runtimewire.comView cited source
  6. [6]

    In moderation, routing or escalation, teams may use a score to decide whether a human should intervene; developers still need to test supported models against their own cases and verify that reported confidence matches observed accuracy.

    Reported Supported Source: runtimewire.comView cited source
  7. [7]

    llama.cpp merged a local typed-decision API on October 2nd, adding a /v1/systemone endpoint for five model families.

    Reported Supported Source: runtimewire.comView cited source
  8. [8]

    The change was authored by Xuan-Son Nguyen; Georgi Gerganov reviewed and approved the pull request and announced the endpoint on X.

    Reported Supported Source: runtimewire.comView cited source
  9. [9]

    The pull request names Laya, Julia-1, Lev, OpenJev and Kev as supported model families.

    Reported Supported Source: runtimewire.comView cited source
  10. [10]

    The answer format can be yes-or-no (noul), a choice among labels, or a score on an ordered scale.

    Reported Supported Source: runtimewire.comView cited source
  11. [11]

    The pull request's example sends a shared state containing a customer's message and order details, then asks several questions at once: whether the customer wants a refund, which team should handle the case, and how urgent or frustrating it is. The endpoint returns typed answers and probability distributions for those decisions.

    Reported Supported Source: runtimewire.comView cited source
  12. [12]

    With the llama.cpp implementation, operators can run inference on their own hardware or avoid routing every classification request through a hosted service.

    Reported Supported Source: runtimewire.comView cited source
  13. [13]

    A community discussion had proposed a native endpoint and described a wrapper built from existing llama-server features; Nguyen's merged change adds the capability to the runtime, where conversion and server support can be maintained alongside the project.

    Reported Supported Source: runtimewire.comView cited source
  14. [14]

    In the pull request's author disclosure, Nguyen wrote that most of the code was AI-written, while he owned the design.

    Reported Supported Source: runtimewire.com, citing Nguyen's PR disclosureView cited source
  15. [15]

    OpenAI says its decision model returns results in 150 milliseconds, compared to GPT-6 Luna, which would take 1.6 seconds.

    Reported Supported Source: OpenAI, via The New StackView cited source
  16. [16]

    Most teams handle this today with a regular chat model and a carefully worded prompt, sometimes reading token probabilities for something resembling a confidence score; the alternative is a small classifier that is fast and cheap but needs labeled data and a retraining run every time the label set changes.

    Reported Supported Source: The New StackView cited source
  17. [17]

    A decision model takes new labels in the prompt but returns a score a developer can work with.

    Reported Supported Source: The New StackView cited source
  18. [18]

    The endpoint does not make every open model compatible: the pull request describes model-specific conversion, metadata and server handling.

    Reported Supported Source: runtimewire.comView cited source
  19. [19]

    OpenAI's claimed decision-model latency is about 10.7 times lower than its GPT-6 Luna figure.

    Derived Supported
  20. [20]

    Nguyen wrote on X that the feature was expected to ship with llama.cpp v0.6.0 "early next week" and that developers could use development builds in the meantime.

    Reported Insufficient Source: runtimewire.com, citing Nguyen on XView cited source

Sources

3 independent publishers whose own reporting we read for this story.

  1. runtimewire.com

    1 article · October 2, 2026

    llama.cpp adds a typed-decision API for five specialized open models
  2. techcrunch.com

    1 article · September 30, 2026

    OpenAI’s Jev clone could help the frontier lab stop its swarming agents
  3. thenewstack.io

    2 articles · September 29, 2026

    OpenAI answers TypeSafe’s Jev with a Decision API built on Luna

Topics and entities