Swiss-based · the local autonomy lab

Own your intelligence.

A desktop agent, a runtime, the models and the tools to run AI on hardware you own. We publish the measurements — including where it is not enough yet.

Latest release · LFM3-Omni-2B Q4_K_S imx v1.0.0

Autonomy should belong to you, not a server.

We build for one question: how much can you do — and how much can you own — without the cloud? More than most people expect. An agent that works for you, models you can hold, your data staying yours. Small steps toward a future that is more utopian than dystopian.

Build · Measure · Publish · Explain · Repeat

One lab, five layers.

Rijoda Labs is not a single product. It is a stack that moves intelligence from a server to your machine — and keeps every layer inspectable. Read it from the metal up.

01
MachineRijo Box
A disposable, isolated computer for the agent. Own Rust VMM, a Rust-first Linux guest, Servo — so the agent can run wild without touching your host.
02
RuntimeRijo Run
A pure-Rust inference runtime for ordinary laptops. Own kernels, GGUF first, agent-aware scheduling. Working title; M0 is measured.
03
IntelligenceModels & quantisations
Open models we rebuild for a specific machine and measure against stock — and, next, small models trained here with published checkpoints and provenance.
04
Agent appRijo Code
The desktop app (coming) that does the work: projects, sessions, 34 native tools, MCP, browser. The engine underneath is Rijo Core — public and inspectable.
05
OutputRijo Stack + Rijo Vector
What the agent builds with: web and desktop from one Rust codebase, and vector graphics it can write and edit as deterministic SVG.

The software.

Five products, one stack. Some run today; some are early. Each card says which — no roadmap theatre.

The desktop app App coming · CLI v0.1.0

Rijo Code

The finished desktop app, still coming: a workbench where the agent does real work on your machine — projects, sessions, approvals, 34 native tools, MCP, browser. The CLI is the headless entry point today.

Runs on the open engine Rijo Core — the app is the product, the engine is public.

See how it is built
The machine Early · P0/P1

Rijo Box

A disposable, isolated computer for your agent. Own Rust VMM on KVM/WHPX, a Rust-first Linux guest, Servo for the screen. A vCPU and a kernel already boot; a full Linux guest is the next gate.

The runtime M0 · working title

Rijo Run

A pure-Rust inference runtime for ordinary laptops: own CPU kernels, GGUF first, agent-aware scheduling. M0 is measured on a local Qwen2.5-1.5B; G0 is not decided.

The builder Prototype · CI green

Rijo Stack

Web and desktop from one Rust codebase and one binary, with SQLite embedded. Verified end to end — auth, jobs, mail, migrations, MCP and deploy. No public release yet.

The generator Core runs

Rijo Vector

A JSON language for vector scenes that compiles deterministically to SVG — built so a model can create and surgically edit graphics. 365 tests, 202 error codes, an MCP server.

Models you can hold.

We publish two kinds of artifacts. Quantisations are open models we rebuild for a specific machine and measure against the stock release. Own models are trained here — still ahead. Every release ships with its method, its numbers and its limits.

Published · Quantisation v1.0.0 · live on Hugging Face
LFM Open License v1.0

LFM3-Omni-2B Q4_K_S · mixed imatrix

A quantised derivative of Liquid AI's omni-modal 2B model, tuned for laptops without a discrete GPU. Smaller, measurably better and faster than the stock Q4_K_M — on the reference machine. No retraining, no fine-tuning.

1007 MiB
Size · 4.7% smaller than stock
23.11
Perplexity · vs 24.06 stock (−4.0%)
18/22
Task suite · same as stock, no regression
34.0 t/s
Decode @512 · +9.3% vs stock
Head to head, same text and tasks
MetricStock Q4_K_MRijoda
Size1048.7 MiB1007.1 MiB
Perplexity24.06 ±0.4423.11 ±0.42
Task suite18/2218/22
Decode @51231.1 t/s34.0 t/s
Decode @409628.8 t/s33.3 t/s

Measured on Intel Core Ultra 7 255U, Intel iGPU, Vulkan, llama.cpp b12110. Speed: interleaved, 5 rounds, first 2 discarded, control model in the loop. This quant won decode in all 10 pairwise comparisons.

Not a trained model: a derivative of LiquidAI/LFM3-Omni-2B. The multimodal projector is not redistributed — pull the unmodified file from the base repository. “Liquid”, “Liquid AI” and “LFM” are trademarks of Liquid AI, Inc.; this release is not endorsed by or affiliated with Liquid AI. Full licence and NOTICE ship with the weights; commercial use is conditioned on annual revenue below USD 10M (LFM Open License §5).

1

Profile the machine

Decode reads every weight once per token, so bytes are speed — but kernel format beats file size. On this iGPU, a smaller Q4_0 file was 18–25% slower. Profile first.

2

Calibrate on the job

An importance matrix over mixed prose + code. A code-only matrix improved perplexity and broke arithmetic — so we measure tasks, not just one scalar.

3

Measure, then publish

Quality first, speed last. Cooled, interleaved runs, a control model, raw eval files and a SHA256 manifest shipped with the weights. The method transfers; the numbers do not.

Next In progress · no weights yet

Own models, trained here.

Small, purpose-built models with published checkpoints and data provenance — the Pythia pattern. RijoBench, our agentic benchmark for tool use, safety and latency on the reference machine, is built and baselining. No model release yet; we name that plainly.

The catalog Growing

What every release carries.

A version, a SHA256 manifest, a model card, raw evaluation files, the exact method and a licence/NOTICE. More quantisations follow as we tune them for the reference laptop — and each one will be comparable, not just downloadable.

Rijo Code is the app.
Rijo Core is the engine.

Rijo Code — the finished desktop app, still coming — is the product you use. Rijo Core — its engine — is the backend that executes tools, enforces the guard, manages sessions and talks to models. We publish the engine; the app stays the product.

Product · coming Desktop app

Rijo Code

The workbench you will use once it ships: projects, session tabs, approvals, activity inspector and the window model. The app is the product surface; its source stays private while it matures.

Open engine · public now Apache-2.0

Rijo Core

The backend functions underneath: executor, 34 native tools, guard, sessions, transcript model, inspect, LLM adapter, brain, config and MCP. The CLI and rijo mcp serve are headless entry points to the same engine.

Open engine Public since 2026-11-08

rijo-core

The engine as a library: executor, 34 native tools, guard, sessions, transcript model, UI event contract, inspect, LLM adapter, brain and config. Rust. Apache-2.0.

github.com/rijoda/rijo-core
The app Desktop app · coming

Rijo Code

The finished desktop app, still coming: a workbench with projects, session tabs, approvals and an activity inspector. The CLI is the headless entry point today; MCP reaches the same engine. The app source stays private — the app is the product, not the crate.

Rijo Core is Apache-2.0. The CLI and MCP ship with the public engine; the desktop app source stays private. This website's code is MIT OR Apache-2.0; documentation licensing is being finalised. The trademark search for the name is still open.

Where we are, right now.

No roadmap theatre. This is the state of each part today — running, in progress, or still only researched.

Running today

Running and working

  • Rijo Code — CLI v0.1.0, the daily driver.
  • Rijo Core — public engine since 2026-11-08.
  • LFM3-Omni quant — v1.0.0 live on Hugging Face.
  • Rijo Stack — builds and runs; CI green.
  • Rijo Vector — core runs; 365 tests.
In progress

Being built and measured

  • Rijo Code desktop app — workbench, packaging, parity.
  • Rijo Run — M0 kernels measured; G0 not decided.
  • Rijo Box — vCPU + kernel boot; Linux guest next.
  • Own models — RijoBench baselines; no weights yet.
Research

Researched, not built

  • Vector diffusion — the method is still unnamed.
  • Reasoning core + memory — S0 error budget first.
  • FrugalMoE — an optional research track (ADR 0008).

Proof, not promises.

Six numbers from three layers of the stack. Each one names its setup in the linked release note or benchmark; none of them is a universal claim.

188×–1037×
Faster native tool calls than a Python reference (agent).
26% → 94%
Prompt-cache hit rate after the schema fix (agent).
33×
Less prefill with a persistent local server and prefix-KV reuse (670 → 5 tokens).
23.11 PPL
LFM3-Omni quant vs 24.06 stock — 4.0% lower, in a smaller file.
34.0 tok/s
Decode @512 on the reference laptop, +9.3% vs stock Q4_K_M.
18/22
Task suite score of the quant — identical to stock, no regression.

Measured in our own agent and model benchmarks, on our own hardware. Reproducible.

Not ‘we are the fastest’. Here is the measurement, here is the code, and here is where it is not enough yet.

What we are not.

Not a frontier lab
We do not train giant models or race the big labs. Small, local and useful is the point.
Not a cloud provider
Working without the cloud is the whole idea, not a paid tier.
Not a closed assistant
Rijo Code's engine is open and inspectable — it works for you, not for a platform.
Not a model trainer — yet
We publish tuned quantisations of open models today. Our own weights are planned, not shipped.
No invented numbers
Every claim is measured, or marked open. Honest notes are the brand.
Not finished
Rijo Box, Rijo Run, the model and the generator are early. We name what is still open.
A provisional name
Rijoda is chosen but not yet cleared — the formal trademark search is pending.