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 serve runs the daemon; ollaya run, pull, list, ps, show, rm, cp, stop, create work like Ollama's CLI. The CLI auto-starts the daemon if needed.
  • TypeSafe-compatible API (described above).
  • Native API too: /api/decide adds routing info and timings; /api/pull streams 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 mcp serves models to Claude Code, Claude Desktop, Cursor, etc. There's also an ollaya-decisions skill that teaches agents when/how to use them.
  • Routers: laya detects the script and language of each request, then picks laya:en or laya:multilingual.
  • Modelfiles: you can bake a question set into your own model (like a Dockerfile for models):
    FROM laya
    QUESTIONS ./triage.json
    PARAMETER precision fp32
    
    Then ollaya create triage -f Modelfile and ollaya 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 with laya (516 ms on CPU).
  • laya — router (language detection), with laya: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:flash 73.7, jeb:27b 69.1, d3:mini 68.0, d3:flash 67.8, jeb:9b 66.0. Fastest of these: jeb:9b at 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 | iex in 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 :cuda12 for 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 resolution
  • crates/ollaya-api — API types and client
  • crates/ollaya-registry — model names, manifests, blob store, resumable pulls
  • crates/ollaya-decision — question schema, sequence layouts, calibration, answers
  • crates/ollaya-runner — inference engines (ONNX Runtime, llama.cpp for GGUF)
  • crates/ollaya-lang — script/language detection for routers
  • convert/ — build-time Python (ONNX export, parity checks, packaging)
  • site/ — website and static model registry host

Development

  • cargo test --workspace and cargo 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 into registry/.

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