construct

A terminal-native agentic development environment.

Install the latest release:

curl -fsSL https://raw.githubusercontent.com/construct-worlds/construct/main/install.sh | sh

More screenshots and demos: gallery.

• tmux for agent fleets — manage Codex, Claude Code, OpenCode, Prime Agent, Muse, Antigravity, Grok, and smith sessions from your terminal. Sessions live in the daemon, not your terminal: SSH drops, laptop sleeps — agents keep working, and you reattach exactly where you left off, scrollback and all. Single Rust binary.

• Lineage — sessions branch like ideas do: fork one when you want a parallel attempt (new idea, side quest, or a long shot) — even a cross-harness fork — and merge the results back.

  

• Playbook — collaborative, executable Markdown (docs/playbook.md): co-develop workflows, tasks, and ideas with the agent, then run them from the same document.

  

• Agent-to-agent orchestration — let your Codex and Claude Code sessions talk to each other: one agent can hand a task to another, check how it's going, and pick up the results. Every session gets construct's MCP tools, so any harness can spawn subagents, send them input, and read their output — no glue code.

• ACP (Agent Client Protocol) server — point Agent Client Protocol clients at construct acp to create, load, resume, prompt, cancel, and close construct daemon sessions through the same installed binary.

• Generative widgets — construct generates and updates widgets for your task, so you can track progress, review outputs, and take action without leaving the TUI or web client.

  

• Remote control when you step away — /remote-control opens a browser-accessible web client with a QR code. Connect from your phone, no service signup, no setup required.

      →    

• Extensible harness protocol — adapters are separate processes speaking JSON-RPC over stdio, so new tools can plug in without changing the daemon.

Bring the agents you want to run. construct wraps the CLIs already on your machine, so install whichever harnesses you use, keep them on PATH, and log in first:

• Codex — install the codex CLI and complete its OAuth login.
• Claude Code — install the claude CLI and complete its OAuth login.
• OpenCode — install the opencode CLI and authenticate the providers you plan to use.
• Antigravity — install the agy CLI and complete its OAuth login.
• Grok — install the grok CLI and complete its OAuth login.
• Muse — install the muse CLI and run muse login.
• Prime Agent — install the prime-agent CLI and configure a provider or subscription.
• smith — built in to construct. Talks to OpenAI, Anthropic, Google Gemini, or xAI Grok via API key, a local Ollama, a ChatGPT subscription via Codex OAuth, a Claude subscription via the authenticated Claude Code CLI, or a Grok subscription via the authenticated Grok CLI.

Once those CLIs are available and authenticated, construct can create and resume their sessions from the fleet TUI.

The installer downloads the right prebuilt binary for your platform, verifies its SHA-256 checksum, and drops every binary into one directory on your PATH:

curl -fsSL https://raw.githubusercontent.com/construct-worlds/construct/main/install.sh | sh

Pin a version or change the directory with CONSTRUCT_VERSION=v0.2.0 / CONSTRUCT_BIN_DIR=/usr/local/bin.

construct

If no daemon is running yet, construct auto-starts one in the background and attaches — there's no separate daemon step. (Opt out with CONSTRUCT_NO_AUTOSTART=1, e.g. in scripts that manage the daemon themselves.)

Use ? for help and M-x for the command palette. From the TUI you can create sessions, switch between agents, send input, inspect diffs, and interrupt or stop work without leaving the flow.

You can also launch straight into construct by prepending construct new to your favorite CLI harness command:

construct new codex
construct new claude --model opus
construct new pi
construct new muse

To open construct on a remote machine with working copy and paste of text and images, plus drag-and-drop file upload from your laptop into the remote TUI:

construct ssh devbox
construct ssh -J bastion -p 2222 devbox

To run the daemon explicitly instead (e.g. on a server, or under a process supervisor):

construct daemon run

It owns sessions, persists state, and exposes the local IPC socket used by clients. Lifecycle helpers are also available for background daemons:

construct daemon start
construct daemon stop             # stops adapters; sessions resume on next start
construct daemon stop --sessions  # explicit spelling of the same session-safe stop
construct daemon restart
construct daemon restart --sessions

Happy hacking. Chase the idea from your terminal: ask Codex, Claude Code, OpenCode, Antigravity, Grok, and smith to dive into the hard parts, then keep steering from your phone when you're in motion.

construct upgrade            # install the latest release (atomic in-place replace)
construct upgrade --check    # just compare your version against the latest
construct upgrade --restart  # upgrade, then restart a running daemon to apply

construct upgrade re-runs the installer for you (pin a release with --version vX.Y.Z); re-running the install one-liner does the same thing. A running daemon keeps the old code until it restarts — pass --restart, or run /construct restart in the TUI, to pick up the upgrade without losing sessions. Interactive client commands also ask whether to upgrade when a newer release is available; saying yes upgrades in place, restarts a running daemon, and resumes the original command under the new binary. The TUI still surfaces a one-line notice from the cached check. Disable both with CONSTRUCT_NO_UPDATE_CHECK=1.

construct acp runs an Agent Client Protocol stdio server. Configure ACP clients to launch this command:

construct acp

It auto-starts the daemon if needed, then maps ACP session lifecycle calls onto construct daemon sessions. Use --harness, --model, or --cwd to set defaults for session/new requests that omit those fields.

git clone https://github.com/construct-worlds/construct.git
cd construct
cargo build --workspace

Debug binaries land in target/debug/:

• target/debug/construct — TUI, control CLI, the daemon (construct daemon run), ACP stdio server (construct acp), MCP bridge (construct __mcp, internal), and all harness adapters (construct __adapter <name>, internal)

For an optimized build, use cargo build --workspace --release and replace target/debug with target/release.

• Gallery — screenshots and demo clips of the TUI and web client.
• Architecture — daemon/client split, crates, and the Agent Harness Protocol (AHP).
• Harnesses and session modes — supported adapters, interactive vs. headless modes, worktree isolation, and resume behavior.
• Playbook — the per-session Markdown document you and the agent co-edit and run: smart clips, run shimmer, templates, and live collaboration.
• Playbook selection verbs — typed refinement actions on a Playbook selection (challenge assumptions, simplify, crystallize, interview), the pinned inline terminal for interactive verbs, and authoring your own.
• smith built-in agent — providers, model selection, tools, approvals, automode, and hooks.
• Model routing — redirect a session's model traffic to another provider, and publish route targets into a harness's native model picker.
• Unified tool layer — MCP servers and shared tools for fleet control, browser automation, and agent coordination.
• Generative widgets — agent-generated Markdown UI for compact session-scoped task state, timelines, and action links.
• Memory — durable Markdown context for project workflows, decisions, preferences, and pitfalls.
• Configuration — XDG paths, CONSTRUCT_* overrides, and TUI theme customization.
• Extending construct (plugins) — community adapters, verb and template packs, IPC clients, and the construct-plugin publishing convention.
• Remote control — phone/browser access, QR setup, LAN binding, authentication, public tunnel providers, and local debug mode.
• Operators and channels — authenticated headless session ingress, routing, and explicit per-channel publication.
• Contributing — building from source and the dev loop: run your changes as an isolated instance with CONSTRUCT_HOME=/tmp/construct-dev ./target/debug/construct.

MIT — see LICENSE.