Command Line (CLI)

The cyborg CLI — install it, log in to the relay, and drive workspaces, agents, tasks, and terminals on any daemon you have access to, all from the command line.

The cyborg CLI lets you work from a terminal: log in to the relay and drive workspaces, channels, agents, cybos, tasks, and terminals running on any daemon you have access to. Cyborg7 is CLI-first — everything you can do in the app, you can script from the shell.

Install

On Linux the CLI ships with the headless daemon installer (it bundles its own runtime, so no system Node is required):

curl -fsSL https://raw.githubusercontent.com/Cyborg7-com/cyborg7-releases/main/cyborg-cli/install.sh | sh

On macOS and Windows the desktop app bundles the same cyborg binary.

Authenticate

Log in to the relay and save your credentials locally. You can pass --email / --password (or set CYBORG_PASSWORD), point at a self-hosted relay with --url, or reuse an existing --token.

cyborg login --email you@example.com

Confirm who you're logged in as and check daemon/relay connectivity:

cyborg whoami   # show the logged-in user
cyborg status   # show daemon + relay status

Global flags

Every command accepts these output controls, which make the CLI scriptable:

Flag Purpose
-o, --format <table|json|yaml> Output format (default table)
--json Shorthand for -o json
-q, --quiet Minimal output, IDs only
--no-headers Omit table headers
--no-color Disable colored output

Most workspace commands also accept --host <host> to target a specific daemon directly (host:port, or tcp://host:port?ssl=true&password=…; defaults to the local socket, then localhost:6767) and --token / --email for explicit auth.

Manage the daemon

A daemon is the agent host: it runs agents and terminals on a machine and connects them to your workspaces through the relay. On a server you manage one with the cyborg daemon group:

cyborg daemon start --foreground   # run in the foreground (systemd, containers)
cyborg daemon status               # running? which port/home?
cyborg daemon doctor               # version, relay link, online state, update available
cyborg daemon restart
cyborg daemon stop

Useful start flags: --port <port> / --listen <target> (listen target), --home <path> (state directory, default ~/.cyborg7), --replace (take over from an already-running daemon after an update), --no-relay (fully local), --relay-use-tls (wss:// relay connection).

Update

cyborg daemon update

Pulls the latest published bundle (or the latest code, in a source checkout), restarts the daemon onto it, verifies it comes back online, and rolls back if it doesn't. Live terminals survive the restart — they run in a detached pty host process, not in the daemon itself.

Pair & claim

cyborg daemon pair    # QR code + link to attach this daemon to your account
cyborg daemon claim   # claim it for the currently logged-in user
cyborg daemon set-password   # protect direct (non-relay) connections

Pairing is how a headless daemon shows up in the app's daemon list.

Workspaces & channels

Most commands take a workspace id as their first argument — get one with ws:list.

cyborg ws:list
cyborg ws:create "My Team"
cyborg ch:list <workspace-id>
cyborg ch:create <workspace-id> engineering

Messaging

cyborg send <workspace-id> <channel-id> "deploy is out"
cyborg listen <workspace-id> <channel-id>            # stream messages live (Ctrl-C to stop)
cyborg slash <workspace-id> <channel-id> summarize   # run a channel slash command, wait for the result

slash accepts --no-wait (dispatch only) and --timeout <seconds> (default 120). Set model preferences for channel AI commands like /summarize:

cyborg slash:model <workspace-id> <provider> <model>                 # your personal preference
cyborg ch:model <workspace-id> <channel-id> <provider> <model>       # per-channel override

Run either without provider/model to see the current value; pass --clear to reset (back to auto-resolve / the inherited default).

Agents

Agents are live AI sessions running on a daemon.

cyborg agent:create <workspace-id> --provider claude --channel <channel-id> --cwd ~/repo
cyborg agent:list <workspace-id>
cyborg agent:prompt <workspace-id> <agent-id> "run the test suite and summarize failures"
cyborg agent:stop <workspace-id> <agent-id>               # interrupt a stuck run
cyborg agent:mode <workspace-id> <agent-id> acceptEdits   # default | plan | acceptEdits | bypassPermissions
cyborg agent:model <workspace-id> <agent-id> <model>      # 'default' clears the override

Cybos

Cybos are reusable agent templates — identity, personality, and provider defaults.

cyborg cybo:create <workspace-id> reviewer "Code Reviewer"
cyborg cybo:list <workspace-id>
cyborg cybo:spawn <workspace-id> reviewer --channel <channel-id> --cwd ~/repo

Tasks

The same task board the app shows, scriptable:

cyborg task:create <workspace-id> "Fix login redirect" \
  --description "302 loops on expired session" \
  --assignee <user-or-agent-id> --priority high --label bug
cyborg task:list <workspace-id>
cyborg task:update <workspace-id> <task-id> --state <state-id>
cyborg task:archive <workspace-id> <task-id>       # --unarchive to restore
cyborg task:bulk-update <workspace-id> <id1> <id2> --priority low
cyborg project:list <workspace-id>

task:create also supports --due <iso>, --start <iso>, --parent <task-id> (subtasks), --channel, --project, --cycle, and repeatable --label / --module.

Terminals

The cyborg terminal command group drives real terminals running on any daemon you have access to. You can open one, send keystrokes, and read its output entirely from the CLI — no GUI needed. Input is gated by ownership: you can only write to terminals you own.

Commands that take a <terminal-id> accept a full ID, a unique ID prefix, or the terminal's name. Add --host <host> to target a specific daemon.

List terminals

Lists terminals in the current workspace directory. Add --all to list across all workspaces and daemons, or --cwd <path> to scope to a directory.

cyborg terminal ls [--all] [--cwd <path>]

Create a terminal

Opens a new terminal. --cwd sets the working directory (defaults to the current one) and --name gives it a name you can reference later.

cyborg terminal create [--cwd <path>] [--name <name>]

Send keystrokes

Writes input into a terminal. Special tokens like Enter, Tab, Escape, and C-c are interpreted as the matching control sequences; pass --literal to send them verbatim instead.

cyborg terminal send-keys <terminal-id> "<keys>" [Enter] [--literal]

Capture output

Reads the terminal's current screen. Add --scrollback to read from the beginning of history, --ansi to keep color/escape codes, or --json for machine-readable output.

cyborg terminal capture <terminal-id> [--scrollback] [--ansi] [--json]

Kill a terminal

Closes the terminal and frees its process.

cyborg terminal kill <terminal-id>

Workspace terminals (via the relay)

Pass --workspace <id> to route through the relay instead of the local socket — the command reaches whichever daemon hosts the terminal, from any machine you're logged in on. A terminal created with --workspace is bound to that workspace and appears in the app's sidebar for its members — the CLI and the app share one source of truth. When several daemons are connected, pick one with --daemon <id>.

cyborg terminal create --workspace <ws-id> --name deploy --cwd /srv/app
cyborg terminal ls --workspace <ws-id>
cyborg terminal send-keys deploy --workspace <ws-id> "systemctl status app" Enter
cyborg terminal capture deploy --workspace <ws-id>

End-to-end example

Open a terminal, run a command in it, and read the result — entirely from the CLI:

# 1. Create a named terminal and note its id
cyborg terminal create --name demo

# 2. Type a command and press Enter
cyborg terminal send-keys demo "ls -la" Enter

# 3. Read what the terminal printed
cyborg terminal capture demo

# 4. Close it when you're done
cyborg terminal kill demo

Because terminals are referenced by name or ID prefix, the same flow works against a terminal running on any daemon you have access to — just add --host (direct) or --workspace (via the relay).

Next steps