Raptor 0.5

Most Macs are not the ones model releases are sized for. The MacBook Air, the base MacBook Pro, the Mac mini — 8 or 16 GB of memory, and whatever runs on them has to share that memory with the person using the machine. Raptor 0.5 is built for exactly that slot: an 8B mixture-of-experts that activates only ~1B parameters per token, ships at 6.3 GB, and is fine-tuned on the Osaurus tool surface so its capacity goes to finishing tasks, not to relearning the harness on your time.

It is an automation and business-work model: read the folder, open the spreadsheet, check the report against the data, draft the email, back the file up before touching it, and come back with the answer.

What it is

Raptor 0.5 is built on Ling-3.0-tiny (MIT), a 7.9B mixture-of-experts with 128 experts per layer of which 8 plus one shared expert fire per token. Decode cost on Apple Silicon is bandwidth — the weights that must move per token — and this architecture moves roughly an eighth of what a dense 8B moves, for the same stored capacity.

The second thing the architecture buys on a small Mac is memory that does not grow with the conversation. Eighteen of the twenty-four layers use Kimi Delta Attention, a linear-attention design whose decode state is a fixed ~19 MB regardless of context length; the six remaining MLA layers keep a compressed KV cache of about 10 KB per token. A 32K-token agent session costs roughly 0.3 GB of cache. On an 8 GB machine that is the difference between a long agent session and swapping.

And in Osaurus even that cache is not held in RAM. The runtime streams the session cache fully to SSD as it is produced — a paged hot set in memory, a disk cache underneath — and the disk cache survives an app restart, so a long session picks up where it left off instead of re-prefilling. Raptor 0.5 is unusually well suited to this: its chat template renders history byte-stable across turns, which is what makes prefix-cache hits reliable in practice.

In an agent loop both properties compound: a real task is six or eight tool-call round trips, each one a fresh decode over the conversation so far. A model that is cheap per token and per context-byte is a model that finishes the task while a dense one is still on step three.

Built for 8–16 GB

The 6.3 GB bundle is not a uniform quant. We ran a Hessian-trace sensitivity sweep over a 1.36M-token calibration capture and let a water-fill allocator spend a 6-bit average budget where it matters — least sensitive expert tensors at 5-bit, most at 6-bit, the touchy ones at 7–8-bit. Sensitivity across expert tensors spanned 4,878×; uniform treatment would have left quality on the table. The parameters a recurrent layer compounds error through — the router, the attention gates, the convolution states — stay in full precision.

Measured on a held-out corpus against the BF16 reference:

bundle	size	mean KL	top-1 agreement
JANG_6M (ships)	6.3 GB	0.018	95.8%
JANG_4M	4.6 GB	0.088	90.3%
MXFP8	7.7 GB	0.070	92.1%

The other two rows are why only the 6-bit build ships. FP8 is 1.4 GB larger and 4× further from the reference. The 4-bit build saves 1.7 GB but sits 5× further from the reference — on a model whose whole job is precise tool calls, that is the wrong trade, so we didn't make one.

The soft corpus

Small models do not fail agentic work because they lack knowledge. They fail on the contract: the tool-call syntax, which tools exist right now, when to call one, when to stop. A frontier model has the headroom to improvise around a harness it has never seen; a 1B-active model does not — every token spent recovering from a malformed call is a token a small Mac paid for.

So the fine-tune is deliberately light — 1,150 examples, 230K supervised tokens, LoRA rank 4, merged into the base weights. It teaches one thing: fluency in the harness the model will actually live in.

• Real schemas, not paraphrases. Every example renders through the real Osaurus chat template against the real tool catalog — 81 tool schemas and 24 system-prompt variants extracted directly from the host source.
• Absence is trained, not assumed. More than half the supervised rows expect zero tool calls — no tools offered, or a menu where nothing fits, with a direct answer as the target. Over-calling is a defect class, not enthusiasm.
• A mechanical gate, not vibes. Nine automated checks per example — template render, call parsing, tool existence, schema-valid arguments, reasoning-tag structure, lossless tokenizer round-trip — rejected our own generator's output four times before a single row existed.
• Base capabilities maintained. The corpus does no behavior-override training — it adds harness fluency and deliberately leaves the base model's general abilities intact.

The result on our 40-task agentic bench: zero schema violations and zero parse failures across 281 tool calls. The syntax layer stops being where the model loses.

The corpus itself is released — OsaurusAI/raptor-0.5-harness-corpus — with per-row provenance hashes and the training schedule.

How it performs

On the 40-task agentic bench (fresh schemas, greedy decoding, 8-step cap) the model scores identically with reasoning on and off — which matters, because reasoning-off is how most automation actually runs, and it is the faster mode.

Weak spots, stated plainly: exact group-by counting over database results, byte-exact file targets, and recovering when a prompt names a wrong file path. Sums, filters, chained multi-step workflows, and restraint cases pass cleanly.

Raptor 0.5 ships with a tuned sampling profile — temperature 0.7, top_p 0.95, top_k 20, repetition penalty 1.05 — stamped in generation_config.json. It is not decoration: at temperature 1.0 the model occasionally narrates before calling a tool; at 0.7 that defect measured zero across the sweep. Use the shipped defaults.

See it work

Three unedited recordings in Osaurus, each a single pasted prompt against a folder of ordinary business files — a quarterly review docx and sales workbooks for two (fictional) coffee companies. Together they cover the three shapes of work this model is for: verifying, handling files safely, and turning spreadsheet data into a decision.

Checking a report against its data

The Q4 review claims shipping cost per order jumped from about $6 to over $8 mid-year. The model opens the workbook's Monthly Summary sheet, walks the months, and confirms it — $6.10 in January, $8.40 from June onward. This is the general automation underneath: a claim in a memo, review, or deck, verified against the spreadsheet it came from, without anyone re-opening Excel.

Backing up before touching anything

Asked for the five numbers a new hire should know from the business review — with one condition: make a dated backup first. It copies the file, then extracts the summary. The order matters; the backup-before-write behavior is trained, and it is the difference between an agent you let near your only copy and one you don't.

From spreadsheet to decision

The COGS sheet shows Cold Brew's gross margin sliding month over month after a February packaging-cost increase that was never passed through. The model quantifies the slide, then computes the price increase that would restore January's margin — math shown, ready to paste into the pricing thread. Small operational decisions from live workbook data, on-device.

The first Raptor

Raptor is the smallest tier of a family of models we're building, each sized for a different class of Mac. Raptor 0.5 is the first release of that family — and the number is honest: this is the small one, here to prove the recipe at a size every Mac can run. A small-active MoE, taught its harness, resident all day.

Raptor 1 comes next: trained much deeper on Osaurus — more of the tool surface, longer multi-step agentic work, more of the harness's real workflows — built to carry the sessions 0.5 is too small for. Larger siblings for bigger machines follow.

What it's for

Raptor 0.5 is a resident model for machines where residency is expensive. Good fits: agent loops and tool calling, file and folder work, document-versus-spreadsheet checks, drafting emails and summaries as reviewable files, shell one-liners in the sandbox, long multi-turn sessions where a person is waiting on each step.

Less good, by design: it is not a coder — route real code-writing to a big model; Raptor 0.5 runs the workflow around the code and will happily execute code it did not write. And it is not a research synthesizer; it reads your files, not twenty sources.

Downloads & usage

The model runs in Osaurus with tools included and no setup — download it from the model list. It loads in any MLX runtime, but note that its tool-call dialect is Ling's native XML-argument format, which generic parsers do not autodetect; outside Osaurus you will need the matching parser for tool calling to work.

• Raptor 0.5 JANG_6M — 6.3 GB — Hugging Face
• Training corpus — OsaurusAI/raptor-0.5-harness-corpus

Base model inclusionAI/Ling-3.0-tiny is MIT-licensed; Raptor 0.5 inherits it.

Notes

• The harness is the contract. The model is trained against Osaurus's real tool surface; that is where its edge is, and keeping it current as the surface evolves is a maintenance cost we accept rather than hide.
• Numbers are reproducible. Quantization KL is measured on a held-out corpus disjoint from calibration; bench runs use fresh schemas and greedy decoding; the do-no-harm sweep is 48 cases × 3 samples per model. Final throughput figures will be medians of repeated live-runtime probes on the shipped bundle.

@misc{osaurus2026raptor05,
  title  = {Raptor 0.5: an 8B-A1B on-device agent model for small Macs},
  author = {Osaurus},
  year   = {2026},
  url    = {https://osaurus.ai/models/raptor-05}
}