Ollaya runs open decision models locally behind a Jev-compatible API

Why it matters

Ollaya turns open decision models into a locally deployable, TypeSafe-compatible service. Its reported latency and calibration results are promising, but the published comparison is not apples-to-apples, leaving developers to validate quality on their own workloads.

Mert Cobanov is building Ollaya around a narrow proposition: software often needs a dependable decision from AI, not another paragraph of generated text. The open-source runtime runs decision models on a developer's own machine and exposes an API compatible with TypeSafe's Jev service, giving teams a local option for classifying, routing and scoring text or JSON.

Cobanov's GitHub profile describes him as a senior AI engineer at Refik Anadol Studio, where he works on Dataland, as well as an open-source developer with projects spanning Docker tools and AI infrastructure. Ollaya fits that pattern: its Rust-based repository packages a command-line tool, daemon, desktop app and Docker image around models made by other researchers and developers. The product places Cobanov in the growing layer of independent tools trying to make new AI model formats practical for application developers.

A runtime for decisions, not chat

A decision model takes an input, such as a customer message, and a set of typed questions. It returns values such as a category, score or yes/no answer, along with probabilities, in a single forward pass. It does not generate a free-form response. In Ollaya's example, a billing complaint produces fields for intent, urgency, frustration, refund request and churn risk.

That output is designed to go straight into application logic. A support system could route a refund request; an operations tool could flag a ticket; an agent could use a score to decide what to do next. Those examples are possible use cases, not evidence of Ollaya deployments or customers.

The design also changes what developers must evaluate. A model that returns a probability can help code distinguish a high-confidence decision from an uncertain one, but the probability is useful only if it tracks real-world accuracy on the task at hand. Ollaya says its Laya model has an expected calibration error of 0.081 after temperature fitting, compared with 0.246 for Jev. Those are company-published figures, and the site does not establish that the models were tested on the same data under the same conditions.

Ollaya's catalog brings together distinct model families: Laya from ConvAI Innovations, decider from Mapika, NLI classifiers associated with Moritz Laurer, and GLiClass from Knowledgator. Cobanov's contribution is the serving and packaging layer, rather than the underlying model research. Ollaya says it retrieves model weights from their authors' Hugging Face repositories, pins them to a commit and verifies them with SHA-256 checks; it says it does not host the weights itself.

The benchmark is a signpost, not a verdict

Ollaya reports that a five-question request using Laya takes about 8 to 10 milliseconds end to end on an NVIDIA RTX 4090. Its displayed results list 9.6 milliseconds for English Laya and 8.1 milliseconds for its multilingual model. That kind of local latency could matter in software that makes many small decisions or needs to keep sensitive text on a user's own hardware.

The comparison on Ollaya's site puts those timings beside 236 to 276 milliseconds for TypeSafe's hosted Jev API. The comparison comes with an important qualification: Ollaya's figures are local tests on an RTX 4090, while the Jev numbers come from third-party benchmarks and include network time. Ollaya itself calls the comparison an order-of-magnitude reference. It is not a controlled head-to-head test, so the figures do not establish that Ollaya's models are faster at equivalent accuracy or under equivalent workloads.

TypeSafe introduced Jev on September 14th, 2026, describing it as a model for structured decisions in software. Ollaya's compatible /v1/systemone and /v1/models endpoints let developers use the TypeSafe Python SDK against a local server by changing its base URL. That makes interoperability a practical adoption path: developers can experiment with the local runtime without rewriting the code that calls the API. The compatibility does not establish a partnership between Ollaya and TypeSafe.

Local control brings its own costs

The privacy and pricing pitch is straightforward: Ollaya runs on user-controlled hardware, listens on 127.0.0.1 by default, and charges no per-token fee. The trade-off is that teams supply and maintain the machine, manage model versions, and test whether the open models meet their accuracy requirements. Its published platform details also show that GPU acceleration depends on supported NVIDIA hardware and software; the listed fast results are specifically for an RTX 4090.

For now, the clearest case for Ollaya is an engineering team that wants structured model outputs without sending every request to a hosted service, or that already has a compatible Jev integration and wants to test local inference. The project offers a route to that test, including CPU support and a TypeSafe-shaped API. Its reported speed and calibration numbers give developers a reason to run their own evaluations, rather than settling the question for them.

The strategic bet is in the layer between open model weights and production software. As more models return typed decisions instead of prose, someone has to handle model discovery, local serving, routing and API compatibility. Ollaya is Cobanov's attempt to make those decisions installable like ordinary developer infrastructure. Whether that convenience earns lasting use will depend on model quality, maintenance and reproducible benchmarks, not the resemblance of its name to a familiar local-model tool.