What devctrl does

Run and resume native Claude, Codex and Antigravity sessions across your remote machines. Sessions run in persistent workspaces on infrastructure you choose. One controller manages projects, access and history; the terminal and browser connect to it. Resume and telemetry support vary by client. CLI commands retain the devctl name.

Use an existing local checkout directly. For a repository that lives only on the server, you can create an optional local Project copy (source access required) in an empty folder you choose. Git files and private configuration are copied from the server; Exchange synchronizes in both directions. Press Shift+L in Projects; browser users receive a command to run locally. Local edits pause updates to the copy. The server remains the persistent store for configuration.

Product capabilities

Need Current workflow Boundary / setup
Install without a local stack One-command remote setup installs missing Ubuntu dependencies, returns a browser link and adds devctrl tui remote A URL needs no local Docker; a local Git folder automatically installs the Exchange client and requires Docker + an SSH agent
Run management tools under a limited account Fresh Ubuntu/systemd setup creates a locked OS tooling account, private Rootless Docker and persistent user services automatically No sudo/docker-group grant; restricted networking requires Rootless Docker 29.9.1+. Existing rootful installs are preserved; aggregate hard quotas need verified delegation
Use a desktop console Optional Tauri client bundles the shared React interface, discovers saved/SSH connections, and connects to remote gateways Source-built Tauri 2 packages; native SSH checks and fresh Ubuntu setup; no local controller. Signing, automatic updates and native background notifications are not configured
Leave work running Persistent tmux sessions survive detach, browser close and client disconnect A server-side controller/gateway keeps the console online without a laptop; laptop-hosted authority does not
Find what needs attention Settings selects questions, permission requests, idle agents and exhausted quota for Projects navigation; group tabs and individual session headings show a hand without a number Hidden sessions are excluded. Questions and permissions default on; idle and quota default off. Sound and push remain independent. Marker settings
Understand session activity Active tool calls and Antigravity-reported background work differ from questions, permissions, provider errors and a current blocked goal Tool execution keeps the working icon; recoverable tool failures stay working. No process-tree guessing or prose classifier; unconfirmed long waits stay explicit. Status evidence
Hear a question or permission request Settings → Attention sound: optional local signal in TUI, web and desktop, with Test sound OFF by default; per-user preference. Fresh native attention and new MCP requests only; no repeats on reconnect. Web Audio needs interaction; TUI uses the terminal bell. Guide
Reuse or isolate an environment Existing compatible container is the operator wizard default; separate container/worktree is available Sharing is a same-owner trust boundary; tenant containers never mix users; native folder mounts need a dedicated container
Edit one repository concurrently New coding sessions receive separate working files, Git index and branch, even in one container Existing sessions retain their paths. Relative worktrees when supported, independent clones on older Git. Container sharing remains a shared trust boundary. Checkout lifecycle
Resume with another subscription Quota-aware account choices, same-provider continuation, supported import and handoff Another eligible authorized account is required; import capabilities differ by provider
Exchange context and artifacts Browser file download and drag-and-drop upload, TUI file actions, optional local exchange mirror Server Exchange does not require a laptop mirror; local sync requires the enrolled client to be online
Inspect changes and results Expandable Project/repository/folder tree, session results, tests, artifacts, blockers, filtering and patch export in both clients Working-tree files belong to their checkout; saved results retain their session provenance. Refresh and export require an explicit action
Connect folders r/rw grants, health checks, source-host MCP operations and repository/session counters Gateway byte counters measure successful payloads; native binds and direct filesystem traffic are unknown
Connect services Published endpoints, project grants, narrow fixed-target routes, runtime secrets and files Network reachability, credentials and upstream operation permissions remain separate
Bring a custom gateway Operator TypeScript/JavaScript or other runtime, YAML/JSON host registration and selected project grants Gateway code stays outside devctrl; process supervision or lifecycle scripts are explicit
Choose your console language 14 interface languages across shared TUI, browser and Tauri sources, including forms, inventories, tooling and native connection notices Per-user saved preference; native binaries need a new build. Agent output, model IDs, commands and upstream diagnostics remain original. Guide
Customize console shortcuts Settings → Hotkeys: grouped commands, conflict checks, per-command/all resets and shared TUI/web preferences Controller user scope; text, modal navigation, clipboard and attached agent-terminal keys keep native behavior
Operate through MCP Scoped session tools and approvals; operator API discovery/calls, local-folder registration, private-file resync and network-template administration Existing API authentication and ownership apply; secrets are redacted and interactive/file transports retain native interfaces
Review agent access requests Built-in MCP requests, grouped repository approvals, action/constraint checkboxes, history and withdrawal Approving is distinct from verified live delivery; policy text alone is not a firewall or SQL authorization engine
Set approval policies and remember a task intent Add system, Project-group and repository policy text; review an editable general task intent, confirm it for a legal repository or Project-group scope, inspect history and revoke it Source ownership, account locks and team limits remain binding. A remembered intent or reviewer verdict is separate from current approval, delivery and technical fulfillment. Policies
Reuse MCP restrictions Templates for allowed methods/tools and rate limits at group/repository/session scopes Managed broker calls are enforced; independent direct access is outside the broker boundary
Configure workspace Internet access Settings → Network access or Project Security → w: grouped AI/API providers, group/domain checkboxes, search, private templates and defaults for new Projects; immediate gateway delivery with progress Required agent sign-in/model hosts remain locked on. Tenant edits may narrow their grant; explicit policies do not silently widen. Mode changes need explicit rebuild
Run a shared console Server application users with private projects, Git/LLM accounts, credentials and containers Multiuser is explicitly enabled on the server profile; local mode uses one implicit operator
Share one live session Invite server users or create a revocable browser link for guests without an account View-only by default; control is explicit and uses one input lease. Guests cannot start sessions or access the console
Personal coding accounts Each developer connects their own eligible Claude/Codex account Private credentials/history; provider terms apply to account use
Budget server use Atomic per-user/per-host launch reservations and aggregate limits Admission accounting and measured kernel enforcement are distinct; hard mode requires verified cgroup/quota prerequisites
Inspect access and storage Categorized inventories, search, complete fields and consumers, keyboard and browser scrolling Views expose metadata; inspecting a host does not assign access or create a quota. Fresh owned Docker CPU/RAM remains visible without an aggregate allocation
Choose subagent models Optional Decisions API advice in supported Claude Agent/Task and Codex spawn hooks Codex inherited-history forks retain their model; timeouts, low confidence and unknown baselines keep the original launch
Assess the main-session model Independent Decisions policies for start, resume and temporary-capacity recovery; consider a lower eligible model in the same provider and account Fresh model, context, tool and effort evidence plus quality/confidence gates are required. Unknowns retain the baseline; a running change needs a genuine native acknowledgement. Main-session routing
Inspect tokens and context Native session/subagent token observations and reported context-window use in Projects, Mosaic and details Missing values stay unknown; context use, cumulative usage and latest-response tokens remain distinct. Telemetry
Read a brief progress snapshot Native background questions every 15 minutes by default; timestamped answers in Projects tree and Mosaic Settings → Session status changes the interval or disables it. Supported detached working clients only; uses their account quota. Progress snapshots
Compact after completed work Server-side Global → Project → Session settings, idle interval, cooldown, durable history and native context tokens before/after OFF by default; requires an explicit completed-task report and native Stop. Questions, active/unknown children, pending permissions and attached terminals block it. Auto compact
See model-selection value Provider/project history, budgets and API-equivalent cost forecasts against a baseline Subscription monetary savings and actual child quality/retries are not measured; no universal savings percentage
Choose hosted or self-hosted Decisions Grouped provider packages, one active connection, masked encrypted credentials and independent history attribution Operator configuration; live Jev/SubQ tests are opt-in. Unavailable risk reviews stay manual
Add compute/integrations Independent optional provider packages and capability contracts VMs, sandboxes, Git, Decisions, tunnels and managed services use distinct contracts; installed adapter capabilities control availability
Upgrade selected workspaces Update installed CLIs inside containers; new sessions use verified latest versions, with separate launched-version and old-image markers Running provider processes retain their version. Image rebuilding and explicit container replacement are separate operations
Follow control-plane updates Shared update banner with actor stages, measured progress when available and explicit recovery status Queued, running and ready are separate. Compatible rollback uses current data; stale database backups are not restored automatically. Update progress, maintenance
Configure sessions by repository Project → repository → agent → session navigation, inherited defaults and explicit exact-session restart Defaults belong to the repository/provider; selecting a session does not create another defaults scope
Reuse launch recipes Create, edit, copy, delete and start Claude/Codex launch profiles in TUI/web Profiles grant no new access; CPU/RAM values are placement requirements, not changes to a running container's limits
Manage context tools Private user → template → group → repository defaults and per-container RTK OSS, sgrep, ast-grep, Repomix and Graphify selection; live installation with per-tool timing, default-off package auto-updates, release notes, cached images and refreshed agent instructions. Graphify has separate Git storage and manual/after-commit/before-push code-refresh settings Saving defaults is distinct from applying tools to a running container. Manual installations and running processes are preserved. Graphify automatic refresh is local and code-only, preserves user hooks and never auto-commits. Package upgrades are separate from index refresh; actual subscription savings are not measured
Stop empty development containers Owner-scoped Settings timeout, enabled by default at 15 minutes; the server retains files, checkouts, volumes and conversations while stopping the empty execution container and managed companions. Bounded history explains grace periods, safety holds, queued work and host receipts Active/waiting/quota/hidden/starting sessions and pending operations keep it running. Fresh inventory and a live native-process recheck are required. Queued is separate from host-confirmed stop. Separate from cloud-server Overnight shutdown; details
Inspect lifecycle decisions Repository compaction history spans sessions with an explicit session filter; idle history filters owned containers and hosts Read-only lazy pages, separate from /state; missing telemetry stays unknown and previous events are not invented. History guide (source access required)
Trace container tooling changes Paged history for agent CLIs, context tools and observed Node/npm/pnpm/gh/Git/Docker CLI/tmux versions, with actual container ID, source, actor, requested target and verified before/after outcome Starts with recorded evidence; no retroactive history or substitution of image versions for installed tools
Inspect disk and clean task artifacts Managed project/container sizes and session HOME breakdowns; the same reviewed artifact manifest supports live ready-only and stopped-session cleanup Shared storage is deduplicated. Live cleanup accepts only explicitly ready owned TMPDIR paths and stopped DinD containers; it preserves the agent and history. Coverage
Bound operational history Settings separates hotkeys, event/result retention and authenticated audit streaming Server-side cleanup works without a connected console; current/referenced result journals remain protected
Reclaim unused CI database volumes Optional daily maintenance for a pinned rootless CI daemon, with a seven-day unused observation period and per-run cap Anonymous PostgreSQL test volumes only; stopped-container references protect volumes. Main Docker and production databases are outside this scope

Execution and access model

SESSION → WORKSPACE → COMPUTE. A Project is a repository, optionally inside a group. A workspace identifies a managed container or a provider-backed compute workspace. A Project can have multiple workspaces and a workspace can retain multiple session records. Session history is distinct from provider resource lifetime; destroying disposable compute does not delete controller history.

The terminal and browser compile the same React application with Ink and DOM adapters. A separately hosted static PWA connects to an authenticated server gateway; the gateway protects the controller API and terminal WebSockets. SSH is an optional transport for the TUI, not the application-user identity system. The optional desktop client packages the same DOM interface and API transport; it does not start another controller or an execution host.

Same-owner container reuse does not isolate hostile sessions from each other. UIDs are account/profile-derived, and physical container/host administrators remain trusted. Different server users always have separate containers, sidecars, homes and storage. Sharing an account or service never permits shared tenant compute.

Guides

Additional control features What it does Details
Control Room Dedicated administrator Claude/Codex session without a repository, native history and inline progress, independent follow-up drafts during delivery, delivery-ID checks without duplicate messages, local system-voice reply playback (automatic reading off by default), server-wide MCP operations, model defaults, statistics and messenger routing. Eligible ordinary Claude sessions expose their scoped native Remote Control link A genuine provider link is required; restricted reviewers stay excluded. Codex experimental daemon/pairing is not integrated or enabled. Authority and lifecycle
Resource history Server-side CPU/RAM/disk I/O samples, host/container timelines and measured interval totals in Dashboard → Resources Coverage and retention
Voice input Reviewed Claude subscription dictation without a separate STT key; optional external mode, shared TUI/web/desktop flow and local microphone bridges Configuration and limits
Telegram Browse sessions, inspect output, send prompts, receive attention notifications and review MCP requests without a Mini App Optional package; setup and access boundaries
Project toolchain updates Update CLI tools without stopping sessions, rebuild images separately and review important release changes Toolchain upgrades
Session names and subagent activity Rename without changing conversation identity; show native active-child counts, models, exact child goals and confirmed goal-scoped task percentages when supported Names and telemetry limits
Project activity dashboard Daily heatmap cards, recorded tokens, agents, commits and line deltas over today/7/30 days; group organizations, drill into repositories, hide/restore cards per user, and sort Last by tokens or commits Counting and coverage
OOM recovery and RAM warnings Retain confirmed OOM failures and notify active sessions about sustained RAM pressure OOM recovery (source access required), notification interval and prerequisites
User storage and CPU placement Approved workspace roots, CPU affinity and aggregate CPU/disk quotas Host enforcement prerequisites and retained roots
Account network routes Per-account HTTP, SOCKS or an existing VPN gateway for managed coding-agent traffic Applied generations and restart behavior
Account model defaults Select from installed CLI catalogs; native default follows the current CLI without a fixed override Account models
Account display order Shift+Up/Down or visible buttons move an account and its nested sessions; per-user order persists across TUI/web/desktop and detailed/compact views Ordering and API
Weekly account attribution Recorded Claude native tokens by account, repository, conversation and model, including cache and subagents; provider reset windows or explicit rolling fallback Token shares are not weighted subscription charges. Missing/copied histories remain partial; Codex/Antigravity account attribution is not yet included. Counting rules
Configured review triggers User defaults and project overrides choose admitted reviewers for commit and push-attempt events, with exact-subject queue/history Local hooks are bypassable and push attempts do not prove remote delivery. Ordinary local/managed Git contexts require manual integration; policy, budget, identity and required checks remain authoritative. Hook limits
Antigravity quota fallback Ordered account model chain, native shared quota groups and safe server-side continuation after a quota stop Safety and limitations
Public console address Cloudflare/localhost.run, optional installed ngrok, or an existing HTTPS domain Next-launch settings
Audit collection Paginated Events, streamed JSONL export and authenticated resumable WebSocket output Scope, redaction and collection
Weekly reset timing Elapsed-week graph beside weekly quota consumption, with time until reset shown in text Same Accounts component in TUI/web; official reset/window metadata

Standalone local modules

Server installation leaves a small Python/SSH launcher: devctrl tui remote displays the server TUI, and devctrl web remote opens its private browser link. Optional devctrl client install pulls the public prebuilt AMD64/ARM64 image and synchronizes explicitly selected local Exchange folders with Project-scoped enrollment; it needs local Docker and an unlocked SSH agent, without a local controller or checkout. Explicit devctrl host install local adds a separate local execution-host module with Docker socket access. Server sessions remain independent of both local modules. Setup and boundaries.

The main installer accepts a repository URL or local Git folder. A URL installs only the remote stack and SSH launcher. A folder also invokes the same local-client installer for its agent-interchange, resolving the repository from Git origin and validating local Docker/SSH prerequisites before server changes. Exchange does not upload the whole checkout or uncommitted changes. Local-folder setup.

Antigravity native CLI

Antigravity uses its official agy binary inside managed Docker workspaces. New sessions use --dangerously-skip-permissions inside that container, while Project network, storage and resource boundaries remain enforced by devctrl. The native CLI handles Google login. Its private account data survives container replacement; managed hooks observe conversation identity, activity and model. Release notes and bounded structured handoffs use the existing client registry. Native conversation conversion, per-session token/context/subagent telemetry and Claude/Codex-specific automation are not implied. See the per-client capability matrix.

Antigravity Accounts verifies saved Google sign-in with an account-owned read-only userinfo probe; account identity is independent of the Project. A version-gated read-only native quota command displays remaining percentages and reset times grouped by shared model limits. Its temporary account-UID helper excludes project API keys and configuration and never starts an agent turn. Background refresh runs on the host even with no active sessions or running project container. An isolated idle-account check can renew expired authorization through the official CLI without waking a stopped workspace. Unavailable observations retain explicitly historical quota samples.

Frozen sessions

Projects supports Freeze / Thaw (Shift+F), independently of Hide and Detach. The server saves the last terminal screen, stops the exact agent process, retains native history and the original account/profile, and resumes through the existing durable launch path. Frozen has its own tab; empty Frozen, Hidden and Quota tabs are omitted. Temporary compute requires a verified encrypted S3 archive and recovery index. See Freeze and thaw for recovery and storage boundaries.

An explicitly confirmed permanent deletion removes a stopped Frozen card and controller screen without thawing it. The exact reviewed Freeze ID protects against a newer snapshot, and a durable receipt states retained native files, repository data and shared archives. This is not a complete storage erasure.

Combined repositories

One coding session can include up to 32 owned Git repositories, each with its own working files and branch. Import all accessible repositories from a verified GitHub organization, reuse named groups, and review optional Control Room metadata suggestions. Suggestions never combine organizations or grant additional access. See combined repositories for preparation, isolation and current limits.