throughthewire.dev

How it works

What runs where, what a workspace can and cannot reach, and where it can run for you.

The shape of it

Three pieces. The hub serves the page and logs people in. A node is any Linux box with nested virtualization, and runs the workspaces. Each workspace is a microVM built from an ordinary container image.

browser https login SSO hub the node connects out — no inbound port node — any Linux hostwith nested virtualization gateway workspace own kernel workspace own kernel isolated bridge filtered outbound only

What a workspace is

You name an image — golang:1-trixie, python:3-trixie, your own — and the node pulls it straight from the registry, turns it into a disk and boots it as a microVM with its own kernel. Inside, a small server runs tmux in a pseudo-terminal; the terminal emulator itself runs in the browser as WebAssembly.

Workspaces keep their home disk between restarts, can share a volume, and stop themselves when nobody is attached. The things people usually need — git identity, tokens, environment variables — live in profiles that a workspace picks up at start, so no secret is baked into an image.

An agent gets the workspace's keys, never yours

An agent needs credentials to be useful, so it usually runs where they already are, on someone's laptop or a shared runner, and inherits everything that person can do. Here, keys live in profiles: each holds variables and secrets, and a workspace attaches only the profiles its job needs. Whoever starts it, admin or not, the agent gets those and nothing else.

The usual way

It runs in a session that already has keys.

  • deploy:prod
  • db:write
  • org:admin

Whatever the person could do, it can do.

Here

The workspace agent-support attaches two profiles.

  • github-readonlyGITHUB_TOKENGIT_AUTHOR_NAME
  • npm-registryNPM_TOKENNPM_CONFIG_REGISTRY

An admin pressing start hands over these, never their own. Secrets reach the machine once, at boot, in memory: never the node's disk, and the hub only ever shows their names.

Develop where your code is built

Laptops drift from the environment code is built and shipped in, and that gap is where "works on my machine" comes from. Here you start from any image, your CI build image for example, and the hub injects the devtools you've defined into it: your editor, your shell, your helpers. Seconds later you're developing, or chasing a failed build, inside the environment your code is built and validated in, with your own tools. A new engineer gets the same setup on their first day.

The image

ghcr.io/acme/ci-build:1.42

Any image, such as the one CI builds in: same compiler, same libraries, same OS.

Your devtools

  • LazyVim
  • lazygit
  • ripgrep

Defined once, injected into any image you pick.

A workspace

Ready in seconds

The environment your code ships from, with your tools in it. Nothing to install in the image, nothing to rebuild.

What it cannot reach

This is the part that matters if you are pointing an agent at it. The boundaries are enforced on the host, not by anything inside the workspace, so code in the workspace cannot talk its way out of them.

The worryWhat stops it
Code escapes onto the host Each workspace is a virtual machine with its own kernel, not a container sharing yours. An escape means getting out of the microVM's minimal device model and KVM.
It reaches your network Outbound traffic is an allowlist: DNS and HTTPS by default. Private ranges, your tailnet, cloud metadata, Docker networks and loopback are refused unless you name them. The network policy can be adapted to your needs.
It reaches another workspace Bridge port isolation blocks workspace-to-workspace traffic at layer 2, and firewall rules block it again at layer 3.
It reaches the node itself Workspaces cannot open connections to the host — not SSH, not the gateway, not the Docker socket. That also takes the pain out of building container images: in Kubernetes-based infrastructure it usually means mounting the host's Docker socket or running privileged containers on a shared kernel. A workspace has a kernel of its own, so it runs its own Docker and builds images without touching the host.
Something reaches in from outside Workspaces are not routable from outside, and the node needs no open port: it dials out to the hub. Each workspace also has its own random token.
One person sees another's work Every user gets their own namespace for workspaces, volumes and secrets. The hub verifies the login itself and maps every name into that user's prefix.
A bad image walks over the host Images are unpacked with every path resolved inside the VM's own root, so symlinks and .. cannot climb out. Every blob is checked against its digest.

Why this suits agents

An agent that can run commands is useful in proportion to how much you let it do, and risky for exactly the same reason. The usual answer is to review every command, which throws away most of the benefit.

The other answer is to make the blast radius small enough that you stop caring. A workspace has no path to your network, no cloud credentials to find, and nothing in it you can't rebuild from an image. If an agent destroys it, you have lost a machine that took seconds to make. You can hand it the keys and let it work.

Where it runs

Fully managed by us, on your own hardware, or split between the two: we run the control plane, and the workspaces run on your machines. A node is any Linux box with nested virtualization, and because it connects out to the hub rather than waiting for connections, it can sit in an office, a rack or a cloud account without being exposed.

Which setup fits depends on your team, your compliance needs and where your code already lives. Talk to us and we'll work it out with you.

Want to see it run?

Book a demo and we'll walk you through it on a real node, and help you work out where it should run.