Sary-OS: Technical Capability Report

Sary-OS is one immersive screen for building software, producing media and working with AI. A single web app at sary-os.com brings together a live development runtime, a multi-file IDE, multi-model chat, a full creative studio, document tools and a voice agent that can drive the screen. Every workspace keeps its own conversation and saved work, every generation lands in one Drive, and memory follows the person to every model and every surface.

The platform
LiveLoop: the live development runtime
Self-healing patch pipeline
State, versions and persistence
Developer workspaces
Multi-model intelligence and memory
Creative production suite
Documents, files and research
Voice, recording and control
Integrations and developer tooling
Cloud architecture
Access, billing and security

1. The platform

                         ┌──────────────── Portal bar ────────────────┐
                         │ LiveLoop · Code Lab · Sary-OS Code · Chat  │
                         │ Canvas · StudioLab · Drive · DocLab · Social│
                         └──────────────────────┬─────────────────────┘
                                                ▼
   [ Cosmos navigation ] ──flight──> [ Centre frame: the docked workspace ]
                                                │
             ┌──────────────────────────────────┼──────────────────────────────┐
             ▼                                  ▼                              ▼
   [ Own composer + chat ]          [ Own saved state ]            [ Shared Drive + memory ]

One screen, many workspaces. LiveLoop is the landing experience. A portal bar swaps every other workspace into a centre frame without a page load, and each keeps its own composer, conversation and persistence.
Spatial navigation. The interface is a real-time Three.js cosmos: workspaces are nodes you fly to along curved camera paths, with banking, fog and field-of-view effects. A Static motion mode dissolves panels in instead.
Nothing leaves the page. Sign-in, sign-up, pricing and legal pages open inside the app; signing in re-hydrates the workspace in place.
A shared composer. One standard input shell powers every surface that talks to a model, so attachments, model choice and effort behave the same everywhere.
25 interface languages, with models replying in whatever language the person writes in.
Personalised. Light and dark panels, solid or transparent surfaces, live wallpapers (video clips, galaxy, particle field) and a draggable favourites orbit.
Sary-OS Lite, the phone edition at sary-os.com/lite: LiveLoop, Chat, Create and Gallery on the same account.

2. LiveLoop: the live development runtime

[ Running scene ] ───> [ Live patch, appended to the running scope ] ───> [ Same viewport ]
        │                                                                   ▲
        └──────── scene, camera and state stay where they are ──────────────┘

Describe an app, game, page or 3D scene, and LiveLoop builds it on a live stage, then keeps changing it while it runs.

Live patching. Changes are written as self-contained patches that run inside the running page instead of reloading it, so the scene graph, the camera, physics and anything the person has built up stay exactly where they are. The model judges between a patch and a full redraw; a change of scenery redraws.
2D to 3D in one session. The runtime handles Canvas 2D, DOM apps and Three.js WebGL scenes. Moving from a flat layout to a rotating 3D world, with characters and controls, can happen entirely through live patches.
The file is saved behind every patch. After a patch runs, the complete file is written behind it, so the saved state always matches what is on screen.
Single file and Project mode. Single-file builds for fast iteration; Project mode for multi-file projects, where a reply cut off mid-file is continued by the same model until it is complete.
A natural queue. Instructions typed while a turn runs queue and send in order, exactly as typed. No mode chips and no confirmations.
The full picture on every turn. Each turn carries the complete current source, a report of the running page and its asset reports, so the model works from what actually exists, not from memory.
Asset manager. Upload images, models, audio and other files into a project and reference them from the build.

Four records, not a chat log

[ conversation ] ──> [ specification ] ──> [ plan ] ──> [ ledger ]
  what was said       what is wanted now    what's next   what happened, with evidence

A conversation shows what was said, not what was actually done. A model saying "done" is a claim, not evidence. LiveLoop therefore keeps four separate records, linked so every task names the instruction that caused it and every ledger entry names its task:

conversation: what the person said, in order, never rewritten.
specification: what the person currently wants, after every revision.
plan: what LiveLoop intends to do about it.
ledger: what actually happened, with evidence from the host's receipts.

Today's work

A live checklist built from those records shows every task as Working on, Updating your creation, Needs your input, Blocked, Failed, Planned, Ready or Skipped, with retry, skip and reprioritise actions. The Today's work report answers "what did I ask for, what changed, what is still outstanding" and counts repairs. It is built by lookup, never by asking a model, so it cannot invent a session that did not happen.

Context rotation at 82%

[ Context meter ] ── 82% of the model's window, or 250k tokens ──> [ Handover brief ] ──> [ Fresh context ]
                                                                          ▲
                                         built from the four records ─────┘

A LiveLoop session fills a model's context fast, because every build carries a complete file. LiveLoop watches a live context meter and, at 82% of the selected model's window, or 250,000 tokens if that comes first (the line above which long-context pricing multiplies the cost), carries the session to a fresh context before the next send, so it never interrupts a build in flight.

The handover brief is assembled from the four records by lookup, not summarised by the model that is losing the session, so the next model is handed facts rather than a recollection.
The thread being left behind is saved with the workspace first. If that save cannot land, the move is held back.
The stage, versions, assets, checklist and account copy are untouched, because none of them ever lived in the chat. The current file is attached in full to the very next message.
Each project has its own thread and its own handover, so one project's brief is never sent to another.
Frontier models to choose from, including GPT, Claude, Gemini and Grok models, or the person's own API key.

3. Self-healing patch pipeline

[ Model writes patch ] ─> [ Rehearsal in a hidden copy of the page ] ─┬─ clean ─> [ Delivered live ]
                                     ▲                                │
                                     └──── exact error, repair ◄──────┘

Rehearsal before delivery. The model has a try_live_patch tool: the server asks the person's open page to run the candidate patch in a hidden copy of the current document, never the real scene, and returns whether it ran, what it returned and the exact error, including errors thrown in the next frames of the animation loop. The model repairs and retries before it submits.
Automatic repair after delivery. If a delivered patch still throws, the exact error and the failed patch go straight back to the model that wrote it as the next turn. The corrected patch lands in the running scene, never as a reload. Up to three passes run automatically.
Parse-checked saves. A file saved behind a patch is parse-checked first. A file whose scripts do not parse is never saved: the last good file with the patch written in is saved instead, and the person is told which script broke.
Project builds are parse-checked too. Every .js/.mjs file and every inline HTML script in a finished Project-mode reply goes through Node's parser. Anything that fails goes back to the same model for the smallest repair, up to three passes, before delivery.
No arbitrary timeouts. A slow network never cancels a patch. The page waits for its own answer, and only the person's Stop or New ends a turn early.

4. State, versions and persistence

Every state is kept. Each save is a complete, numbered state that is never overwritten. Open any state from Versions, with undo, redo, a timeline and a journal of what changed.
Full snapshots, not deltas. Each state is a whole document, so switching between states is instant and never depends on replaying a chain of changes.
Content-addressed, integrity-checked storage. Project files and assets are stored by their SHA-256 hash and verified against the bytes the cloud bucket holds, so identical assets are stored once and corruption is caught.
Local and cloud together. Work is cached in the browser (IndexedDB) and saved to Firebase (Firestore and Cloud Storage), so it survives a reload, a crash or a new device.
Runs survive the tab. A LiveLoop turn is recorded on the server and keeps running if the tab closes, the person logs out or the network drops. The next page that opens LiveLoop, on any device, collects the result.
Projects and export. Rename and import projects, download any state, or download a full zip backup.

5. Developer workspaces

Workspace	What it does
LiveLoop	Live build stage with patching, rehearsal, repair and every state kept.
Code Lab	One file with a live preview side by side and a Code agent that edits it. The file and the conversation survive a reload.
Sary-OS Code	A multi-file IDE with a Project Agent: browse, search and edit a whole codebase, with its own chats.
Canvas	Renders whatever a model writes (HTML, a full app, a Mermaid diagram) live at full frame.
Vision	A full-screen canvas on its own.
Game Engine	Builds complete Canvas 2D and Three.js 3D games as one runnable file, with a play preview, code view, Undo and a change box, in its own panel.
Web Architect	Designs, plans and builds web apps with a live preview, code view and Undo, in its own panel.

Game Engine and Web Architect have separate panels, so a game and a web app can be built at the same time without either replacing the other. Agent runs in Code Lab and Sary-OS Code also keep going when the page closes.

6. Multi-model intelligence and memory

                 [ Memory that follows the person ]
                                │
     ┌──────────────┬───────────┼────────────┬──────────────┐
     ▼              ▼           ▼            ▼              ▼
   Chat         LiveLoop     Code Lab    Sary-OS Code    Every model

Many frontier models in one chat, including OpenAI GPT, Anthropic Claude, Google Gemini and xAI Grok, plus an Auto mode that picks for you.
Switch models mid-conversation. The new model sees the same chat, the person's memories and recent summaries, so nothing resets.
Persistent memory everywhere. Facts the person shares, recent chat summaries and custom instructions carry across Chat, LiveLoop, Code Lab and Sary-OS Code, on every device. The person controls it: a memory toggle, saved details they can delete, and custom instructions.
Long chats that never run out. As a Chat conversation grows, GPT Luna keeps a structured handover record of it in the background (decisions, rejections and open threads), while the most recent turns stay word for word. The conversation carries on past the model's limit, and the person's chosen model keeps answering. The record is written by the free model, so a long thread never costs more for being long.
Effort control. Low, Medium, High and Hyperdrive set how long and deep a reply may be. Style presets (Default, Creative, Code, Concise), Deep Think and Code toggles.
Live web search with citations, only when the person switches Web on.
Free to start. Lightweight models on Low effort cost nothing.

7. Creative production suite

Every generation is saved to Sary-OS Drive, so assets move between tools.

Image

Image Generation: GPT Image models up to 4K, Nano Banana 2 and Pro for photorealism and flexible aspect ratios, and Grok Imagine Image, with reference images and a cost estimate before generating.
ImageLab: a layer-based photo editor for up to four images. Quick edits, resizing and transforms are free; AI edits run on Flux Kontext, GPT Image, Nano Banana or Grok Imagine.

Video

Video Generation: Veo 3.1, Seedance 2.0, Gemini Omni Flash, Kling 3 Omni and Luma, with start frames, end frames and reference images.
MotionEdit: a browser-based multi-track editor (main video, B-roll, titles and graphics, dialogue, music and SFX) with export settings for resolution, frame rate, codec and bitrate.
StudioLab: a production workspace combining Drive, generation and a timeline; it also joins clips into one video.

Audio

Music Studio: full tracks with custom lyrics, from 10 seconds to 5 minutes.
Voiceover: realistic narration in any language from a catalogue of voices.
2-Way Podcast: a two-host podcast from a topic, an article or your own dialogue.
Music Player: play and queue tracks from Drive, a free library or the device.

Publishing

Social: connect accounts and publish or schedule posts to Instagram, Facebook, LinkedIn, X, Threads, TikTok, YouTube, Pinterest and Bluesky.
Presentations: conference, pitch and board decks from a brief, opened as a slide preview.

8. Documents, files and research

DocLab: four tools in one panel, all running free in the browser.
- Write: documents, with .docx, .html, .md and .txt in and out, and print to PDF.
- Grid: spreadsheets with formulas, reading and writing .xlsx, .xls, .ods and .csv.
- Deck: presentations, with .pptx in and out and full-screen presenting.
- Scribe: speak to write, and notes from a recording.
File Analysis: attach audio, images, video, YouTube links, documents, spreadsheets or project ZIPs (up to 20 files, 2 GB each) and the chosen model reads and analyses them.
Vault: type or speak to search everything in your own account (chats, files, memories, notes, projects, calendar plans and sticky notes). It answers counts, dates, sizes and projects, and can download results as a zip.
Live-data tools: Smart Search, Daily Briefing and Market Watch.
Share: turn a chat into a public link you can revoke, or download it as a self-contained page.

9. Voice, recording and control

Talk: a live voice agent that drives the screen. A two-way spoken conversation you can interrupt. It opens panels, reads what is on screen, finds and opens past chats, and in LiveLoop it drafts build requests, undoes, redoes, exports and records. It always asks before anything that spends credits or deletes.
Screen recording across every tool. One continuous take across the whole app, with an optional microphone, saved as a video plus a proof file.
Dictation and read-aloud in Chat, and dictation in DocLab Scribe.
Sary-OS Support: a multilingual support agent that can read your own account, open the right screen and hand over to a person.

10. Integrations and developer tooling

Model Context Protocol (MCP) server. Sary-OS exposes itself over MCP (Streamable HTTP) at sary-os.com/api/liveloop-mcp, so Claude, Cursor or Codex can list, read, build on and check LiveLoop projects (and, on the top plan, the whole account), with the person's own AI plan doing the reasoning. Access is token-based and scoped per plan.
GitHub from the browser. A built-in Git panel, backed by a GitHub App, commits, pushes, pulls, branches, shows history and opens pull requests from LiveLoop with no local Git.
Local bridge and terminal. Connect LiveLoop to a real folder on your own machine and work in it with a terminal.
Bring your own key. Store your own OpenAI, Anthropic, Gemini, xAI or any OpenAI-compatible key and use it across Chat, Canvas, Code Lab, Sary-OS Code and LiveLoop. Keys are kept in a sealed, encrypted vault.

11. Cloud architecture

Layer	Technology
Front end	HTML, CSS and vanilla JavaScript; Three.js (WebGL) for 3D and navigation
API	Node.js 22 serverless functions on Vercel, each able to run up to 30 minutes
Data	Firebase Authentication, Cloud Firestore, Cloud Storage and Cloud Functions
Server identity	Keyless: Vercel's OIDC tokens are exchanged for a Google service account through Workload Identity Federation, so no service-account key exists
Durable runs	Server-recorded turns that outlive the tab and are collected on any device
AI providers	OpenAI, Anthropic, Google, xAI, Replicate, Luma and ElevenLabs
Rendering and conversion	Headless Chromium, Sharp, document and presentation generators
Reliability	Rate limiting on Upstash Redis; monitoring with Sentry and OpenTelemetry
Payments	Stripe (web) and Apple StoreKit
Delivery	Continuous deployment from Git; native wrappers with Capacitor (iOS and Android) and Electron (macOS)

Every generation is stored permanently in Cloud Storage; temporary provider links are never kept.

12. Access, billing and security

Credits, shown before you spend. Paid operations show their cost first. One-time credit packs never expire; LiveLoop plans add monthly credits, storage, voice minutes and Project mode.
A 30-day LiveLoop trial for every new account, with trial credits and voice minutes, plus a week of free bring-your-own-key use.
Fair free allowances. Free credits go once per verified person, with protection against disposable and alias addresses. Sign-up itself is never blocked.
Your data stays yours. Chats, memories, notes and media are stored with the account and never sold. Deleting the account removes everything.

Sary-OS is built solo in Bahrain. Try it at www.sary-os.com.

Built With

capacitor
claude
elevenlabs
firebase
gemini
grok
javascript
node.js
openai
stripe
three.js
vercel

Updates

Sary Ismail started this project — Oct 09, 2026 05:22 AM EDT

Leave feedback in the comments!

Log in or sign up for Devpost to join the conversation.