Build a Gumloop-style agent builder

What you're building

a no-code agent-builder surface where people assemble flows of AI nodes and run them Modelled on Gumloop, by Gumloop.

A canvas of nodes (prompts, tools, data, logic) is wired into a flow; the platform runs the flow for the user and returns structured output, with reusable flows and credentials.

Primitives you'll use: Sandbox · Agent and harness · Postgres · Deployment (App Engine)

• A visual canvas of AI and tool nodes
• Flows that run on a schedule or on demand
• Structured output from each run
• Shared flows and stored credentials

Source: www.gumloop.com. Gumloop is a trademark of its owner; this guide is not affiliated with or endorsed by them.

What you need on MIOSA

Each row is one thing to create before you start. The number matches the step that uses it.

1. 1 Organization and API key Scopes every call; a workspace key is all a worker needs. miosa api-key create app-key --preset agent Docs
2. 2 Sandbox The isolated Linux workspace the agent writes code and runs commands in. miosa create app-box --template nextjs --wait Docs
3. 2 Postgres Managed relational data, injected as DATABASE_URL in the machine and in production. miosa api POST /databases -d '{"name":"app-db","engine":"postgresql"}' Docs
4. 2 A workspace per customer Isolates each customer’s machines, deployments, and data as they onboard. miosa workspace create customer-1 Docs
5. 2 Branding and white-label Your name and slug on previews, deployments, and the desktop; customers never see MIOSA. miosa org Docs
6. 2 Usage metering and bill-to Usage per customer, and which account pays for new machines. miosa org bill Docs
7. 3 Agent and harness Turns a prompt into work: pick the harness and model a run uses. miosa agent harnesses Docs
8. 5 Deployment (App Engine) Publishes the app to an immutable, versioned URL with rollback. miosa deploy create --from-sandbox app-box --name app --wait Docs

Architecture

How it maps onto MIOSA

The builder UI and the flow runner -> a MIOSA sandbox per flow run, from your control plane

Each step of a flow -> agent runs (`miosa prompt`, client.runs) streaming events that call the model and the tools you allow

Flows, versions and credentials -> managed Postgres (`DATABASE_URL`) for definitions; secrets through the Secrets API

Serving the builder to your users -> a MIOSA deployment (`miosa deploy create`), immutable and versioned

Data and storage

Flows are the product: keep the node graph, its versions, its owner and its run history in Postgres. The data a flow touches lives in your users' own systems, reached through connections they authorise.

Auth and tenancy

Your organization is the platform; customers never get a MIOSA account, they sign into YOUR product. One workspace per customer, created as they onboard, isolates their machines, runs and data.

miosa workspace create gumloop-customer-1

Tag every machine and run with the customer id in `metadata`, and never query across customers. Meter usage per customer with GET /api/v1/usage and set who pays with PUT /api/v1/bill-to (/docs/platform/usage-and-billing).

Agent loop

Harness: OSA is MIOSA's own harness and works with any model provider you connect, including your own model.

Model: Anthropic (Claude). Calls use my own provider key (`miosa connections add models`); MIOSA platform keys are never used.

Sessions: one chat per project or conversation, so the agent keeps its context. The first `miosa prompt` on a computer uses `--new-chat` (a chat id is printed); every later turn passes `--chat <chat-id>`. `--reuse chat` keeps one new machine per chat so files persist.

Streaming: follow a run with `miosa run follow <run-id>` or client.runs.streamEvents(run.id), and steer or stop it with `miosa run steer` and `miosa run interrupt`.

The canvas is yours; the run is the harness. Your runner walks the graph and dispatches each AI or tool node as a run inside the flow sandbox, so node code is isolated exactly like any other agent.

Steps

1. Create the flow runner: a sandbox per flow run so each user's run is isolated and cannot see another user's data.

   miosa create gumloop-box --template agent-node --wait

   Check: The sandbox is running and one flow run leaves no state behind for the next.

2. Store flows and their versions in Postgres: the node graph as JSON, the owner, the schedule and the last result.

   miosa api POST /databases -d '{"name":"gumloop-flows","engine":"postgresql"}'

   Check: A saved flow can be reloaded and re-run from its stored JSON.

3. Define the node types your canvas offers (prompt, model call, tool call, branch, loop, human approval) and execute them in order in the sandbox.

   miosa prompt --sandbox gumloop-box --harness osa --model <anthropic-model-id> --chat <chat-id> "Run the node graph for flow <id>; return the structured output of the final node"

   Check: A two-node flow runs end to end and returns structured output.

4. Keep per-user connections as secrets, not in the flow: a node refers to a connection by name and the runner resolves it at run time.

   miosa connections add models

   Check: A flow that uses a connection runs without the key ever appearing in the flow definition.

5. Run flows on demand, on a schedule, or from a webhook, and record each run with its inputs, output and errors.

   miosa schedule

   miosa run follow <run-id>

   Check: A scheduled flow fires, a failed run is retried without duplicating its side effects, and every run is listed.

6. Publish the builder and its API.

   miosa deploy create --from-sandbox gumloop-box --name gumloop --dir /workspace --port 3000 --run-command "npm start" --wait

   Check: The public_url serves the canvas and a saved flow runs from it.

Limits and costs

Cap nodes per flow and runs per user; a canvas invites runaway loops, so give every run `--max-time` and a step budget.

Set `idle_timeout_sec` so idle flow sandboxes pause, and reuse one warm sandbox per active user.

Treat each connection as a secret: the flow stores a name, the runner resolves the value.

Prototype: keep it to one machine at the default size, skip replicas and custom hostnames you do not need, and delete everything when you are done.

Acceptance checks

A user builds a flow on the canvas, runs it, and reads a structured result.

A scheduled run fires and is recorded with its output.

One user's flow cannot reach another user's data or connections.

Each customer is isolated in its own workspace and usage is metered against them.

Everything it created can be deleted with nothing left running.

Next steps

• Agent prompt builder Pick a product shape and hand the brief to your agent.
• Run coding agents Run Claude Code, Codex or Cursor in the cloud, or build a product on them.
• Compare MIOSA How MIOSA compares to other sandbox and agent platforms.
• What you can build Every product pattern MIOSA supports.