ollaya-dev/ollaya
Jev-compatible API server for open decision models. Ollama for decision models: pull and serve 29 model families (Laya, pplx-decider, Clef, Winnow, coba...) locally or self-hosted behind /v1/systemone. The TypeSafe SDK works unchanged: set its base URL and pick an open model. CLI, desktop app, Docker, MCP server, public bench.
What is Ollaya?
Ollaya is a self-hosted program that runs "decision models" on your own computer — the same way Ollama runs large language models (LLMs), but for a different job. Instead of generating text, decision models answer typed questions (like "is this urgent?" or "which team should handle this?") with calibrated probabilities — e.g., "0.91 chance this is a refund request" — in milliseconds, without calling an LLM.
The pitch: AI agents need quick, reliable decisions (routing, guardrails, triage, tool approval). Ollaya gives you that as a local service with open models, so your data never leaves your machine.
How it works
You send a state (a message, email, ticket, or any JSON) plus typed questions (choice, score, noul). The model returns probabilities in a single forward pass. It never generates text.
Example from the README — running a triage model on a complaint email:
ollaya run winnow:e4b --preset triage "Third time this year you've double-charged me. Refund it today or I'm cancelling..."
Output (abbreviated):
intent refund ███████████████░ 0.91
is_urgent yes ███████████████░ 0.92
frustration 2.89 / 3 ██████████████░░ 0.86
refund_requested yes ████████████████ 0.99
churn_risk yes ████████████████ 0.99
You can also ask your own questions: ollaya run kev --ask "Is a refund requested?" --ask "Which team?" --choice billing --choice sales < ticket.txt.
Jev compatibility (the key integration)
Ollaya exposes an HTTP API that is wire-identical to TypeSafe's hosted "Jev" service (POST /v1/systemone, /v1/decisions, GET /v1/models). That means the official TypeSafe SDK and any existing Jev client work unchanged — you just point them at Ollaya and pick an open model:
export TYPESAFE_BASE_URL=http://localhost:11435
export TYPESAFE_API_KEY=local # any non-empty value
export TYPESAFE_DEFAULT_MODEL=winnow:e4b # instead of "jev-latest"
So Ollaya is essentially a drop-in, self-hosted replacement for TypeSafe's Jev, using open models instead of TypeSafe's closed one.
Comparison (from the README's table)
| Ollaya | TypeSafe Jev | Ollama | |
|---|---|---|---|
| Runs on | Your machine or server | TypeSafe's cloud | Your machine or server |
| Jev API | /v1/systemone, /v1/decisions, /v1/models |
The original | /v1/systemone |
| Models | Open decision models from Perplexity, Cloudflare, PostHog, Bespoke Labs and others | Jev (closed) | Its own GGUF builds of nine decision models |
| Probabilities | Each author's calibration | TypeSafe's | Raw softmax |
| Your data leaves the machine | No | Yes | No |
| License | Apache-2.0 | Proprietary, hosted | MIT |
Key features
- One binary.
ollaya serveruns the daemon;ollaya run,pull,list,ps,show,rm,cp,stop,creatework like Ollama's CLI. The CLI auto-starts the daemon if needed. - TypeSafe-compatible API (described above).
- Native API too:
/api/decideadds routing info and timings;/api/pullstreams progress; plus/api/tags,/api/show,/api/ps. - Weights come from their authors. Ollaya publishes only small ONNX graphs (~3 MB each) that read the original weight files from the author's Hugging Face repo, pinned to a commit and sha256-verified. For models whose authors publish GGUF files, it runs those directly on llama.cpp. Ollaya never re-hosts weights.
- For agents:
ollaya mcpserves models to Claude Code, Claude Desktop, Cursor, etc. There's also anollaya-decisionsskill that teaches agents when/how to use them. - Routers:
layadetects the script and language of each request, then pickslaya:enorlaya:multilingual. - Modelfiles: you can bake a question set into your own model (like a Dockerfile for models):
ThenFROM laya QUESTIONS ./triage.json PARAMETER precision fp32ollaya create triage -f Modelfileandollaya run triage "…". - Hardware support: ONNX Runtime on CPU and CUDA on NVIDIA GPUs; GGUF models run on llama.cpp (CPU, ROCm/HIP on AMD, Vulkan on Windows, CUDA, Metal on Apple silicon).
- Precision: fp16 on GPU, fp32 on CPU when available; fp32 exports match the PyTorch reference on 100% of 2,383 questions per checkpoint.
Models (a sample)
winnow:e4b— recommended: 0.724 accuracy on typed decisions, 113 ms for five questions on an RTX 5090. 4B-class model; without an NVIDIA GPU, start withlaya(516 ms on CPU).laya— router (language detection), withlaya:en,laya:multilingual,laya:typed-decisions.decider— Mapika's Qwen3.5 decoders (2B default, 4B, 0.8B, plus a vision variant).kev— Jared Palmer's Kev (LoRA + pointer head on Qwen3.5, calibrated).pplx-decider— Perplexity's flash model, calibrated, up to 255 options.clef— Cloudflare's Clef-Flash, scores every question's options in one forward pass.jeeves— PostHog's Jeeves-9B without reasoning chain.d1,d1-omni— Liquid AI's models (text and image decisions).qwen3guard— safety guard with built-in questions (safe/controversial/unsafe).nli,gliclass,von,clm,jevk5,nimble,strands-decider,d3,jeb,cygnet,snap,decima,largha,arbiter— many more, each with its own author and characteristics.
All models are browsable at ollaya.dev/search; accuracy, speed, and memory are on Ollaya Bench.
Results / benchmarks
Every model is measured on Ollaya's own machines with the same 5,880 questions. From the 2026.10 edition (Ollaya 0.13.0–0.19.0 on an RTX 5090):
- Score (chance-corrected accuracy over 14 tasks):
pplx-decider:flash73.7,jeb:27b69.1,d3:mini68.0,d3:flash67.8,jeb:9b66.0. Fastest of these:jeb:9bat 111 ms for five questions. - Calibration (lowest errors): 0.016 (
pplx-decider:flash), 0.018 (jeeves:9b), 0.020 (jeb:9b). - Speed: five-question requests take 14 ms to 1.0 s on the RTX 5090; 314 ms to 62.0 s on a Threadripper 3960X CPU.
- Parity: before shipping, each model's runtime is checked question-by-question against the authors' code.
- A comparison with Ollama on the same GPU found calibration error 0.022 on Ollaya vs 0.115 on Ollama for the same Nimble weights.
Install
- Linux (x86_64/arm64, glibc ≥ 2.38):
curl -fsSL https://ollaya.dev/install.sh | sh(adds CUDA runtime if an NVIDIA GPU is present). - macOS (Apple silicon): same command.
- Windows (x64):
irm https://ollaya.dev/install.ps1 | iexin PowerShell. - Desktop app for macOS/Windows/Linux (menu bar on macOS): ollaya.dev/download.
- Docker:
docker run -d --gpus=all -p 11435:11435 ghcr.io/ollaya-dev/ollaya:cuda(or:cuda12for older drivers, or the CPU-only image).
Configuration via environment variables: OLLAYA_HOST, OLLAYA_MODELS, OLLAYA_KEEP_ALIVE, OLLAYA_DEVICE, OLLAYA_API_KEY, etc.
Repository structure
crates/ollaya— the binary (CLI, daemon, runner)crates/ollaya-server— HTTP API, scheduler (one runner process per model), model resolutioncrates/ollaya-api— API types and clientcrates/ollaya-registry— model names, manifests, blob store, resumable pullscrates/ollaya-decision— question schema, sequence layouts, calibration, answerscrates/ollaya-runner— inference engines (ONNX Runtime, llama.cpp for GGUF)crates/ollaya-lang— script/language detection for routersconvert/— build-time Python (ONNX export, parity checks, packaging)site/— website and static model registry host
Development
cargo test --workspaceandcargo build --release -p ollaya --features cuda- Three test tiers (K1 every change, K2 every release, K3 major releases) with the same parity tolerances, checking runtime output against golden fixtures.
convert/rebuilds models: exports, checks parity against PyTorch reference, generates goldens, packages intoregistry/.
License
Ollaya itself is Apache-2.0. Each model keeps its own license (mostly Apache-2.0 or MIT, with exceptions: nimble:9b-v3 is CC BY-NC 4.0 non-commercial, d1 is under LFM Open License v1.0 with a revenue threshold, arbiter's base Gemma 3 is under Gemma Terms of Use). llama.cpp (shipped for GGUF models) is MIT.
Important: Ollaya is an independent project — not affiliated with or endorsed by Ollama or TypeSafe.
Bottom line
Ollaya is a local, open-source alternative to TypeSafe's hosted Jev service for AI-agent decision-making. It runs open decision models on your own hardware, is API-compatible with TypeSafe's SDK, and is fast (millisecond decisions) without generating text. If you're building agents that need routing, guardrails, triage, or tool approval, Ollaya lets you do that locally with open models and calibrated probabilities.
Related
- Dispatch
- Dispatch
- Project
- Dispatch
- Dispatch