Agent product reference map

This page maps public app-builder, agent-company, virtual-device, and open workspace products to MIOSA implementation patterns. Use it when you want to build a product where agents create apps, operate a business, share persistent devices, create artifacts, run browser work, publish apps, and keep working in the background.

Reference links

App builders and generated software products

These products are useful references for the user-facing loop: prompt, plan, generate files, run commands, show preview, accept feedback, version changes, and publish.

Agent-company, virtual-device, and business-operator products

What the references have in common

App-builder architecture

Genspark, Emergent, Blackbox AI, Lovable, Replit Agent, Bolt, and v0-style products are not just code generators. The durable product shape is an agent runtime wrapped around a persistent build workspace, a visible event stream, a file/artifact panel, a preview surface, and a publish path.

The key rule is that code should be created and modified inside the MIOSA sandbox when the product is an agent-builder. The user’s laptop or your backend can orchestrate, but the actual files, installs, tests, preview server, and artifact outputs should live in the assigned workspace.

App-builder implementation checklist

1. Create or resume a persistent sandbox for each app project.
2. Store the sandbox id on your app/project record.
3. Stream agent reasoning summaries, tool calls, file writes, command output, preview readiness, and deployment state.
4. Show a file/artifact panel next to chat.
5. Show a live preview frame using the returned preview URL.
6. Use snapshots before risky rewrites and after working milestones.
7. Add a browser computer only when the agent must visually inspect, log into a site, fill forms, or do human-style QA.
8. Publish from /workspace to MIOSA Deploy or App Engine.
9. Store the deployment id and version id on the app/project record.
10. Charge credits for model work, sandbox runtime, computer runtime, storage, and deploy/runtime usage.

Cofounder-style company OS on MIOSA

Cofounder describes the product around a company workspace, departments, agents, tasks, roadmap, shared library, skills, integrations, managed services, publishing, and settings. The MIOSA implementation uses your backend as the company control plane and MIOSA as the execution substrate.

Company workspace
  -> roadmap and tasks
  -> departments
  -> agent roster
  -> shared library/context
  -> connected tools and secrets
  -> assigned MIOSA devices
  -> artifacts, previews, deployments, receipts

Recommended mapping:

MIOSA BusinessOS reference

BusinessOS is the MIOSA-owned open reference for this product category. It is a self-hosted business workspace template that gives agents an actual operating environment instead of only a chat thread.

Use BusinessOS as the concrete example when explaining how MIOSA can power a customer’s own business OS, agency OS, content OS, or custom operator product.

Recommended BusinessOS-style runtime layout inside a MIOSA sandbox:

/workspace
  /agents
    founder.md
    engineering.md
    sales.md
    support.md
  /context
    company.md
    customers.md
    policies.md
  /modules
    crm/
    docs/
    tasks/
    reports/
  /artifacts
    proposals/
    screenshots/
    exports/
  /runbooks
    launch.md
    support-triage.md
    weekly-review.md

BusinessOS is also the bridge between the two major product shapes:

• for an app-builder product, BusinessOS can be the generated app or template the agent modifies and deploys;
• for an agent-company product, BusinessOS can be the persistent operating workspace where the agent departments work every day.

Founder guide implementation map

The Cofounder guide is organized around four operating loops: start, build, sell, and scale. In a MIOSA product, each loop becomes a set of agents, devices, artifacts, and approvals.

Start loop

Purpose: turn a vague idea into a specific problem, market, wedge, name, and next step.

Outputs:

• problem brief
• wedge market definition
• customer interview list
• name/domain shortlist
• first-week plan
• landing-page draft

Build loop

Purpose: move from idea to working product, repo, deployment, auth, database, frontend, tests, and production operations.

Outputs:

• product spec
• repo/files in /workspace
• preview URL
• test/build logs
• deployment URL
• run receipts
• issue/debug report

Sell loop

Purpose: build brand, website, ICP, competitor research, sales workflow, outbound, pitch, and marketing loop.

Outputs:

• brand brief
• website/landing page
• ICP definition
• competitor map
• CRM pipeline
• lead list
• email sequence drafts
• content calendar
• marketing reports

Scale loop

Purpose: improve the loops that already work: analytics, support, unit economics, expansion, and operating cadence.

Outputs:

• analytics event plan
• funnel report
• knowledge base
• support decision trees
• unit economics dashboard/report
• expansion memo
• weekly operating review

Reference architecture

Open-repo patterns to borrow

Product implementation checklist

1. Choose the product family: app builder, artifact factory, agent-company, virtual device, browser operator, or hybrid.
2. Define workspace, project, app, and company records.
3. Define departments and agent roster when the product is an operator/company product.
4. Create a primary persistent sandbox for code, files, artifacts, and builds.
5. Add optional computer for browser, dashboard, screenshot, and visual QA work.
6. Store shared company context and library artifacts.
7. Add app/project task and roadmap models.
8. Dispatch prompts into assigned agents and devices.
9. Stream tool calls, files, commands, screenshots, previews, and artifacts.
10. Add connector grants and managed secrets.
11. Add approval gates.
12. Add credit estimates and ledger entries.
13. Add snapshots, forks, and rollback.
14. Add deploy and App Engine for public apps.
15. Add recurring jobs for support, analytics, marketing, and monitoring.
16. Add audit receipts for every external action.

See also