LyboAI Mobile Edge Runtime · open & model-agnostic

Build agents that live on the device, not in the cloud.

The developer framework for shipping mobile apps with private on-device AI agents — small-model native, offline-first, with installable capability packs, local RAG, durable workflows, and human-in-the-loop approval built in.

Get the framework Open Edge Studio Read the docs ▶ Try in Colab

New · LYBO OS

The agent layer for every OS

Android, iOS and Windows now ship their own on-device AI (Gemini Nano, Apple Foundation Models, Phi Silica). LYBO OS turns them into interchangeable engines under one governed agent: it leverages the OS model where it exists, augments what it lacks — signed skills, memory, governed RAG, schema repair, app actions — and runs fully independent when you choose. Guardrails are structural, not prompt-deep: schema-validated outputs, confidence gating with a deterministic fallback, human-in-the-loop consent on side-effecting tools, and a glass-box trace for every decision. One A2A mesh connects every device to your cloud hub.

Gemini Nano · AndroidFoundation Models · iOSPhi Silica · WindowsSovereign · no Big-Tech AIA2A device mesh

Run the live demo Read the LYBO OS docs Take the Academy course

The developer ecosystem

One privacy-first agent stack — from device to cloud.

The concepts you know from cloud agent frameworks — orchestration, observability, deployment — redesigned for phones, small language models, and offline execution. Build it once; run it on-device, tag it in Claude, or serve it from the cloud.

Edge Runtime

lybo-core · @lyboai/runtime · expo-lyboai

The embedded agent engine: 8 bounded agent patterns, a declarative workflow engine with checkpoints and rewind, local hybrid RAG, device-aware model routing, policy-bound tools, encrypted persistence, and streaming — a ~2.4 MB native library your app calls through a typed SDK.

LYBOAI Edge StudioMembers

lybo studio · /studio members area

Your developer home. Locally: simulate conversations, approve actions, inspect traces — plus the visual App Builder that composes an agent and exports a ready-to-run Expo or Node app. Online: the members area with your licence keys, quickstarts and MCP setup.

Open Edge Studio

Device & Modality Toolkit

camera · mail · share · STT · TTS · OCR · vision · search

Thirteen governed device tools with native Expo handlers — camera → identify → research → summarise → email, speech-to-text dictation, text-to-speech, OCR. Every call runs permission → policy → schema → human confirmation → audit.

MCP — tag it anywhere

@lyboai/mcp

Call your private agent from inside Claude Desktop, Claude Code or Cursor. Per-skill tools, context ingestion into local RAG, and approval gates that survive the MCP boundary — the knowledge base never leaves your machine.

Cloud Runtime

lybo serve --http · Cloud Run

The same signed agent definition served over HTTP for teams, backends and integrations — identical SDK via HttpTransport, identical packs, approvals, traces and licensing. On-device and in the cloud are the same platform.

Control Plane

lybo-plane · lybo sync

Ship new agent capabilities after release. Publish ed25519-signed capability packs, gate by entitlement, roll out by percentage cohorts, revoke keys, roll back instantly. Devices verify everything locally — the server is untrusted by design.

Why on-device

Your users' data never has to leave their hands.

Private by default. Raw user content never leaves the device unless the user explicitly consents. Telemetry is redacted, aggregate, and policy-gated.
Works offline. Field crews, flights, dead zones — a deterministic fallback tier means the agent always answers, even before a model is downloaded.
Small-model native. Bounded workflows, schema-first outputs with auto-repair, context budgeting, and retrieval compression — designed for 1–8B quantised models.
Humans stay in charge. Sensitive actions pause for approval. Every tool call passes permission → policy → schema → confirmation → audit.
Zero inference bills. Compute is the user's device. Cloud fallback exists — but only when policy and user consent allow it.

App.tsx — Expo

import { createLyboClient } from "expo-lyboai";

const lybo = await createLyboClient({
  data_dir: FileSystem.documentDirectory + "lybo",
  secure_key_hex: await getOrCreateSecureKey(),
  runtime: {
    app_version: "1.0.0",
    privacy_mode: "local_only",
    base_agent: {
      name: "Notes Assistant",
      purpose: "Research & capture notes.",
    },
  },
});

const session = await lybo.startSession();
lybo.onEvent((e) =>
  e.type === "agent.token" && append(e.token));

const out = await lybo.submitInput(session,
  "what does the manual say about the pump seal");
// → answered from local docs, with sources

if (out.state === "awaiting_approval")
  await lybo.resolveApproval(out.approval_id, true);

The full agent stack, redesigned for the edge.

8 agent patterns

Chat, retrieval, ReAct tool-use, router, extraction, summarisation, planner-executor, deep task — all bounded and traceable.

Durable workflows

Declarative state graphs with pause/resume, auto-checkpointing, rewind & fork, surviving app restarts.

Local knowledge / RAG

Install-time chunking, hybrid BM25 ⊕ embedding search, retrieval compression, source attribution.

Model portability

Task-first router with device-aware cascades. Swap llama.cpp, MediaPipe, or Core ML without touching agent logic.

Signed capability packs

Ship new skills, workflows, and knowledge after release. ed25519-signed, declarative-only, instant rollback.

Human-in-the-loop

Sensitive actions park for approval with redacted argument previews. Approvals survive restarts.

Streaming UX

Token, step, retrieval, approval, and checkpoint events — a transparent agent without exposing hidden reasoning.

Privacy-first observability

Encrypted local traces with tamper-evident hash chaining and six consent-gated telemetry modes.

Security built in

Least-privilege pack permissions, policy gates, encrypted storage, verified downloads, full threat model.

Familiar concepts, new constraints

If you know cloud agent frameworks, you already know LyboAI.

You use today	For	On-device with LyboAI
Cloud agent SDKs	Agents, tools, memory, RAG	Edge Runtime SDK — bounded patterns, permissioned tools, encrypted memory, local RAG
Graph orchestration engines	Stateful orchestration	Workflow engine — declarative graphs, checkpoints, interrupts, rewind/fork
Agent observability platforms	Tracing & deployment	Local traces + Studio + pack delivery — observability that respects privacy
Indexing & retrieval toolkits	Knowledge & retrieval	Knowledge packs — install-time indexing, hybrid search, attribution
Skill/plugin frameworks	Skills & plugins	Capability packs — signed, declarative, entitlement-gated
On-device ML kits	On-device models	Model router — manifests, device checks, verified downloads, cascades

From clone to on-device agent in four steps.

Try it — no install

Open the cloud Canvas in Edge Studio: design a workflow, run the eval gate, try it on the cloud simulator, sign a pack — all in the browser. (Contributors can still run Studio locally: install Rust, clone the repo, and run the command from inside it.)

lyboai.app/studio → Canvas — Visual Builder

Define your agent

Configure the base agent, add skills and declarative workflows, register native tools, bundle local knowledge.

docs/sdk-guide.md

Embed in your app

Add the Expo module and TypeScript SDK; the prebuilt native core ships as a ~2.4 MB library per platform.

npm i @lyboai/runtime expo-lyboai

Ship & evolve

Sign capability packs, publish to your catalogue, roll out gradually, roll back instantly.

lybo sign · lybo-plane · lybo sync

Try it online — nothing to install

Two clicks to a running agent.

Both paths run the production runtime — the same binary your app embeds, the same protocol your SDK speaks.

▶

Google Colab — Python notebook

The full agent-building loop, cell by cell: local knowledge with sourced answers, a human-approval workflow you click through, routing trained from labelled examples, a signed capability pack, and an eval gate. ~10 minutes, no API keys.

Open the notebook →

⌘

GitHub Codespaces — full workspace

The complete dev environment in your browser: Studio (chat, approvals, traces, workflow rewind), the CLI, signed example packs, and the Expo reference app — pre-built and ready in one click.

Launch the workspace →

Download & install

Pick your entry point.

One repository: Rust core, C ABI, CLI, TypeScript SDK, Expo module, reference control plane, example packs, and a reference Expo app.

App developers — Expo / React Native

Typed SDK + native module. Any framework can bind via the 4-function C ABI.

npm i @lyboai/runtime expo-lyboai
# native core (once per release, or via CI):
cargo ndk -t arm64-v8a -o android/…/jniLibs \
  build -p lybo-ffi --profile release-mobile

Framework & tool developers — Rust

Embed the core directly or talk to the JSON-lines protocol.

# requires Rust; run from INSIDE the cloned repo
git clone https://github.com/rajandua20/lyboai-mobile-edge-runtime && cd lyboai
cargo build --workspace && cargo test --workspace
cargo run -p lybo-cli -- studio --port 4242

Pack publishers

Author declarative packs, sign with ed25519, deliver over the air.

lybo keygen                   # once; secret → vault
lybo sign pack.json --key $SECRET -o my.lybopack
lybo verify my.lybopack --publisher you --pubkey $PUB

Tag your agent in Claude — MCP

One npx command exposes lyboai_ask, per-skill tools and context ingestion to any MCP host.

npm i -g @lyboai/mcp   # or npx -y @lyboai/mcp
# Claude Desktop → mcpServers: { "lyboai": { "command": "npx",
#   "args": ["-y", "@lyboai/mcp"] } }

Platform operators

Single static binary. Devices verify everything — the server is untrusted.

cargo build -p lybo-plane --release
lybo-plane --dir /var/lybo/packs --port 8787 \
  --rollout new.pack:25 --entitle org1:pro

The next generation of mobile apps will think locally.

Open, model-agnostic, and private by default. Build yours on LyboAI.

Start building →Open Edge Studio Talk to us