Self-hosted dev platform · EU
Your servers.
Your team’s cloud.
A cloud VPS, a mini PC under a desk, a rack in the office — Spunto turns the machines you already own into one scheduled fleet: instant dev environments for your developers and AI agents, plus production deploys, no Kubernetes cluster to run. Nothing leaves your network.
€0 to startone docker commandno lock-in
spunto · what your team sees next
Build workspacesShip to productionRun it liveone fleet, your metal
Dev environments shouldn't live on someone else's cloud.
Codespaces and Gitpod proved the workflow. Then the invoice arrived — or compliance asked where, exactly, the code sleeps at night. Spunto gives your team the same one-click workspaces on hardware you control: your rack, your VPS, your VPC.
A fleet, not a cluster.
Point Spunto at every Linux box you own — a VPS, a mini PC, a rack in the back office — and it becomes one scheduled fleet: workspaces and production spread across whatever's free. Custom domains, automatic TLS, pre-deploy hooks, instant rollback — without adopting Kubernetes as a lifestyle.
AI agents are teammates now. Give them desks.
Every agent gets exactly what your developers get: an isolated container with the repos, secrets and lifecycle hooks — spawned over a REST API in seconds, destroyed without a trace. Run ten in parallel; they can't step on each other, or on you.
No cluster. Just a few boxes doing real work.
Most platforms cover one third of this page, and most tools that call themselves a “fleet” mean adopting Kubernetes to get one. Spunto’s bet is smaller: a lightweight agent on every box you own, a scheduler that spreads work across them, and none of the control plane you’d otherwise have to run.
01 — Build
A workspace in fifteen seconds, on whichever box has room.
Anyone on the team — human or agent — spawns an isolated container, and the scheduler places it on the least-loaded node in your fleet: a cloud VPS, a mini PC under a desk, a rack in the office, it's all the same to Spunto. Repositories cloned, secrets injected, VS Code and SSH waiting.
- spawn
- under 15 seconds, scheduled across your fleet
- editor
- VS Code in the browser, or SSH from your own
- state
- repos, secrets, dotfiles and lifecycle hooks — preloaded
- isolation
- one Docker network per workspace, zero host ports
code-server · :3000
ssh · postgres:16
agent · via API
idle — free for more
a kubernetes cluster
- control plane + etcd
- ingress controller
- yaml manifests
a spunto fleet
- one agent binary per box
- one rest api
- any linux box, mixed hardware
02 — Ship
Production joins the fleet — no cluster required.
When it's ready, ship it: Docker services scheduled onto any node you choose, a dev box or a dedicated one. Traefik routes your domain, Let's Encrypt signs it, pre-deploy hooks run your migrations — no control plane, no YAML, no ingress objects to reason about.
- deploy
- zero-downtime rollout, previous version kept for rollback
- domains
- point a CNAME, verify with TXT, TLS is automatic
- hooks
- migrations and warmups run before traffic switches
- network
- services talk by name on a private network
code-server · :3000
ssh · postgres:16
agent · via API
https://shop.acme.eu · TLS ✓
a kubernetes cluster
- control plane + etcd
- ingress controller
- yaml manifests
a spunto fleet
- one agent binary per box
- one rest api
- any linux box, mixed hardware
03 — Run
Watch the whole fleet breathe, not just one box.
Live logs, CPU and memory per node, recurring jobs with full history — aggregated across however many machines you've joined. Not a monitoring empire, just enough visibility to trust a fleet you can actually picture.
- logs
- streamed live, dev workspaces and production alike
- stats
- cpu & memory per node, continuously refreshed
- jobs
- cron or on-demand, every run's output kept
- history
- deploys and job runs, recorded and searchable
code-server · :3000
ssh · postgres:16
agent · via API
https://shop.acme.eu · TLS ✓
a kubernetes cluster
- control plane + etcd
- ingress controller
- yaml manifests
a spunto fleet
- one agent binary per box
- one rest api
- any linux box, mixed hardware
code-server · :3000
ssh · postgres:16
agent · via API
idle — free for more
a kubernetes cluster
- control plane + etcd
- ingress controller
- yaml manifests
a spunto fleet
- one agent binary per box
- one rest api
- any linux box, mixed hardware
three boxes, no cluster ↓
Your agents work here too.
Anything a human does from the dashboard, an agent does with a bearer token: spawn a sandbox, open terminals, read logs, expose a port, tear it all down. Your coding agent gets a real computer — not a browser tab pretending to be one.
- terminals
- persistent tmux sessions over WebSocket — reconnect, don't restart
- ports
- anything the sandbox listens on is reachable at an authenticated URL
- parallelism
- spawn a fleet; every sandbox is isolated from the others
Brief them where you already talk.
There is no agent dashboard to babysit. Mention one on Slack — or flip a Notion card to in progress — and Spunto hands it a fresh worker from your fleet. The proof comes back in the thread: card filed, tests green, PR open, a screen recording made inside the sandbox. Once it’s merged, the worker is gone.
- brief
- a Slack mention, a Notion status change, or a plain API call
- desk
- a fresh worker from your fleet, ready in seconds
- proof
- tests and a recorded demo, produced inside the sandbox
- cleanup
- the worker is destroyed once the PR lands
Sovereignty you can check, not just believe.
Every line on the right is an architecture decision, not a policy paragraph. The docs show how each one works.
- where code runs
- On your machines. The control plane orchestrates; it never stores your source.
- network exposure
- Zero published host ports. Each workspace lives on its own Docker bridge network.
- agent connection
- Outbound WebSocket only — no inbound firewall rules, no VPN, no bastion host.
- secrets
- AES-256 encrypted at rest, injected as environment variables at spawn time.
- ssh access
- One-time tokens with a five-minute TTL. No long-lived keys on the wire.
- exit path
- Devcontainer spec and plain Docker images. Walk away with everything, any day.
- jurisdiction
- European software. Your data stays inside whatever border you choose — including your basement.
From a bare server to a live node.
step 1
Create a node
Dashboard → Nodes → Add node. You get a token; that's all the ceremony there is.
step 2
Run the agent
One Docker command on your server. It connects outbound — no firewall rules, no open ports.
step 3
Spawn away
The node is online in seconds and joins the fleet. Workspaces, agents and production schedule onto it automatically.
What do I need to start?
Any Linux machine that runs Docker: a €4 VPS, a retired desktop, a bare-metal beast, a VM in your VPC. One is enough — add more and workspaces spread across the fleet automatically.
Is this Kubernetes?
No, and that's the point. Plain Docker under the hood, one small agent per node, a control plane that stays out of your way. Dev environments and production for teams without a platform team.
Can we leave?
Cleanly. Projects follow the devcontainer spec, deployments are ordinary Docker images, and it all runs on your hardware already. Nothing is stored in a shape only Spunto can read.
How do agents use it?
Through the same REST API the dashboard uses — spawn a workspace, run terminals, read logs, expose ports, clean up. Every endpoint is documented at /api/docs.
Can dev and prod share nodes?
If you want. You decide which nodes take workspaces, production, or both. A small team shares one box; a bigger one splits the fleet. Either way it's one platform and one bill — yours.
What does it cost?
You already own the expensive part — the compute. Spunto starts free; pricing covers team plans.
// the pitch, one last time
Bring a server.
Leave with a cloud.
docker run ghcr.io/spunto/agent — that’s the whole install.