Wave OS — Automation & Agent Capabilities

Feature SpotlightWave OS TeamAug 18, 2026 9 min read
#Flows#Surf#Agent Mode#Mesh#Theta EdgeCloud

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.