Introduction

Spunto covers the full lifecycle of a project: build isolated dev environments, ship them as production services, and run everything with the observability you need to operate it — all on compute you control, via BYOC (Bring Your Own Compute).

Think of it as your own GitHub Codespaces, Heroku, and basic ops dashboard combined — with workers and deployments running on infrastructure you control via BYOC.

Build, Ship, Run

Spunto is organized around three things you do with a project, all on the same underlying compute:

Build

Spin up isolated workers — Docker containers running code-server, pre-loaded with your project's tools, extensions, dependencies, and git credentials, ready to use from any browser or over SSH. Workers are defined by a project (a devcontainer-compatible config: image, repos, features, lifecycle commands), and every project change is versioned so you can roll a worker back to any past config. Images are pre-built and cached per project version, so spawning a new worker takes seconds, not minutes. → Build docs

Ship

Run production Docker services — databases, web apps, background workers — as deployments: groups of services that share a private network and talk to each other by service name. Deployments live on the same BYOC nodes as your dev workers, support custom domains with automatic TLS, force-pull-and-recreate deploys with pre-deploy hooks (e.g. running a migration before the new version takes traffic), and a marketplace of one-click presets (Postgres, Redis, MinIO, ...). → Ship docs

Run

Once code is live — in a worker or a deployment service — Run is how you watch and operate it: live log tailing, CPU/memory stats, automatic detection of any port your code listens on (no config needed), and one-off jobs (migrations, cron-style scripts) with full run history. The same tooling applies whether you're debugging a dev worker or a production service. → Run docs

BYOC: your infrastructure, fully isolated

Everything above runs on compute you provide. Connect any server — a cloud VM, on-prem box, even a Raspberry Pi — as a worker node by running a single Docker command. The lightweight agent on that node connects outbound to the Spunto API over a WebSocket; no inbound ports or firewall changes are ever required.

• No host ports published — workers and services run on isolated Docker bridge networks; the agent reaches containers directly by bridge IP, and traffic is relayed back through the persistent agent connection
• Multi-node, auto-scheduled — add as many nodes as you want; new workers and deployments land on the least-loaded online node
• Org-scoped — a node belongs to a single organization; there's no shared multi-tenant fallback compute
• GCP auto-provisioning — or skip manual setup entirely and let Spunto spin up a GCE VM with the agent pre-installed

→ Nodes / BYOC docs

Other key features

• Multi-tenant — organizations with role-based access (owner / admin / member)
• SSH access — connect to a worker with your own SSH client via one-time tokens
• GitHub integration — automatic deploy keys, git credentials, and repo cloning at spawn
• AI agent ready — workers expose a full API; use them as sandboxes for AI coding agents

Architecture overview

Organization
├── Projects        (devcontainer configs, versioned)
│   └── Workers      (Build — dev containers, belong to a user)
├── Deployments      (Ship — groups of production Docker services)
│   └── Services      (one container each, shared private network)
└── Worker Nodes     (BYOC compute, running the agent)
    └── runs Workers + Deployment services, exposes Run tooling for both

Traffic flows through the platform's edge proxy → agent tunnel → container. No ports are published to the host; isolation is guaranteed at the Docker bridge network level.