# MIOSA Documentation

> MIOSA is an operating layer for agent products, sandboxes, desktop computers, immutable deployments, managed data, integrations, and customer infrastructure.

Canonical docs: https://miosa.ai/docs
Full plain-text docs: https://miosa.ai/llms-full.txt
Docs index JSON: https://miosa.ai/docs-index.json
OpenAPI spec: https://miosa.ai/openapi.yaml
Sitemap: https://miosa.ai/sitemap.xml

## Start Here

- [Agent operating guide](https://miosa.ai/docs/guides/agent-operating-guide) - Authoritative CLI, sandbox, release, recovery, and rollback contract for automated workers.
- [What you can build](https://miosa.ai/docs/use-cases) - Product patterns for agents, creative systems, vertical software, open-source applications, and model infrastructure.
- [Capability availability](https://miosa.ai/docs/availability) - Current, integrated, self-hostable, gated, and planned capabilities.
- [Customer infrastructure](https://miosa.ai/docs/platform/byoc) - MIOSA-managed compute, OpenComputers, AWS, Google Cloud, and hybrid placement.

## Core Agent Rules

- Run `miosa capabilities --json`, `miosa app inspect`, and `miosa app plan` before reconstructing a workflow from old examples.
- Resolve one exact organization, workspace, application, and environment before mutating resources.
- Reuse the linked persistent sandbox unless it is proven terminal. Do not replace resources because an identifier or route was not resolved.
- Use `miosa app preview` to create and test an immutable candidate release. Preview never promotes production.
- Verify and promote one exact release ID. Never promote an inferred latest release.
- Call a release live only when the active release, running artifact digest, route contract, placement, data bindings, and required configuration agree.
- Recover interrupted operations with the recorded operation ID and idempotency key instead of starting duplicates.
- Use URLs returned by MIOSA. Do not construct preview, deployment, or custom-domain hostnames.

If an automated fetcher is blocked by Cloudflare on miosa.ai, use the Worker fallback for the same paths:
- https://miosa.roberto-c49.workers.dev/docs
- https://miosa.roberto-c49.workers.dev/llms.txt
- https://miosa.roberto-c49.workers.dev/llms-full.txt
- https://miosa.roberto-c49.workers.dev/docs-index.json
- https://miosa.roberto-c49.workers.dev/openapi.yaml

## Primary Docs

- [MIOSA Documentation](https://miosa.ai/docs) - Build, preview, deploy, prove, and operate AI-generated applications on MIOSA sandboxes, computers, Docker Host, and white-label domains.
- [Agent Development Kit (ADK)](https://miosa.ai/docs/adk) - Build LLM agents that use MIOSA sandboxes, desktops, and deploys with the tool-call loop already wired. TypeScript ADK first; Python next.
- [Agent Studio](https://miosa.ai/docs/agents/agent-studio) - Chat with an agent in a dedicated workspace, with one warm sandbox per chat and honest status and errors.
- [Chat with an agent on a machine](https://miosa.ai/docs/agents/chat-on-a-machine) - Open a computer, or the Agent section of a sandbox, and chat with an agent bound to that machine.
- [Agent confinement](https://miosa.ai/docs/agents/confinement) - An agent runs inside its machine and cannot use MIOSA's own platform key unless an Environment grants it a scoped one.
- [Harnesses and auth](https://miosa.ai/docs/agents/harnesses) - The agents MIOSA can run on your machine, how each one authenticates, and how MIOSA gets each one ready.
- [Interactive API Reference  -  MIOSA Docs](https://miosa.ai/docs/api) - Browse and try the allowlisted MIOSA Sandbox V1 API interactively. Use the written endpoint guides for the wider platform API.
- [API Reference](https://miosa.ai/docs/api-reference) - REST API reference for the MIOSA platform - base URL, auth, request/response envelopes, and endpoint guides.
- [Agent Run Groups](https://miosa.ai/docs/api-reference/agent-run-groups) - Create durable multi-agent orchestration groups, dispatch run manifests, inspect counts, and cancel grouped work.
- [Agent Runs](https://miosa.ai/docs/api-reference/agent-runs) - Dispatch prompts into MIOSA devices with a stable run response shape for agent work.
- [Agent Runtime Profiles](https://miosa.ai/docs/api-reference/agent-runtime-profiles) - Configure reusable agent runtime defaults for sandboxes, computers, and custom agent sessions.
- [Audit Log API](https://miosa.ai/docs/api-reference/audit-log) - Retrieve a cursor-paginated audit log of all actions taken within your tenant.
- [Cloud and BYOC API](https://miosa.ai/docs/api-reference/cloud) - Organization-scoped AWS and GCP accounts, regions, pools, nodes, preflight, and host provisioning.
- [Computers API](https://miosa.ai/docs/api-reference/computers) - API reference for creating, managing, and controlling MIOSA computers  -  full lifecycle, desktop control, files, metrics, and env vars.
- [Credits API](https://miosa.ai/docs/api-reference/credits) - API reference for checking credit balance, transaction history, and usage data.
- [Custom Domains API](https://miosa.ai/docs/api-reference/custom-domains) - API reference for mapping tenant-owned FQDNs to MIOSA previews with automatic TLS.
- [Databases API](https://miosa.ai/docs/api-reference/databases) - Provision and operate managed databases, backups, restores, branches, replicas, credentials, and placement.
- [API Reference / Deployments](https://miosa.ai/docs/api-reference/deployments) - REST API for the Deployment resource  -  create, list, get, update, delete, publish, rollback.
- [Desktop API](https://miosa.ai/docs/api-reference/desktop) - API reference for all desktop control endpoints  -  screenshot, mouse, keyboard, clipboard, windows, accessibility tree.
- [API Reference / Docker Host](https://miosa.ai/docs/api-reference/docker-deploy) - REST API for Docker Host templates, workspace hosts, and sandbox-to-container publishing.
- [Egress (Security) API](https://miosa.ai/docs/api-reference/egress) - API reference for the MIOSA Egress credential vault, network allowlist, OAuth Connect, and audit log.
- [Error Codes](https://miosa.ai/docs/api-reference/errors) - Every error code the MIOSA API returns, what it means, and how to handle it.
- [Events (SSE)](https://miosa.ai/docs/api-reference/events) - Server-Sent Event streams for real-time updates from sandboxes, computers, deployments, and builds.
- [Exec API](https://miosa.ai/docs/api-reference/exec) - API reference for executing bash commands and Python code on MIOSA computers.
- [Files API](https://miosa.ai/docs/api-reference/files) - API reference for file upload, download, list, export, and delete operations.
- [Filesystem API](https://miosa.ai/docs/api-reference/filesystem) - Complete API reference for file and directory operations on MIOSA computers  -  upload, download, stat, mkdir, rename, copy, chmod, and readdir.
- [Invites API](https://miosa.ai/docs/api-reference/invites) - API reference for the workspace invite and org invite flows  -  send, list, revoke, preview, and accept email invitations.
- [Workspace Members API](https://miosa.ai/docs/api-reference/members) - API reference for managing workspace member rosters  -  add, remove, and update roles for users inside a workspace.
- [Network Policy API](https://miosa.ai/docs/api-reference/network-policy) - API reference for configuring per-computer network access controls on MIOSA computers.
- [OpenComputers API](https://miosa.ai/docs/api-reference/open-computers) - Register and control customer-owned machines, including on-premises servers, via the MIOSA API  -  exec, files, tunnels, AI agents, inference clusters, and secrets.
- [Preview Tokens API](https://miosa.ai/docs/api-reference/preview-tokens) - Generate short-lived signed tokens for iframe embedding without exposing an API key.
- [Previews and publish API](https://miosa.ai/docs/api-reference/previews) - Expose a sandbox port as a preview URL, publish a sandbox to a stable deployment, and promote a running sandbox to a deployment route.
- [Projects API](https://miosa.ai/docs/api-reference/projects) - API reference for creating and managing projects inside MIOSA workspaces.
- [Quotas API](https://miosa.ai/docs/api-reference/quotas) - Set per-end-user resource limits for white-label multi-tenant deployments.
- [Regions API](https://miosa.ai/docs/api-reference/regions) - List available regions and pin Computers and Sandboxes to a specific region.
- [Releases API](https://miosa.ai/docs/api-reference/releases) - Inspect and activate exact immutable deployment artifacts.
- [Runtime Env](https://miosa.ai/docs/api-reference/runtime-env) - Store inherited runtime environment variables for sandboxes, computers, agents, and deployments.
- [Sandbox Env API](https://miosa.ai/docs/api-reference/sandbox-env) - CRUD for per-sandbox environment variables, encrypted at rest.
- [Sandbox Files (Advanced) API](https://miosa.ai/docs/api-reference/sandbox-files-advanced) - Upload a file, write bytes as well as text, traverse the file tree, batch write, and watch file-change events in a sandbox.
- [Sandbox Processes API](https://miosa.ai/docs/api-reference/sandbox-processes) - Start, monitor, and stream logs for long-running background processes inside sandboxes.
- [Sandbox Shares API](https://miosa.ai/docs/api-reference/sandbox-shares) - Create and manage public share URLs for sandboxes.
- [Sandbox Templates API](https://miosa.ai/docs/api-reference/sandbox-templates) - The templates that stage content inside the one sandbox image, the legacy image ids that are aliases, and how to create a sandbox from a template.
- [Sandboxes API](https://miosa.ai/docs/api-reference/sandboxes) - API reference for creating, managing, and executing code in MIOSA sandboxes - persistent-by-default isolated microVM workspaces.
- [Sandboxes API - create and run](https://miosa.ai/docs/api-reference/sandboxes/create) - Create a MIOSA sandbox, use the fused run endpoint, start a template app, get artifacts, and the custom-template boundary.
- [Sandboxes API - manage](https://miosa.ai/docs/api-reference/sandboxes/manage) - List, get, destroy, pause, resume, restart, fork, extend the timeout, and read usage for MIOSA sandboxes.
- [Services API](https://miosa.ai/docs/api-reference/services) - API reference for managing long-running systemd services inside MIOSA computers.
- [Snapshots API](https://miosa.ai/docs/api-reference/snapshots) - API reference for creating, listing, and restoring microVM snapshots (checkpoints).
- [Streaming Exec API](https://miosa.ai/docs/api-reference/streaming-exec) - API reference for streaming command output in real-time from MIOSA computers via SSE.
- [Tenant Branding API](https://miosa.ai/docs/api-reference/tenant-branding) - Customize the logo, name, and colors shown on sandbox 404 and 502 error pages.
- [Tenant Events (SSE) API](https://miosa.ai/docs/api-reference/tenant-events) - Subscribe to a real-time server-sent event stream of all tenant-wide platform events.
- [Tenant Preview Domain API](https://miosa.ai/docs/api-reference/tenant-preview-domain) - Configure a custom apex domain for sandbox preview URLs (white-label).
- [Usage Rollup API](https://miosa.ai/docs/api-reference/usage-rollup) - Aggregate sandbox compute usage and spend by external user, project, or workspace.
- [API Reference / Versions](https://miosa.ai/docs/api-reference/versions) - Immutable deployment version sub-resource. List, get, promote, archive.
- [Webhooks API](https://miosa.ai/docs/api-reference/webhooks) - Subscribe to platform lifecycle events via outgoing HTTP callbacks with HMAC signature verification.
- [Workspaces API](https://miosa.ai/docs/api-reference/workspaces) - API reference for creating and managing MIOSA workspaces - the customer/client layer inside an organization.
- [Authentication](https://miosa.ai/docs/authentication) - How to authenticate with the MIOSA API using msk_ API keys or JWT tokens.
- [Availability & Roadmap](https://miosa.ai/docs/availability) - Current MIOSA product availability, what is generally available, what is in hardening, and what is planned next.
- [Benchmarks](https://miosa.ai/docs/benchmarks) - MIOSA's results in the independent ComputeSDK benchmarks. Burst time-to-interactive and DAX sandbox builds, every run, with links to the raw JSON.
- [Browser use](https://miosa.ai/docs/browser-use) - A live browser inside any MIOSA sandbox - watch it, take control, share a view-only link, and let agents drive the same browser over CDP.
- [Drive a sandbox browser over CDP](https://miosa.ai/docs/browser-use/cdp) - Connect Playwright and Puppeteer to a live sandbox browser over CDP and drive the same session a viewer is watching.
- [How browser use works](https://miosa.ai/docs/browser-use/how-it-works) - The parts of a sandbox browser, the three surfaces that see it, and how the live view and CDP sockets are exposed.
- [Browser use integrations](https://miosa.ai/docs/browser-use/integrations) - Connect a Chrome DevTools Protocol client to a MIOSA sandbox browser. Only clients verified end to end are listed.
- [Browser use limits, billing, and security](https://miosa.ai/docs/browser-use/limits) - Availability and size, lifecycle across pause and resume, how browser use is billed, and how access is enforced.
- [Browser use live viewer](https://miosa.ai/docs/browser-use/live-viewer) - Watch a sandbox browser live, take control, share a revocable view-only link, and go full screen.
- [Browser use quickstart](https://miosa.ai/docs/browser-use/quickstart) - Start a live browser in any MIOSA sandbox, read its stream and CDP endpoints, and stop it when you are done.
- [Build an app like...](https://miosa.ai/docs/build) - Guides for platform builders. Run open-source agents and frameworks on MIOSA, or build familiar AI products like Lovable, Manus and Perplexity - app builders, coding agents, autonomous and computer-use agents, chat and companions, answer engines, multi-agent, voice, design, video, vertical apps, and an internal Business OS.
- [Build an Anything-style app](https://miosa.ai/docs/build/anything) - Anything: Prompt to a working web or mobile app. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Base44-style app](https://miosa.ai/docs/build/base44) - Base44: Describe an app, get a working, previewed one. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Bland-style phone agent](https://miosa.ai/docs/build/bland) - Bland AI: Programmable phone agents at scale. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Bolt-style app](https://miosa.ai/docs/build/bolt) - Bolt: Full-stack apps from a prompt, on a real dev server. Build it on MIOSA with the exact resources, steps and commands.
- [Run Browser Use on MIOSA](https://miosa.ai/docs/build/browser-use) - Browser Use: Install the open-source library and let an agent drive a real browser. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build an internal Business OS](https://miosa.ai/docs/build/business-os) - BusinessOS is MIOSA's own Apache-2.0 internal company OS. Clone the real repo, run it on a MIOSA sandbox or computer, preview it, customize the modules, and publish it behind your own domain.
- [Build a Character-style companion](https://miosa.ai/docs/build/character-ai) - Character.AI: Persona companions users chat with over time. Build it on MIOSA with the exact resources, steps and commands.
- [Build a browser and computer-use agent](https://miosa.ai/docs/build/chatgpt-agent) - Browser and computer-use agent: An agent that browses, clicks and fills forms to finish a task. Build it on MIOSA with the exact resources, steps and commands.
- [Run Claude Code on MIOSA](https://miosa.ai/docs/build/claude-code) - Claude Code: Install it in a sandbox; stream and collect its work. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build a Cowork-style desktop agent](https://miosa.ai/docs/build/claude-cowork) - Claude Cowork: An agent that works alongside you on your desktop. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Clay-style sales agent](https://miosa.ai/docs/build/clay) - Clay: Research and enrich leads at scale. Build it on MIOSA with the exact resources, steps and commands.
- [Run Cline on MIOSA](https://miosa.ai/docs/build/cline) - Cline: The most-installed open-source coding agent, headless in a sandbox. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Run Codex on MIOSA](https://miosa.ai/docs/build/codex) - Codex: Install the Codex CLI in a sandbox with streamed events. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build a coding-agent product](https://miosa.ai/docs/build/coding-agent-product) - A branded coding-agent product: Wrap a harness in your own branded product. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Comet-style agentic browser](https://miosa.ai/docs/build/comet) - Comet: A browser that navigates and answers in place. Build it on MIOSA with the exact resources, steps and commands.
- [Run Cursor agents on MIOSA](https://miosa.ai/docs/build/cursor) - Cursor: Install the Cursor CLI agent and run it headless on isolated machines. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build a Decagon-style support agent](https://miosa.ai/docs/build/decagon) - Decagon: Resolve tickets across chat and email, with handoff. Build it on MIOSA with the exact resources, steps and commands.
- [Build a deep-research-style agent](https://miosa.ai/docs/build/deep-research) - ChatGPT deep research: A long-running research agent producing a report. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Descript-style editor](https://miosa.ai/docs/build/descript) - Descript: Edit video by editing the transcript. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Devin-style SWE agent](https://miosa.ai/docs/build/devin) - Devin: An autonomous engineer with a shell, IDE, and browser. Build it on MIOSA with the exact resources, steps and commands.
- [Build a dots-style companion](https://miosa.ai/docs/build/dots) - dots: Always-on companions, each with its own cloud computer. Build it on MIOSA with the exact resources, steps and commands.
- [Build an ElevenLabs-style voice agent](https://miosa.ai/docs/build/elevenlabs) - ElevenLabs Agents: A voice agent that talks and takes real actions. Build it on MIOSA with the exact resources, steps and commands.
- [Build an Emergent-style app](https://miosa.ai/docs/build/emergent) - Emergent: Prompts become running software with real infrastructure. Build it on MIOSA with the exact resources, steps and commands.
- [Build an employee onboarding agent](https://miosa.ai/docs/build/employee-onboarding-agent) - Employee onboarding agent: Walks a new hire through their first week. Build it on MIOSA with the exact resources, steps and commands.
- [Build a prompt-to-UI design tool](https://miosa.ai/docs/build/figma-make) - Figma Make: Prompt (and a design file) to a working, previewed UI. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Gamma-style deck app](https://miosa.ai/docs/build/gamma) - Gamma: Prompt or document to a polished, shareable deck or page. Build it on MIOSA with the exact resources, steps and commands.
- [Build an orchestrator that delegates](https://miosa.ai/docs/build/gemini-agent) - An orchestrator that delegates: One agent that plans, delegates to sub-agents and joins the result. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Genspark-style agent](https://miosa.ai/docs/build/genspark) - Genspark Super Agent: A super-agent that plans and produces finished work. Build it on MIOSA with the exact resources, steps and commands.
- [Build a GitHub Copilot-style coding agent](https://miosa.ai/docs/build/github-copilot) - GitHub Copilot coding agent: An agent that takes an issue, works, and opens a PR. Build it on MIOSA with the exact resources, steps and commands.
- [Build a post-call analysis agent](https://miosa.ai/docs/build/gong) - Gong: Turn call transcripts into sourced insights and next steps. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Grok Bot-style chat app](https://miosa.ai/docs/build/grok-bot) - Grok Bot: A team of named bots sharing one cloud computer. Build it on MIOSA with the exact resources, steps and commands.
- [Run Hermes Agent on MIOSA](https://miosa.ai/docs/build/hermes-agent) - Hermes Agent: Install the open-source agent harness and run many tool-using agents. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build an avatar-video app](https://miosa.ai/docs/build/heygen) - HeyGen: Script to talking-avatar video with TTS and lip-sync APIs. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Higgsfield-style video studio](https://miosa.ai/docs/build/higgsfield) - Higgsfield: A multi-model studio: brief, steer camera and look, generate. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Fin-style support agent](https://miosa.ai/docs/build/intercom-fin) - Fin: An AI support agent resolving customer tickets. Build it on MIOSA with the exact resources, steps and commands.
- [Build an internal tools builder](https://miosa.ai/docs/build/internal-tools-builder) - Internal tools builder: Prompt to a shipped dashboard behind your domain. Build it on MIOSA with the exact resources, steps and commands.
- [Build a knowledge-base agent](https://miosa.ai/docs/build/knowledge-base-agent) - Knowledge-base agent: Answer from the company docs with citations. Build it on MIOSA with the exact resources, steps and commands.
- [Run LiveKit Agents on MIOSA](https://miosa.ai/docs/build/livekit-agents) - LiveKit Agents: The leading open-source realtime voice agent framework. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build a Lovable-style app](https://miosa.ai/docs/build/lovable) - Lovable: Prompt a full-stack app, preview it live, publish it. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Magic-Patterns-style tool](https://miosa.ai/docs/build/magic-patterns) - Magic Patterns: Generate UI components from a prompt. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Manus-style agent](https://miosa.ai/docs/build/manus) - Manus: A general agent with a desktop, browser, and files. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Muse-style companion](https://miosa.ai/docs/build/meta-muse) - Muse: A personal companion that acts on your behalf across apps. Build it on MIOSA with the exact resources, steps and commands.
- [Run OpenClaw on MIOSA](https://miosa.ai/docs/build/openclaw) - OpenClaw: Install the open-source assistant on a persistent computer that never sleeps. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build an OpenEvidence-style evidence engine](https://miosa.ai/docs/build/openevidence) - OpenEvidence: Cited answers over a trusted corpus. Build it on MIOSA with the exact resources, steps and commands.
- [Run OpenHands on MIOSA](https://miosa.ai/docs/build/openhands) - OpenHands: Install the open-source software agent; the sandbox is its workspace. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build an OpenSwarm-style multi-agent app](https://miosa.ai/docs/build/openswarm) - OpenSwarm: An AI desktop built around running several agents in parallel. Build it on MIOSA with the exact resources, steps and commands.
- [Build an ops and support copilot](https://miosa.ai/docs/build/ops-support-copilot) - Ops and support copilot: Triage tickets and run runbooks, with human approval. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Perplexity-style answer engine](https://miosa.ai/docs/build/perplexity) - Perplexity: Search, read, and answer with citations. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Phind-style answer engine](https://miosa.ai/docs/build/phind) - Phind: Technical answers rendered as interactive mini-apps. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Pi-style companion](https://miosa.ai/docs/build/pi) - Pi: A warm, conversational personal assistant. Build it on MIOSA with the exact resources, steps and commands.
- [Run Pipecat on MIOSA](https://miosa.ai/docs/build/pipecat) - Pipecat: Install the open-source voice pipeline from speech-to-text to text-to-speech. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build a Polar-style AI browser](https://miosa.ai/docs/build/polar) - AI browser: Build your own browser that runs hours-long tasks and scheduled workflows, on a live MIOSA browser you control. Exact resources, steps and commands.
- [Build a Replika-style companion](https://miosa.ai/docs/build/replika) - Replika: A personal companion with long-term memory. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Replit-Agent-style app](https://miosa.ai/docs/build/replit) - Replit Agent: A cloud workspace where a prompt becomes a running app. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Retell-style voice agent](https://miosa.ai/docs/build/retell) - Retell AI: Phone agents that handle real calls. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Rork-style app](https://miosa.ai/docs/build/rork) - Rork: Prompt to a mobile app you can preview. Build it on MIOSA with the exact resources, steps and commands.
- [Run coding agents in the cloud](https://miosa.ai/docs/build/run-agents) - Cloud coding agents: Claude Code, Codex, Cursor: background agents in the cloud. Build it on MIOSA with the exact resources, steps and commands.
- [Build a video-generation app](https://miosa.ai/docs/build/runway) - Runway: Generate and edit video on top of video-model APIs. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Same-style app](https://miosa.ai/docs/build/same-new) - Same: Clone and rebuild a UI from a screenshot or URL. Build it on MIOSA with the exact resources, steps and commands.
- [Build a text-to-video app](https://miosa.ai/docs/build/sora) - Sora: Prompt to video through a video-model API. Build it on MIOSA with the exact resources, steps and commands.
- [Run Stagehand on MIOSA](https://miosa.ai/docs/build/stagehand) - Stagehand: Install the framework and run reliable browser automations on a computer. Install and run it on a MIOSA sandbox or computer, then wrap it for your team or your customers.
- [Build an internal AI workspace](https://miosa.ai/docs/build/team-ai-workspace) - Internal AI workspace: One place for your team's agents, apps, and data. Build it on MIOSA with the exact resources, steps and commands.
- [Build a sketch-to-mockup tool](https://miosa.ai/docs/build/uizard) - Uizard: A sketch or screenshot becomes editable UI code. Build it on MIOSA with the exact resources, steps and commands.
- [Build a v0-style app](https://miosa.ai/docs/build/v0) - v0: Generate a UI from a prompt and publish it. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Vapi-style voice agent](https://miosa.ai/docs/build/vapi) - Vapi: Voice agents for phone and web. Build it on MIOSA with the exact resources, steps and commands.
- [Build a Windsurf-style agentic IDE](https://miosa.ai/docs/build/windsurf) - Windsurf: An editor with an agent that edits across files and runs commands. Build it on MIOSA with the exact resources, steps and commands.
- [Build a You.com-style search and answer API](https://miosa.ai/docs/build/you-com) - You.com: An API your agents call to search and answer, with sources. Build it on MIOSA with the exact resources, steps and commands.
- [Changelog](https://miosa.ai/docs/changelog) - Customer-facing updates to MIOSA products, platform capabilities, SDKs, CLI tools, and documentation.
- [CLI overview](https://miosa.ai/docs/cli) - The miosa command line tool. Install, sign in, and drive sandboxes, computers, agents, deployments and every platform resource from the terminal.
- [Access, org and billing](https://miosa.ai/docs/cli/access-billing) - API keys, service accounts, webhooks, members, billing, audit log, alerts and notifications from the miosa CLI.
- [Account and environment](https://miosa.ai/docs/cli/account) - Check who you are, which organization pays, the organization's members and limits, and the CLI version.
- [Agents, chats and runs](https://miosa.ai/docs/cli/agents) - Run agents on a sandbox or computer, manage saved agent definitions, chats and durable runs, and see how runs stream.
- [Raw API access](https://miosa.ai/docs/cli/api) - Call any MIOSA API endpoint from the CLI with your stored credentials, using miosa api.
- [CLI or MCP: which to use](https://miosa.ai/docs/cli/cli-vs-mcp) - The miosa CLI is for humans and scripts in a terminal; MCP gives AI clients the same capabilities as tools. Both use the same API key and scopes.
- [Config and profiles](https://miosa.ai/docs/cli/config) - Named sign-ins and defaults in ~/.miosa/config.toml, plus the config commands, options and environment variables.
- [Devices](https://miosa.ai/docs/cli/devices) - miosa device is one surface over every runtime kind you can run work on - sandboxes, computers and more - for listing, exec, files, ports and lifecycle.
- [Environments](https://miosa.ai/docs/cli/environments) - The template a new sandbox or computer starts from: repositories, variables, secret files and credentials, with immutable versions.
- [Install and authenticate](https://miosa.ai/docs/cli/install) - Install the miosa CLI from npm, Homebrew, the install script or a release archive on macOS, Linux and Windows, verify 2.3, then sign in.
- [Machines and lifecycle](https://miosa.ai/docs/cli/machines) - Create, list, inspect, stop, fork, recover and destroy sandboxes and computers with the miosa CLI.
- [Platform resources](https://miosa.ai/docs/cli/platform) - Deployments, databases, storage, volumes, workflows, schedules, functions, templates, hosts, forge, cloud, egress and the AI gateway from the miosa CLI.
- [JSON output and scripting](https://miosa.ai/docs/cli/scripting) - Machine-readable output, streaming, error shapes, exit codes and CI patterns for the miosa CLI.
- [Snapshots, checkpoints and restore](https://miosa.ai/docs/cli/snapshots) - Browse, name, fork and delete snapshots of sandboxes and computers, plus checkpoints and restore.
- [Run commands and move files](https://miosa.ai/docs/cli/work-inside) - exec, ssh, console, files, background processes, services, logs, ports and public previews in a sandbox.
- [MIOSA vs other platforms](https://miosa.ai/docs/compare) - How MIOSA compares to Railway, Render, Fly.io, E2B, Daytona, Modal, Vercel, Cloudflare, Freestyle, Runloop, Blaxel, Beam, boat and CodeSandbox, using independent benchmark data and each vendor's public documentation as of 2026-10-23.
- [MIOSA vs Beam](https://miosa.ai/docs/compare/beam) - A factual comparison of MIOSA and Beam, using the independent ComputeSDK benchmark and Beam's public documentation as of October 2026.
- [MIOSA vs Blaxel](https://miosa.ai/docs/compare/blaxel) - A factual comparison of MIOSA and Blaxel, using the independent ComputeSDK benchmark and Blaxel's public documentation as of October 2026.
- [MIOSA vs boat](https://miosa.ai/docs/compare/boat) - A factual comparison of MIOSA and boat (boat.dev), cloud sandboxes for AI agents, using boat's public documentation as of 2026-10-23.
- [MIOSA vs Cloudflare Sandboxes](https://miosa.ai/docs/compare/cloudflare) - A factual comparison of MIOSA and Cloudflare Sandboxes, using the independent ComputeSDK benchmark and Cloudflare Sandboxes's public documentation as of October 2026.
- [MIOSA vs CodeSandbox](https://miosa.ai/docs/compare/codesandbox) - A factual comparison of MIOSA and CodeSandbox, using the independent ComputeSDK benchmark and CodeSandbox's public documentation as of October 2026.
- [MIOSA vs Daytona](https://miosa.ai/docs/compare/daytona) - A factual comparison of MIOSA and Daytona, using the independent ComputeSDK benchmark and Daytona's public documentation as of October 2026.
- [MIOSA vs E2B](https://miosa.ai/docs/compare/e2b) - A factual comparison of MIOSA and E2B, using the independent ComputeSDK benchmark and E2B's public documentation as of October 2026.
- [MIOSA vs Fly.io](https://miosa.ai/docs/compare/fly) - A factual comparison of MIOSA and Fly.io for running apps and machines, using Fly.io's public documentation as of 2026-10-23.
- [MIOSA vs Freestyle](https://miosa.ai/docs/compare/freestyle) - A factual comparison of MIOSA and Freestyle, using the independent ComputeSDK benchmark and Freestyle's public documentation as of October 2026.
- [MIOSA vs Modal](https://miosa.ai/docs/compare/modal) - A factual comparison of MIOSA and Modal, using the independent ComputeSDK benchmark and Modal's public documentation as of October 2026.
- [MIOSA vs Railway](https://miosa.ai/docs/compare/railway) - A factual comparison of MIOSA and Railway for running services, using Railway's public documentation as of 2026-10-23.
- [MIOSA vs Render](https://miosa.ai/docs/compare/render) - A factual comparison of MIOSA and Render for running services, using Render's public documentation as of 2026-10-23.
- [MIOSA vs Runloop](https://miosa.ai/docs/compare/runloop) - A factual comparison of MIOSA and Runloop, using the independent ComputeSDK benchmark and Runloop's public documentation as of October 2026.
- [MIOSA vs Vercel Sandbox](https://miosa.ai/docs/compare/vercel) - A factual comparison of MIOSA and Vercel Sandbox, using the independent ComputeSDK benchmark and Vercel Sandbox's public documentation as of October 2026.
- [Foundation Component Library](https://miosa.ai/docs/component-library) - MIOSA Foundation UI reference with design intent, Tailwind v4 tokens, CSS variables, and design tokens.
- [Computer use](https://miosa.ai/docs/computer-use) - Let software operate a real Linux desktop on a MIOSA Computer - screenshots, mouse, keyboard, windows, accessibility, and a live viewer a human can take over.
- [Computer use API reference](https://miosa.ai/docs/computer-use/api-reference) - Every MIOSA Computer desktop control endpoint - screenshot, mouse, keyboard, scroll, clipboard, windows, accessibility tree, and the one-shot window-state read.
- [Computer use limits](https://miosa.ai/docs/computer-use/limits) - Latency, coordinate space, sizing, authentication, and rate limits for MIOSA Computer desktop control.
- [Computer use quickstart](https://miosa.ai/docs/computer-use/quickstart) - Create a MIOSA Computer, run the first screenshot-act-verify loop, and watch the live desktop a human can take over.
- [Computer use SDK examples](https://miosa.ai/docs/computer-use/sdk-examples) - Python and TypeScript method names for driving a MIOSA Computer desktop, with runnable examples for screenshots, input, windows, accessibility, and shell.
- [Computer use vs browser use: which to pick](https://miosa.ai/docs/computer-use/vs-browser-use) - A short comparison of MIOSA browser use inside a sandbox and full computer use on a durable desktop, to pick the right one for a task.
- [Inside a Computer](https://miosa.ai/docs/computers/anatomy) - What ships in a Computer and how the desktop, persistent disk, stream gateway, and control API fit together.
- [Embedding & Streaming](https://miosa.ai/docs/computers/embedding) - Embed a live Computer desktop in your own UI with a short-lived stream URL. Pixel streaming and input forwarding are handled by MIOSA.
- [Fast start & readiness](https://miosa.ai/docs/computers/fast-start) - How MIOSA starts managed desktop Computers quickly, defines browser readiness, and exposes failures without false Live states.
- [Lifecycle and sizing](https://miosa.ai/docs/computers/lifecycle) - Computer fast startup, the desktop state machine, resource sizes, and workspace-scoped creation for per-tenant attribution.
- [Computers (Desktop)](https://miosa.ai/docs/computers/overview) - Durable cloud desktops for browser agents, human takeover, GUI automation, and long-running computer-use workflows.
- [Production checklist](https://miosa.ai/docs/computers/production-checklist) - The defaults to verify before relying on a Computer in production: workspace attribution, access, secrets, state, observability, and recovery.
- [Computers vs sandbox](https://miosa.ai/docs/computers/vs-sandbox) - Choose a Computer or a Sandbox for a workload, with the rule of thumb and a side-by-side table.
- [Core Concepts](https://miosa.ai/docs/concepts) - The canonical MIOSA product model, from mutable sandboxes to immutable releases, stable deployments, persistent data, and customer-owned infrastructure.
- [Computers (desktop product)](https://miosa.ai/docs/concepts/computers-desktop) - The MIOSA cloud desktop product: full GUI environments with screenshot, click, type, and keyboard APIs, and how they differ from Sandboxes.
- [Data and bindings](https://miosa.ai/docs/concepts/data-and-bindings) - Managed Postgres, Redis, object storage, volumes, and auth - the durable resources a Deployment attaches to, and how bindings inject credentials.
- [The publish pipeline](https://miosa.ai/docs/concepts/publish-pipeline) - Builder, Release, Runtime Instance, Domain, Deployment, and Version - how a mutable Sandbox becomes an immutable, verified production release.
- [Resource model](https://miosa.ai/docs/concepts/resource-model) - The MIOSA ownership chain and the mutable development resources - Organization, Workspace, Project, Sandbox, and Preview.
- [Tenancy](https://miosa.ai/docs/concepts/tenancy) - White-label tenancy and external attribution - how platforms build a product on MIOSA and map MIOSA resources to their own customers.
- [Tenant configuration](https://miosa.ai/docs/concepts/tenant-config) - Tenant preview domain and tenant branding - the apex hostname that replaces the MIOSA fallback preview domain and the error pages your end users see.
- [Preview and share tokens](https://miosa.ai/docs/concepts/tokens) - Short-lived preview tokens (mp_*) and revocable share tokens (ms_*) for loading a sandbox preview in a browser without exposing a workspace key.
- [Cookbook](https://miosa.ai/docs/cookbook) - Every MIOSA recipe in one place, grouped by area. Sandbox procedures and platform-builder walkthroughs, each with a working code path.
- [Agent builds an app](https://miosa.ai/docs/cookbook/agent-builds-app) - Your AI agent receives a prompt, writes code into a sandbox, iterates visually with live preview, checkpoints progress, branches experiments, shares with stakeholders, and publishes to production.
- [Agent with secrets  -  full walkthrough](https://miosa.ai/docs/cookbook/agent-with-secrets) - Create a sandbox, store an OpenAI key and connect GitHub via OAuth, run an AI agent, watch the audit log live, lock the network down, then rotate the key mid-run.
- [Browser agent](https://miosa.ai/docs/cookbook/browser-agent) - Put an LLM in the loop of a real browser running inside a sandbox. Start the sandbox browser, drive it over CDP with Playwright, and run the screenshot → action → screenshot loop.
- [Build a virtual-device product](https://miosa.ai/docs/cookbook/build-virtual-device-product) - Build a Nebula-style product on MIOSA with persistent devices, files, browser work, jobs, artifacts, and connected tools.
- [Embed sandbox in an iframe](https://miosa.ai/docs/cookbook/embed-sandbox-iframe) - Your server mints a preview token; your frontend uses it as an iframe src. Covers React, Vue, Svelte, and vanilla JS, plus token TTL refresh.
- [Multi-tenant SaaS](https://miosa.ai/docs/cookbook/multi-tenant-saas) - Embed MIOSA into your SaaS  -  tag sandboxes per tenant, query usage per workspace, and mint short-lived preview share tokens so customers interact directly with their sandboxes.
- [Per-user quotas and billing](https://miosa.ai/docs/cookbook/per-user-quotas-billing) - Set per-end-user resource caps, pull monthly usage rollups keyed by external_user_id, and generate invoices for your customers.
- [Sandbox events in real time](https://miosa.ai/docs/cookbook/sandbox-events-realtime) - React to sandbox lifecycle events using either HMAC-signed webhooks (server-to-server) or the SSE event stream (in-process). Covers both patterns, idempotency, and when to choose each.
- [Streaming code execution](https://miosa.ai/docs/cookbook/streaming-code-execution) - Run a long Python script in a sandbox and stream stdout to your UI in real time via SSE, with backpressure handling.
- [Data retention and deletion](https://miosa.ai/docs/data-retention) - What MIOSA keeps, for how long, and what "delete" actually removes for sandboxes, snapshots, the audit log, usage records, and stored data.
- [Auth-as-a-Service](https://miosa.ai/docs/data/auth) - Opt-in end-user signup, login, and JWT issuance for a sandbox or deployment.
- [Transactional Email](https://miosa.ai/docs/data/email) - Configure MIOSA-managed transactional email for project auth, password reset, email confirmation, and platform notifications.
- [Fractal enterprise data](https://miosa.ai/docs/data/fractal) - MIOSA and Fractal run dedicated Fractal instances for massive-scale structured data and computation, secure and isolated for enterprise, government, and regulated customers.
- [MongoDB](https://miosa.ai/docs/data/mongodb) - Managed MongoDB per project for document data.
- [MySQL](https://miosa.ai/docs/data/mysql) - Managed MySQL per project with durable storage and DATABASE_URL injection.
- [Data](https://miosa.ai/docs/data/overview) - Managed databases, object storage, auth, and volumes with explicit lifecycle, credentials, and recovery operations.
- [Postgres](https://miosa.ai/docs/data/postgres) - Managed Postgres per project with lifecycle controls, backup, restore, and DATABASE_URL injection.
- [Public database endpoint](https://miosa.ai/docs/data/public-endpoint) - Open a TLS-only TCP endpoint for one managed database, with an allowlist, so a laptop or an outside service can connect.
- [Qdrant (Vector Database)](https://miosa.ai/docs/data/qdrant) - Per-project vector database for semantic search and embedding storage. QDRANT_URL injected at boot.
- [Redis / Cache](https://miosa.ai/docs/data/redis) - Managed Redis per project for caching, sessions, and pub/sub.
- [Storage / Buckets](https://miosa.ai/docs/data/storage) - Per-project object storage with signed-URL uploads and downloads.
- [Volumes](https://miosa.ai/docs/data/volumes) - Persistent block storage attached to a runtime instance. State that doesn't fit in Postgres.
- [Files & Exec](https://miosa.ai/docs/develop/files-and-exec) - Read, write, watch files inside a sandbox. Run commands, stream stdout/stderr, manage processes.
- [Previews](https://miosa.ai/docs/develop/previews) - Live URLs that proxy into a sandbox port. Public, private, embeddable, share-tokenized.
- [Sandbox shares](https://miosa.ai/docs/develop/sandbox-shares) - Create a public, read-only link to a running sandbox so a teammate or an outside user can view it, and revoke the link at any time.
- [Sandboxes](https://miosa.ai/docs/develop/sandboxes) - Fast, isolated Linux VMs for code execution, builds, tests, and dev servers, with live preview URLs and snapshots.
- [Capabilities](https://miosa.ai/docs/develop/sandboxes/capabilities) - What sandboxes are for, what a sandbox is concretely, and the core exec, files, preview, snapshot, and lifecycle capabilities.
- [Connecting to a running sandbox](https://miosa.ai/docs/develop/sandboxes/connect) - Four ways into a live sandbox: the SDK, the CLI, SSH over an authenticated tunnel, and preview URLs. What each is good for, and what does not work.
- [Create and connect](https://miosa.ai/docs/develop/sandboxes/create) - Create a sandbox with the fused run endpoint or a full create, manage its lifetime in Python context managers, and connect to an existing sandbox by id or name.
- [Docker in sandboxes](https://miosa.ai/docs/develop/sandboxes/docker) - Run containers inside MIOSA sandboxes, publish ports, and reach them through preview URLs. Which templates ship Docker Engine, Compose, and Buildx.
- [Environment variables](https://miosa.ai/docs/develop/sandboxes/environments) - Set sandbox-level env at create time, inherit account-level runtime env by scope and target, and understand precedence, the per-sandbox env API, secret files, and secrets, and how a value reaches exec.
- [Sandbox events](https://miosa.ai/docs/develop/sandboxes/events) - Subscribe to sandbox lifecycle and activity events over SSE to monitor agent runs and detect unexpected exits.
- [Internet access and egress](https://miosa.ai/docs/develop/sandboxes/internet-access) - Whether a sandbox can reach the internet by default, the two layers of egress control, how to lock a sandbox to an allowlist, and how to debug a blocked call.
- [Sandbox lifecycle](https://miosa.ai/docs/develop/sandboxes/lifecycle) - The sandbox state machine from creating to destroyed, what each state means, what stop keeps, what resets the idle clock, and how to stop, pause, resume, and restart.
- [Long-running tasks](https://miosa.ai/docs/develop/sandboxes/long-running-tasks) - Work that outlives a single exec: background processes, their logs and status, always-on sandboxes, and what comes back after pause and resume.
- [Metadata and labels](https://miosa.ai/docs/develop/sandboxes/metadata) - Attach arbitrary metadata to a sandbox at create time, read it back, and use external IDs for anything you need to query or bill on.
- [Production checklist](https://miosa.ai/docs/develop/sandboxes/production-checklist) - The defaults to set on sandboxes before relying on them in production: timeouts, persistence, idempotency, templates, secrets, and event subscription.
- [Sizing and limits](https://miosa.ai/docs/develop/sandboxes/sizing) - Named sandbox resource contracts, raw resource overrides, how sandbox usage is billed, and the opt-in runner fast path.
- [Timeouts and auto-stop](https://miosa.ai/docs/develop/sandboxes/timeouts) - The sandbox active-session timeout, how to extend it, and how runtime, CPU, and network usage are measured and reported.
- [Snapshots, restore, pause, and forks](https://miosa.ai/docs/develop/snapshots) - Create durable sandbox checkpoints, restore or fork new sandboxes, and preserve work through pause and resume.
- [Templates](https://miosa.ai/docs/develop/templates) - The one sandbox image, the templates that stage content inside it, the desktop, and how to start a Next.js, FastAPI, or static project.
- [Deploy from GitHub](https://miosa.ai/docs/docker-host/deploy-from-github) - Build and publish a GitHub repository with miosa deploy create --git - connect GitHub, public and private repositories, the branch, logs, redeploys, and the webhook that rebuilds on every push.
- [The deployment model](https://miosa.ai/docs/docker-host/deployment-model) - How a publish becomes a stable production URL - the pipeline, static vs dynamic, deployments, versions, domains, and the proof contract.
- [Docker Host](https://miosa.ai/docs/docker-host/docker-deploy) - Run many small apps on one always-on workspace host while MIOSA owns routing, domains, and attribution.
- [Deployment Domains](https://miosa.ai/docs/docker-host/domains) - Preview domains, tenant deployment domains, managed fallback URLs, exact custom domains, DNS verification, automatic TLS, and route changes.
- [Environments](https://miosa.ai/docs/docker-host/environments) - Production, staging, preview/<source>: variable and secret scoping for deployments.
- [Docker Hosts](https://miosa.ai/docs/docker-host/hosts) - How a workspace Docker Host works: lifecycle states, publishing flow, proof, updates, recovery, runtime boundary, and domains.
- [Docker Host](https://miosa.ai/docs/docker-host/overview) - Your own always-on host that runs apps published from a sandbox, with immutable versions, health checks and rollback. Formerly App Engine.
- [Publishing](https://miosa.ai/docs/docker-host/publishing) - Turn a Sandbox into an immutable Deployment Version. Source snapshots, build modes, static artifacts, dynamic runtimes, Docker Host containers, public URLs, and proof.
- [Releases](https://miosa.ai/docs/docker-host/releases) - The immutable build artifact: static files or dynamic server artifact, sha256-keyed.
- [Rollback](https://miosa.ai/docs/docker-host/rollback) - Repoint a deployment at an older version. Seconds, no rebuild.
- [Dynamic Runtimes](https://miosa.ai/docs/docker-host/runtime-instances) - Dynamic deployments: production runtimes started from a release, health-checked, and reconciled by MIOSA.
- [Docker Host templates](https://miosa.ai/docs/docker-host/templates) - Curated app shapes for Docker Host - Dockerfile, Compose, command, port, environment, and persistence defaults.
- [Versions](https://miosa.ai/docs/docker-host/versions) - Immutable history of every publish. Inspect, promote, archive.
- [Evaluations](https://miosa.ai/docs/evaluations) - Measure sandbox, desktop, and agent workflows with reproducible tasks, traces, and desktop-readiness benchmarks.
- [FAQ](https://miosa.ai/docs/faq) - Short answers to the questions that come up most, grouped by topic: getting started, sandboxes and computers, agents, browser use, pricing, security, and support.
- [Agents](https://miosa.ai/docs/faq/agents) - Supported harnesses, creating and running an agent, OSA, model keys, and where agents run.
- [Browser and computer use](https://miosa.ai/docs/faq/browser-and-computer-use) - Where browser automation runs, what starting a browser returns, CDP, live takeover, and billing.
- [Business OS and internal use](https://miosa.ai/docs/faq/business-os) - Running your own company on MIOSA, connectors, device choice, and platform checklists.
- [Getting started](https://miosa.ai/docs/faq/getting-started) - Where to start, how to authenticate, install the CLI, get an API key, attach IDs to a sandbox, and pick a region.
- [Pricing and limits](https://miosa.ai/docs/faq/pricing-and-limits) - What you are billed for, paused cost, named sizes, hard caps, rate limits, and credits.
- [SOMA and runtimes](https://miosa.ai/docs/faq/runtimes) - What SOMA is, the default runtime, how to select one, access requests, and availability.
- [Sandboxes and computers](https://miosa.ai/docs/faq/sandboxes-and-computers) - Sandbox vs Computer, the default sandbox, run length, states, pausing, and snapshots.
- [Security and compliance](https://miosa.ai/docs/faq/security-and-compliance) - SOC 2, HIPAA, where data lives, how secrets are stored, retention, and publishable keys.
- [Support](https://miosa.ai/docs/faq/support) - How to get help, what to include in a request, status and changes, and the community.
- [White-label and platform builders](https://miosa.ai/docs/faq/white-label) - White-label architecture, branded URLs, end-user auth, billing your customers, and branding.
- [Forge](https://miosa.ai/docs/forge) - Git hosting built into MIOSA: a home for code written by you, your sandboxes and your agents, with deploys, pull request previews and merge rules.
- [Agents and the Forge API](https://miosa.ai/docs/forge/agents) - Use Forge from the TypeScript and Python SDKs and the REST API: repositories, files, branches, pull requests, checks and releases.
- [Forge CLI reference](https://miosa.ai/docs/forge/cli) - Every miosa forge command with an example: auth, repositories, pull requests, checks, branch policy, grants, forks and releases.
- [Forge limits and FAQ](https://miosa.ai/docs/forge/faq) - What Forge does and does not do yet: visibility, permissions, merge methods, issues, repository secrets and CI.
- [Pull requests and checks](https://miosa.ai/docs/forge/pull-requests) - Open a pull request on Forge, report checks, set branch policy and merge.
- [Forge quickstart](https://miosa.ai/docs/forge/quickstart) - Create a Forge repository, push to it with plain git and open your first pull request, in five minutes.
- [Forge from a sandbox](https://miosa.ai/docs/forge/sandboxes) - Clone and push to Forge from inside a sandbox with plain git, using the sandbox's own identity.
- [Fundamental Concepts](https://miosa.ai/docs/fundamentals) - The mental model every MIOSA integrator needs  -  workspace, authentication, resources, attribution, idempotency, rate limits, errors, and events.
- [Ownership and external attribution](https://miosa.ai/docs/fundamentals/attribution) - Canonical ownership fields, opaque external attribution, and usage rollup for platforms that resell MIOSA to their own customers.
- [Authentication](https://miosa.ai/docs/fundamentals/authentication) - API keys, browser tokens, and the five MIOSA token types with their prefixes, callers, and trust levels.
- [Events (SSE)](https://miosa.ai/docs/fundamentals/events) - Stream progress over Server-Sent Events using one-time tickets - per-resource streams, the tenant-wide stream, and the event catalog.
- [Requests, limits, and errors](https://miosa.ai/docs/fundamentals/requests) - Idempotency keys, rate limits and quota headers, and the MIOSA error envelope with its HTTP status codes.
- [Tenant configuration](https://miosa.ai/docs/fundamentals/tenant-config) - Tenant-level API surfaces for white-label integrators - webhook subscriptions and per-end-user quotas.
- [MIOSA Glossary](https://miosa.ai/docs/glossary) - Plain-language definitions for MIOSA resources, services, deployment stages, domains, on-premises infrastructure, OpenComputers, Optimal, agent workflows, data, and billing. Search by topic, study with flashcards, and link straight to any term.
- [Integrating an AI agent](https://miosa.ai/docs/guides/agent) - How to bring your own AI agent and drive MIOSA Sandbox or Computer primitives to build, run, and deploy applications autonomously.
- [What MIOSA agents can do](https://miosa.ai/docs/guides/agent-capabilities) - Built-in tools, connected app actions, device execution, artifacts, browser work, and the permission model for agents running on MIOSA.
- [Agent CLI workflow](https://miosa.ai/docs/guides/agent-cli-workflow) - The full CLI release workflow for agents: discovery, scope, sandbox development, preview, publish, promote, recovery, and rollback.
- [Agent product reference map](https://miosa.ai/docs/guides/agent-company-reference-map) - Reference products and implementation patterns for building Genspark, Emergent, Blackbox AI, Lovable, Replit, Cofounder, Polsia, Nebula, and BusinessOS-style products on MIOSA.
- [Runtime profiles and artifacts](https://miosa.ai/docs/guides/agent-company-runtime-artifacts) - The end-to-end lane from runtime profile to artifact export, the prompt-to-device flow, how env and secrets are inherited, and how agent outputs become downloads.
- [Agent device selection](https://miosa.ai/docs/guides/agent-device-selection) - Decide when an agent needs no device, a sandbox, a computer, a local device, or a deployment target.
- [Agent devices](https://miosa.ai/docs/guides/agent-devices) - MIOSA's device model for agent work: sandbox workers, computers, local devices, primary devices, persistence, and Docker Host boundaries.
- [Agent operating guide](https://miosa.ai/docs/guides/agent-operating-guide) - The CLI and release workflow for AI agents using MIOSA.
- [Agent orchestration](https://miosa.ai/docs/guides/agent-orchestration) - How to coordinate multiple agents across MIOSA sandboxes, computers, artifacts, previews, events, and deployments.
- [Orchestration examples](https://miosa.ai/docs/guides/agent-orchestration/examples) - Worked orchestration flows on MIOSA: an app builder with browser QA, a sandbox-first code agent, a computer QA agent, a minimal orchestrator shape, and the product UI pattern.
- [Orchestration patterns](https://miosa.ai/docs/guides/agent-orchestration/patterns) - Coordination patterns for MIOSA agent systems: prompt dispatch, durable run groups, subagents, sandbox-hosted orchestrators, self-configuring agents, artifact export, credentials, and permissions.
- [Agent product model](https://miosa.ai/docs/guides/agent-product-model) - The canonical MIOSA model for agents, devices, runs, tools, artifacts, credits, and deployments.
- [Agent runtime routing](https://miosa.ai/docs/guides/agent-runtime-routing) - How MIOSA routes prompts to OSA, Codex, Claude Code, Pi, Hermes, custom runtimes, and assigned devices.
- [Agent safety and status](https://miosa.ai/docs/guides/agent-safety) - How agents interpret deployment health, preserve durable resources, and respect current capability boundaries.
- [Agent workflow patterns](https://miosa.ai/docs/guides/agent-workflow-patterns) - Simple-to-complex workflows for using MIOSA agents, devices, events, artifacts, and deployments.
- [Build your own AI platform](https://miosa.ai/docs/guides/build-agent-company) - Build your own Genspark, Emergent, Blackbox AI, Lovable, Replit, Polsia, Cofounder, or Nebula-style product on MIOSA.
- [Configure an agent](https://miosa.ai/docs/guides/configure-agent) - Configure an agent's identity, instructions, model, devices, tools, memory, connected accounts, triggers, and approval policy.
- [Connect agent accounts (keys and subscriptions)](https://miosa.ai/docs/guides/connect-agent-accounts) - Connect a model key, a Claude or ChatGPT plan, or a tool-server key to your workspace, or to one of your end users, from your own code. No console visit needed.
- [Build an internal Business OS for your team](https://miosa.ai/docs/guides/internal-business-os) - Build one internal platform where your team's agents, apps, data, and workflows live together, on MIOSA. Organization and workspaces, a machine per agent, connections, secrets, RBAC, audit, and internal deployments.
- [Managed connectors for sandbox agents](https://miosa.ai/docs/guides/managed-connectors) - Attach MIOSA-managed tools like Refero to sandbox or computer agents without client-supplied vendor tokens.
- [Runtime env for agent devices](https://miosa.ai/docs/guides/runtime-env) - Define inherited environment variables for sandboxes, computers, and agent runtimes at tenant, workspace, or project scope.
- [Skills](https://miosa.ai/docs/guides/skills)
- [AWS customer-cloud regions](https://miosa.ai/docs/infrastructure/byoc/aws) - Architecture and readiness contract for running MIOSA worker capacity inside a customer AWS account.
- [Google Cloud customer-cloud regions](https://miosa.ai/docs/infrastructure/byoc/gcp) - Architecture and readiness contract for running MIOSA worker capacity inside a customer GCP project.
- [Bring Your Own Cloud](https://miosa.ai/docs/infrastructure/byoc/overview) - Run MIOSA worker capacity inside a customer AWS account or GCP project while MIOSA orchestrates the product.
- [Infrastructure options](https://miosa.ai/docs/infrastructure/overview) - Choose where workloads run: MIOSA-managed compute, on-premises servers through OpenComputers, or customer-cloud regions.
- [Shared responsibility](https://miosa.ai/docs/infrastructure/shared-responsibility) - Responsibility boundaries for MIOSA-managed, on-premises servers connected through OpenComputers, and customer-cloud infrastructure.
- [Build your product on MIOSA](https://miosa.ai/docs/integrations) - Ship a white-label SaaS where your end-users never see the MIOSA brand. Isolated compute, custom domains, branded previews, usage rollup, and webhooks  -  all under your domain.
- [Backend orchestration](https://miosa.ai/docs/integrations/backend-orchestration) - Backend patterns for dispatching prompts into MIOSA sandboxes, computers, and local devices.
- [Compute provider comparison](https://miosa.ai/docs/integrations/comparison) - How MIOSA's published compute rates compare with Freestyle, E2B, Railway and Vercel Sandbox. Competitor prices checked 2026-10-20.
- [Example Apps](https://miosa.ai/docs/integrations/examples) - Four full-stack white-label examples you can clone, run locally, and adapt to your own stack.
- [External computer providers](https://miosa.ai/docs/integrations/external-computers) - Which kinds of compute MIOSA can run on today, and why connecting a third-party sandbox or desktop provider is not offered.
- [Webhooks](https://miosa.ai/docs/integrations/webhooks) - Subscribe to sandbox and deployment lifecycle events, verify HMAC-SHA256 signatures, handle retries, and test locally.
- [Known Limitations](https://miosa.ai/docs/known-limitations) - An honest list of what doesn't work yet, what's in progress, and what's intentionally out of scope. Updated continuously.
- [Learn MIOSA your way](https://miosa.ai/docs/learn) - Learn MIOSA your way - read the basics, learn the words, or play the games - then follow five steps from zero to production.
- [Learn and earn](https://miosa.ai/docs/learn/earn) - Earn up to $100 in credits by learning MIOSA - learn the words and play the games, then pass a short final in each. The videos track pays $30 and opens when the videos are ready.
- [{title} - MIOSA Docs](https://miosa.ai/docs/learn/final/[kind]/[item])
- [Build and deploy a Next.js app](https://miosa.ai/docs/learn/first-production-app) - Build a small Next.js app in a Sandbox, preview it, publish it as an immutable Deployment, prove it is live, connect a custom domain, and roll back safely - with the miosa CLI 2.x and the SDKs.
- [Learn with games](https://miosa.ai/docs/learn/games) - Learn how MIOSA works by playing. One puzzle game for each part of the path, from the words to building a product, with no timers and wording for your level, from like I'm 9 to technical.
- [Learn with videos](https://miosa.ai/docs/learn/videos) - Every MIOSA video in one place - each topic explained through the documentation's code, and clicked through in the console.
- [Machine capabilities](https://miosa.ai/docs/machines) - What every machine ships with, its sizes, runtimes, and pre-installed tools.
- [MCP overview](https://miosa.ai/docs/mcp) - Connect OSA, Claude Code, Codex, Cursor, Hermes or Claude Desktop to the MIOSA MCP server for sandboxes, computers, deployments, storage and 151 tools across the platform.
- [Advanced MCP setup](https://miosa.ai/docs/mcp/advanced) - How the MIOSA MCP server works, per-client configuration for Claude Code, Cursor, and Windsurf, environment variable reference, worked usage examples, troubleshooting, and security considerations.
- [Tool server catalog](https://miosa.ai/docs/mcp/catalog) - Add an official tool server in one step, test its key before saving, and keep the key in the workspace vault.
- [Install and authenticate](https://miosa.ai/docs/mcp/install) - Choose the hosted MIOSA MCP endpoint or the local stdio package, create a key, and set organization context.
- [Tools reference](https://miosa.ai/docs/mcp/tools) - All MIOSA MCP tools, grouped by family. This overview covers workspaces, billing, and API keys; the tool families link to their own pages.
- [Computer tools](https://miosa.ai/docs/mcp/tools/computers) - Hosted MIOSA MCP computer tools: lifecycle, files, checkpoints, env, domains, and the desktop surface (screen, pointer, keyboard, windows).
- [Data tools](https://miosa.ai/docs/mcp/tools/data) - Hosted MIOSA MCP data tools: managed databases and object storage.
- [Deployment tools](https://miosa.ai/docs/mcp/tools/deployments) - Hosted MIOSA MCP deployment tools: deployments, Docker Host, versions, env, and logs.
- [Platform tools](https://miosa.ai/docs/mcp/tools/platform) - Hosted MIOSA MCP platform tools: computer services, cron, volumes, webhooks, functions, and regions.
- [Sandbox tools](https://miosa.ai/docs/mcp/tools/sandboxes) - Hosted MIOSA MCP sandbox tools: create, exec, files, previews, deploy, snapshots and templates.
- [Moving from Railway](https://miosa.ai/docs/migrate/railway) - Bring a Railway project to MIOSA with one reviewed plan, every environment in its own Deploy target, services created stopped, and an exact list of what carries over and what you finish by hand.
- [Moving from Vercel](https://miosa.ai/docs/migrate/vercel) - Import a Vercel project with miosa import vercel, review the plan, and what carries over.
- [Migrating from miosa-sandbox](https://miosa.ai/docs/migrating-from-miosa-sandbox) - Move off the deprecated @miosa/sandbox, miosa-sandbox, and sandboxes-go packages onto the canonical MIOSA SDKs.
- [OpenComputers](https://miosa.ai/docs/opencomputers) - Connect machines you already own to MIOSA and manage them as hosts - commands, containers, meshes, GitHub Actions runners, backups, tunnels, and devices.
- [Backups and snapshots](https://miosa.ai/docs/opencomputers/backups) - Schedule directory backups on your own hosts, keep a rolling snapshot history, and restore a snapshot onto the same host or a different one.
- [Billing and limits](https://miosa.ai/docs/opencomputers/billing) - What a plan allows on OpenComputers - hosts, containers, tunnels - and the operational caps on commands, transfers, backups, and tunnels.
- [Connect your first host](https://miosa.ai/docs/opencomputers/connect) - Install the host agent, enroll a machine, verify a command on that exact host, and configure service startup for Linux, macOS, or Windows.
- [Containers on a host](https://miosa.ai/docs/opencomputers/containers) - Run Docker or Podman containers on one of your hosts, stream their logs and resource usage, and keep docker-compose projects running.
- [Devices](https://miosa.ai/docs/opencomputers/devices) - The device model - one id-addressed surface for running commands, moving files, exposing ports, and driving lifecycle across runtime kinds.
- [GitHub Actions runners](https://miosa.ai/docs/opencomputers/gha-runners) - Register self-hosted GitHub Actions runners on your own hosts for one repository, and stream their activity from MIOSA.
- [Hosts and capabilities](https://miosa.ai/docs/opencomputers/hosts) - Inspect enrolled hosts, read their runtime and services, run commands on one host or a group, manage files, apps, compose projects, secrets, SSH keys, and clusters.
- [Meshes](https://miosa.ai/docs/opencomputers/meshes) - Link several of your hosts on a private encrypted WireGuard network so they reach each other without going over the public internet.
- [API, CLI, and SDK reference](https://miosa.ai/docs/opencomputers/reference) - Every OpenComputers endpoint group, the CLI command families that call them, and the SDK namespaces that wrap them.
- [Security model](https://miosa.ai/docs/opencomputers/security) - How the host agent connects, what MIOSA can and cannot reach on your machine, which credentials exist, and how audit and revocation work.
- [OpenComputers troubleshooting](https://miosa.ai/docs/opencomputers/troubleshooting) - Diagnose offline hosts, rejected credentials, failed commands, container, mesh, runner, backup, and tunnel problems.
- [Tunnels and exposing services](https://miosa.ai/docs/opencomputers/tunnels) - Expose a port on a host at a MIOSA-managed address, choose who can reach it, and understand what a tunnel does and does not do.
- [Recovery Playbooks](https://miosa.ai/docs/operations/recovery) - Symptom-first recovery procedures for deployments, domains, TLS, Docker Host hosts, sandboxes, and production rollback.
- [Optimal](https://miosa.ai/docs/optimal) - Optimal is MIOSA's built-in agent. Chat with it to answer questions about your workspace, build on your own sandboxes and computers, and investigate problems.
- [Optimal Engine](https://miosa.ai/docs/optimal-engine) - Optimal Engine is the self-hosted memory and knowledge engine behind a workspace - it keeps source evidence, builds reviewed memory, and returns cited context to people and agents over HTTP, a CLI, and MCP.
- [Agents and workflows](https://miosa.ai/docs/optimal-engine/agents-and-workflows) - What Optimal Engine gives an agent - a boot briefing, open loops, a daily rhythm, an operating protocol, allow, ask, or deny rules, organization policy, scheduled analyses, webhooks, and action traces.
- [Optimal Engine API reference](https://miosa.ai/docs/optimal-engine/api) - The Optimal Engine HTTP API - base URL, keys, scopes, paging, rate limits, errors, and the main routes for workspaces, ingest, search, ask, memory, claims, and operations, with curl examples.
- [Optimal Engine CLI, SDKs and MCP](https://miosa.ai/docs/optimal-engine/cli-sdks-mcp) - The optimal client CLI, the Engine's MCP server for Claude Code and Codex, the mix tasks for operators, and the TypeScript and Python clients - how to install each from the repository and point it at an Engine.
- [Optimal Engine concepts](https://miosa.ai/docs/optimal-engine/concepts) - The objects Optimal Engine is built from - tenants, workspaces, nodes, signals, source packages, claims, facts, memories, context packages, and projections - and how a source becomes reviewed memory.
- [Sources and ingestion](https://miosa.ai/docs/optimal-engine/ingestion) - Every way to get data into Optimal Engine - text, files, chat sessions, Notion exports, batch imports, and apps such as Slack, GitHub, and Linear - with the file types it parses and the limits that apply.
- [Install and configure Optimal Engine](https://miosa.ai/docs/optimal-engine/install) - Requirements, the three ways to install a self-hosted Optimal Engine (checkout, Docker, release), every setting it reads, where it stores data, embeddings, and how API keys and scopes work.
- [Memory and retrieval](https://miosa.ai/docs/optimal-engine/memory-and-retrieval) - How Optimal Engine searches (full-text, vector, hybrid), what ask and assemble return, how claims are reviewed into facts, how versioned memories work, and what the benchmark numbers mean.
- [Optimal Engine on MIOSA](https://miosa.ai/docs/optimal-engine/miosa) - Run a managed Optimal Engine on MIOSA - workspace Memory in the console, how Optimal chat uses it, the miosa engine commands, client keys for the optimal CLI and MCP server, the API, sizes, backups, and how to get it enabled.
- [Operate a self-hosted Optimal Engine](https://miosa.ai/docs/optimal-engine/operations) - Backups and restore, upgrades and migrations, size profiles and rate limits, replication between Engines, moving a workspace, erasure and retention, and metrics for a self-hosted Optimal Engine.
- [Optimal Engine quickstart](https://miosa.ai/docs/optimal-engine/quickstart) - Run Optimal Engine on your own machine, mint an API key, create a workspace, store a source, and search it - from a checkout or with Docker - plus the shortest path on MIOSA.
- [Optimal Engine troubleshooting](https://miosa.ai/docs/optimal-engine/troubleshooting) - Fixes for common Optimal Engine problems - nothing listening, health checks, keys refused, empty search, hybrid search unavailable, busy store, failed migrations, Docker health, and errors from a managed Engine on MIOSA.
- [Optimal API](https://miosa.ai/docs/optimal/api) - HTTP reference for Optimal - mint an Optimal token, create chats, send messages, stream replies, bind a machine, upload attachments, decide approvals, and read a chat's cost.
- [Approvals](https://miosa.ai/docs/optimal/approvals) - Decide which Optimal steps wait for you, approve or decline them in the chat, allow a step for the rest of a chat, and let an API key approve.
- [Brains and agents](https://miosa.ai/docs/optimal/brains) - Choose who answers an Optimal chat - the built-in Optimal model, a coding harness on your own account, or a saved agent you built in Agent Studio.
- [Chats and modes](https://miosa.ai/docs/optimal/chats) - How an Optimal chat works - the composer, Ask, Build and Investigate, attachments, queued messages, the context meter, and renaming or deleting a chat.
- [Isolation and permissions](https://miosa.ai/docs/optimal/isolation) - Optimal acts only inside your organization and workspace, with your permissions, and never on MIOSA's own keys.
- [Build on your machines](https://miosa.ai/docs/optimal/machines) - Choose the sandbox or computer Optimal works on, use the side panel to watch and steer it, publish a preview, and take over from the agent at any time.
- [Pricing and usage](https://miosa.ai/docs/optimal/pricing) - What an Optimal chat costs, how the cost strip and the Usage page report it, what happens when credits run out, and how harness brains are billed.
- [Optimal quickstart](https://miosa.ai/docs/optimal/quickstart) - Ask Optimal a question, build and preview a small app on a sandbox, then send your first message over the Optimal API.
- [Team chats and sharing](https://miosa.ai/docs/optimal/team-chats) - Optimal chats are personal until you share them with your workspace. Owners and admins can read and join members' chats, and every view is recorded.
- [Optimal troubleshooting](https://miosa.ai/docs/optimal/troubleshooting) - Fixes for common Optimal problems - no credits, no workspace, a missing machine, attachments, harness sign-in, taking over, and API errors.
- [Tasks, artifacts and history](https://miosa.ai/docs/optimal/workspace) - The Optimal sidebar pages - Tasks, Investigations, Artifacts, Approvals, History, Usage and Preferences - and what each one keeps for you.
- [Plans and limits](https://miosa.ai/docs/plans-and-limits) - The four MIOSA plans, what each includes, and the limits per service and per account.
- [Agent credit metering](https://miosa.ai/docs/platform/agent-credit-metering) - How to meter credits for MIOSA agent runs, model usage, devices, tools, storage, and deployments.
- [Agents in your product](https://miosa.ai/docs/platform/agents-in-your-product) - Give each of your users a machine with an agent or harness working inside it, and show the result in your own UI.
- [API Keys](https://miosa.ai/docs/platform/api-keys) - User and platform API keys for personal tools, backend automation, and scoped MIOSA API access.
- [Resource Ownership and Attribution](https://miosa.ai/docs/platform/attribution) - Scope resources to MIOSA workspaces and projects while preserving your own workspace / user / project IDs for billing and reconciliation.
- [Browser Tokens](https://miosa.ai/docs/platform/browser-tokens) - Short-lived scoped credentials your backend mints for end-user-facing access. Never expose `msk_*` to the browser.
- [Platform builder guide](https://miosa.ai/docs/platform/overview) - Run your users' agents, previews, and workspaces on MIOSA: architectures, costs, and provisioning patterns.
- [Platform patterns](https://miosa.ai/docs/platform/patterns) - The three architectures that cover most products on MIOSA, plus the model and backend jobs every platform shares.
- [Templates and sizing](https://miosa.ai/docs/platform/templates-and-sizing) - Pick a template and a size for each user's machine, cap concurrency, and set idle defaults so unused machines pause.
- [Usage & Billing](https://miosa.ai/docs/platform/usage-and-billing) - Track MIOSA usage per workspace, per project, per external customer, and per user. Chargeback to your customers.
- [Branding and domain setup](https://miosa.ai/docs/platform/white-label) - Configure organization slug, workspace/project ownership, preview domains, deployment domains, branding, and resource attribution.
- [Pricing and limits](https://miosa.ai/docs/pricing) - What a sandbox costs per hour, what a plan buys, how many sandboxes you can run and start, and how that compares to other providers.
- [Projects](https://miosa.ai/docs/projects) - Group the resources for one app, site, or deliverable inside a Workspace, without becoming a runtime.
- [Project lifecycle](https://miosa.ai/docs/projects/lifecycle) - Create a project, add resources, configure environments and secrets, deploy, then retire it.
- [Members and usage](https://miosa.ai/docs/projects/members-and-usage) - Project members, permissions, usage attribution, the operating checklist, and common mistakes.
- [Project resources](https://miosa.ai/docs/projects/resources) - The project record, everything that attaches to a project, and how a project maps to your own platform.
- [Quickstart](https://miosa.ai/docs/quickstart) - Install the CLI, start a sandbox, let an agent build something inside it, and open it at a live URL.
- [Agent-driven build](https://miosa.ai/docs/quickstart/agent-driven-build) - Dispatch work to your agent, stream events, and collect artifacts from your backend, tagging every resource with your own customer IDs.
- [Docker Host](https://miosa.ai/docs/quickstart/app-engine) - Run containerized applications on a workspace Docker Host host, then confirm the app is live.
- [Sandbox to deployment](https://miosa.ai/docs/quickstart/sandbox-to-deployment) - The full first walkthrough: create a sandbox, write code, preview it live, publish to production, and prove the deployment is running.
- [Rate limits](https://miosa.ai/docs/rate-limits) - The per-workspace and per-endpoint API request limits, how to read the rate-limit headers, and how to back off on 429.
- [Regions](https://miosa.ai/docs/regions) - Which regions MIOSA runs in, what is region-local, how to pin a sandbox or computer to one, and the cross-region story.
- [Sandboxes or Computers?](https://miosa.ai/docs/sandboxes-or-computers) - Pick where your app or agent runs on MIOSA: a Sandbox for code, previews and a built-in browser, a Computer for a full desktop, Docker Host to publish.
- [SDKs overview](https://miosa.ai/docs/sdks) - Official MIOSA client libraries for TypeScript, Python, Go, Elixir, Java and Rust, with package names, versions, install commands and status.
- [Egress SDK reference](https://miosa.ai/docs/sdks/egress) - Every Secrets, Connect Accounts, Network Allowlist, and Audit Log SDK method across Python, TypeScript, Go, Java, and Elixir  -  side by side.
- [Elixir SDK](https://miosa.ai/docs/sdks/elixir) - Install, authenticate and use the miosa Elixir SDK 1.1.0 - sandboxes, exec, files, snapshots, computers, agents and typed errors.
- [Go SDK](https://miosa.ai/docs/sdks/go) - Install, authenticate and use the miosa-go v2 SDK - sandboxes, exec, files, snapshots, computers, agent runs and typed errors.
- [Java SDK](https://miosa.ai/docs/sdks/java) - Install, authenticate and use the miosa Java SDK 0.5.1 - sandboxes, exec, files, snapshots, computers, agent runs and thrown exceptions.
- [Python SDK](https://miosa.ai/docs/sdks/python) - Install, authenticate and use the miosa Python SDK 2.16.5 - sync and async, sandboxes, exec, files, snapshots, computers, agents and typed errors.
- [Rust SDK](https://miosa.ai/docs/sdks/rust) - Install, authenticate and use the miosa Rust SDK 0.1.0 - sandboxes, exec, files, computers, agents and a typed error enum.
- [TypeScript SDK](https://miosa.ai/docs/sdks/typescript) - Install, authenticate and use @miosa/sdk 3.7.1 - sandboxes, exec, files, snapshots, computers, agents and typed errors.
- [Security](https://miosa.ai/docs/security) - Built-in credential vault, outbound network controls, and audit log on every MIOSA sandbox and computer. No setup. Free on all plans.
- [API keys](https://miosa.ai/docs/security/api-keys) - Create, scope, rotate and revoke the keys programs use, with the presets and limits the platform enforces.
- [Audit Log](https://miosa.ai/docs/security/audit-log) - Egress audit log for outbound calls: rows, live tail, filters and export. Capture is not yet enabled in the current release.
- [Connect Accounts (OAuth)](https://miosa.ai/docs/security/connect-accounts) - Authorize accounts (GitHub, Google, Slack, …) once. MIOSA manages token refresh; your sandbox sees an env var.
- [Network Allowlist](https://miosa.ai/docs/security/network) - Watch what your sandbox calls. When you're ready, lock it down with a one-click allowlist. Reversible.
- [Secrets  -  Quickstart](https://miosa.ai/docs/security/secrets) - Store API keys in MIOSA. Your sandbox uses an opaque placeholder. The real key never lives inside the VM.
- [Security  -  Troubleshooting](https://miosa.ai/docs/security/troubleshooting) - Top 15 issues across MIOSA Secrets, Connect Accounts, Network Allowlist, Audit Log, and White-label Credentials  -  with root causes and fixes.
- [End-user credentials and OAuth](https://miosa.ai/docs/security/white-label) - How to scope secrets and OAuth connections to your own end-users on top of MIOSA  -  with your branding, not ours.
- [Services CLI](https://miosa.ai/docs/services/cli) - Every miosa service command and flag, from create and deploy to variables, domains, releases and rollback.
- [Service settings as code](https://miosa.ai/docs/services/config-file) - Put a service's settings in a file at the repository root, so the repository says how the service runs and the console shows where each value came from.
- [Dedicated vCPU](https://miosa.ai/docs/services/dedicated-vcpu) - Run a service on vCPUs that are one hardware thread each and never shared: sizes, prices, and how to select one.
- [Services addresses and domains](https://miosa.ai/docs/services/domains) - How services reach databases while private networking is not available, the public miosa.app address a web service or static site can have, and how TLS is handled.
- [Services environments](https://miosa.ai/docs/services/environments) - Every project starts with a production environment. Fork it into staging or a preview, and switch between environments on the canvas.
- [Services logs](https://miosa.ai/docs/services/logs) - Read a service's runtime logs per replica, the build log of a release, and the events that led to its state.
- [Service metrics](https://miosa.ai/docs/services/metrics) - Requests, errors and latency per service, and what the series does not measure.
- [Edge middleware](https://miosa.ai/docs/services/middleware) - Ordered path rules and an optional function that run at the edge, in front of a server service.
- [Services](https://miosa.ai/docs/services/overview) - Run web services, workers, private services and static sites in a project, with releases, variables, domains and rollback.
- [Preview environments](https://miosa.ai/docs/services/previews) - Open a pull request and MIOSA deploys it to its own environment with its own addresses, then removes it when the pull request closes.
- [Protection and WAF](https://miosa.ai/docs/services/protection) - Put a password in front of a service, mint share links, and set the web application firewall rules the proxy enforces.
- [Services quick start](https://miosa.ai/docs/services/quickstart) - Take a repository to a live URL, add Postgres and Redis, add a worker, attach a domain, read a failed release and roll back.
- [Services releases](https://miosa.ai/docs/services/releases) - Deploy a service, follow the release state machine, read a failure reason, promote or roll back, and cancel a release.
- [Services replicas and scaling](https://miosa.ai/docs/services/replicas) - Set how many replicas a service runs, where, and how large they are, and what a scale change does to the running release.
- [Services SDKs](https://miosa.ai/docs/services/sdk) - TypeScript and Python methods for services, releases, variables, addresses and projects.
- [Services and types](https://miosa.ai/docs/services/services) - The source, settings, address and limits of a web service, worker, private service, static site, cron job and database service.
- [Static sites from Git](https://miosa.ai/docs/services/static) - Build a static site from a repository and serve it from the static lane, with an optional build command and output directory.
- [Services variables](https://miosa.ai/docs/services/variables) - Set a service's variables, reference another service's, share variables across an environment, and generate secrets.
- [SOMA](https://miosa.ai/docs/soma) - SOMA is MIOSA's own open-source virtual machine monitor, written in Rust. It gives every sandbox a hardware-isolated machine with its own Linux kernel, restored from a certified snapshot.
- [Choosing a runtime](https://miosa.ai/docs/soma/choosing-a-runtime) - Choose Firecracker, SOMA or auto when you create a sandbox with the runtime option. List the runtimes your organization offers and see what each runtime reports it supports today.
- [Support](https://miosa.ai/docs/support) - How to reach the MIOSA team, what to include so a ticket resolves fast, and where to check status and what has shipped.
- [Troubleshooting](https://miosa.ai/docs/troubleshooting) - The front door for things that are not working: sandbox, exec, preview, secret, network, and deploy failures, and where to look for each.
- [UI Components](https://miosa.ai/docs/ui-components) - Drop-in React, Vue, and Svelte components for embedding MIOSA sandboxes in your own frontend.
- [Foundation UI](https://miosa.ai/docs/ui-components/foundation) - The owned MIOSA frontend primitives used by the platform application.
- [React UI Components](https://miosa.ai/docs/ui-components/react) - Drop-in React components for embedding MIOSA sandboxes  -  MiosaPreview, MiosaTerminal, MiosaFileTree, MiosaUsage.
- [Svelte UI Components](https://miosa.ai/docs/ui-components/svelte) - Drop-in Svelte 5 components for embedding MIOSA sandboxes  -  MiosaPreview, MiosaTerminal, MiosaFileTree, MiosaUsage.
- [Vue UI Components](https://miosa.ai/docs/ui-components/vue) - Drop-in Vue 3 components for embedding MIOSA sandboxes  -  MiosaPreview, MiosaTerminal, MiosaFileTree, MiosaUsage.
- [What you can build with MIOSA](https://miosa.ai/docs/use-cases) - Concrete product patterns for MIOSA sandboxes, computers, agent runtimes, generated artifacts, previews, and deployments.

## Machine-Readable Artifacts

- [OpenAPI YAML](https://miosa.ai/openapi.yaml)
- [Docs index JSON](https://miosa.ai/docs-index.json)
- [Full docs text](https://miosa.ai/llms-full.txt)
- [XML sitemap](https://miosa.ai/sitemap.xml)