Observability for multi-agent mobile software engineering.

Kairo is a collaborative workspace where specialized agents design and ship an Expo mobile app from a product brief, while every step stays inspectable: agents, VMs, events, artifacts, decisions, memory, metrics, live device previews, and backend traces.

Describe the product. Agents plan screens, run in isolation, and compose a shared design system. You watch the build unfold on a Figma-like canvas, scrub time-travel replay, scan Expo Go QR when the primary screen ships, and export telemetry to Laminar without leaving Kairo as the control surface.

https://youtu.be/n5WmgDGZk-U

Mobile product work is usually a black box: a prompt goes in, a half-working app comes out. Kairo flips that model:

It’s built for mobile app development as a first-class outcome: Expo Router, dual-theme tokens, real device frames, and a generated app you can open in Expo Go while remaining agents are still shipping screens.

• Free-text product brief
• Curated example library (focus timer, recipes, habits, markets, budget, studio booking, trips, standups)
• Planner (mock heuristics or live LLM) returns navigation + 2–5 screens - not a fixed Home/Profile/Settings shell

1. Architecture - routes & navigation from the brief
2. Design system - dual-theme tokens + shared primitives
3. Primary screen - unlocks live preview / QR
4. Remaining screens - parallel agents on the same theme

• Laminar (@lmnr-ai/lmnr) - Laminar.initialize() + spans for pipeline, agents, LLM calls
• agentOS bridge - local per-agent VMs under agentos/ (or simulated when offline)
• OpenAI-compatible inference - OpenAI / OpenRouter / any chat-completions API
• mem0 - optional shared agent memory

• Node 20+
• npm
• Expo Go on a phone (optional, for QR preview)
• Same Wi‑Fi for Expo Go LAN (or tunnel)

git clone https://github.com/harishkotra/kairo.git
cd kairo
npm install
cp .env.example .env   # add keys as needed
npm run agentos:install
npm run dev            # starts the agentOS bridge + Expo together

Press w for web (best for the workspace UI), or use npm run dev:web to open web directly. The agentOS bridge is required for the Expo Go QR to resolve your LAN IP and serve the preview to phones.

1. Pick an example brief or write your own
2. Build app
3. Watch agents on canvas / DAG / timeline
4. When the primary screen ships → Expo Go QR or Open here
5. Inspect decisions, artifacts, memory, metrics

npm run agentos:install
npm run agentos
# → http://localhost:7420
# Workspaces: agentos/.vms/

With the bridge up, each agent boots an isolated workspace. Without it, VMs are simulated so the UI still shows lifecycle and files.

# .env
EXPO_PUBLIC_AI_MODE=live
EXPO_PUBLIC_AI_BASE_URL=https://openrouter.ai/api/v1
EXPO_PUBLIC_AI_API_KEY=...
EXPO_PUBLIC_AI_MODEL=openai/gpt-4o-mini

EXPO_PUBLIC_LMNR_PROJECT_API_KEY=...   # Laminar project key
# EXPO_PUBLIC_MEM0_API_KEY=...         # optional memory
# EXPO_PUBLIC_DEV_SERVER_HOST=192.168.x.x:8081  # Expo Go if LAN detect fails

Restart Expo after changing .env.

Top bar shows lmnr when Laminar initializes successfully.

User brief
    ↓
App planner (mock | live LLM)  →  AppPlan { screens, navigation }
    ↓
Agent pipeline
  architecture → designSystem → primary screen → parallel screens
    ↓                    ↓
  Laminar spans     agentOS VM per agent
    ↓
Kairo UI: canvas · DAG · timeline · artifacts · decisions · memory · metrics
    ↓
Live preview (DynamicScreen) + Expo Go exp://HOST/--/preview

Kairo is not only an agent demo - it’s a mobile delivery loop:

• Expo-native from day one (Router, tokens, previews)
• Device-accurate frames for design review on the canvas
• Expo Go for real-device validation mid-pipeline
• Shared design system so screens stay consistent as agents parallelize
• Observability so product and eng can debug agent decisions, not only final UI

Use it to explore product shapes quickly, then harden the generated structure into production Expo code under the same token system.

MIT - see LICENSE.

• Expo docs (SDK 57): https://docs.expo.dev/versions/v57.0.0/
• Laminar: https://laminar.sh/docs
• agentOS concepts: https://agentos-sdk.dev/docs/

Kairo was built entirely with the Codex desktop app, using the GPT-5.6 Terra model at High effort. Brainstorming on the idea, decisions to include agent-os vms, laminar, mem0 for shared memory across multiple agents was done using ChatGPT.

Codex was used throughout the project lifecycle: shaping the product concept and architecture, implementing the Expo and React Native workspace, building the multi-agent orchestration and observability surfaces, integrating agentOS, Laminar, mem0, and OpenAI-compatible inference, and iterating on the UI, documentation, and verification.

GPT-5.6 helped turn the product direction into working TypeScript code across the app shell, agent pipeline, canvas, timeline, artifact and decision views, live previews, and developer setup. The result is Kairo: an inspectable workspace for multi-agent mobile software engineering.