Any agent. Any machine. One workspace.

Set up your projects, tooling and account connections once. Launch that same environment on any machine, hand it to whichever agent you like, and swap models — or go local — without losing any of it.

getting started the idea

experimental

suped is early, and it is not security-hardened. Treat it as a prototype.

Your agent holds real credentials for real accounts. A container is not a security boundary against a capable attacker, and suped does not sandbox the agent from the services you connect to it. An agent that makes a mistake, or is talked into one, can do anything those credentials allow.

Connect accounts you could afford to have misused. Prefer scoped tokens and separate accounts over production credentials, and give it the narrowest access that still does the job.

Anything that lets outside content reach the agent — email, chat, a webhook — is a prompt-injection surface: text written by a stranger becomes instructions to something holding your keys. Those surfaces are not built yet, and this is the problem to solve before they are.

Provided as-is under the MIT licence, with no warranty. Interfaces will change without notice while the project is at 0.x.

the idea

A headless operating system, run by a single agent of your choosing.

During setup you pick the toolset your agent gets and connect the accounts you want it to use. What you end up with is a workspace you can launch from anywhere, carrying the projects, tooling and connections you set up.

The environment grows with you. Start a project that needs tooling the workspace doesn't have and your agent installs it — and that addition travels, so your other machines gain it too. What began as a curated setup becomes yours.

It stays fast by staying thin. There is no framework to learn and no preamble to read before acting: the operating brief is sixty-eight words, and everything else is an ordinary filesystem the agent reads when it needs to. That is what lets you kill a session at any moment and have a fresh one pick up where it left off.

One agent runs the box, but that does not make it single-threaded. Your agent can install a multi-agent manager, or build one, the same way it installs anything else.

Because the environment holds the tools, the accounts and the work, it does not matter much which model is driving. Change providers, or run something local, and everything you built is still there.

available now

Suped 0.6.0 opens a persistent Ubuntu workspace with guided tool setup. It needs Docker running and Node 18 or newer. The first run builds the image locally.

Choose from 23 optional CLIs — repository hosts, deployment platforms, databases, Python, Go, Deno, Bun and the Docker client — connect your accounts, and add app connections through your agent's MCP client. Get started or upgrade your existing workspace.

set it up

Choose your tools. Connect your accounts. Hand it over.

Start the workspace. Guided setup opens on the first interactive run.
Choose your tools. Pick repository hosts, deployment platforms, databases, and an agent client. Connect the accounts and apps your work needs.
Give your agent the job. It uses those CLIs to work with repos, apps, and deployments, with the access you granted.
Come back to your work. Your home directory keeps projects, installed tools, and saved account configuration between sessions.

See setup, account status, and reconnect commands.

GitHub or GitLab. Cloudflare, Vercel, Netlify, or other hosts. Supabase, Neon, Turso, or PlanetScale. Add payments and cloud tools, then connect apps such as Notion, Linear, Figma, and Sentry through your agent's MCP client.

what's inside

Ubuntu, bash, Python, Node, and Git. A normal filesystem, a user with sudo, and tools installed under your home. Nothing you have to learn.

/home/suped/
  workspace/    where commands and shells start
  projects/     your repos            — travels
  notes/        anything worth keeping — travels
  scratch/      stays on this machine
  downloads/    stays on this machine
  .local/bin/   tools on PATH

The folders say what happens when you move. Anything you keep in a git repo under the first three comes with you; scratch and downloads are the places you can be sure stay put.

Suped prepares the workspace. The agent uses ordinary programs and files inside it. You supply the agent and the objective.

Home survives a container reset. System packages installed with apt do not. See exactly what survives what.

hand it a job

After setup, a job can start with the services already connected:

Build a project dashboard in ~/projects/dashboard.
Create a GitHub repo and deploy the app to Cloudflare Pages.
Return the repo URL and live app URL.
Save the code and run instructions in the workspace.

Setup can install Codex or Claude Code, or you can bring another agent. It prepares tools and account access; your agent creates the resources for the job. Hand over the workspace.

take it with you

Move the whole workspace to another machine — including whatever you were in the middle of.

suped move save ./my-workspace      # on this machine
suped move restore ./my-workspace   # on the other one

That brings your tools, your projects, and your account logins. It also brings the work you had not finished: files you changed but never committed turn up on the other machine exactly as you left them.

Nothing is copied wholesale. Tools are installed fresh for the machine they land on, and projects are cloned from wherever they already live, so a workspace built on a laptop works on a server.

Using more than one machine regularly? Point them all at the same git repository and each one catches up with whatever the others added.

suped state init <your-git-url>   # once on each machine
suped state sync                   # whenever you want to catch up

Logins travel encrypted, with nothing in the middle holding them. Today most services still want a quick sign-in when you arrive; GitHub does not. How moving works.

where it's going

Not built yet. Written down so you can see the shape of it.

Logins that always travel. Account access can move between machines now, encrypted and with no service in the middle, but only GitHub reconnects on its own. Every other service still wants a sign-in when you arrive. Closing that gap, one service at a time, is slow work: each one has to be proved against a real account rather than taken from its documentation.

More ways to reach it. Today the surface is a CLI. Email, chat, a local interface, a web one — each is a way to give the agent work and get something reviewable back. Read the note above first: every inbound channel is also an attack surface.

A human layer. Everything above describes a headless box. What is missing is the part where a person hands over work, sees what came back, and decides what happens next — from whatever device they happen to be holding. It is deliberately the least designed part, and it is what the rest is building toward.