# Ollaya

> System 1 for AI agents. Ollaya serves open decision models on your own machine, behind a self-hosted, Jev-compatible API: typed, calibrated answers in milliseconds for routing, guardrails, triage and tool approval.

A decision model reads a state (a message, an email, a ticket, any JSON) plus typed questions (choice, score, yes/no) and returns calibrated probabilities in a single forward pass, in milliseconds. It never generates text. Ollaya pulls these models by name from their authors' Hugging Face repositories and serves them from a local daemon on port 11435 behind a self-hosted, Jev-compatible API (TypeSafe's `/v1/systemone` wire format), so the TypeSafe SDK and other Jev clients work unchanged once they point at Ollaya and name an open model. Install: `curl -fsSL https://ollaya.dev/install.sh | sh`.

## Docs
- [Quickstart](https://ollaya.dev/docs/quickstart): Install Ollaya, run your first decision model and call the local API.
- [From the browser to your code](https://ollaya.dev/docs/browser-to-code): Take the model you tried in your browser to your own code. Pull coba:150m-ternary with Ollaya and call it from curl, Python, TypeScript or a Docker container.
- [CLI reference](https://ollaya.dev/docs/cli): Every ollaya command and flag: run, pull, serve, list, ps, show, stop, rm, cp, create, preset, update and mcp.
- [API reference](https://ollaya.dev/docs/api): The native /api endpoints, the TypeSafe-compatible /v1 endpoints, errors, streaming and limits.
- [Modelfile](https://ollaya.dev/docs/modelfile): Bake a question set, calibration, precision and license into a model you can run by name.
- [TypeSafe compatibility (Jev-compatible API)](https://ollaya.dev/docs/typesafe-compatibility): Ollaya is a self-hosted, Jev-compatible API server. Use the official TypeSafe SDK and existing Jev code with local, open models by changing environment variables.
- [Open-source Jev alternative: which open model on which hardware](https://ollaya.dev/docs/jev-alternative): Replace TypeSafe's hosted Jev with an open decision model on your own machine, behind the same API. Which model to run on a 4, 8 or 12 GB GPU or a CPU, with measured accuracy, calibration and speed.
- [Agents: MCP and skill](https://ollaya.dev/docs/agents): Give AI agents local, typed decisions: the Ollaya MCP server for Claude Code, Claude Desktop, Cursor and other clients, and an agent skill that teaches when and how to use it.
- [Guardrails: prompt injection and jailbreak detection](https://ollaya.dev/docs/guardrails): Check prompts, tool results and retrieved documents for prompt injection, jailbreaks and harmful content on your own machine, with open guard models and calibrated probabilities.
- [Routing: pick the model for each request](https://ollaya.dev/docs/routing): Route each request to the right LLM, tool or team with a local decision model. Difficulty, domain, tool use and sensitivity come back typed and calibrated, in milliseconds.
- [Replacing LLM classification calls with a local model](https://ollaya.dev/docs/replace-llm-classifiers): Move the classify, triage and yes/no prompts you send to a hosted LLM onto a local decision model, with typed answers, calibrated probabilities and no per-token cost. Nothing leaves your machine.
- [Zero-shot classification on a CPU](https://ollaya.dev/docs/cpu-classification): Classify text into labels you choose per request, on a CPU with no GPU, in under a second. Which open models to run, and how fast and accurate they are, measured.
- [FAQ](https://ollaya.dev/docs/faq): How Ollaya relates to Ollama and TypeSafe, hardware, privacy, where weights come from, and licensing.
- [For model authors: Day-0 support](https://ollaya.dev/docs/model-authors): Releasing a decision model? Share it with Ollaya before launch and `ollaya run` works on announcement day, with parity against your code and benchmark numbers you can quote.
- [Integrations: LiteLLM, LangChain, AI SDK, DSPy, LlamaIndex, n8n and Dify](https://ollaya.dev/docs/integrations): Use Ollaya from LiteLLM, LangChain, the Vercel AI SDK, DSPy and LlamaIndex through their TypeSafe integrations, with a base URL and nothing else to install, and from n8n and Dify workflows over HTTP.

## Models
- [winnow](https://ollaya.dev/library/winnow): Decision models by EldanRing, fine-tuned from Google's Gemma 4 and published as GGUF. Winnow reads the answer labels' logits after its own prompt; Ollaya runs the author's file on llama.cpp, on NVIDIA GPUs, Vulkan GPUs on Windows, Apple silicon or the CPU.
- [laya](https://ollaya.dev/library/laya): Open decision models from Convai Innovations. Typed, calibrated answers to choice, score and yes/no questions in a single forward pass, in English and 100+ languages.
- [decider](https://ollaya.dev/library/decider): Decoder decision models by Mapika on Qwen3.5: the answer is read from option-letter logits in one forward pass.
- [kev](https://ollaya.dev/library/kev): Decision models by Jared Palmer: a LoRA on a Qwen3.5 base plus a pointer head that scores every option at its own span, in one forward pass per question. Calibrated with Kev's own temperature.
- [nli](https://ollaya.dev/library/nli): Zero-shot classifiers by Moritz Laurer: every option becomes a hypothesis scored for entailment. The most accurate encoder model on typed decisions in our tests.
- [gliclass](https://ollaya.dev/library/gliclass): Instruction-following zero-shot classifier by Knowledgator: all options of a question are scored in one pass, so on a GPU the cost barely grows with the number of options; on a CPU it grows with them.
- [qwen3guard](https://ollaya.dev/library/qwen3guard): Safety guard by the Qwen team: is a text safe, controversial or unsafe, and which unsafe category? It answers its own built-in questions, in 119 languages, in one forward pass.
- [decision](https://ollaya.dev/library/decision): Decision models by the vLLM Semantic Router contributors: a fully fine-tuned Qwen3.5 backbone plus an endpoint head that scores every option at its own last token against the question, in one forward pass per question. 16k-token rows.
- [von](https://ollaya.dev/library/von): Decision model by Victor Hugo Panisa on ModernBERT-large: every option is scored at its own marker, all options of a question in one pass, with an input-conditioned calibration. 8k-token context.
- [jevk5](https://ollaya.dev/library/jevk5): Decision model by alibiserikbay, fine-tuned from Qwen3.5-4B and published as GGUF. JevK5 reads the answer letters' logits after its own JSON prompt; Ollaya runs the author's file on llama.cpp, on NVIDIA GPUs, Vulkan GPUs on Windows, Apple silicon or the CPU.
- [clm](https://ollaya.dev/library/clm): Contrastive decision model by Contrastive-LM: the Qwen3-8B encoder embeds the state and every option, and two trained heads pick the option closest to the state. Repeated questions and options are cached.
- [nimble](https://ollaya.dev/library/nimble): Decision model by Bespoke Labs: a LoRA on Qwen3.5-9B trained on contrastive pairs. Nimble reads the whole request as a JSON schema and scores each option by the next-token logit of its code; Ollaya applies the author's temperature, so its probabilities are calibrated. Up to 255 options.
- [jeb](https://ollaya.dev/library/jeb): Decision models by Jason Brashear and AINode: LoRAs merged into Qwen3.5 and Qwen3.8, published as GGUF. Jeb reads the option labels' logits after AINode's own decision prompt, with a fitted temperature per question type; Ollaya runs the authors' files on llama.cpp.
- [cygnet](https://ollaya.dev/library/cygnet): Frozen Gemma 4 12B IT with blockbrain-ai's Cygnet prompt: the options as letters, one answer slot, and one calibration temperature. No fine-tuning; Ollaya runs ggml-org's Q8_0 GGUF on llama.cpp.
- [jeeves](https://ollaya.dev/library/jeeves): Decision model by PostHog: Qwen3.5-9B with a LoRA merged in and a pointer head that scores every option at its own marker. Ollaya runs it without its reasoning chain, in one forward pass per question, calibrated with the authors' temperature.
- [clef](https://ollaya.dev/library/clef): Decision models by Cloudflare. Clef-Flash is Qwen3.5-9B, fully post-trained, with a joint schema head that scores every option of every question together, in one forward pass per request. Its probabilities come straight from the head. Ollaya runs its text path.
- [snap](https://ollaya.dev/library/snap): logitlab's snap1-2b: MiniCPM5-2B fine-tuned to read one option letter after the prompt of emnlmn's snap engine. Ollaya runs the author's Q8_0 GGUF on llama.cpp with snap's own prompt, on NVIDIA GPUs, Apple silicon or the CPU.
- [decima](https://ollaya.dev/library/decima): A. M. Madani's Decima: multilingual encoders (mmBERT-base, multilingual-e5-small) with a late-interaction scorer that reads every option against the state, so option order never changes the answer, and an ordinal head for scores. A general model, one for coding-agent decisions, two guards for LLM apps, and a small one that is the fastest on a CPU.
- [arbiter](https://ollaya.dev/library/arbiter): Codekins' Arbiter (Zyot Lab): Gemma 3 4B IT with a LoRA and a fixed 24-slot head that reads every option at the end of one prompt per question. It answers yes/no questions, choices of up to 16 options and scores of exactly 6 levels.
- [credence](https://ollaya.dev/library/credence): Txoka's Credence v1: MiCA refinements of EldanRing's Winnow-E4B (Gemma 4), run from the author's Q8_0 GGUFs on llama.cpp. Two checkpoints trade public accuracy against calibration, each with a vision tag that adds Winnow-E4B's unchanged projector; neither beats original Winnow on every metric.
- [strands-decider](https://ollaya.dev/library/strands-decider): Strands Agents' decision model: a LoRA and a pointer head on Qwen3.5-2B base. Each question is one row with a line per option, every option scored at the end of its own line, and the probabilities are calibrated with the authors' temperature for each question type. Up to 255 options.
- [pplx-decider](https://ollaya.dev/library/pplx-decider): Perplexity's decision model: Qwen3.5-4B distilled from its 27B decision models, with a readout over 255 answer codes. Every question of a request shares one sequence and reads the whole request, and the probabilities are calibrated with Perplexity's temperature. Up to 255 options.
- [largha](https://ollaya.dev/library/largha): Phocinae's Largha: Laya's decision network on mmBERT-small (144M), fine-tuned on the typed-decisions workflows. Small enough for a CPU, on the Apple GPU through MLX.
- [coba](https://ollaya.dev/library/coba): Ollaya's own decision model: Laya's network on Ettin encoders, distilled from pplx-decider:flash. English. Full-precision 1b and 400m, and ternary sizes small enough for a browser.
- [d1](https://ollaya.dev/library/d1): LiquidAI d1-3B: typed decisions with max-pooled answer forms, Q8_0.

## Optional
- [Results](https://ollaya.dev/results): accuracy, calibration, speed and parity of every model, with Ollama on the same GPU
- [Ollaya Bench](https://bench.ollaya.dev): the public leaderboard of open decision models
- [Source code](https://github.com/ollaya-dev/ollaya): Apache-2.0
- [Full docs](https://ollaya.dev/llms-full.txt): every docs page above in one Markdown file