Ollaya Decisions
Make typed, calibrated decisions about text or JSON with local decision models served by Ollaya: classify (choice), rate (score) or check a yes/no statement (noul) in milliseconds, with probabilities you can threshold. Use it to triage tickets and emails, route requests, moderate posts, screen prompts for jailbreaks or injections, or any step where the agent needs a quick judgement it can act on, instead of reasoning it out in text. Works through the Ollaya MCP server (the decide tool), the ollaya CLI, or the local HTTP API.
Get the complete skill folder, including its scripts and reference files.
When to use this skill
Use Ollaya Decisions when an AI agent needs a reusable SKILL.md workflow for this job: Make typed, calibrated decisions about text or JSON with local decision models served by Ollaya: classify (choice), rate (score) or check a yes/no statement (noul) in milliseconds, with probabilities you can threshold. Use it to triage tickets and emails, route requests, moderate posts, screen prompts for jailbreaks or injections, or any step where the agent needs a quick judgement it can act on, instead of reasoning it out in text. Works through the Ollaya MCP server (the decide tool), the ollaya CLI, or the local HTTP API.
When not to use it
Skip Ollaya Decisions when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/ollaya-decisions # Save SKILL.md to ~/.claude/skills/ollaya-decisions/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/ollaya-decisions/SKILL.md. For a shared project, commit the folder at .claude/skills/ollaya-decisions/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Ollaya Decisions skill for this task: Use Ollaya Decisions when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
71/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 77/100
- Practical detail
- 68/100
- Source evidence
- 63/100
- Source signals
- 72/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamainferred
The skill text mentions Llama or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.
- perplexityinferred
The skill text mentions Perplexity or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# Typed decisions with Ollaya
Ollaya runs *decision models* on this machine. A decision model reads a **state** (a message, an email, a ticket, any JSON) and a set of **typed questions**, and returns a calibrated answer to each question in one forward pass, in about 10 ms on a GPU and a few hundred ms on a CPU. It never generates text.
Reach for it when the answer is one of a known set of outcomes and you will act on it: route, label, block, escalate, pick a template. Keep reasoning in text for open-ended work.
## When a typed decision is the right tool
| Situation | Use | |---|---| | Label, route or filter many items (tickets, emails, messages, rows) | `decide` on each item | | A yes/no gate before an action (is this spam, a jailbreak, a refund request) | a `noul` question | | A rating you will compare with a threshold (urgency, severity, frustration) | a `score` question | | One of N categories, teams or intents | a `choice` question | | Summaries, explanations, answers that need new text | not this skill |
A decision costs no tokens and no API call, so it is fine to run one per item, per step.
## How to call it
Check which of these is available, in this order.
1. **MCP** (tool `decide`, server `ollaya`): pass `state`, and `questions` or `preset`, plus optionally `model`. Other tools: `list_models`, `show_model`, `pull_model`. Resources `ollaya://presets/<name>` show each preset's questions. 2. **CLI** (`ollaya` on PATH): ```sh ollaya run laya --preset triage --format json "I was charged twice and want a refund." ollaya run laya --questions questions.json --format json "$TEXT" ollaya run laya --questions '{"angry":{"type":"noul"}}' --format json "$TEXT" echo '{"subject": "…", "body": "…"}' | ollaya run laya --preset email --format json ``` `--format json` prints the full response. The CLI starts the server if it isn't running and pulls the model on first use. 3. **HTTP** (`http://127.0.0.1:11435`), TypeSafe-compatible: ```sh curl -s http://127.0.0.1:11435/v1/systemone -H 'Content-Type: application/json' \ -d '{"model": "laya", "state": "…", "questions": {…}}' ```
If none is available, tell the user how to install Ollaya: `curl -fsSL https://ollaya.dev/install.sh | sh`.
## Picking a model
| Model | Strength | Speed (5 questions) | |---|---|---| | `winnow:e4b` (recommended with an NVIDIA GPU) | The best accuracy for its speed: 0.722 on typed decisions (Jev: 0.738); calibrated | ~90 ms GPU, ~5 s CPU | | `laya` (default when `model` is omitted) | English and 100+ languages, routed automatically; calibrated; the fastest | ~10 ms GPU, ~0.2–0.4 s CPU | | `kev` | Qwen3.5 decoder with a pointer head, 0.8b to 9b (`kev:9b` 0.722); calibrated | `kev:4b` ~0.35 s GPU | | `decider` | Qwen3.5 decoders, 0.8b to 4b (`decider:4b` 0.680) | ~0.2–0.5 s GPU, ~1 s CPU | | `decider:2b-vision` | Questions about an image as well as the state: one PNG in `images` (base64) on `/api/decide`, `--image` in the CLI | ~0.2 s GPU for a small image | | `clm` | Contrastive: embeds the state and each option (Qwen3-8B); questions and options are cached; for agent, game and tool-calling states | ~0.15 s GPU with cached questions | | `nli` | Zero-shot, good at yes/no with clear statements | ~20 ms GPU | | `gliclass` | Zero-shot, many options in one pass | ~15 ms GPU | | `decision` | Decision 1.0 Eos: fully fine-tuned Qwen3.5-0.8B with an endpoint head; rows up to 16k tokens; calibrated | ~0.2 s GPU, ~0.85 s CPU | | `qwen3guard` | Safety guard; answers only its built-in questions (send no `questions`) | ~40 ms GPU, ~2 s CPU | | `von` | ModernBERT-large, every option scored at its own marker; states up to 8k tokens; calibrated | ~25 ms GPU, ~0.8 s CPU | | `decima` | Decima-base (mmBERT-base, 321M): options read against the state one by one, order never matters; calibrated; states up to 512 tokens. `decima:agent` for coding-agent gates, tool choice and knowledge-graph judgments (2,048-token states), `decima:small` for a CPU | ~15 ms GPU, ~0.45 s CPU (`decima:small` ~0.15 s) | | `arbiter` | Gemma 3 4B IT with a LoRA and a fixed 24-slot head; noul, choices of up to 16 options, scores of exactly 6 levels (other questions are rejected); about 8 GB | ~0.15 s GPU for three or more questions | | `nimble` | Bespoke Labs' Nimble (LoRA on Qwen3.5-9B): reads the whole request as a schema; calibrated; up to 255 options; needs a 24 GB GPU | ~2.3 s GPU | | `strands-decider` | Strands Agents' Strands Decider (LoRA and pointer head on Qwen3.5-2B base): one row per question, options scored at their own lines; calibrated per type; up to 255 options; about 8 GB | ~0.35 s GPU | | `pplx-decider` | Perplexity's pplx-decider-flash (Qwen3.5-4B): every question in one sequence, read at a marker after each; calibrated; up to 255 options; about 9 GB | ~0.29 s GPU | | `jeeves` | PostHog's Jeeves-9B (no thinking): Qwen3.5-9B with a pointer head; calibrated; needs a 24 GB GPU | ~0.84 s GPU | | `clef` | Cloudflare's Clef-Flash: Qwen3.5-9B with a joint schema head, all questions in one pass; well calibrated without a temperature; needs a 24 GB GPU | ~0.53 s GPU | | `jeb` | Jebadiah (Qwen3.5 4b/9b, Qwen3.8 27b) on llama.cpp; per-type calibration | `jeb:9b` ~0.12 s GPU | | `cygnet` | Frozen Gemma 4 12B IT with Cygnet's letter prompt; 0.683 on typed decisions; calibrated; up to 20 options | ~0.2 s GPU |
With an NVIDIA GPU, start with `winnow:e4b`. Without one, start with `laya`, and move to a larger model when `laya`'s confidence is often low on your data.
## Presets
Built-in question sets, usable as `preset` (MCP), `--preset` (CLI):
- `triage`: intent (refund, technical_help, billing_question, information, cancellation, other), is_urgent, frustration (0–3), refund_requested, churn_risk. State: a customer `message`. - `email`: category, is_spam, is_phishing, urgency, needs_reply. State: an email `body`. - `guard`: jailbreak, prompt_injection, sensitive_data, harm_severity, topic. State: a `prompt`. - `moderation`: toxic, harassment, threat, spam, severity. State: a `post`. - `router`: difficulty, domain, needs_tools, is_sensitive. State: a `request`. - `agent`: action (run, ask, block), on_task, risk (0–2), destructive. Reviews a command an agent is about to run. State: the user's `request` and the `command`.
A preset's instructions refer to a field (`message`, `body`, `prompt`, `post`, `request`, or `request` and `command`). Pass the state as an object with that field, or as a plain string.
## Writing your own questions
Questions are an object keyed by an id you choose:
```json { "team": { "type": "choice", "instructions": "Which team should handle `ticket`?", "criteria": { "billing": "invoices, charges, refunds, plans", "engineering": "bugs, outages, errors, integrations", "sales": "pricing, demos, upgrades", "other": "anything else" } }, "urgency": { "type": "score", "instructions": "How urgent is `ticket`?", "criteria": ["can wait", "this week", "today", "right now: an outage or a deadline"] }, "wants_refund": { "type": "noul", "instructions": "Does the customer ask for their money back?" } } ```
Rules that make answers better:
- **choice**: give every option a short description in `criteria`, make the options mutually exclusive, and include a catch-all (`other`). Up to a few dozen options work. - **score**: 3–5 levels, lowest first, each described concretely. The answer is the expected level (it can fall between levels), with a `legend`. - **noul**: phrase one statement that is true or false ("Does the customer ask for a refund?"). Avoid double negatives and two questions in one. - Name the state's field in `instructions` (`` `ticket` ``) when the state is an object. - Keep instructions short and literal. The model reads them; it does not follow long prompts.
## Reading answers and acting on them
| `type` | Fields | |---|---| | `choice` | `choice`, `confidence` (0–1), `probabilities` per option | | `score` | `score` (expected level), `confidence`, `legend`, `probabilities` per level | | `noul` | `noul`: the probability that the statement is true |
Act on the answer only when it is clear, and escalate otherwise:
- `choice`: act when `confidence` ≥ 0.6; below that, treat the top two options as candidates or ask a human. - `noul`: treat ≥ 0.8 as yes and ≤ 0.2 as no; in between, escalate or look closer. - `score`: compare `score` with your threshold and look at `confidence` before acting on it.
Tune thresholds on a handful of real examples when the stakes are high. Say in your output which model answered and the probability behind each action, so a person can audit it.
## Example: triage a batch of tickets
1. Pick questions: the `triage` preset, or your own `team`/`urgency` set. 2. For each ticket, call `decide` with `{"model": "laya", "state": {"message": ticket_text}, "preset": "triage"}`. 3. Route by `intent`, flag `is_urgent` ≥ 0.8 or `frustration` ≥ 2, and send `churn_risk` ≥ 0.8 to a retention queue. Put every ticket with a low-confidence intent in a "needs review" list. 4. Report a table: ticket, action, and the probabilities behind it.
Intended uses
- Use Ollaya Decisions when this documented workflow matches the task.
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.