What you can build with MIOSA

MIOSA is the infrastructure underneath AI products. Your product, or your agent, gets real machines and real URLs:

Sandboxes for code, files, builds, and previews.
Computers for browsers and full desktops, with human handoff.
Agents you dispatch, stream, and collect artifacts from.
Deployments and Docker Host for immutable releases on stable URLs, with custom domains and rollback.
Platform features for white-label products: organizations, workspaces, scoped keys, domains, and usage metering.

User request
  -> agent plans work
  -> sandbox does code, files, builds, tests, artifacts
  -> computer does browser, desktop, screenshots, manual-style tasks
  -> MIOSA streams events and previews
  -> deployment ships the finished app

MIOSA is not just a remote shell. It is the execution layer for products that need AI agents to do real work safely.

Browse the Build gallery

Every product shape below has a step-by-step guide in the Build gallery: the primitives you need, an architecture diagram, six steps from API key to custom domain, and a prompt you can hand to your coding agent.

AI app builders Lovable, Bolt, v0, Replit-style: prompt to a deployed app.

Run coding agents Claude Code, Codex, Cursor in the cloud.

Autonomous agents Agents with their own machine that finish work.

Browser and computer-use agents Agents that drive a real browser or desktop.

AI chat and companions Assistants and always-on companions.

Answer engines Research products that cite their sources.

Multi-agent One request, many agents in parallel.

Voice agents Agents that talk and act on calls.

AI design tools Prompt to a designed UI or asset.

AI video and creative Generate, edit, and produce media.

Vertical AI apps Agents for a specific industry workflow.

Internal tools A company OS where agents, apps, and data live together.

Builders and developers

Lovable and v0-style products where an agent turns a prompt into a live app, then fixes and republishes it.

Sandbox Preview Deployment

Start here: build a Lovable-style app

Run Claude Code, Codex, or OSA inside a persistent sandbox with the files, packages, and shell a real repo needs.

Sandbox Agent runs Snapshots

Start here: run coding agents

Run untrusted user code in an isolated microVM, stream stdout, and collect the artifacts it produces.

Sandbox Events Artifacts

Start here: streaming code execution

Run repeatable evals and benchmark bursts on real runtimes, with per-run evidence instead of mocks.

Sandbox Benchmarks Events

Start here: evaluations and benchmarks

Agent product teams

dots and Grok Bot-style agents that keep a device, files, a browser, and long-running jobs across sessions.

Sandbox Computer Agent devices

Start here: agent devices

Browser use runs inside every sandbox: an agent drives a real browser over CDP while a human can watch.

Sandbox Browser use Live viewer

Start here: browser use

Agents that screenshot, click, and type on a durable Linux desktop, with human takeover when they get stuck.

Computer Computer use Embedding

Start here: computer use

Platform and agency teams

Lumen-style platforms with your brand, your domains, and your end users, while MIOSA runs behind them.

Org and workspaces Branding Attribution

Start here: Platform builder guide

Northwind-style agencies that give each client an isolated workspace, build their apps, and hand over domains.

Multi-tenant Quotas Custom domains

Start here: Platform builder guide

An Acme Corp-style internal platform where your team agents, apps, and data live together on MIOSA.

Sandbox Connectors Data

Start here: internal Business OS

Infrastructure and enterprise

OpenComputers enrolls machines you own so agents can run commands and files on your own hardware.

OpenComputers Hosts Meshes

Start here: OpenComputers

Fractal gives enterprise data a governed home, so agents work against your systems with the right controls.

Fractal Data Governance

Start here: Fractal enterprise data

Product primitives

Primitive	Use it for	Not for
Sandbox	Code, files, commands, package installs, builds, tests, generated artifacts, preview servers	GUI/browser interaction
Computer	Browser automation, screenshots, mouse/keyboard, desktop apps, visual QA, user handoff	Headless code builds that do not need a desktop
Deployment	Stable public app/site/API URLs, versions, releases, rollback	Active development iteration
Docker Host	Many customer apps running as isolated containers on one workspace Docker Host host	Generic sandbox development
Artifacts	Files created by agents: PDFs, docs, images, reports, exports, screenshots	Hidden temporary state
Events	Real-time UI updates: tool calls, stdout, file writes, preview readiness, deployment status	Long-term storage

Build an agent-company product

Several modern AI products package the same high-level pattern: an agent, a persistent workspace, connected apps, a browser or cloud device, jobs, files, and generated deliverables. MIOSA exposes those primitives directly, so you can build your own version inside your product.

Your product UI
  -> agent configuration
  -> device policy
  -> sandbox/computer/local device
  -> connected accounts and managed connectors
  -> streamed tool calls and events
  -> files, artifacts, previews, jobs, and deployments

Product shape	MIOSA primitives
Always-on virtual device	Persistent sandbox or computer, primary device policy, snapshots, jobs
Agent team	Orchestrator, child sandboxes, child computers, shared artifacts, event stream
Mini-app builder	Next.js sandbox, preview URL, artifact panel, publish flow
Operator agent	Browser computer, connected apps, schedules, approvals, memory
Design/research agent	Web research, a managed research connector, files, browser screenshots
24/7 monitoring job	Scheduled trigger, persistent device, app connector, notifications

The important architecture point is that the agent should work in a MIOSA device. The local CLI, MCP client, or your backend orchestrates, but files, commands, browser actions, previews, and artifacts live in the assigned runtime.

See Build an agent-company platform, What MIOSA agents can do, Agent devices, and Agent orchestration for the full model.

Example: generated app builder

Your frontend can show the same work stream users expect from modern AI builders: tool calls, command output, generated files, preview links, screenshots, and final deployment URLs.

Example: artifact workspace

Use a sandbox when the output is a file, not a deployed app.

User asks for a proposal
  -> agent writes Python or Node generator
  -> sandbox creates proposal.html
  -> sandbox renders proposal.pdf
  -> sandbox creates proposal.docx
  -> product shows artifacts in a side panel
  -> user downloads or asks for edits

Good artifact outputs:

client proposals
pitch decks
data reports
PDF invoices
SVG diagrams
PNG charts
HTML previews
ZIP bundles
code archives

Two sandbox choices, and both cover the jobs

Choice	Intended job
The default sandbox (`miosa-sandbox`)	Everything in one place: Python and Node execution, generated web apps, reports and artifacts, browser testing, and database-backed apps.
The desktop (`miosa-desktop`)	GUI work and human takeover, when a person needs to see and drive the screen.

The product shape stays the same: start the default sandbox, let the agent work inside it.

What to show users in your product

Users should not have to understand VM internals. Show them useful work:

current task and plan
tool calls
command output
files created or edited
artifacts generated
preview URL
screenshots from browser checks
deployment URL
rollback/version history
credits and runtime usage

The message should be: “Your agent is working in a real cloud workspace. You can watch it, inspect the files, preview the result, and ship when ready.”