Ollaya is an open source tool that runs decision models locally, behind an API compatible with TypeSafe’s Jev and with no per-call charges. Despite the name, it’s not Ollama: it’s an independent project, with no affiliation to Ollama or TypeSafe, and code written for Jev can point to your own machine by changing three environment variables.
Status as of September 26, 2026: the current version is v0.6.0, released on September 25. The project site still identifies Ollaya as Beta, and the list of models changes with each release.
The project takes the development experience of Ollama almost command by command: a single binary, models that you download with pull and run with run by name, Modelfiles to customize them, and a local REST API. The difference is in what it runs: models that answer typed questions with calibrated probabilities instead of generating text. In English, the category is known as decision models, and Ollaya presents itself as an open-source Jev alternative for local inference.
This article is based on the code, release notes, and documentation published by Ollaya. We have not run it nor independently reproduced its benchmarks.
What is a decision model?
A decision model reads a state and returns a typed response with calibrated probabilities for each question, in a single pass of the model. The state can be a message, an email, a ticket, or any JSON object. The questions are of three types: choice, score, and noul. The model never generates text.
That result is easy to convert into action: route the ticket, block the message, or escalate when a probability exceeds a threshold.
TypesSafe’s closed Jev model created this category. We explain how it works and how much it costs in Jev by TypeSafe: how AI that makes decisions without generating text works. That article ended with a limitation: Jev’s weights are not public, so you can’t host it yourself. Ollaya’s answer is to serve open decision models behind the same API shape.
This is the first example from the README:
ollaya run laya --preset triage "I was charged twice for my subscription this month and want a refund."
intent refund ████████████████ 1.00
is_urgent no ██████████████░░ 0.88
frustration 1.76 / 3 ██████░░░░░░░░░░ 0.36
refund_requested yes ██████████████░░ 0.90
churn_risk no ██████████░░░░░░ 0.61
What’s the difference between Ollaya, Ollama, and Jev?
Ollaya applies Ollama’s workflow to decision models instead of generative LLMs, and exposes Jev’s API format with open models underneath.
Versus Ollama:
- The commands will be familiar to you:
serve,run,pull,list,ps,show,rm,cp,stop, andcreate. - If the daemon is not running, the CLI starts it.
- The default port is
11435, one more than Ollama’s11434, so both can run at the same time.
If what you’re looking for is running generative LLMs on your machine, Ollama is still the tool; we compare it with its alternatives in LM Studio, Ollama or llama.cpp: what really runs on your machine.
Versus Jev:
- The endpoints
/v1/systemone,/v1/decisions, and/v1/modelsare identical to TypeSafe’s at the protocol level. - The models are different, and their quality also varies by task (we see this below).
What models can you run with Ollaya?
As of September 26, 2026 (v0.6.0), the README lists these models. Each one keeps its own license:
| Model | What it is | License |
|---|---|---|
laya |
Router: sends English to laya:en and other languages to laya:multilingual |
Apache-2.0 |
laya:en |
Decision model in English (ModernBERT-large); the fastest | Apache-2.0 |
laya:multilingual |
More than 100 languages (mmBERT-base) | Apache-2.0 |
laya:typed-decisions |
Fine-tuned on typed decision flows | Apache-2.0 |
decider, decider:0.8b |
Mapika’s Qwen3.5 decoders; the most accurate and the slowest | Apache-2.0 |
kev |
LoRA and pointer head by Jared Palmer on Qwen3.5-0.8B (new in v0.6.0) | Apache-2.0 |
von |
Von 1.1 by Victor Hugo Panisa on ModernBERT-large, 8k token context (new in v0.6.0) | Apache-2.0 |
qwen3guard |
Qwen security guard (safe / controversial / unsafe, 119 languages; new in v0.6.0) | Apache-2.0 |
nli:modernbert-large |
Zero-shot NLI classifier by Moritz Laurer | Apache-2.0 |
nli:deberta-v3-large |
Zero-shot NLI classifier by Moritz Laurer | MIT |
gliclass |
Zero-shot classifier by Knowledgator that follows instructions | Apache-2.0 |
Two details matter if you work in Spanish:
- The router covers non-English text.
layasends any text in another language tolaya:multilingual. It’s relevant because TypeSafe indicates that Jev currently offers its highest accuracy in English. - Ollaya never re-hosts weights. It only publishes small ONNX graphs (about 3 MB each) that read the original weights from each author’s Hugging Face repository, pinned to a commit and verified with sha256.
How do you install Ollaya?
Linux and macOS (Apple silicon):
curl -fsSL https://ollaya.dev/install.sh | sh
On Linux you need x86-64 or ARM64 with glibc 2.38 or higher: Ubuntu 24.04, Debian 13, Fedora 39, RHEL 10 or later. If there’s an NVIDIA GPU with driver R580 or higher, the installer adds the CUDA runtime.
Windows (x64, PowerShell):
irm https://ollaya.dev/install.ps1 | iex
Docker:
docker run -d --gpus=all -p 11435:11435 ghcr.io/ollaya-dev/ollaya:cuda
Use ghcr.io/ollaya-dev/ollaya if you only have CPU. The Docker image is also the way for older Linux distributions.
Desktop app: available for macOS, Windows, and Linux at ollaya.dev/download. Starts and stops the server, downloads models, and runs them from a single window. On macOS it lives in the menu bar, which v0.6.0 redesigned.
Does Ollaya work on Windows? Do you need GPU?
Yes, but on Windows it only works with CPU. To use an NVIDIA GPU on Windows, you need WSL 2 with the Linux installer.
GPU is not required on any platform: Ollaya works with CPU on all of them, and on Linux x86-64 it uses an NVIDIA GPU when it finds one. The speed figures published by the project were measured on GPU (see below), so expect higher latencies on CPU.
How to use Ollaya with Claude Code via MCP?
You register its MCP server (MCP server) in Claude Code with a single command:
claude mcp add ollaya -- ollaya mcp
ollaya mcp speaks MCP over stdio and starts the local server if it’s not running. It exposes four tools:
decideanswers typed questions about a state. Receivesstate,questionsorpreset, andmodel(defaults tolaya).list_modelsshows what you have installed.show_modelreturns the details of a model, including its license.pull_modeldownloads a model.decidealso downloads it on first use.
What about Claude Desktop, Cursor, or VS Code?
In Claude Desktop, add this block to claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"ollaya": { "command": "ollaya", "args": ["mcp"] }
}
}
If Claude Desktop can’t find ollaya, use the full path, for example /usr/local/bin/ollaya or ~/.local/bin/ollaya.
In Cursor and VS Code, use the same command, ollaya mcp, in .cursor/mcp.json or .vscode/mcp.json. VS Code needs "type": "stdio".
Is there a skill for agents?
Yes. Ollaya includes a skill that teaches Claude Code when a typed decision is better than reasoning in text and how to act based on probabilities:
npx skills add ollaya-dev/ollaya --skill ollaya-decisions
Add -g to install it across all your projects.
Can Ollaya prevent an agent from executing a dangerous command?
That’s what the new --preset agent in v0.6.0 is for. It takes the user request (request) and the proposed command (command), and answers four questions:
action: run, ask, or blockon_task: whether the request really needs that commandrisk: how much damage it could causedestructive: whether it deletes or overwrites work
The release notes use this example:
ollaya run decider --preset agent '{"request": "Fix the typo in README.md", "command": "git push --force origin main"}'
According to the release notes, decider:2b blocks that command in about 180 ms on an RTX 4090:
| Question | Answer | Probability |
|---|---|---|
action |
block | 0.53 |
on_task |
out of task | 0.75 |
destructive |
yes | 0.90 |
The same request with a sed that fixes the typo gets run with 0.90. The preset also works from the MCP server (preset: "agent") and from the desktop app.
Note that a block probability of 0.53 is a signal, not a guarantee. Keep permission checks strict in deterministic code.
How do I migrate my code from Jev to Ollaya?
Point the official TypeSafe Python SDK (0.7.1) to localhost with three environment variables:
export TYPESAFE_BASE_URL=http://localhost:11435
export TYPESAFE_API_KEY=local # the SDK needs a non-empty key; any value works
export TYPESAFE_DEFAULT_MODEL=laya # otherwise the SDK sends "jev-latest"
Three differences to keep in mind:
- Model names change. You need
layaorlaya:en, notjev-latest. - Give descriptive names to your questions. When a question doesn’t have
instructions, the model reads its id instead, sois_urgentworks better thanq1. - Limits: maximum 256 questions per request, between 2 and 255 options, and between 2 and 10 scoring levels. Each model also has an option budget: roughly 125 for
laya:enand 250 forlaya:multilingual.
Is Ollaya as good as Jev?
It depends on the task, and Ollaya’s own documentation makes this clear. All the figures below are published by the project; they are not independently verified.
Where it comes out ahead:
laya:typed-decisionsscores 0.766 on the typed-decisions benchmark, versus 0.727 that TypeSafe published for Jev 1.13.- Laya’s calibration error after temperature adjustment is 0.081, versus 0.246 for Jev.
Where it clearly falls behind:
- Laya’s base checkpoints are near random in zero-shot on typed-decisions (0.362).
- Multiple-choice questions with many options (more than about 20) are weak. On Banking77, Laya scores 0.425 versus 0.870 for Jev.
Speed: measured end-to-end on an RTX 4090, the project reports these medians:
| Model | Five questions |
|---|---|
laya:multilingual |
8 ms |
laya:en |
10 ms |
von |
23 ms |
kev |
185 ms |
Fidelity: ONNX exports chose the same answer as the PyTorch reference in fp32 on 100% of 2,383 questions across Laya checkpoints.
Follow the advice from the documentation itself: measure with your data before moving production traffic. For the thresholds you depend on, retune temperatures with your labeled data and incorporate them in a Modelfile.
Is Ollaya free? Do your data stay on your machine?
Ollaya is open source under the Apache-2.0 license. Running it has no per-call cost; the cost is your own compute.
The models have their own licenses, as shown in the table above: all are Apache-2.0 except nli:deberta-v3-large, which is MIT. If you build a product on one of them, review that model’s license instead of assuming the project license covers it.
The server listens by default on 127.0.0.1:11435. The network is only used to download models, and the documentation indicates that states and questions are never logged. This is a relevant difference compared to any hosted decision API when the state contains customer tickets or emails.
Who benefits from Ollaya today?
Three profiles get the most value from it today:
- Teams already prototyping with Jev who want a local alternative or want to test without API calls.
- Those building agents in Claude Code or Cursor and want a fast filter before destructive commands execute.
- Teams whose work isn’t in English, thanks to the multilingual router.
It’s in Beta, the model list grows every week, and on some task types open models clearly lag behind Jev. As an installable way to put a decision step of less than 100 ms in front of an agent, it’s worth an afternoon of testing.