PRIME OS — Every AI Product Installs an Intercom. We Handed Grok the Keys.

(xAI-submission variant — pairs with the provider-neutral edition of this case study.)

Think about how every AI product you've used actually treats its AI. It's an intercom at the front door: you can talk to it, it can talk back — brilliantly, even — but it can't come inside. It describes the room; it cannot cross the threshold. "You should open X and do Y," it says, and then you open X and do Y, because the assistant lives in a sidebar and the building doesn't know it exists.

PRIME OS flips the arrangement — and it was designed around Grok from the start. Give the model residency: let it see which windows are open, remember yesterday, search the web and X in real time, generate images and video, open applications by itself, and run work overnight while you sleep. The question the product answers: what happens when the environment is addressable by the model — when an answer can be an operation instead of a suggestion?

This is our first-party build. The client was us.

The Product

PRIME OS is a complete operating environment in a browser tab: boot sequence, desktop, taskbar, four virtual workspaces, a global command palette — and 50 registered applications in draggable, snappable, tileable windows. Terminal, Files, Calendar, Mail, spreadsheet, canvas, Kanban; wallet, vault, markets; social, chat, streaming; a real GitHub App integration; GeomC, a purpose-built language with its own lexer, parser, and compiler, editable inside the OS. Below 1024px the entire shell swaps to a mobile launcher over the same applications and data.

And in residence: ROKCAT — a Three.js neon cat companion with TTS-synced speech, persistent memory, desktop-state awareness, and, on the Grok 4.20 multi-agent path, a live Thinking Panel that names each of Grok's workers as they run, so a long answer is legible while it forms rather than only after it lands.

The Architecture of Residency

Applications never import each other — they speak through events. A typed publish/subscribe EventBus carries every cross-application message. When every capability is an event, then Grok drives the whole OS through one interface instead of fifty special cases.

Model output is executable. When Grok's response contains an action tag, the OS parses it, executes it through the EventBus, and re-renders it as a clickable chip inline in the prose. Ask ROKCAT how to wire a webhook and the answer arrives with CloudHooks already open behind it and a chip in the text to jump back. Prose becomes interface.

The resident remembers and works unattended. Persistent conversations with auto-compaction, categorized durable memories, live desktop context on every request — and an agent/bot runtime with three trigger classes (event-driven, cron-scheduled, external API-key) whose every step lands in an audit trail. Overnight bot, morning reasoning trace.

Grok's native edges are wired in as system features, not demos. Two switches in ROKCAT enable Live Search — web_search and x_search passed through as xAI's built-in server-side tools on the Grok 4.20 path, so answers ground in something posted an hour ago with no scraping layer in the stack. Grok Imagine powers image generation (up to four per request) and asynchronous video with client polling, every asset persisted to a gallery tied to the account rather than a chat thread. The same encrypted key powers all of it.

The router is engineered, not approximated. One model router serves every AI surface, with dual-API routing: Grok 4.20-family models to xAI's Responses API (system prompts carried as developer-role input, multi-agent reasoning effort attached, agent events re-emitted as thinking frames), everything else to Chat Completions — a single prefix-matched function moving the entire OS between API shapes safely. Seven selectable Grok models, live key validation against /v1/models, automatic provider fallback, and the security spine under everything we ship: 38 tables, 128 RLS policies, roles behind a security-definer check, and AES-GCM/PBKDF2 key custody with server-only decryption — no code path returns a decrypted key to a browser.

The Roadmap, Stated Plainly

Today the model layer is bring-your-own-key, and that's the adoption barrier the published rollout plan removes: baseline instrumentation first (measure before changing anything), then a first-party Grok path — a new account holds a Grok conversation, runs Live Search, and generates an image with no key at all — then Grok-native optimisation (stateful Responses round-trips, parallel tool use, structured outputs, Live Search citations as first-class UI), agent depth with per-tool permissions and approval gates on irreversible actions, hardening, and finally distribution: a one-click clone so anyone can stand up their own instance. Every phase measurement-gated; the submission packet's own rule is that no usage figure appears anywhere until it's observed.

The Results

A complete, live operating environment: 50 applications, 74 application components, a real window manager, a genuine command interpreter with an AI shell, and a full mobile shell — every claim verifiable in the repository
The AI-with-hands thesis shipped: desktop-state awareness, executable Action Chips, persistent memory, Live Search grounding, native image and video generation, and an audited autonomous runtime
A Grok integration with engineering depth: dual-API routing across seven models, multi-agent thinking telemetry surfaced as UI, and streaming normalised across providers
Security as a first-class subsystem: RLS on 100% of public tables, definer-scoped roles, encrypted key custody
A published, instrumented path from BYOK to a first-party Grok default

Why It Worked: The Right Step Was the Bus

The Rocket Now principle applies to our own products hardest of all: a single step in the right direction beats many steps in the wrong one. The wrong steps were the industry's defaults — bolt a chat panel onto each app, integrate the model feature by feature, forever. The one right step was the EventBus: make every capability in the OS speak one language first, and the model gains the whole building the moment it learns that language. Fifty applications, one door, one set of keys — and a resident that can search the live web, see the desktop, and leave the lights on overnight. When the environment is addressable, then intelligence becomes an operator.

Still talking to your AI through an intercom? Come see what residency looks like. → os.rlgix.com · RocketNow.com

Editor's note — before publishing: