YOUR SERVERS. PERSISTENT ENVIRONMENTS. ONE CONTROL PLANE.

Self-hosted infrastructure
for coding agents.

Move ⁠Claude, ⁠Codex, ⁠Antigravity, ⁠Pi and 23 more agent CLIs to your remote servers, inside persistent, isolated ⁠Docker workspaces. Claude Code and Codex can also use models through ⁠OpenRouter, ⁠Vercel AI Gateway or ⁠LiteLLM. Leave them running. Manage sessions, accounts, files and resource access from one console — with separate environments for every developer.

YOUR COMPUTE
Any host over SSHHTTPS / WebSocket (WSS)

Connect your console over HTTPS/WSS and explicitly pair local Docker. Continuous folder sync over WSS is available; on macOS it is verified with OrbStack, while Docker Desktop file sharing is not yet measured.

LOCAL EXECUTION
Local Docker
CLOUD VMs
DigitalOceanFly MachinesHetzner CloudHostmanLinodeProton ComputerVultr
SANDBOXES
Agent37BeamBoatboxdCelestoCloudflare Sandboxes (Containers)CreateOSDaytonaDigitalOcean Harness RuntimeE2BEmbedded agentOSFreestyleInstaBoxMaritimeModal SandboxesPrizedRailway SandboxesRender SandboxesSandboxerSuperserveTenki SandboxUpstash BoxVercel Sandbox
Install on
YOUR COMPUTER. ONE COMMAND.
curl -fsSL https://devctrl.dev/install.sh | sh

Use Docker on this computer. Requires Docker Compose, Node.js, Python and Git; no remote server or SSH. Add accounts and projects in the local console.

EVERYTHING YOUR AGENTS NEED TO WORK.
INFRASTRUCTURE CONTROL

Move the load off your laptop.

Keep repositories, dependency installs and long-running tasks on your servers. Run your control plane there too, so sessions and browser access stay available when your laptop is offline.

devctrl / recorded TUIREAL UI

Loading the recorded terminal…

See setup and daily operations

FROM ONE SESSION TO MANY

More projects.
Less infrastructure to juggle.

A growing stack of terminals, SSH connections, dependency trees and credentials makes every new session harder to manage.

devctrl prepares the remote workspaces, keeps sessions organized and brings files, access, updates and cleanup into the same workflow.

AGENTS AND MODELS

27 coding agents.
One place to run them.

devctrl runs every agent below in the same persistent workspaces on your servers. Files, resources, approvals and session history work the same for all of them. What differs is how much devctrl manages inside the agent: accounts, quota and models for the first three, launch and resume for the rest.

FULL SUPPORT · 3 AGENTS

⁠Claude, ⁠Codex and ⁠Antigravity.

Sign in with your own accounts, see quota and reset times, pick the model from the installed CLI and continue on another account when one runs out. Sessions get the devctrl MCP tools and Project messaging.

ACCOUNT → MODEL → SESSION
MODELS · PAY PER REQUEST

Use a model gateway instead of a subscription.

Claude Code and Codex accounts can run through one of these gateways (Cloudflare AI Gateway: Claude Code only). The key stays encrypted in the controller; sessions get a model allowlist, recorded cost and an optional monthly budget.

  • ⁠OpenRouter
  • ⁠Vercel AI Gateway
  • Cloudflare AI Gateway
  • Requesty
  • Portkey
  • ⁠LiteLLM
Model gateway accounts
BASIC SUPPORT · 24 MORE AGENTS
  • ⁠Pi
  • ⁠OpenCode
  • ⁠Gemini CLI
  • ⁠Qwen Code
  • ⁠GitHub Copilot CLI
  • ⁠Cursor Agent
  • ⁠Kimi Code
  • ⁠Kilo Code
  • ⁠Hermes Agent
  • ⁠OMP
  • ⁠Mastra Code
  • ⁠Factory Droid
  • ⁠Devin CLI
  • ⁠Qoder CLI
  • ⁠Letta Code
  • ⁠Grok Build
  • ⁠Amp
  • ⁠Kiro CLI
  • ⁠Cline
  • ⁠Maki
  • ⁠Command Code
  • ⁠Crush
  • ⁠Muse Code
  • ⁠Prime Agent

devctrl installs, starts and resumes each of them in a managed workspace; all 24 passed that check on Linux x64. These are partial adapters without quota tracking. ⁠Pi, Gemini CLI and Qwen Code sessions also get the devctrl MCP tools and Project messages. Run more agent CLIs

Messages, delegated tasks and handoffs that one agent sends to another are screened before delivery. By default, binaries, encoded data and code-like content wait for your approval.

01 / INFRASTRUCTURE CONTROL

Your servers.
Your choice of compute.

Run the controller and browser gateway on a server you control. Keep repositories, workspace data and credentials on the infrastructure you choose.

Connect an existing server over SSH or use a console link over HTTPS/WSS. Pair local Docker for local execution. Cloud adapters provision compatible hosts; sandbox adapters expose separate API environments. Docker-managed sessions require a Docker-capable adapter. Choose your compute

A modest laptop can control many remote sessions. Dependency installs, containers and background jobs use the servers’ CPU, memory and disk; your computer only needs to run the client.

Your terminalYour browser
↓
SELF-HOSTED ON YOUR SERVERdevctrl controllerusers · projects · accounts · resources
↓
Existing hostSSH / your hardwareCloud machineyour provider accountSandboxoptional / disposable

SESSION → WORKSPACE → COMPUTE
Your infrastructure runs the work.

WAYS TO RUN IT

From one laptop
to a team server.

Put Core, Hosts and consoles where they suit your work: everything on a laptop, agents on a server while Xcode builds on your Mac, or one server shared by a team. Each configuration shows what runs where.

SOLO · ONE LAPTOP

Everything on one laptop

For trying devctrl or working solo, with no server to set up.

LAPTOP → LOCAL DOCKER → AGENTS
SOLO · ONE SERVER

One server for all your sessions

For one developer who wants agents to keep working while the laptop is closed.

LAPTOP / PHONE → SERVER → WORKSPACES
CLOUD · HOME NETWORK

A home server with no public IP

For a machine behind a home router, reached from a phone or laptop on any network.

PHONE → EDGE → ENCRYPTED TUNNEL → HOME SERVER
CLOUD · SEVERAL SERVERS

Several servers, one devctrl Cloud account

For one person with a home server, an office server and a GPU box.

SIGN IN ONCE → EVERY SERVER → ITS OWN ADDRESS
CLOUD · TEAM ORGANIZATION

A team organization on devctrl Cloud

For a team that signs in to its servers with one account per person.

INVITE → MEMBERS → SIGN IN WITH DEVCTRL CLOUD
CLOUD · CONTRACTORS

Contractors see only their servers

For giving a contractor or client access to some of your servers, not all of them.

INVITE → ADD TO ONE SERVER → OTHERS STAY HIDDEN
APPLE PLATFORMS · MAC + SERVER

Agents on the server, Xcode on your Mac

For iOS and macOS developers whose builds and simulators need a Mac.

AGENT EDITS → LOCAL COPY → XCODE BUILD
MIXED · TWO HOSTS

Your Mac joins the server as a Host

For keeping quick sessions on the Mac and sending heavy work to the server.

ONE CORE → TWO HOSTS → A HOST PER PROJECT
TEAM · SHARED SERVER

One server for a whole team

For several developers sharing compute without sharing environments.

USER → OWN PROJECTS → OWN CONTAINERS
ELASTIC · CLOUD + SANDBOXES

Burst to cloud machines and sandboxes

For running many temporary tasks in parallel without buying hardware.

CORE → PROVIDER API → TEMPORARY HOSTS
TWO CORES · FEDERATION

A personal Core linked to the company’s

For keeping your own installation separate while its agents work with a team’s.

PAIR → LINK A PROJECT → MESSAGE ACROSS CORES

02 / ISOLATED ENVIRONMENTS

A workspace that lasts
as long as the work.

Keep the checkout, dependencies and session data together in a persistent ⁠Docker workspace. Configure its folders, credentials and service access, then leave the coding session running.

REUSABLE WORKSPACES

Stop preparing the same environment.

Use the managed runtime or a supported devcontainer.json; the Host creates the container itself through the Docker API. Every new coding session gets its own working directory and Git branch. Reuse a compatible container, or start another for separate processes and resources.

REPOSITORY → RUNTIME → PERSISTENT STORAGE
FILES, SERVICES AND SECRETS

Connect only the resources it needs.

Attach selected local or remote folders with read-only or read/write access. Grant fixed-target service routes and deliver selected runtime secrets. MCP tools and skills show agents the resources already configured.

MOUNTS + ENDPOINTS + CREDENTIALS → PROJECT

Control access through container boundaries, folder permissions, runtime credentials and enforced Internet allowlists. New or rebuilt restricted workspaces keep required agent endpoints reachable on rootful Docker 28+ or Rootless Docker 29.9.1+.

03 / TEAM INFRASTRUCTURE

Shared servers.
Separate environments.

Give developers access to shared compute, with private projects, accounts, storage and containers for each person. Manage the team’s infrastructure from one server console.

USER ISOLATION

Private containers for every developer.

Each user’s work runs in separate containers, account homes and storage. Teammates can work on the same repository in their own environments.

USER → OWN PROJECTS → OWN CONTAINERS
PRIVATE CREDENTIALS

Personal accounts stay personal.

Connect your own ⁠Claude, ⁠Codex, ⁠Antigravity and Git accounts. Runtime credentials go to your workspaces, and private session history stays with you.

ACCOUNT → OWNER → RUNTIME CREDENTIALS
SHARED SERVICES

Connect once. Share selectively.

Publish selected APIs, databases, folders and model endpoints to the team. Grant access per project while keeping each developer’s containers and credentials separate.

RESOURCE → USER ACCESS → PROJECT GRANT
AGGREGATE BUDGETS

Give each user a resource budget.

Plan CPU, RAM, storage and workspace capacity across all of a developer’s containers. Track measured use alongside reservations and enable hard caps on supported hosts.

USER BUDGET → ALL OWNED WORKSPACES
04 / AGENT OPERATIONS

Know what’s running.
Keep the work moving.

See every ⁠Claude, ⁠Codex and ⁠Antigravity session by project, account and host. Find work waiting for input, check quota and continue from another eligible account when needed.

Send context, connect resources and manage updates and cleanup alongside the sessions. Detach and return from the terminal or browser while the server keeps working.

Open the Task Graph to follow each session: the plan its agent reports, one line per conversation turn and what is waiting for you. Follow what each agent is doing

Leave the agents working. Let Overnight turn the server off. Enable it before you leave; when every session finishes or needs your input, devctrl shuts down eligible cloud compute through its hosting adapter. Set up Overnight

From your Mac, choose between two remote servers for different projects. Leave sessions running when you disconnect, return to the same workspace, and grant access to the specific services each project needs. Docker containers share the host kernel; a separate worktree separates working files, not infrastructure.

Run doctor for configuration and telemetry checks without an AI account. Inspect repository technologies, partial parser coverage and suggested skills before activating a pinned bundle. Additional analysis uses an explicitly assigned, admitted Control Room account; unavailable checks stay visible. Diagnostics and technology coverage

PROJECTAGENT / ACCOUNTRUNNING ONSTATE
atlas⁠Claude / personalremote / dev-01● working
ledger⁠Codex / workremote / dev-02◇ needs you
api-lab⁠Antigravity / clientsandbox / experiment✓ ready
CONTEXT + RESULTS

Give agents context.
Get their work back.

Drop screenshots, documents or datasets into a remote workspace. Download reports, builds and archives from your browser. Enable a two-way folder mirror when you want files synchronized with your computer.

reference.pngYOUR SCREENSHOT
→EXCHANGE←
▣atlas / workspace⁠Claude · ⁠Codex · ⁠Antigravity
▧result.zipBACK TO YOU
CONNECTED RESOURCES

The right access.
For each project.

Connect APIs, databases, model endpoints, GPU hosts and folders once. Give selected projects the resources they need, with read-only or read/write folder access and connection health in view.

Need a custom connection? Write a gateway in TypeScript or another runtime. Register it on your host and grant selected projects access. Your integration code stays outside devctrl. Build your own gateway

Built-in MCP tools and skills tell agents how to use configured connections. Review additional access requests in the console and deliver approved changes to the running session.

Private APIremote machineModel endpointGPU hostShared folderlocal disk / SSH host
PROJECT GRANT → MCP + SKILLS → AGENT
atlas ✓ledger ✓api-lab —
SEARCH + ARCHIVE

Find past work.
Keep it recoverable.

Search running, frozen and stopped ⁠Claude and ⁠Codex sessions by words or by meaning, then open the match, restore the session or hand the work off. Choose a local embedding model or your own provider key. Search your sessions

Archive ended sessions to your own S3 storage under a dedicated encryption key. Free local history once the copy is verified, and restore it when you need it. Core also writes a complete copy of its database every day. Archive and restore sessions

Import local Claude Code and Codex sessions directly into devctrl Cloud or your own S3 bucket. Connect multiple buckets and choose the default for new imports. See the project and repository for each import and download the original history. Continue an imported session on a managed Boat sandbox using your subscription.

AUTOMATION + CONTROL

Script it. Schedule it.
Attach to it.

Every devctl command that reaches the controller is also a typed MCP tool with the same authorization, so Control Room and your own agents can manage schedules, reviews, hosts and Projects directly. Drive devctrl through MCP

Run a schedule now without moving its next slot. Attach your own terminal to a session’s tmux with devctl remote-terminal, and complete commands in bash, zsh or fish. Attach to a session

THE SAME DEVCTRL. ANOTHER WINDOW.

Your sessions,
within reach.

Start sessions, choose repositories, connect resources and move files with browser controls. Review changes as a folder tree, edit session names and manage CLI updates. Desktop and mobile use the same React screens and authenticated server API.

Host the controller and gateway remotely to keep the console available when your laptop is offline.

INTERACTIVE DEMO

Explore the sample projects, accounts, files and access requests. Live sessions and file transfers are available in your own console.

Desktop app

Coming soon

Mobile app

Coming soon

Everything around the session, in one place

Your compute

Move the load off your laptop.
Keep repositories, dependency installs and long-running tasks on your servers. ▶ Release video 0.12.0
Leave sessions running. Resume the task.
Disconnect from your AI agents and return to the retained session. ▶ Release video 0.34.0
Reuse a container or isolate a task
Every new coding session gets its own working directory and Git branch.
Share servers. Keep users separate.
Put the team’s compute to work without mixing private environments.
Manage team access without taking over accounts
See whether each server user is invited, active or disabled. ▶ Release video 0.4.0
Let teammates start sessions in your repository
Grant server users or groups the right to start sessions in a repository, Project group or repository set, separately from session sharing.
Set up tools under a limited server account
Connect a fresh Ubuntu/systemd server with root SSH.
Use disposable compute for temporary tasks
Choose an optional sandbox adapter for temporary work.
Place each user’s work on the right storage
Inspect workspace paths and retained roots per host.
Cap CPU and memory where the work runs
Set optional CPU and memory limits per Project group, repository or session. ▶ Release video 0.4.0

Workspaces and access

One task across your repositories.
Give one agent the API, frontend and services it needs.
Give projects the resources they need
Connect APIs, databases and model endpoints once.
Internet access with an enforced boundary
New or rebuilt managed ⁠Docker workspaces restrict public HTTP/HTTPS access to approved hosts while keeping required agent endpoints available. ▶ Release video 0.13.0
Move files and connect storage
Drop in screenshots or datasets, download the results, and attach host-local, SSH or S3 folders with read-only or read/write access. ▶ Release video 0.21.0
Bring local-only work to the server
Connect a local folder to a server Project and devctrl collects its local branches, stashes, uncommitted work and ⁠Claude sessions.
Start projects from your repositories
Browse ⁠GitHub or ⁠GitLab repositories and prepare a remote project. ▶ Release video 0.19.0
Let agents use configured integrations
Built-in MCP tools and skills help sessions discover resources and request access.
Bring your own gateways
Write a gateway in TypeScript or another runtime, register it with a host service definition and grant selected projects access.
Keep account routes separate
Choose an HTTP, SOCKS5 or existing VPN-gateway route for each account.
Connect services across your hosts
Grant a workspace access to a specific service on another owned host; membership alone grants no traffic, and observed connection health stays visible.

Sessions and accounts

Freeze a session. Keep the context.
Stop an agent and keep its conversation, account, profile and last terminal screen.
Limit account choices for each Project.
Set administrator ceilings for agent and Git accounts, then narrow choices per Project or repository.
See quota before starting work
Compare reported five-hour and weekly usage, reset times and elapsed windows, including ⁠Antigravity’s shared model groups.
Choose account models. Keep work moving.
Select defaults from the installed agent’s model list.
See which sessions need an answer
Choose which visible sessions add attention markers: questions, permission requests, idle agents or exhausted quota. ▶ Release video 0.16.1
Understand what a session is waiting for
See active tool calls as working, separately from reported background work, questions, permissions, provider errors and blocked goals. ▶ Release video 0.16.1
Name sessions. Follow subagent work.
Rename sessions without interrupting them.
Follow what each agent is doing
Open Task Graph to see what each session is doing: the plan its agent reports, one row per conversation turn and the steps behind them. ▶ Release video 0.7.0
Let agent sessions message each other
Sessions of the same owner in one Project send each other messages through the devctrl MCP, across hosts.
Track goals by completed tasks
See native ⁠Claude and ⁠Codex goals beside their sessions.
Review changes and results by project
Browse changed files as folders, inspect saved session results, tests and artifacts, and export a patch from the selected repository.
Share one session by link
Let someone view a running session in their browser without a devctrl account.
Reuse session setups across tasks
Save launch recipes for agent, account and integrations.
Read progress without opening every terminal
⁠Claude can report task status through its verified background /btw command.

Tools and maintenance

Keep agent CLIs up to date
Review release notes and update managed agent CLIs inside existing containers.
Add Cursor Agent and Grok Build
Install the Cursor Agent and Grok Build CLIs in managed workspaces from pinned, digest-checked packages.
Run more agent CLIs
Besides ⁠Claude, ⁠Codex and ⁠Antigravity, start 24 more agent CLIs in managed workspaces, including ⁠GitHub Copilot CLI, Cursor Agent, OpenCode, Gemini CLI, Qwen Code and Grok Build.
Choose optional workspace components
Select optional tools in a template, prepared image or running container.
Keep useful context. Cut noisy output.
Filter noisy output, find relevant code and query a persistent repository graph with RTK, sgrep, ast-grep, Repomix or Graphify.
Compact context after completed work
Enable automatic compact globally or for a project or session.
Check disk use. Clean up finished tasks.
See project, container and session disk sizes. ▶ Release video 0.17.0
Choose models for delegated work
Choose a hosted Decisions API or your own compatible server.
Know what changed in each container
Review tooling updates by container: who requested them, which versions were found and whether each update succeeded.
Review the model for the main task
Set independent Decisions API policies for session start, resume and capacity recovery.
Choose skills for your stack.
Match package manifests to curated skill links, keep project defaults and override repository choices.

Visibility and automation

See where the work goes
Compare daily activity, recorded tokens, commits and changed lines by project or repository. ▶ Release video 0.7.0
See where server capacity goes
Inspect CPU, RAM and disk I/O over time for hosts and containers in the Dashboard. ▶ Release video 0.4.0
Recognize memory failures and pressure
See kernel-confirmed OOM failures and measured RAM pressure, even while your client is offline.
Remember the task you approved
Review an editable task intent for a repository or Project group. ▶ Release video 0.26.0
Follow an update through recovery
See actor stages, elapsed activity and measured progress while the shared console stays open.
Plan a whole-system update
Check the latest product version from the changelog view.
Keep the control plane fast under load
Console polls receive only the parts of the state that changed, and Hosts reconcile at a pace that follows their load.
Chat with your server operator
Keep server administration outside coding projects. ▶ Release video 0.41.0
Run prompts on a schedule
Save recurring prompts with cron rules and an explicit timezone.
Tell each session how its CI ended
Track ⁠GitHub Actions runs and check runs for the commits each session pushed.
Overnight: finish the work, then shut down
Enable Overnight before you leave.
Save workspaces and session history to S3
Overnight saves encrypted, verified archives of workspace files and native conversation history, with an index of saved work.
Archive any session. Restore it when you need it.
Keep encrypted copies of ended ⁠Claude and ⁠Codex sessions, or a snapshot of a running one, in your S3 storage under a dedicated archive key.
Check in through ⁠Telegram, ⁠Slack or ⁠Teams
Connect an optional messenger bot to inspect sessions, send prompts, receive attention notifications and review access requests.
Use ChatGPT as your operator interface
Connect an optional OpenAI Secure MCP Tunnel to the server operator API.
Give external MCP clients a narrow view
Optionally let ⁠Claude connectors, Cursor and other OAuth 2.1 clients list granted Projects and sessions, read task graphs or send text to a running session.
Drive every command through typed MCP tools
Every devctl command that reaches the controller has a Control Room and operator MCP tool with the same name, schema, route and authorization.
Harden the boundaries agents can reach
Keep credentials out of process arguments and search indexes, create containers without third-party tooling and expire links that grant terminal control. ▶ Release video 0.41.0
Trace changes and export the journal
Browse durable operations, access and lifecycle events in independent pages.
Keep operational history under control
Set separate retention limits for audit events and completed command results.
Delegate tasks and retain their results
Delegate bounded work across supported coding agents; inspect the target session, result and cleanup under an enabled execution policy.
Keep required review checks enforceable
Preserve required skills and checks for a fixed code snapshot; the server keeps incomplete review evidence from becoming a passing gate.
Understand current problems and verify safe fixes
See current problems grouped by affected target, with impact and observed versus expected state.
Inspect your repository technology evidence
Inspect declared technologies, versions and component evidence from bounded static scans; unsupported formats and missing sources remain explicit.
Connect issues to tasks and review
Link tracker issues to implementation tasks and review records; successful result delivery requires the current gate and configured write permissions.

Your console

Open a desktop window onto your server
Open the console in a desktop window or connect the local TUI through a private console link.
Attach your own terminal to a session
Open a session’s tmux directly from your shell with devctl remote-terminal, over SSH when the Host is remote, or print the exact command instead.
See why a session is taking time to open
Watch the actual connection, authorization, workspace, agent and terminal stages with elapsed time.
Keep the controls you use
Hide unused menu sections and arrange the rest to suit your workflow.
Make the console fit your workflow
Rebind console commands in Settings.
Hear when a session needs you
Enable local sounds for questions, permission requests and new MCP approvals.
Use the console in your language
Choose from 14 interface languages and keep your saved preference across clients.

Installation currently requires authorized source access. An anonymous GitHub source download was unavailable at the latest check. Read setup and source-access requirements.

05 / HOW IT WORKS

One command.
Your first remote workspace.

  1. 01 / SET UP YOUR SERVER

    A repository or folder. An SSH destination.

    Setup adds missing server dependencies, prepares the controller and workspace, and imports only the accounts you select. A repository URL leaves just a small Python/SSH launcher on your computer. Pass a local Git folder instead to read its remote and automatically install the Exchange sync client too.

    curl -fsSL https://devctrl.dev/install.sh | sh -s -- 'https://github.com/devctrldev/devctrl.git' 'remote-server'
  2. 02 / OPEN YOUR CONSOLE

    Your terminal. Or your browser.

    The TUI runs on the server over SSH; the browser connects to the server’s gateway. Neither needs local Docker. Disconnect your laptop and the controller, web console and coding sessions stay online.

    devctrl tui remote
    devctrl web remote
  3. 03 / LOCAL FOLDERS AND COMPUTE

    Sync folders. Add local compute.

    Started with a local Git folder? Its agent-interchange sync is already configured. Started with a URL? Add the same client whenever you want. It pulls a prebuilt Docker image and needs local Docker plus an unlocked SSH agent. No local controller; browser uploads and downloads need no helper.

    devctrl client install

    To run workloads on your computer too, explicitly connect local Docker as an execution host. Only this additional module gets access to its Docker socket.

    devctrl host install local

Start with an Ubuntu server and working SSH access. Optional folder sync requires local Docker, an unlocked SSH agent and trusted host keys. Local client setup and boundaries

YOUR AGENTS. YOUR INFRASTRUCTURE.

Put your server to work.

Give your agents persistent remote workspaces. Start with one repository and server, then add projects, developers and resources from the same console.