Wave OS is a browser-based, desktop-class operating system that turns Theta EdgeCloud's decentralized GPU network into a consumer-friendly computer. Instead of exposing raw, API-heavy compute, Wave OS wraps it in a familiar OS experience — a windowed desktop with a sidebar of native apps — and meters everything through a simple credit economy.
This report maps the automation and agent layer we've built on top of that computer: the Flows pipeline engine, the Surf automation browser, Agent Mode, and the on-chain deployment path — all running on Theta rather than centralized cloud.
Wave OS — The Decentralized Cloud Computer
The "computer" we built with Theta
Wave OS presents as a full operating system in the browser, with native apps in the sidebar and a compute backend that runs on Theta EdgeCloud's distributed GPU/CPU fleet:
- Desktop shell — windowed multi-app environment with a persistent sidebar (Surge, Story, Vision, Surf, Files, Notes, Chat, Wallet, Terminal, Calendar, Reef, Mesh, Token Launchpad, WaveSwap, AMP, Edge Node, Games).
- Decentralized compute — image generation, LLM inference, and code execution route to Theta EdgeCloud GPU/CPU workers instead of a centralized provider.
- Credit economy — every compute action is metered: CPU ~1 credit/min, GPU T4 ~4/min, GPU V100 ~20/min, images ~5 each. Free / Pro / Team tiers keep it approachable.
- On-chain identity & value — WaveIdentity NFTs for identity, a $WAVE token credit economy, and non-custodial wallet linking (bring-your-own-wallet, challenge-signature).
- Headless compute runner — a dedicated Theta EdgeCloud container (execution-as-a-service) compiles and runs real code (e.g. Solidity via pinned solc 0.8.14) for the OS's build tools.
Wave OS Flows — Visual Automation Engine
Flows is Wave OS's built-in automation builder — a visual, node-based pipeline engine that runs server-side on Theta-backed infrastructure. Users chain nodes together to browse the web, extract data, run AI steps, and deliver results, all without code.
Engine capabilities
- Visual 3-panel editor with a linked-list node model (each node declares its next step).
- 15 node types spanning triggers, browsing (navigate/extract), AI (compile/transform), and delivery (email/post).
- Safe templating —
{{node_X.output}}and{{user.email}}interpolation via regex, never eval. - Server-side execution — a real runFlow engine walks the graph, threads context, logs every step to PipelineRun, meters credits (1 credit/run), and fail-stops cleanly on errors.
- Per-node approval gates — email/post nodes suspend the run (awaiting_approval) with a fully-resolved preview; nothing sends until explicitly approved.
- Real browser under the hood — navigate/extract drive the Surf Cloud headless browser (CDP), with a simple-fetch fallback so runs never hard-crash.
Live pipelines (pulled from production data)
Five active pipelines currently live in the Wave OS app:
- Crypto Morning Briefing — Trigger: Manual. 10-node chain: CoinDesk headlines → CLARITY Act search → Theta Network → Bitcoin price → compile briefing → post to the Wave Hi "Crypto Briefing" channel.
- Daily Briefing — Trigger: Manual. Searches news on a topic, checks weather, compiles a digest, emails it to the user.
- Price Watcher — Trigger: Manual. Opens a stock quote (e.g. AAPL), extracts the price, compiles and emails an update.
- Site Change Monitor — Trigger: Manual. Visits a page, extracts content, compiles a summary, emails a site-check.
- Topic Digest — Trigger: Manual. Researches a topic via search, compiles a digest, emails it.
The Crypto Morning Briefing has been verified end-to-end: it renders all four sources, compiles a structured digest, suspends for approval, and on approval posts a real message to Wave Hi. Next natural step is putting it on a daily schedule (currently manual-run).
Surf — The AI-Drivable Cloud Browser
Surf is Wave OS's automation-first web browser: a real Chromium instance running in a Theta/Railway cloud container, controlled over the Chrome DevTools Protocol (CDP) and embedded directly in the OS as a browser app window.
- Cloud Chromium via CDP — full navigate / click / type / extract / screenshot control, typically responding in under 300ms.
- Embedded viewer — the live browser renders inside the Wave OS "Surf" window with its own native chrome.
- "Ask AI" panel — an in-browser assistant (Theta EdgeCloud model) plans a task, then executes each step through the Surf Cloud API — a self-contained agent loop, independent of any external assistant.
- Bookmarks, folders & history — organizational entities where folders can double as saved workflows linked to a Pipeline.
- Powers Flows — the same headless browser backs the navigate/extract nodes in Flows, so automations browse the real web, not a stripped-down fetch.
Agent Mode — Wave OS Drives Itself
Agent Mode is the orchestration layer that lets Wave OS act on a user's behalf. A single waveAgentLoop plans a task, calls tools through an MCP router, routes across Wave apps, meters credits, and returns a structured step log — the OS operating itself.
- MCP tool router — 50+ native tools exposed to the agent (Surf control, Flows CRUD/run, Surge code tools, Forge world-building, messaging, memory, and Theta compute).
- Cross-app reach — the agent drives sibling Wave apps (e.g. Wave Forge) over a secure cross-app key, so one instruction can create a 3D world, a pipeline, or a contract.
- Gated actions — sensitive tools (deploy, run, create-skill) are approval-gated; reads and CRUD run freely at zero credit cost.
- compute_run — the agent can compile and run real code on the Theta headless runner, closing the "compute gap" the browser runtime couldn't fill.
- Graceful degradation — with no runner provisioned, compute calls return runner_unavailable instead of throwing, keeping production stable.
Mesh — Verified On-Chain Deployment
Mesh is Wave OS's dApp builder and on-chain deployment path. It takes automation all the way to the blockchain: compiling, verifying, and deploying smart contracts to Theta mainnet — with a strict no-hallucinated-bytecode rule.
- Verified compile — source is compiled on the Theta runner (pinned solc 0.8.14 / istanbul), and the resulting bytecode is verified before any transaction is signed. LLM-generated bytecode is never deployed.
- Keystore signing — deploys are signed from an encrypted V3 keystore held in the app's secret vault, as a standard EIP-155 transaction on Theta mainnet (chain 361).
- Platform fee built in — a 2% fee routes to the Wave OS treasury on every deploy, consistent with the platform's "everything takes 2%" model.
- Proven live — first mainnet deploy succeeded end-to-end: contract confirmed on-chain and a read-back call returned the expected value, verifying the full compile → verify → sign → broadcast → confirm loop.
The through-line: Browse (Surf) → Automate (Flows) → Reason & act (Agent Mode) → Ship on-chain (Mesh) — every layer running on decentralized Theta compute, metered in credits, with human approval on anything that sends or deploys.
Capability Matrix
- Flows — Visual node pipelines, server-side execution, credit metering — Live
- Flows — Per-node approval gates on email/post — Live
- Flows — Scheduled/cron auto-trigger of pipelines — Planned
- Surf — Cloud Chromium via CDP (navigate/click/type/extract) — Live
- Surf — In-browser "Ask AI" task planner — Live
- Surf — Saved bookmark-workflows in folders — Planned
- Agent — waveAgentLoop + 50+ MCP tools, cross-app — Live
- Agent — compute_run on Theta headless runner — Live
- Mesh — Verified compile + on-chain deploy (Theta mainnet) — Live
- Theta — Decentralized GPU/CPU compute + credit economy — Live
Wave OS is a working decentralized computer with a complete automation stack — from a real cloud browser, to a visual pipeline engine, to a self-driving agent, to verified on-chain deployment — all metered on Theta EdgeCloud.


