Learning Paths
Choose what you want to accomplish, then follow one path from setup to verified result.
Each path connects the detailed guides, examples, and API references already in the documentation. It gives that material a practical order and a clear finish line without replacing it.
Choose your goal
Build a Next.js app in a Sandbox, preview it, publish it, verify the live Deployment, connect a custom domain, and prepare for rollback.
Finish line: a verified public URL serving your application.
Create a Sandbox, dispatch an Agent Run, stream its progress, collect artifacts, and publish the result.
Finish line: one tracked run produces an artifact and a verified application.
Create a Computer, wait until it is ready, connect to its desktop, complete browser work, and preserve evidence.
Finish line: the agent completes a visible browser task and the session can reconnect safely.
Model customer Organizations and Workspaces, provision resources, apply your brand, route domains, attribute usage, and isolate access.
Finish line: two customer boundaries operate independently under your brand.
The shared learning loop
Every path follows the same proof-driven sequence:
| Stage | Question it answers | Required evidence |
|---|---|---|
| Choose | Which MIOSA product matches the job? | The selected resource and ownership scope are explicit. |
| Build | What is the smallest working implementation? | A copyable example completes without hidden steps. |
| See | What should appear in the UI or response? | The expected state, field, URL, or output is shown. |
| Verify | How do I know it truly worked? | A proof command or public response confirms the result. |
| Recover | What happens when the common failure occurs? | The symptom, likely cause, repair, and re-check are documented. |
| Continue | What makes this production-ready? | The next guide covers security, scale, data, policy, or operations. |
Path 1: Deploy your first production app
Recommended first- Read the Glossary for Sandbox, Preview, Release, Version, Deployment, and Domain.
- Complete Build and deploy a Next.js app.
- Read Publishing for the full immutable release contract.
- Read Deployment domains before using customer DNS.
- Read Rollback before the first production update.
You are finished when:
- The Sandbox Preview displays your application.
- The publish response contains a Deployment ID and API-selected
public_url. - Deployment proof passes.
- The public URL returns the expected application content.
- You know which earlier Version is available for rollback.
Path 2: Build an agent product
- Read What agents can do.
- Choose a device with Agent device selection.
- Follow Integrating an AI agent.
- Configure the runner with Runtime profiles.
- Add durable coordination with Agent Run Groups.
- Publish the result with Agent builds an app.
You are finished when:
- Every Agent Run has an explicit Organization, Workspace, and target resource.
- Progress events can be streamed or retrieved.
- Artifacts remain attached to the run.
- Sensitive operations wait for the required approval.
- The resulting application is verified independently of the agent’s completion message.
Path 3: Automate a real desktop
- Compare compute choices in Computers overview.
- Understand readiness in Fast start and readiness.
- Complete the Browser agent cookbook.
- Learn connection behavior in Desktop control.
- Add customer-controlled machines through OpenComputers.
You are finished when:
- The Computer reaches a usable readiness state.
- The desktop session can connect and reconnect.
- The agent completes one visible action with evidence.
- A temporary connection loss does not create a second unintended Computer.
- Ownership and access remain scoped to the correct Organization.
Path 4: Build a white-label platform
- Read the White-label SaaS walkthrough.
- Model isolation with Platform and Organizations.
- Configure White-label setup.
- Implement Backend orchestration.
- Configure Deployment domains and Browser tokens.
- Attribute and limit consumption with Usage and billing.
You are finished when:
- Each customer operates inside the intended Organization and Workspace.
- Browser credentials are short-lived and cannot act as server API keys.
- Domains route only to resources owned by the correct Organization.
- Usage is attributed to the correct customer boundary.
- A test with two customers proves that resources and data do not cross scopes.
Choose the right compute product
| Need | Start with | Why |
|---|---|---|
| Edit code, install packages, run tests, and expose a development port | Sandbox | Mutable, isolated development environment built for code and agent tools. |
| Give an agent a full graphical desktop and browser | Computer | Interactive operating system with desktop streaming and human handoff. |
| Run many workspace applications on one always-on container host | App Engine | Durable workspace host with MIOSA-owned application routing and proof. |
| Run governed workloads inside customer AWS or Google Cloud | Bring Your Own Cloud | Customer-owned cloud boundary with explicit placement and shared responsibility. |
| Connect an individual customer-controlled machine | OpenComputer | Outbound connection from one owned machine without treating it as a cloud region. |