CHOOSE YOUR AGENT INFRASTRUCTURE

Run the sessions.
Own the infrastructure.

Put ⁠Claude, ⁠Codex, ⁠Antigravity, ⁠Pi and 23 more agent CLIs in persistent, isolated workspaces on your servers. devctrl prepares the containers, connects project resources and gives each developer a private environment — with sessions and operations in one console.

AT A GLANCE

Key features

Choose a product to compare hosting, isolation, files, teamwork and operations.

  • Yes
  • Limited
  • With extension
  • Manual setup
  • Unavailable / unverified
Amika comparison

Agent VM workstations on your machines or cloud accounts with private connectivity. Current CLI operations use the hosted control plane; a complete supported self-hosted control plane is not established.

Sources: Amika: own-compute VMs and private networking · Amika: open components, hosted control plane and Rig interfaces · Amika: removed local CLI mode and current self-hosting limitations
Key features: the same properties for devctrl and Amika
FeaturedevctrlSelf-hosted control planeAmikaVM workstations + hosted control plane
Software pricingFree self-hosted softwareWebsite advertises free own-compute use for teams of up to three during early access; cloud costs and broader plans require current terms
Keep running after client disconnectYesSessions keep running after client disconnect; execution host must stay onlineNot documentedNot documented in reviewed sources
Use your own remote execution serversYesConnect your existing execution hosts over SSHYesVM workstations on your own machines and cloud accounts
Run the control plane on your serverYesRun controller and browser gateway on your serverLimitedCurrent Rig CLI talks to hosted control plane; local ⁠Docker CLI mode was removed. Self-hosted gateway path remains described as upcoming
Send session prompts from a browserYesOpen the web console and type in the same live sessionNot documentedNot documented in reviewed sources
Upload inputs and download artifactsYesUpload and download through Exchange in web/TUI; no scp commandsNot documentedNot documented in reviewed sources
Execution isolation boundaryManaged ⁠Docker containers; optional sandbox provider boundaryVM-based Rig workstations; several agents can share a Rig
Application-level user identitiesYesPrivate users; password sign-in and remembered devices in TUI, browser and app. Invited/active/disabled status, invitations of up to 7 days for new users only, reset access, disable/enable and an effective-access viewNot documentedNot documented in reviewed sources
Create environments from devcontainer.jsonYesRepo devcontainer config for operator; managed template for tenantsNot documentedNot documented in reviewed sources
Overnight: shut down the server when you’re awayYesEnable Overnight before you leave. Keep agents working, then shut down the server once every session has finished or is waiting for you. Your client can stay offline. Available through hosting adapters with shutdown support.Not documentedAn opt-in server shutdown mode triggered by every coding session finishing or waiting for its absent user is not established by reviewed sources
Save workspaces and session history to S3YesOvernight saves encrypted, verified workspace and conversation archives to S3-compatible storage, with an index of saved work. Restore on the same enrolled host when you return, or run pnpm overnight:restore to place saved repository and native-history trees in new isolated directories on another host without resuming sessions. Runtime credentials are excluded.

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.

Not documentedA supplied S3 export/restore workflow covering workspaces and native coding-session history is not established by reviewed sources
Security modelContainer/tenant separation, supported ⁠Docker egress enforcement and managed routes; agent rules remain instructionsNot documented in reviewed sources

All features

All features: the same properties for devctrl and Amika
FeaturedevctrlSelf-hosted control planeAmikaVM workstations + hosted control plane
Product and cost
Software pricingFree self-hosted softwareWebsite advertises free own-compute use for teams of up to three during early access; cloud costs and broader plans require current terms
Model usage costsYour provider subscriptions/API bill; optional Decisions advisor calls cost extraNot documented in reviewed sources
Execution compute costsYour local/remote compute billNot documented in reviewed sources
Client platformsTerminal + web; macOS + Windows desktop; Linux build target; Android ARM64 preview. Clients are source-built; Android verified in an emulator. No iOS app.Not documented in reviewed sources
ImplementationTypeScript/Node controller and agents; one shared React App for TUI, web, desktop and Android; SQLite; Tauri desktop/mobile shells. Shared built-in interface and native onboarding sources in 14 languages; native binaries need a new buildApache-2.0 CLI/daemon/SDK components; README lists control plane, UI and relay as closed
Primary product modelSelf-hosted control plane for persistent agent environments and team infrastructureNot documented in reviewed sources
Infrastructure ownership
Local, self-hosted and vendor Cloud modelLocal or self-hosted controller; SSH or HTTPS/WSS clients; optional local ⁠Docker, cloud hosts and capability-gated sandbox adaptersYour compute or hosted devboxes; current control-plane service remains hosted
Run agents on this computerYesStart sessions on this computer; ⁠Docker requiredLimitedOwn-machine VM provider is documented; removed --local ⁠Docker CLI path is not supported
Use vendor-managed execution computeYesOptional cloud-VM and sandbox packages; API-only adapters cannot launch Docker-managed sessions; provider billing and limits applyYesOptional Amika-hosted devboxes
Run the control plane on your serverYesRun controller and browser gateway on your serverLimitedCurrent Rig CLI talks to hosted control plane; local ⁠Docker CLI mode was removed. Self-hosted gateway path remains described as upcoming
Execution isolation
Execution isolation boundaryManaged ⁠Docker containers; optional sandbox provider boundaryVM-based Rig workstations; several agents can share a Rig
Give parallel tasks separate checkoutsYesSeparate working files, Git index and branch for every new coding session, including in a shared container; native worktrees or a shared-object clone on older Git. Existing sessions retain their pathsNot documentedNot documented in reviewed sources
Sessions
Keep running after client disconnectYesSessions keep running after client disconnect; execution host must stay onlineNot documentedNot documented in reviewed sources
One session list across execution hostsYesProjects and Mosaic list sessions from enrolled hosts togetherNot documentedNot documented in reviewed sources
Use your own remote execution serversYesConnect your existing execution hosts over SSHYesVM workstations on your own machines and cloud accounts
Identify sessions waiting for inputYesShows working / waiting-for-input states for supported agent sessions; Choose questions, permission requests, idle or exhausted quota in Settings; Projects counts visible matches and group tabs show a hand. Hidden sessions are excluded; sound is separate. optional local sounds for explicit questions, permissions and new MCP approvals while the console is open; off by defaultNot documentedNot documented in reviewed sources
Send session prompts from a browserYesOpen the web console and type in the same live sessionNot documentedNot documented in reviewed sources
See actual stages while opening a sessionYesTerminal and browser show reported account, access, workspace, import and attachment stages with elapsed time; cancel without stopping the persistent agentNot documentedNot documented in reviewed sources
Name sessions without changing their native historyYesRename the visible session or review a local title suggestion without changing conversation IDs or prompting the agentNot documentedNot documented in reviewed sources
Capture periodic progress summaries in session headersYesServer-side ⁠Claude /btw status questions every 15 minutes by default, with version/input/viewer guards, capture date and previous answer retained on failure. Uses agent quota. ⁠Codex automation is disabled because /side changes the visible terminal; other agents require verified safe captureNot documentedNot documented in reviewed sources
Show active native subagent countsYes⁠Claude/⁠Codex native telemetry reports active children, models, own child goals and goal-scoped checklist progress where supported; unavailable or stale observations are shown as unknownNot documentedNot documented in reviewed sources
Open a web server running in a session from the browserYesOpt-in per session: the agent binds its HTTP server to a stable preview port and the owner opens a one-use link on a per-session origin. Only that container port is reachable; WebSocket upgrades work. The listener is local by default; reach it over an SSH port forward or a per-port originNot documentedNot documented in reviewed sources
Mark what each session is doingYesActivity tags from structured state (waiting input, needs approval, blocked, quota, frozen, outdated CLI, working) plus agent-declared work kinds and milestones and Git facts such as unpushed commits; nothing is inferred from free textNot documentedNot documented in reviewed sources
Separate main-session and subagent workYesTask Graph attributes every task to the main session or the subagent that did it, with per-agent codes, lanes and scopingNot documentedNot documented in reviewed sources
Show conversations between agent sessionsYesTask Graph lists messages, questions, replies, delegations and handoffs between sessions with their status; bodies are reduced to a redacted subject lineNot documentedNot documented in reviewed sources
Auto compact after completed workYesManaged ⁠Claude/⁠Codex/⁠Antigravity: submit /compact server-side after an explicit completed-task report and native turn end, even with the client offline. Off by default; Global → Project → Session policy, idle delay and cooldown. Questions/permissions, active or unknown children, attached terminals and quota waits block it. Native context-limit compaction is separate.Not documentedEquivalent workflow is not established by the reviewed primary sources
Freeze an agent and retain its terminal snapshotYesStop one agent and retain its screen, native conversation and checkout in Frozen. Thaw prepares the container before resuming the same account/profile; idle containers stop. Temporary compute requires verified encrypted S3 storage. Permanently remove a confirmed stopped card with its exact Freeze ID; retained files/history/archives and a retry receipt remain.Not documentedA separate frozen-session view with retained terminal snapshots and this S3 recovery workflow is not established by the reviewed sources
Follow each agent’s tasks and steps as a treeYesTask Graph combines tasks agents report through the devctrl MCP tool with native ⁠Claude hook steps: classified shell commands, checklists and named subagents, with sanitized agent-written descriptions, start times and running durations. Raw commands are never recorded. Projects Activity shows current work in the mosaic grid. Reports are unverified progress claims; ⁠Codex plans and subagents are not captured.Not documentedAn equivalent tree of agent-reported tasks and hook-recorded native steps for each session is not established by reviewed sources
Let agent sessions message each otherYes⁠Claude, ⁠Codex, ⁠Antigravity and ⁠Pi sessions of the same owner in one Project exchange messages through devctrl MCP tools, across enrolled hosts. Messages arrive in an inbox inside an untrusted-peer envelope and are never typed into a terminal; idle ⁠Claude/⁠Codex sessions can receive a body-free wake line. Not yet exercised end to end with real agents; team members and other servers are not included.Not documentedAn owner-scoped inbox in which separate agent sessions exchange messages through a managed MCP tool is not established by reviewed sources
Files and storage
Upload inputs and download artifactsYesUpload and download through Exchange in web/TUI; no scp commandsNot documentedNot documented in reviewed sources
Automatically sync a folder both waysYesTwo-way Unison through the optional SSH client. Per-user HTTPS/WSS synchronization is a preview with an unresolved clean-restart limitation. Each selected folder is a whole-folder read/write grantNot documentedNot documented in reviewed sources
Attach folders from local/remote sourcesYesHost-local / SSH / S3 bucket folders with MCP read/write grants. S3 uses the gateway. Shell mounts: host-local/pre-mounted sources in a new dedicated containerNot documentedNot documented in reviewed sources
Save workspaces and session history to S3YesOvernight saves encrypted, verified workspace and conversation archives to S3-compatible storage, with an index of saved work. Restore on the same enrolled host when you return, or run pnpm overnight:restore to place saved repository and native-history trees in new isolated directories on another host without resuming sessions. Runtime credentials are excluded.

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.

Not documentedA supplied S3 export/restore workflow covering workspaces and native coding-session history is not established by reviewed sources
Environment management
Give one agent multiple repositoriesYesSelect existing repositories or import an entire accessible ⁠GitHub organization; save launch groups with independent checkouts. Operator Control Room suggestions stay within one verified organization. Matching runtime, Git grants and Internet policies requiredNot documentedNot documented in reviewed sources
Create environments from devcontainer.jsonYesRepo devcontainer config for operator; managed template for tenantsNot documentedNot documented in reviewed sources
Keep workspace files when compute stopsYesDisk-backed workspaces/history; disposable providers have explicit lifetimesYesRigs may be short-lived or persistent
Reuse prepared execution environmentsYesManaged runtime templates and cached prepared image variantsNot documentedNot documented in reviewed sources
Deliver secrets to selected runtime scopeYesEncrypted controller vault; scoped runtime file/broker deliveryNot documentedNot documented in reviewed sources
Publish shared services to selected users/projectsYesAdmin publishes resources; users grant them to owned projectsLimitedPrivate network and HTTPS previews are documented; exact devctrl-style project/service grant equivalence is unverified
Enforce CPU/RAM/storage resource limitsYesAggregate CPU/RAM/PID cgroups and XFS/ext4 quotas require verified host delegation and quota prerequisites. Finite running-container CPU/RAM requests preserve user budgets; approval stays separate from verified ⁠Docker/kernel/parent limits and session preservationNot documentedNot documented in reviewed sources
Choose a workspace storage base per user/hostYesAdministrators choose a provisioned storage base per user/host for new workspaces; retained workspace paths do not moveNot documentedNot documented in reviewed sources
Pin a user's containers to selected CPUsYesVerified cgroup-v2 CPU sets apply across a user's containers; updates preserve sessions. Affinity is not exclusive-core reservationNot documentedNot documented in reviewed sources
Prepare tools and dependencies automaticallyYesPrepare checkouts, selected agent/Git tools and images. Custom ⁠GitLab hosts/ports configure controller API access. Restricted workspace Git needs an approved public host on ports 80/443; private/custom-port routes are not provisioned automaticallyNot documentedNot documented in reviewed sources
Preserve repository technology evidence by subjectLimitedBounded static ecosystem parsers, component/evidence snapshots and match/non-match/unknown rules; dynamic syntax remains partialNot documentedEquivalent workflow is not established by the reviewed primary sources
Refresh technology-aware skill recommendationsLimitedCurated language/technology JSON links match bounded manifest evidence. Project defaults and repository exclusions preserve manual choices; pinned bundle installation is explicit. Daily cached catalog metadata stays separate from installed files, compatibility and execution evidence; refresh never activates skillsNot documentedEquivalent workflow is not established by the reviewed primary sources
Accounts and models
Show agent subscription quota and resetsYesTrack remaining quota and reset times for ⁠Claude/⁠Codex. Keep ⁠Antigravity limits separate by model group. Show ⁠Claude free-reset offers and ⁠Codex reset credits when officially reported. Confirm supported ⁠Codex resets in the console; follow account-specific instructions for ⁠Claude.Not documentedNot documented in reviewed sources
Continue on another subscriptionYesEligible account + saved contextNot documentedNot documented in reviewed sources
Continue across ⁠Claude / ⁠Codex / ⁠AntigravityYesSupported ⁠Claude/⁠Codex imports; bounded task handoffs including ⁠Antigravity. Original session retainedNot documentedNot documented in reviewed sources
Recommend a model for a delegated taskYesHosted or self-hosted Decisions advisor selects cheaper eligible subagent models; forecasts costNot documentedNot documented in reviewed sources
Apply model advice in native subagent hooksYes⁠Claude hooks and supported ⁠Codex launches; inherited-history ⁠Codex forks keep their modelNot documentedNot documented in reviewed sources
Track routing budgets by projectYesBudgets + estimated model costsNot documentedNot documented in reviewed sources
Choose a proxy route per agent accountYesOptional HTTP/SOCKS/existing VPN-gateway adapters in restricted ⁠Docker workspaces (rootful 28+ or rootless 29.9.1+); changes apply at the next provider process startNot documentedNot documented in reviewed sources
Choose native model defaults per accountYesChoose current installed ⁠Claude/⁠Codex/⁠Antigravity model catalogs or native default. ⁠Antigravity checks an opt-in reserve chain on the server. Verified native quota refusals skip the failed group even before cached usage updates. Idle selection preserves the conversation and read-only public viewers; unknown reserve quota blocks selection. A verified quota-interrupted task receives one continuation prompt after selection is confirmed; uncertain input is not replayed. ⁠Claude accounts can instead use a metered ⁠OpenRouter, ⁠Vercel AI Gateway or ⁠LiteLLM gateway with a model allowlist, recorded per-request cost and an optional monthly budget; these have no subscription quota windows.Not documentedThis comparison has not established equivalent per-account native model catalogs and default selection from the cited sources
Keep your preferred account order across clientsYesManual account order saved per user for detailed and compact Accounts in TUI, web and desktop. Account and nested session rows move together.Not documentedShared per-user account display ordering across clients is not established by the cited sources
Access and integrations
Let agents manage product sessions/resourcesYesAgents call devctrl MCP management tools and bundled skills. Optional Public Project MCP, off by default, lets external OAuth clients read granted Projects, sessions and task graphs or send text to a running session; Control Room through the remote console remains the primary remote pathYesRig/agent API, CLI and SDK interfaces
Grant service access per projectYesConnect resources once; grant selected projects routed endpoints and scoped runtime credentialsNot documentedNot documented in reviewed sources
Review project access requestsRelease video on YouTube: Approval notices in Main (devctrl 0.1.171)YesReview exact actions and execute approved plans sequentially on the server. Add system, Project-group and repository approval policies; confirm editable general intents for legal repository or Project-group scopes, inspect and revoke them. Owner/account/team ceilings remain binding. Intent, approval, queued delivery and verified technical outcome are separate; uncertain writes are not replayedNot documentedNot documented in reviewed sources
Allow/deny specific MCP tools or methodsYesManaged MCP broker enforces allowed tools/methods for the granted scopeNot documentedNot documented in reviewed sources
Reuse access-policy templatesYesSave access/rate templates and apply them to groups, repositories or sessionsNot documentedNot documented in reviewed sources
Control sessions through messenger botsYes⁠Telegram, ⁠Slack and ⁠Teams support prompts and approvals after bot setupNot documentedNot documented in reviewed sources
Save a public web access providerYesSave Automatic, Cloudflare, localhost.run, ngrok or your HTTPS origin for the next web start; ngrok credentials/agent and own-domain DNS/TLS are external setupNot documentedNot documented in reviewed sources
Cap MCP calls per repository/sessionYesManaged broker enforces configured scoped rate limits and reusable templatesNot documentedEquivalent workflow is not established by the reviewed primary sources
Delegate tracked work across agent runtimesLimitedPersisted isolated ⁠Claude/⁠Codex tasks, shared admission and MCP results. Exact account must be logged in on the target host; managed fresh-VM tasks wait for explicit account preparation. Automatic native credential transport is incompleteNot documentedEquivalent workflow is not established by the reviewed primary sources
Collaboration and tenancy
Share a live session (view / control)YesSession owner grants view/control to server users or guests with a revocable browser link; one active input leaseNot documentedNot documented in reviewed sources
Separate user environments for the same Git repositoryYesUsers import the same Git URL into private Project records; separate user-scoped checkouts/containersNot documentedNot documented in reviewed sources
Application-level user identitiesYesPrivate users; password sign-in and remembered devices in TUI, browser and app. Invited/active/disabled status, invitations of up to 7 days for new users only, reset access, disable/enable and an effective-access viewNot documentedNot documented in reviewed sources
Role-based resource authorizationYesOperator/admin/user roles plus ownership checks at API and host; only the server owner manages other administrators, and every controller route has a checked access policyNot documentedNot documented in reviewed sources
Isolate users on shared execution serversYesDifferent users have separate containers, HOME and user-scoped repository/runtime paths; existing mounts stay in placeNot documentedNot documented in reviewed sources
Preserve required team review skills in lower scopesLimitedTeam/template/project/repository contracts preserve required and locked constraints; configured policies and compatible pinned bundles are requiredNot documentedEquivalent workflow is not established by the reviewed primary sources
Teamwork
Cap total compute allocated to each userYesAggregate launch budgets; hard enforcement needs verified host supportNot documentedNot documented in reviewed sources
Compute and maintenance
Provision isolated compute for a workspaceYesCreate an isolated ⁠Docker workspace or a sandbox through a configured provider adapterNot documentedNot documented in reviewed sources
Manage ⁠Docker environments for agentsYesCreate, reuse, rebuild and remove managed agent containersNot documentedNot documented in reviewed sources
Reuse an environment or create a separate oneYesLaunch in a compatible same-owner container or create a separate one in the session wizardNot documentedNot documented in reviewed sources
Upgrade CLI tools in selected workspacesYesUpdate managed CLIs inside containers; running sessions retain launched versions. Stopped/Frozen cards show the next-start target, including matching rebuilt images. Rebuild images separatelyNot documentedNot documented in reviewed sources
Delete session-declared files/containers centrallyYesReview managed disk sizes and declared files/containers. Clean ready task artifacts, configure empty-container shutdown and optional hourly host retention policiesNot documentedNot documented in reviewed sources
Manage optional context tools in containersYesRTK OSS, sgrep, ast-grep, Repomix and Graphify: exact scoped selections, separate image/container application, managed-tool removal, per-tool progress, all-session guide/notice receipts and explicit failed-step retry; usage is unmeasuredNot documentedNot documented in reviewed sources
Install a standalone server binaryNoInstallation uses a ⁠Docker control-plane stackNot documentedNot documented in reviewed sources
Overnight: shut down the server when you’re awayYesEnable Overnight before you leave. Keep agents working, then shut down the server once every session has finished or is waiting for you. Your client can stay offline. Available through hosting adapters with shutdown support.Not documentedAn opt-in server shutdown mode triggered by every coding session finishing or waiting for its absent user is not established by reviewed sources
Inspect actual tooling changes per containerYesPaged container history for agent CLIs, context tools and observed runtime tools. Actual before/after versions, requested targets, source, actor and outcome stay separate; first observations and missing versions are explicit.Not documentedAn integrated per-container journal covering these tool classes and verified installation outcomes is not established by the cited sources
Remove disposable compute after sessions finishYesBoat workspaces can be deleted automatically when every session has exited. Choose this lifetime when creating the sandbox. Waiting or detached sessions do not trigger deletion; provider expiry still applies.Not documentedDeletion triggered by all coding sessions exiting is not established by reviewed sources; timeouts and inactivity policies are different
Operations and accounting
Resume conversation history after host restartYesRetained native session IDs support resume; running memory is not checkpointedNot documentedNot documented in reviewed sources
Persistence mechanism and process boundariesController disconnect leaves host provider processes alive; reboot uses resumeNot documented in reviewed sources
Record authorization and operation audit eventsYesPaged operation events and network/MCP attempts by project, repository and session. Unique-target counts show allowed/denied and upstream failures separately. HTTP/CONNECT coverage with observed workspace/DinD origins; shared-container traffic stays sharedNot documentedNot documented in reviewed sources
Export visible operation events as redacted JSONLYesExport retained operation events or network/MCP attempt metadata as scoped redacted JSONL; no credentials, URL queries or MCP arguments/resultsNot documentedNot documented in reviewed sources
Stream operation events to a log collectorYesAuthenticated resumable WebSocket feeds, operator-only controller stdout and private server Unix sockets. Filter operation/network/MCP metadata by owner and project; saved cursors and bounded backpressure work with clients closedNot documentedNot documented in reviewed sources
Show workspace CPU/RAM consumptionRelease video on YouTube: devctl and the rest of the Host on the Hosts screen (devctrl 0.6.0)YesHost/container CPU, RAM and disk I/O history with Dashboard timelines and interval totals; allocation budgets are separateNot documentedNot documented in reviewed sources
Warn agents about measured RAM pressureYesHost/controller RAM monitoring continues without the client; warnings wait for safe input. Current managed process metadata is required; no automatic process killsNot documentedNot documented in reviewed sources
Workspace/project cost reportingProject activity: native tokens without requiring Git, commits and line deltas by day/week/month, recorded 91-day totals, metric-specific Last and per-user hidden repositories; ⁠Claude account records add provider-week project/session/model attribution with cache and subagents; recorded token shares, Decisions forecasts and sandbox usage are separate from subscription billingNot documented in reviewed sources
Enforce review against an immutable subjectLimitedServer gate binds subject and effective contract and blocks missing/unknown required evidence. Workflow settings expose user defaults, project overrides, triggers and per-account admission. Automatic hooks are limited to verified native local Git contexts; ordinary global/system and managed-host contexts require manual integration. Trusted identity and remote required-status configuration remain necessary. Review cycles, reviewer models, verdicts and top findings appear in the session's Task GraphNot documentedEquivalent workflow is not established by the reviewed primary sources
Export versioned review outcomes and coverageLimitedImmutable JSON attempt/history and bounded JSONL export; unknown execution/provenance stays explicitNot documentedEquivalent workflow is not established by the reviewed primary sources
Run deterministic and account-backed diagnostic checksLimitedCurrent problems show affected target, observed/expected state, impact and a repair, settings link or recheck. Safe fixes need trusted completion plus fresh verification; history and optional analysis stay separate. Live optional ⁠Claude analysis is unverified; ⁠Codex AI diagnostics unsupportedNot documentedEquivalent workflow is not established by the reviewed primary sources
Security boundaries
Security modelContainer/tenant separation, supported ⁠Docker egress enforcement and managed routes; agent rules remain instructionsNot documented in reviewed sources
Isolate execution with containers/VMs/OS sandboxYesManaged ⁠Docker boundary or optional sandbox provider; same-owner shared containers share a trust boundaryNot documentedNot documented in reviewed sources
Enforce workspace Internet-egress restrictionsRelease video on YouTube: Gateway health in devctl hosts (devctrl 0.3.0)YesNew/rebuilt restricted workspaces use an isolated-network allowlist gateway on rootful ⁠Docker 28+ or Rootless ⁠Docker 29.9.1+. System/user/project-group/repository packages inherit approved team templates; explicit repository policies require opt-in adoption. Public80/443 policy and gateway acknowledgement stay separate; required model/auth hosts remain allowed. Legacy runtimes need rebuild; older rootless daemons and Boat-native networking are unsupportedNot documentedNot documented in reviewed sources
Screen text agents send each other before deliveryYesA bounded deterministic prescreen flags code, binaries and encoded payloads; Decisions or Control Room review suspicious text, and high-risk entry points such as delegated tasks and session input are reviewed even when clean. Holds wait for a personNot documentedNot documented in reviewed sources
Enforce filesystem boundaries outside agent promptsYesTenant mounts/ownership and folder gateways; native access outside grants is distinctNot documentedNot documented in reviewed sources
Instructions versus enforced access boundaryApproval policy text and confirmed task intents guide bounded review; broker/mount/ownership enforcement and actual technical fulfillment remain separateNot documented in reviewed sources

Yes: a supplied workflow. Limited: the stated edition or runtime. Manual setup: your commands, scripts or infrastructure configuration. Red marks unavailable or unverified support; each answer links to the evidence. Pricing, platforms and architecture are shown as facts.

THE devctrl MODEL

SESSIONagent + account + historyWORKSPACErepository + files + grantsCOMPUTEhost + container / sandbox

A session can end while its workspace is retained. Compute can change while history stays in the controller.

devctrl VS Amika

Choose compute and control-plane ownership separately.

Agent VM workstations on your machines or cloud accounts with private connectivity. Current CLI operations use the hosted control plane; a complete supported self-hosted control plane is not established.

Evaluate the documented mode you intend to run. Missing documentation is unknown support, and source review is not a live product test.

Sources: Amika: own-compute VMs and private networking · Amika: open components, hosted control plane and Rig interfaces · Amika: removed local CLI mode and current self-hosting limitations

RESOURCES + PERMISSIONS

Connect once. Grant access per project.

Make an API, database, model endpoint or folder available to selected projects. Deliver scoped runtime credentials, choose read-only or read/write folder access and reuse method and rate limits on managed MCP routes.

Built-in tools and skills show agents how to use the connections you configure. Review additional access requests, adjust their scope and deliver changes to the running session without restarting it.

Approved operational work uses an isolated read-only task chat. Follow the task, its blocked or completed outcome and a separate notification to the exact requesting session; human chats and messenger routes remain independent.

Connect ⁠Telegram, ⁠Slack or ⁠Teams to inspect output, send prompts and review requests in a paired private bot chat.

Service, folder and MCP gateways enforce their managed access boundaries. Keep upstream database permissions scoped on the infrastructure you operate.

New or explicitly rebuilt restricted workspaces use an isolated ⁠Docker network and allowlisted Internet gateway on rootful ⁠Docker 28+ or Rootless ⁠Docker 29.9.1+. Required ⁠Claude/⁠Codex/⁠Antigravity model and sign-in hosts stay available; provider groups and individual API domains use editable private templates. Existing sessions keep their network until a rebuild; older rootless daemons and Boat-native networking are outside this boundary.

Choose access packages at shared system, user, project-group and repository scopes. Team administrators approve shared templates and control additional destinations. Explicit repository policies stay unchanged until you choose inheritance.

The default template covers package registries, toolchain installers, container registries, documentation and many database hosts. Shared object storage and user-content hosts such as Google Cloud Storage, Hugging Face, cloud container registries, JitPack, Read the Docs and Stack Overflow ship as unchecked opt-in groups, because a compromised dependency could use content anyone can upload there for command-and-control or data exfiltration.

Add the Web fonts package to a private Internet-policy template or scoped defaults. It allows Google Fonts stylesheets and font files; saving policy and verified gateway application remain separate.

Give sessions useful resources without repeating the connection setup for every project.

Sources: devctrl · Approvals · MCP policies · devctrl egress · devctrl operator execution

USERS + RESOURCE BUDGETS

A shared server with separate workspaces.

Server mode gives each devctrl user private projects, credentials, histories and containers. Administrators publish selected resources and set aggregate compute budgets across a user's containers.

Give users separate checkouts, runtime directories and containers. Choose provisioned storage for new workspaces, track aggregate reservations and measured use, and enable hard CPU, memory and disk caps through verified host adapters. Configure CPU affinity without restarting sessions; selected cores are not exclusive reservations.

An owner can share a running session with named server users: view live output or control prompts and replies. One participant holds input at a time. Sharing leaves runtime ownership, resource grants and account quota with the original owner; it does not merge users’ private projects or containers.

Shared sessions
One live conversation can have view-only or control access. Viewing follows output; control additionally lets another person prompt or steer the agent.
Same repository, separate environments
Teammates can work on the same Git repository in their own checkouts and containers. devctrl stores private Project records for each owner and separates paths by user; Git carries their code changes. This does not require shared credentials or a shared physical container.
Multi-user infrastructure
Application identities own private credentials, execution environments and resource budgets. Selected services may be published without mixing their containers or sessions.

Put shared servers to work with private developer environments and resource budgets in one control plane.

Sources: Server users · devctrl shared sessions · devctrl containers

VISIBILITY + EVENTS

See the work. Understand the wait.

Opening a session shows the actual account, access, workspace and terminal stages with elapsed time. Native pending tool calls and reported background work are distinct from questions, permission requests, provider errors and current blocked goals. Unconfirmed long waits stay explicit. Give sessions useful display names without changing native history, and see their active subagent counts when the installed CLI supplies readable lifecycle data.

Inspect native model and reasoning effort observations alongside token counters and reported context-window use for the session and its subagents. Configure ordered native status fields for selected agents; existing custom renderers keep precedence and layouts apply on the next safe start. Optional server-side compact waits for explicitly completed work and a native completed turn, with no pending questions, active children or attached terminal. Configure it globally, per project or per session; it is off by default.

Browse repository compaction history across sessions. Filter and page through confirmed results, native counters and held attempts; missing measurements stay explicit.

Inspect why an empty container waits, stays running or stops. Queued commands, confirmed host outcomes and unconfirmed results remain separate; retained work stays available.

RAM monitoring keeps running on the execution infrastructure after you close the client. Current managed sessions receive measured pressure warnings at safe input points, with the scope and limit that caused them. The monitor does not kill unrelated work or predict the next OOM.

Browse operation events independently of the full project inventory. Download your visible journal as redacted JSONL or connect an authenticated, resumable live collector. These records cover controller operations and access changes, rather than every command the agent runs.

Host cards keep UTC clock differences separate from time-zone offsets, with sample age and uncertainty. A missing physical-host timezone stays unavailable; the display changes no server clock.

Control Room has its own human-attention count. Open the current approval or chat without sending input or losing your draft. Running tasks and completed history stay out of the count.

Request ⁠Claude’s native arrival-time markers at the next provider start. Existing settings remain intact, and rendering depends on Anthropic’s rollout. ⁠Codex and ⁠Antigravity have no verified native toggle.

Matching controller and host versions prepare a session-bound caller for eligible managed ⁠Docker sessions on a new provider start or existing broker recovery. Native metadata and guide receipts establish readiness; the running client’s tool list stays separate.

Keep sessions, resource warnings and the operation trail visible without leaving your laptop running.

Sources: devctrl session opening · devctrl session labels · devctrl context telemetry · devctrl auto compact · devctrl RAM warnings · devctrl events · devctrl host clocks · Find requests needing you · Choose native message timestamps · Recover scoped MCP access

PLAN YOUR SETUP

Your infrastructure. Your choices.

Choose your compute.
Use existing servers, SSH hosts, local ⁠Docker or optional sandbox providers. You operate the control plane and choose where projects execute.
Keep access available.
Host the controller and browser gateway on a server to use the console while your laptop is offline.
Continue with the context you have.
Account and provider transfers use supported native import or a saved task handoff. The original session remains available; history support depends on the chosen clients.
Set budgets that match the host.
Give users separate containers and aggregate resource budgets. Enable CPU, memory and storage hard caps through verified host adapters.
Keep networking explicit.
Restricted workspace networking requires a new/rebuilt runtime on rootful ⁠Docker 28+ or Rootless ⁠Docker 29.9.1+; model and sign-in hosts stay allowed. Older rootless daemons and Boat-native networking are outside this ⁠Docker boundary.
Publish the console your way.
Save a tunnel provider or your HTTPS origin for the next web start. Free tunnel URLs can change; ngrok needs its agent and credentials, and an own domain needs your DNS, TLS and reverse proxy.
Connect only what you use.
Add compute, messenger and Decisions providers as optional packages. Model advice requires configuration; cost forecasts estimate API-equivalent usage rather than subscription savings.

PRIMARY SOURCES

Go straight to the documentation.

Follow the product and extension documentation behind the selected comparison.

  1. devctrl: managed RTK OSS, sgrep, ast-grep, Repomix and Graphify, with live installation and Git-aware graph refresh
  2. devctrl: current account model catalogs, defaults and optional ⁠Antigravity quota fallback
  3. devctrl: personal account display order shared by TUI, web and desktop
  4. devctrl: frozen session snapshots, native resume and encrypted S3 recovery
  5. devctrl: opt-in idle cloud shutdown, encrypted S3 archives and restore
  6. devctrl: shipped features and limitations
  7. devctrl: direct browser and terminal file transfers
  8. devctrl: optional prebuilt local synchronization client
  9. devctrl: account and provider continuation
  10. devctrl: ⁠Claude reset offers and ⁠Codex reset credits — checked
  11. devctrl: MCP access requests and delivery
  12. devctrl: managed MCP method and rate policies
  13. devctrl: private server users and resource budgets
  14. devctrl: Decisions and chat integrations
  15. devctrl: opt-in Public Project MCP for external OAuth clients
  16. devctrl: Task Graph and the Projects Activity view
  17. devctrl: Project messaging between agent sessions
  18. devctrl: ⁠OpenRouter, ⁠Vercel AI Gateway and ⁠LiteLLM accounts for ⁠Claude
  19. devctrl: combined repository launches, organization imports and Control Room suggestions
  20. devctrl: ⁠GitHub/⁠GitLab setup, host choices and isolated credentials
  21. devctrl: controller, runtime, grants and trust boundaries
  22. devctrl: process, history and storage persistence
  23. devctrl: installation targets and devcontainer preparation
  24. devctrl: TypeScript/Node implementation and package manifests
  25. devctrl: 14 interface languages across shared clients and native onboarding sources
  26. devctrl: optional source-built Tauri desktop client
  27. devctrl: Android ARM64 development preview and verification limits
  28. devctrl: same-owner container reuse and tenant isolation
  29. devctrl: owner-granted live session viewing, control and input leases
  30. devctrl: optional sandbox lifetimes, secret safety and accounting
  31. devctrl: optional sandbox lifetimes, secret safety and accounting
  32. devctrl: folder access and enforced gateway boundaries
  33. devctrl: isolated ⁠Docker networking and workspace allowlists
  34. devctrl: paginated operation/access history, redacted JSONL export and live collectors
  35. devctrl: measured RAM pressure and safe session warnings
  36. devctrl: server-side CPU, RAM and disk I/O history
  37. devctrl: account-scoped HTTP, SOCKS and existing VPN gateway routes
  38. devctrl: session display names and active native subagent counts
  39. devctrl: observed host UTC samples, physical timezones and uncertainty
  40. devctrl: approval policies and owner-scoped remembered task intents
  41. devctrl: canonical operator host commands and typed, tracked diagnostics or managed-service repair
  42. devctrl: finite current-container resource requests and verified limit application
  43. devctrl: weekly native account attribution and limits
  44. devctrl: project activity, native token history and Git totals
  45. devctrl: native session and subagent token/context observations
  46. devctrl: scheduled native progress questions and timestamped session headers
  47. devctrl: opt-in compact after explicitly completed work
  48. devctrl: saved web access providers and public URL prerequisites
  49. devctrl: verified storage quotas, user workspace placement and CPU affinity
  50. devctrl: per-session browser previews on an isolated origin
  51. devctrl: risk-based screening of text that agents send each other
  52. devctrl: session opening stages and terminal attachment
  53. Amika: own-compute VMs and private networking — checked
  54. Amika: open components, hosted control plane and Rig interfaces — checked
  55. Amika: removed local CLI mode and current self-hosting limitations — checked
  56. devctrl: bounded technology profiles, diagnostic checks and catalog limitations — checked
  57. devctrl: review contracts, evidence and server gate boundaries — checked
  58. Find requests needing you
  59. Choose native message timestamps
  60. Recover scoped MCP access
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.