AI Enablers · In development
Lybo OS — the agent layer for every operating system
One governed agent, four runtimes. Lybo OS routes the same skill across the on-device models built into Android, iOS and Windows — and a fully-offline sovereign mode — so your AI works everywhere your users are, privately.
In plain terms
Android, iOS and Windows have each started shipping a small AI model built into the operating system — Gemini Nano, Apple Foundation Models and Phi Silica. They're free, private and always available, but each one is siloed to its own platform, and none of them gives you enterprise governance, custom skills, or a way to run when an organisation says "no Big-Tech cloud".
Lybo OS isn't a separate product — it's the Edge Runtime, extended. You build on the same model-agnostic engine and the same governed agent, and Lybo OS lets that agent (1) use each platform's built-in model as a governed routing tier, filling in whatever the OS API lacks (structured output, retrieval, audit trails), and (2) join an A2A mesh so agents on different devices can talk to one another and to a cloud hub. Where there's no built-in AI, or policy forbids it, a bundled sovereign model takes over. Same agent, same governance, every device.
Is this like Google AI Edge?
Not quite. Google AI Edge is Google's toolkit for running ML on their own stack (MediaPipe, LiteRT). Lybo OS is vendor-neutral: it sits across Google's, Apple's and Microsoft's on-device models at once and adds the enterprise governance and sovereign fallback none of them provide on their own.
How Lybo OS extends the Edge Runtime
They work together. The Edge Runtime is the engine you build on; Lybo OS is that same runtime, extended two ways — so this isn't "one or the other".
The Edge Runtime gives you
- The model-agnostic agent engine — 8 bounded patterns, durable workflows, local RAG, signed capability packs, human-in-the-loop approval and glass-box traces.
- A task-first router cascade: a deterministic rules tier that always answers, then a downloaded small model — or any external engine you bridge (llama.cpp, Ollama, custom). It ships no model of its own.
- One governed agent definition — the same skills, policy and packs everywhere it runs.
Lybo OS adds on top
- OS-native model tiers — register Gemini Nano, Apple Foundation Models and Phi Silica as governed routing tiers (zero download, NPU-fast), augmenting whatever each OS API lacks (schema repair, retrieval, memory).
- An A2A agent mesh — three tiers, Edge (handhelds) → Node (site PCs) → Core (cloud hub) — where agents @mention one another and sync store-and-forward, redacted at every boundary.
- A sovereign built-in mode — a bundled GGUF model so the same agent still runs with zero Big-Tech AI and no network at all.
- The LYBO Harness — the device decides, task by task, whether work stays on the phone or moves to your desktop, a Windows 365 / WorkSpaces desktop or a cloud runtime, carrying only the memory you let travel.
New to the engine underneath? Start with the Edge Runtime →
New · LYBO Harness
One agent across your phone, your desktops and the cloud
The Edge Runtime is the agent on one machine. The LYBO Harness is what lets that same agent use every machine you have — your phone first, then your own PC, a Windows 365 or AWS WorkSpaces desktop, or a cloud runtime — only when a task really needs it.
The phone goes first
Quick answers, voice and forms run on the device. Work moves only when it needs a desktop app, the web, a bigger model or a machine that stays on.
Your privacy decides
Health, money and passwords never leave the device. Personal tasks only go to machines you own. Every choice comes with the reason.
Memory travels light
A task carries only the memories you chose to share, with personal details removed. The other machine borrows them for that task and keeps nothing.
Lessons come home
Anything the other machine learns comes back to your phone as a suggestion you approve. One record shows where the task went and what happened.
For developers: how the harness works · long-term memory
The architecture
LYBO OS is three things working together: the Edge Runtime on every machine, the Harness joining them, and the Plane delivering signed packs to the fleet.
One skill, four runtimes
Android
Gemini Nano
On-device generative AI on supported Pixel & flagship devices, via ML Kit GenAI.
iOS
Apple Foundation Models
The on-device model layer exposed to apps on modern iPhones.
Windows
Phi Silica
The NPU-accelerated small language model on Copilot+ PCs.
Sovereign
Fully offline
A bundled model for air-gapped and regulated 'no Big-Tech AI' environments.
Write once, run on any OS
Author a skill once as a LyboAI companion pack. Lybo OS maps it to whichever on-device model the hardware provides, so you don't rebuild per platform.
Governed by default
One policy and permission model travels with the agent across runtimes — the same guardrails, audit trail and human-oversight rules everywhere it runs.
Private and offline-capable
Inference happens on the device. Data doesn't have to leave it, and a sovereign mode keeps everything working with no network at all.
How it fits with LyboAI Edge
You build companion packages in Edge Studio and run them with the Edge Runtime. Lybo OS is the layer that lets one signed pack target the native on-device model on each platform, instead of shipping a different build per OS. It's in active development — the live demo shows the routing concept end to end. Want to go deeper? Take the introductory Academy course.
Want to pilot Lybo OS?
Talk to us about early access, or start building on-device today with Edge Studio.