---
id: platform/cli-reference
title: CLI reference
description: Complete bex CLI command reference generated from the binary help tree, with Render compatibility grades.
keywords: [bex, cli, command reference, render cli, compatibility, flags]
sidebar_position: 3
last_updated: 2026-09-23
---

{/* Generated by yarn build:cli-reference from the bex binary help tree. Do not edit by hand. After regenerating English, run: yarn translate-docs --force docs/platform/cli-reference.md */}

This page documents every command the `bex` CLI prints in `--help`, captured from **bex vdev** (upstream pin `v1.1.3-0.20260909214233-a764810a7682`, selection `source-build`, verification `source-build-not-a-release`). Compatibility grades come from the bex checklist (blob `689310e3aa42`).

## Grade legend

| Marker | Meaning |
| --- | --- |
| `[x]` | Verified working against a live bex |
| `[~]` | Works with a documented limitation |
| `[ ]` | Not working / not verified here |
| `[-]` | Deliberate bex non-goal |
| `[bex]` | Native Bex command (not in the Render surface) |

For install, login, and common workflows, see the [CLI guide](../cli.md). For server-side limits, see [compatibility](compatibility.md). For per-operation REST grades, see the [API reference](api-reference.md).

## Global flags {#global-flags}

These flags apply across commands (shown once; individual command tables still list local flags).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--help` | `-h` |  |  | Show help for this command |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--version` | `-v` |  |  | version for bex |

## `blueprints` {#blueprints}

Manage Blueprints, which define your infrastructure as code

**Compatibility:** Works with a documented limitation (`[~]`)

:::note Limitation

manage Blueprints (infrastructure as code)

:::
```bash
bex blueprints <subcommand> [flags]
```

Manage Blueprint files (render.yaml) including validation.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Validate a blueprint file
  bex blueprints validate ./render.yaml
```

### `blueprints validate` {#blueprints-validate}

Validate a YAML file for a Blueprint

**Compatibility:** Verified working (`[x]`)

```bash
bex blueprints validate [file] [flags]
```

Validate a Blueprint file for errors before committing.

Validates:
  - YAML syntax
  - Schema validation (Required fields, types)
  - Semantic validation (valid plans, regions, etc.)
  - Conflict checking against existing resources

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--workspace` | `-w` | `WORKSPACE_ID` |  | Validate against the specified workspace ID (defaults to current workspace) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Validate ./render.yaml
  bex blueprints validate

  # Validate a specific Blueprint file
  bex blueprints validate ./my-blueprint.yaml

  # Output validation results as JSON
  bex blueprints validate -o json
```

## `code` {#code}

Manage the Bex coding-agent launchers (glm, muse, kimi, deepseek)

**Compatibility:** Native Bex command (`[bex]`)

```bash
bex code [subcommand] [flags]
```

`bex glm`, `bex muse`, `bex kimi`, `bex deepseek` each launch a Claude Code
instance connected to that provider's Anthropic-compatible endpoint, in
an isolated per-provider configuration directory under ~/.bex/code
(override with BEX_CODE_HOME). A provider's API key is captured on its
first launch — pasted hidden, verified live, stored owner-only in
~/.bex/code/keys.toml — and the environment always overrides the store.

`bex code` shows provider status; `bex code keys` manages the keys.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

### `code keys` {#code-keys}

Show which provider API keys are configured

**Compatibility:** Native Bex command (`[bex]`)

```bash
bex code keys [subcommand] [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

#### `code keys set` {#code-keys-set}

Capture and verify a provider API key (hidden paste; or piped stdin)

**Compatibility:** Native Bex command (`[bex]`)

```bash
bex code keys set <provider> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

#### `code keys unset` {#code-keys-unset}

Remove a stored provider API key

**Compatibility:** Native Bex command (`[bex]`)

```bash
bex code keys unset <provider> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

## `deepseek` {#deepseek}

Usage: claude [options] [command] [prompt]

**Compatibility:** Native Bex command (`[bex]`)

```text
Claude Code - starts an interactive session by default, use -p/--print for
non-interactive output
Arguments:
prompt                                Your prompt
Options:
--add-dir <directories...>            Additional directories to allow tool
access to
--agent <agent>                       Agent for the current session. Overrides
the 'agent' setting.
--agents <json>                       JSON object defining custom agents (e.g.
'{"reviewer": {"description": "Reviews
code", "prompt": "You are a code
reviewer"}}')
--allow-dangerously-skip-permissions  Enable bypassing all permission checks
as an option, without it being enabled
by default. Recommended only for
sandboxes with no internet access.
--allowedTools, --allowed-tools <tools...>
Comma or space-separated list of tool names to allow (e.g. "Bash(git *)
Edit")
--append-system-prompt <prompt>       Append a system prompt to the default
system prompt
--ax-screen-reader                    Render screen-reader friendly output
(flat text, no decorative borders or
animations).
--bg, --background                    Start the session as a background agent
and return immediately (manage with
`claude agents`)
--bare                                Minimal mode: skip hooks, LSP, plugin
sync, attribution, auto-memory,
background prefetches, keychain reads,
and CLAUDE.md auto-discovery. Sets
CLAUDE_CODE_SIMPLE=1. Anthropic auth is
strictly ANTHROPIC_API_KEY or
apiKeyHelper via --settings (OAuth and
keychain are never read). 3P providers
(Bedrock/Vertex/Foundry) use their own
credentials. Skills still resolve via
/skill-name. Explicitly provide context
via: --system-prompt[-file],
--append-system-prompt[-file], --add-dir
(CLAUDE.md dirs), --mcp-config,
--settings, --agents, --plugin-dir.
--betas <betas...>                    Beta headers to include in API requests
(API key users only)
--brief                               Enable SendUserMessage tool for
agent-to-user communication
--chrome                              Enable Claude in Chrome integration
-c, --continue                        Continue the most recent conversation in
the current directory
--dangerously-skip-permissions        Bypass all permission checks.
Recommended only for sandboxes with no
internet access.
-d, --debug [filter]                  Enable debug mode with optional category
filtering (e.g., "api,hooks" or
"!1p,!file")
--debug-file <path>                   Write debug logs to a specific file path
(implicitly enables debug mode)
--disable-slash-commands              Disable all skills
--disallowedTools, --disallowed-tools <tools...>
Comma or space-separated list of tool names to deny (e.g. "Bash(git *)
Edit")
--effort <level>                      Effort level for the current session
(low, medium, high, xhigh, max)
--exclude-dynamic-system-prompt-sections
Move per-machine sections (cwd, env info, memory paths, git status) from
the system prompt into the first user message. Improves cross-user
prompt-cache reuse. Only applies with the default system prompt (ignored
with --system-prompt). (default: false)
--fallback-model <model>              Enable automatic fallback to specified
model(s) when the default model is
overloaded or not available. Accepts a
comma-separated list to try each in
order. Re-tries the primary at the start
of each user turn. (only works with
--print)
--file <specs...>                     File resources to download at startup.
Format: file_id:relative_path (e.g.,
--file file_abc:doc.txt
file_def:img.png)
--fork-session                        When resuming, create a new session ID
instead of reusing the original (use
with --resume or --continue)
--from-pr [value]                     Resume a session linked to a PR by PR
number/URL, or open interactive picker
with optional search term
-h, --help                            Display help for command
--ide                                 Automatically connect to IDE on startup
if exactly one valid IDE is available
--include-hook-events                 Include all hook lifecycle events in the
output stream (only works with
--output-format=stream-json)
--include-partial-messages            Include partial message chunks as they
arrive (only works with --print and
--output-format=stream-json)
--input-format <format>               Input format (only works with --print):
"text" (default), or "stream-json"
(realtime streaming input) (choices:
"text", "stream-json")
--json-schema <schema>                JSON Schema for structured output
validation. Example:
{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}
--max-budget-usd <amount>             Maximum dollar amount to spend on API
calls (only works with --print)
--mcp-config <configs...>             Load MCP servers from JSON files or
strings (space-separated)
--mcp-debug                           [DEPRECATED. Use --debug instead] Enable
MCP debug mode (shows MCP server errors)
--model <model>                       Model for the current session. Provide
an alias for the latest model (e.g.
'fable', 'opus', or 'sonnet') or a
model's full name (e.g.
'claude-fable-5').
-n, --name <name>                     Set a display name for this session
(shown in the prompt box, /resume
picker, and terminal title)
--no-chrome                           Disable Claude in Chrome integration
--no-session-persistence              Disable session persistence - sessions
will not be saved to disk and cannot be
resumed (only works with --print)
--output-format <format>              Output format (only works with --print):
"text" (default), "json" (single
result), or "stream-json" (realtime
streaming) (choices: "text", "json",
"stream-json")
--permission-mode <mode>              Permission mode to use for the session
(choices: "acceptEdits", "auto",
"bypassPermissions", "default",
"dontAsk", "plan")
--plugin-dir <path>                   Load a plugin from a directory or .zip
for this session only (repeatable:
--plugin-dir A --plugin-dir B.zip)
(default: [])
--plugin-url <url>                    Fetch a plugin .zip from a URL for this
session only (repeatable: --plugin-url A
--plugin-url B) (default: [])
-p, --print                           Print response and exit (useful for
pipes). Note: The workspace trust dialog
is skipped when Claude is run in
non-interactive mode (via -p, or when
stdout is not a TTY, e.g. piped or
redirected output). Only use this in
directories you trust. Settings files
that fail validation are silently
ignored in this mode (no error dialog is
shown).
--prompt-suggestions [value]          Enable prompt suggestions. In print/SDK
mode, emits a prompt_suggestion message
after each turn with a predicted next
user prompt (choices: "true", "false",
"1", "0", "yes", "no", "on", "off",
preset: "true")
--remote-control [name]               Start an interactive session with Remote
Control enabled (optionally named)
--remote-control-session-name-prefix <prefix>
Prefix for auto-generated Remote Control session names (default: hostname)
--replay-user-messages                Re-emit user messages from stdin back on
stdout for acknowledgment (only works
with --input-format=stream-json and
--output-format=stream-json)
-r, --resume [value]                  Resume a conversation by session ID, or
open interactive picker with optional
search term
--safe-mode                           Start with all customizations
(CLAUDE.md, skills, plugins, hooks, MCP
servers, custom commands and agents,
output styles, workflows, custom themes,
keybindings, and more) disabled — useful
for troubleshooting a broken
configuration. Admin-managed (policy)
settings still apply. Auth, model
selection, built-in tools, and
permissions work normally. Sets
CLAUDE_CODE_SAFE_MODE=1.
--session-id <uuid>                   Use a specific session ID for the
conversation (must be a valid UUID)
--setting-sources <sources>           Comma-separated list of setting sources
to load (user, project, local).
--settings <file-or-json>             Path to a settings JSON file or a JSON
string to load additional settings from
--strict-mcp-config                   Only use MCP servers from --mcp-config,
ignoring all other MCP configurations
--system-prompt <prompt>              System prompt to use for the session
--tmux                                Create a tmux session for the worktree
(requires --worktree). Uses iTerm2
native panes when available; use
--tmux=classic for traditional tmux.
--tools <tools...>                    Specify the list of available tools from
the built-in set. Use "" to disable all
tools, "default" to use all tools, or
specify tool names (e.g.
"Bash,Edit,Read").
--verbose                             Override verbose mode setting from
config
-v, --version                         Output the version number
-w, --worktree [name]                 Create a new git worktree for this
session (optionally specify a name)
Commands:
agents [options]                      Manage background agents
auth                                  Manage authentication
auto-mode                             Inspect auto mode classifier
configuration
doctor                                Check the health of your Claude Code
auto-updater. Note: The workspace trust
dialog is skipped and stdio servers from
.mcp.json are spawned for health checks.
Only use this command in directories you
trust.
install [options] [target]            Install Claude Code native build. Use
[target] to specify version (stable,
latest, or specific version)
mcp                                   Configure and manage MCP servers
plugin|plugins                        Manage Claude Code plugins
project                               Manage Claude Code project state
setup-token                           Set up a long-lived authentication token
(requires Claude subscription)
ultrareview [options] [target]        Run a cloud-hosted multi-agent code
review of the current branch (or a PR
number / base branch) and print the
findings
update|upgrade                        Check for updates and install if
available
```

## `deploys` {#deploys}

List, create, and cancel deploys

**Compatibility:** Verified working (`[x]`)

```bash
bex deploys <subcommand> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List deploys for a service
  bex deploys list srv-abc123

  # Trigger a deploy for a service
  bex deploys create srv-abc123
```

### `deploys cancel` {#deploys-cancel}

Cancel a running deploy

**Compatibility:** Verified working (`[x]`)

```bash
bex deploys cancel <serviceID> <deployID> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Cancel a running deploy
  bex deploys cancel srv-abc123 dep-xyz789
```

### `deploys create` {#deploys-create}

Trigger a service deploy and stream logs in real time

**Compatibility:** Verified working (`[x]`)

```bash
bex deploys create [serviceID] [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--clear-cache` |  |  |  | Clear build cache before deploying |
| `--commit` |  | `COMMIT_ID` |  | Deploy the specified commit ID |
| `--help` | `-h` |  |  | Show help for this command |
| `--image` |  | `IMAGE_URL` |  | Deploy the specified Docker image URL |
| `--wait` |  |  |  | Wait for deploy completion and exit non-zero if deploy fails |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Trigger a deploy for a service
  bex deploys create srv-abc123

  # Deploy a specific commit
  bex deploys create srv-abc123 --commit 0123abcd

  # Wait until deploy completes
  bex deploys create srv-abc123 --wait
```

### `deploys list` {#deploys-list}

List deploys for a service

**Compatibility:** Verified working (`[x]`)

```bash
bex deploys list [serviceID] [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List deploys for a service
  bex deploys list srv-abc123

  # Browse deploys interactively
  bex deploys list
```

## `docs` {#docs}

Open the Bex docs in your browser

**Compatibility:** Verified working (`[x]`)

```bash
bex docs [flags]
```

Open the Bex CLI guide in your browser.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Open Bex documentation
  bex docs
```

## `ea` {#ea}

Use early access commands

**Compatibility:** Works with a documented limitation (`[~]`)

:::note Limitation

early-access surfaces; `ea sandbox` create/list/stop (w3/m32) **and exec** (w3/m33) all ship on the gVisor substrate, `ea objects` still out of the compatibility target

:::
```bash
bex ea [subcommand] [flags]
```

These commands are in early access and are subject to change.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List early access object storage resources
  bex ea objects list --region=oregon
```

### `ea objects` {#ea-objects}

Manage object storage in early access

**Compatibility:** Works with a documented limitation (`[~]`)

:::note Limitation

early-access surfaces; `ea sandbox` create/list/stop (w3/m32) **and exec** (w3/m33) all ship on the gVisor substrate, `ea objects` still out of the compatibility target

:::
```bash
bex ea objects <subcommand> [flags]
```

Manage object storage for your Render services.

Object storage allows you to store and retrieve arbitrary data. Use these
commands to list, upload, download, and delete objects.

The --region flag specifies which region to use. Alternatively, set the
RENDER_REGION environment variable. The --region flag takes precedence if both
are provided.

When using the --local flag, objects are stored in the .render/objects/
directory instead of cloud storage.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--local` |  |  |  | Use local storage (.render/objects/) instead of cloud storage |
| `--region` |  | `REGION` |  | Set target region (or set the RENDER_REGION env var) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List objects in object storage
  bex ea objects list --region=oregon

  # Upload an object
  bex ea objects put backups/2026-04-15/users.ndjson --file=./exports/users.ndjson --region=oregon

  # Download an object
  bex ea objects get backups/2026-04-15/users.ndjson --file=./downloads/users.ndjson --region=oregon

  # Delete an object
  bex ea objects delete uploads/test/avatar.png --region=oregon --yes
```

#### `ea objects delete` {#ea-objects-delete}

Delete one or more objects from storage

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`404` (`--local` works client-side)

:::
```bash
bex ea objects delete <key> [additionalKeys...] [flags]
```

This operation is irreversible.

Delete one or more objects from storage.

By default, you will be prompted for confirmation unless you specify the --yes
flag.

In local development mode (--local flag or RENDER_USE_LOCAL_DEV=true), files are
deleted from the .render/objects/ directory.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--yes` | `-y` |  |  | Skip confirmation prompt |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Use local storage (.render/objects/) instead of cloud storage |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--region` |  | `REGION` |  | Set target region (or set the RENDER_REGION env var) |

```bash
# Delete a single object
  bex ea objects delete assets/images/old-logo.png --region=oregon

  # Delete multiple objects without confirmation
  bex ea objects delete tmp/import-001.json tmp/import-002.json --region=oregon --yes

  # Delete from local object storage
  bex ea objects delete local-dev/fixtures/sample.json --region=oregon --local --yes
```

#### `ea objects get` {#ea-objects-get}

Download a file from object storage

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`404` (`--local` works client-side)

:::
```bash
bex ea objects get <key> [--file=<path>] [flags]
```

Download a file from object storage.

If --file is not specified, the object content is written to stdout, which is
useful for piping to other commands.

In local development mode (--local flag or RENDER_USE_LOCAL_DEV=true), files are
read from the .render/objects/ directory.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--file` | `-f` | `string` | `stdout` | Output file path |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Use local storage (.render/objects/) instead of cloud storage |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--region` |  | `REGION` |  | Set target region (or set the RENDER_REGION env var) |

```bash
# Download an object to a file
  bex ea objects get backups/2026-04-15/users.ndjson --file=./downloads/users.ndjson --region=oregon

  # Write object content to stdout
  bex ea objects get config/runtime/env.json --region=oregon

  # Read from local object storage
  bex ea objects get local-dev/fixtures/sample.json --file=./tmp/sample.json --region=oregon --local
```

#### `ea objects list` {#ea-objects-list}

List objects in storage

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

bex `/v1/objects` → `404` (`--local` works client-side)

:::
```bash
bex ea objects list [flags]
```

List objects in object storage for a specific region.

Displays object keys, content types, sizes, and last modified timestamps.

In local development mode (--local flag or RENDER_USE_LOCAL_DEV=true), lists
files from the .render/objects/ directory.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--limit` |  | `COUNT` | `100` | Limit the number of objects returned |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Use local storage (.render/objects/) instead of cloud storage |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--region` |  | `REGION` |  | Set target region (or set the RENDER_REGION env var) |

```bash
# List objects in cloud storage
  bex ea objects list --region=oregon

  # Limit number of objects returned
  bex ea objects list --region=oregon --limit=200

  # List objects from local storage
  bex ea objects list --region=oregon --local
```

#### `ea objects put` {#ea-objects-put}

Upload a file to object storage

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`404` (`--local` works client-side)

:::
```bash
bex ea objects put <key> --file=<path> [flags]
```

Upload a file to object storage.

The key is the path/name under which the object will be stored. Keys can include
path-like structures (e.g., "uploads/images/photo.jpg").

In local development mode (--local flag or RENDER_USE_LOCAL_DEV=true), files are
stored in the .render/objects/ directory.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--file` | `-f` | `PATH` |  | Path to the local file to upload (Required) |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Use local storage (.render/objects/) instead of cloud storage |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--region` |  | `REGION` |  | Set target region (or set the RENDER_REGION env var) |

```bash
# Upload a local file
  bex ea objects put backups/2026-04-15/users.ndjson --file=./exports/users.ndjson --region=oregon

  # Upload with a relative file path
  bex ea objects put assets/images/logo.png --file=./public/logo.png --region=oregon

  # Upload to local object storage
  bex ea objects put local-dev/fixtures/sample.json --file=./fixtures/sample.json --region=oregon --local
```

### `ea sandbox-groups` {#ea-sandbox-groups}

Manage sandbox groups

**Compatibility:** Works with a documented limitation (`[~]`)

:::note Limitation

early-access surfaces; `ea sandbox` create/list/stop (w3/m32) **and exec** (w3/m33) all ship on the gVisor substrate, `ea objects` still out of the compatibility target

:::
```bash
bex ea sandbox-groups <subcommand> [flags]
```

Manage sandbox groups for your Render workspace.

Sandbox groups scope a workspace's sandboxes to a region and (optionally) an
environment. Early Access guarantees at most one default group per workspace;
Beta will add multi-group support.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
bex ea sandbox-groups list
  bex ea sandbox-groups list -o json
```

#### `ea sandbox-groups list` {#ea-sandbox-groups-list}

List sandbox groups in the active workspace

**Compatibility:** Verified working (`[x]`)

```bash
bex ea sandbox-groups list [flags]
```

List sandbox groups in your workspace.

Early Access guarantees at most one default group per workspace, so this
command typically prints a single row.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List sandbox groups in the active workspace
  bex ea sandbox-groups list

  # Output as JSON
  bex ea sandbox-groups list -o json
```

### `ea sandboxes` {#ea-sandboxes}

Manage sandboxes

**Compatibility:** Works with a documented limitation (`[~]`)

:::note Limitation

early-access surfaces; `ea sandbox` create/list/stop (w3/m32) **and exec** (w3/m33) all ship on the gVisor substrate, `ea objects` still out of the compatibility target

:::
```bash
bex ea sandboxes <subcommand> [flags]
```

Manage sandboxes for your Render workspace.

Sandboxes are ephemeral compute environments for running code, agents, and
experiments.

Every sandbox belongs to a sandbox group, which scopes it to a region. Manage
groups with "render ea sandbox-groups".

Snapshot a sandbox with "render ea sandboxes snapshots create" and restore new
sandboxes from it with "render ea sandboxes create --snapshot-id".

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
bex ea sandboxes create
  bex ea sandboxes create --plan=standard --region=oregon
  bex ea sandboxes create --snapshot-id snp-abc123
  bex ea sandboxes copy ./main.py sbx-abc123:/app/main.py
  bex ea sandboxes exec sbx-abc123 -- echo hello
  bex ea sandboxes snapshots create sbx-abc123
  bex ea sandboxes snapshots list --group sbg-abc123
  bex ea sandboxes stop sbx-abc123 --confirm
```

#### `ea sandboxes copy` {#ea-sandboxes-copy}

Copy files to or from a sandbox

**Compatibility:** Works with a documented limitation (`[~]`)

:::note Limitation

early-access surfaces; `ea sandbox` create/list/stop (w3/m32) **and exec** (w3/m33) all ship on the gVisor substrate, `ea objects` still out of the compatibility target

:::
```bash
bex ea sandboxes copy <src> <dst> [flags]
```

Copy a file or directory between the local filesystem and a running sandbox.

Prefix the remote side with the sandbox ID and a colon, like scp. A relative
sandbox path resolves inside the sandbox's home directory; an absolute path
addresses the sandbox filesystem root. Directories are transferred as
archives: uploading a local directory recreates it at the sandbox path, and
downloading a sandbox directory recreates it under the local path. "cp" works
as an alias.

Unlike cp, a directory destination is not nested into: copying ./src to
sbx-abc123:/tmp/src puts src's contents at /tmp/src, not at /tmp/src/src. A
single file copied to an existing local directory does land inside it.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
bex ea sandboxes copy ./main.py sbx-abc123:main.py
  bex ea sandboxes copy sbx-abc123:output.json ./output.json
  bex ea sandboxes copy ./src sbx-abc123:/tmp/src
  bex ea sandboxes cp sbx-abc123:. ./sandbox-home
  bex ea sandboxes copy sbx-abc123:output.json ./downloads/ --output json
```

#### `ea sandboxes create` {#ea-sandboxes-create}

Create a new sandbox

**Compatibility:** Verified working (`[x]`)

```bash
bex ea sandboxes create [flags]
```

Create a new sandbox in the current workspace.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--env-file` |  | `PATH` |  | Path to an env file to load. Repeat to load multiple files (later files override earlier ones). Every listed file must exist |
| `--env-var` |  | `KEY_VALUE` |  | Set environment variables in KEY=VALUE format (can be specified multiple times). Inline values override values loaded from --env-file |
| `--help` | `-h` |  |  | Show help for this command |
| `--network-policy` |  | `NETWORK_POLICY` |  | Outbound network policy: allow-all, deny-all |
| `--plan` |  | `string` |  | Compute plan: starter, standard, pro |
| `--region` |  | `string` |  | Region to run the sandbox in |
| `--snapshot-id` |  | `SNAPSHOT_ID` |  | Start from this snapshot instead of the base image. The snapshot must be available and in the same sandbox group. A runtime snapshot requires --plan to match its plan (**Non-goal on Bex**: Sandbox snapshot restore is a deliberate bex non-goal (checklist pin note for --snapshot-id); upstream help only) |
| `--timeout` |  | `int` | `0` | Maximum sandbox lifetime in seconds. 0 uses the default and maximum of 86400 (24 hours) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
bex ea sandboxes create
  bex ea sandboxes create --plan=standard --region=oregon
  bex ea sandboxes create --timeout=3600
  bex ea sandboxes create --network-policy=deny-all
  bex ea sandboxes create --env-var FOO=bar --env-var BAZ=qux
  bex ea sandboxes create --env-file .env.production --env-var LOG_LEVEL=debug
  bex ea sandboxes create --snapshot-id snp-abc123
```

#### `ea sandboxes exec` {#ea-sandboxes-exec}

Execute a command in a sandbox

**Compatibility:** Verified working (`[x]`)

```bash
bex ea sandboxes exec <sandboxId> -- <command> [flags]
```

Run a single command in a running sandbox. Streams stdout and stderr as
the command runs, then exits with the remote command's exit code.

Pass the command after a "--" separator so its own flags aren't parsed by the
CLI.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
bex ea sandboxes exec sbx-abc123 -- echo hello
  bex ea sandboxes exec sbx-abc123 -- python script.py
```

#### `ea sandboxes list` {#ea-sandboxes-list}

List sandboxes

**Compatibility:** Verified working (`[x]`)

```bash
bex ea sandboxes list [flags]
```

List sandboxes in your workspace.

By default, terminated sandboxes are excluded. Use --all to include them, or
--status to filter by specific statuses.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--all` |  |  |  | Include terminated sandboxes |
| `--help` | `-h` |  |  | Show help for this command |
| `--status` |  | `stringArray` |  | Filter by status (repeatable: creating, running, errored, terminated) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
bex ea sandboxes list
  bex ea sandboxes list --all
  bex ea sandboxes list --status=running
  bex ea sandboxes list --status=running --status=creating
  bex ea sandboxes list -o json
```

#### `ea sandboxes snapshots` {#ea-sandboxes-snapshots}

Manage sandbox snapshots

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

Early-access sandbox snapshots are a deliberate bex non-goal (checklist pin note for CreateSandboxSnapshot*/ListSandboxSnapshots/RetrieveSandboxSnapshot).

:::
```bash
bex ea sandboxes snapshots <subcommand> [flags]
```

Manage snapshots of sandboxes in your Render workspace.

A snapshot captures a running sandbox so a new sandbox can be restored from it
with
"render ea sandboxes create --snapshot-id". A filesystem snapshot captures the
writable filesystem and restores onto any plan. A runtime snapshot also captures
memory and CPU state and restores only onto the plan of the source sandbox.

Snapshots belong to the sandbox group of their source sandbox. Getting or
listing
snapshots uses the active workspace's default group unless --group is provided.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Snapshot a running sandbox
  bex ea sandboxes snapshots create sbx-abc123

  # List the snapshots in the default sandbox group
  bex ea sandboxes snapshots list

  # List the snapshots in a specific sandbox group
  bex ea sandboxes snapshots list --group sbg-abc123

  # Get one snapshot
  bex ea sandboxes snapshots get snp-abc123
```

#### `ea sandboxes snapshots create` {#ea-sandboxes-snapshots-create}

Snapshot a running sandbox

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

Early-access sandbox snapshots are a deliberate bex non-goal (checklist pin note for CreateSandboxSnapshot*/ListSandboxSnapshots/RetrieveSandboxSnapshot).

:::
```bash
bex ea sandboxes snapshots create <sandboxId> [flags]
```

Capture a snapshot of a running sandbox.

The command returns as soon as the API accepts the request, while the snapshot
status is still "creating". Poll with "render ea sandboxes snapshots get" until
the status is "available" before starting a sandbox from it.

The sandbox keeps running after the capture.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--kind` |  | `KIND` |  | Snapshot kind: filesystem (default), runtime |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Snapshot the filesystem (default)
  bex ea sandboxes snapshots create sbx-abc123

  # Also capture memory and CPU state
  bex ea sandboxes snapshots create sbx-abc123 --kind runtime

  # JSON output
  bex ea sandboxes snapshots create sbx-abc123 --output json
```

#### `ea sandboxes snapshots get` {#ea-sandboxes-snapshots-get}

Get a sandbox snapshot

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

Early-access sandbox snapshots are a deliberate bex non-goal (checklist pin note for CreateSandboxSnapshot*/ListSandboxSnapshots/RetrieveSandboxSnapshot).

:::
```bash
bex ea sandboxes snapshots get <snapshotId> [flags]
```

Get one sandbox snapshot by ID.

Uses the active workspace's default sandbox group unless --group is provided.
An expired snapshot is reported as not found.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--group` |  | `SANDBOX_GROUP_ID` |  | Sandbox group the snapshot belongs to (defaults to the active workspace's default group) |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Get a snapshot
  bex ea sandboxes snapshots get snp-abc123

  # Get a snapshot in a specific group
  bex ea sandboxes snapshots get snp-abc123 --group sbg-abc123

  # JSON output
  bex ea sandboxes snapshots get snp-abc123 --output json
```

#### `ea sandboxes snapshots list` {#ea-sandboxes-snapshots-list}

List sandbox snapshots

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

Early-access sandbox snapshots are a deliberate bex non-goal (checklist pin note for CreateSandboxSnapshot*/ListSandboxSnapshots/RetrieveSandboxSnapshot).

:::
```bash
bex ea sandboxes snapshots list [flags]
```

List the snapshots in a sandbox group, newest first.

Uses the active workspace's default sandbox group unless --group is provided.
Deleted and expired snapshots are not listed.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--group` |  | `SANDBOX_GROUP_ID` |  | Sandbox group to list (defaults to the active workspace's default group) |
| `--help` | `-h` |  |  | Show help for this command |
| `--status` |  | `STATUS` |  | Filter by status (repeatable: creating, available, failed) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List every snapshot in the default sandbox group
  bex ea sandboxes snapshots list

  # List snapshots in a specific group
  bex ea sandboxes snapshots list --group sbg-abc123

  # Only snapshots that are ready to start a sandbox from
  bex ea sandboxes snapshots list --status available

  # JSON output
  bex ea sandboxes snapshots list --output json
```

#### `ea sandboxes stop` {#ea-sandboxes-stop}

Terminate a sandbox

**Compatibility:** Verified working (`[x]`)

```bash
bex ea sandboxes stop <sandboxId> [flags]
```

Terminate a running sandbox. This action is irreversible.

Without --confirm, this command previews what would be terminated and makes no
changes. Pass --confirm to actually terminate the sandbox.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Preview termination (no changes made)
  bex ea sandboxes stop sbx-abc123

  # Terminate the sandbox
  bex ea sandboxes stop sbx-abc123 --confirm

  # JSON output
  bex ea sandboxes stop sbx-abc123 --confirm --output json
```

## `environments` {#environments}

List project environments by project ID

**Compatibility:** Verified working (`[x]`)

```bash
bex environments <projectID> [flags]
```

List environments for a specified project in the active workspace. In
interactive mode you can view each environment's individual services.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List environments for a project
  bex environments prj-abc123
```

## `glm` {#glm}

Usage: claude [options] [command] [prompt]

**Compatibility:** Native Bex command (`[bex]`)

```text
Claude Code - starts an interactive session by default, use -p/--print for
non-interactive output
Arguments:
prompt                                Your prompt
Options:
--add-dir <directories...>            Additional directories to allow tool
access to
--agent <agent>                       Agent for the current session. Overrides
the 'agent' setting.
--agents <json>                       JSON object defining custom agents (e.g.
'{"reviewer": {"description": "Reviews
code", "prompt": "You are a code
reviewer"}}')
--allow-dangerously-skip-permissions  Enable bypassing all permission checks
as an option, without it being enabled
by default. Recommended only for
sandboxes with no internet access.
--allowedTools, --allowed-tools <tools...>
Comma or space-separated list of tool names to allow (e.g. "Bash(git *)
Edit")
--append-system-prompt <prompt>       Append a system prompt to the default
system prompt
--ax-screen-reader                    Render screen-reader friendly output
(flat text, no decorative borders or
animations).
--bg, --background                    Start the session as a background agent
and return immediately (manage with
`claude agents`)
--bare                                Minimal mode: skip hooks, LSP, plugin
sync, attribution, auto-memory,
background prefetches, keychain reads,
and CLAUDE.md auto-discovery. Sets
CLAUDE_CODE_SIMPLE=1. Anthropic auth is
strictly ANTHROPIC_API_KEY or
apiKeyHelper via --settings (OAuth and
keychain are never read). 3P providers
(Bedrock/Vertex/Foundry) use their own
credentials. Skills still resolve via
/skill-name. Explicitly provide context
via: --system-prompt[-file],
--append-system-prompt[-file], --add-dir
(CLAUDE.md dirs), --mcp-config,
--settings, --agents, --plugin-dir.
--betas <betas...>                    Beta headers to include in API requests
(API key users only)
--brief                               Enable SendUserMessage tool for
agent-to-user communication
--chrome                              Enable Claude in Chrome integration
-c, --continue                        Continue the most recent conversation in
the current directory
--dangerously-skip-permissions        Bypass all permission checks.
Recommended only for sandboxes with no
internet access.
-d, --debug [filter]                  Enable debug mode with optional category
filtering (e.g., "api,hooks" or
"!1p,!file")
--debug-file <path>                   Write debug logs to a specific file path
(implicitly enables debug mode)
--disable-slash-commands              Disable all skills
--disallowedTools, --disallowed-tools <tools...>
Comma or space-separated list of tool names to deny (e.g. "Bash(git *)
Edit")
--effort <level>                      Effort level for the current session
(low, medium, high, xhigh, max)
--exclude-dynamic-system-prompt-sections
Move per-machine sections (cwd, env info, memory paths, git status) from
the system prompt into the first user message. Improves cross-user
prompt-cache reuse. Only applies with the default system prompt (ignored
with --system-prompt). (default: false)
--fallback-model <model>              Enable automatic fallback to specified
model(s) when the default model is
overloaded or not available. Accepts a
comma-separated list to try each in
order. Re-tries the primary at the start
of each user turn. (only works with
--print)
--file <specs...>                     File resources to download at startup.
Format: file_id:relative_path (e.g.,
--file file_abc:doc.txt
file_def:img.png)
--fork-session                        When resuming, create a new session ID
instead of reusing the original (use
with --resume or --continue)
--from-pr [value]                     Resume a session linked to a PR by PR
number/URL, or open interactive picker
with optional search term
-h, --help                            Display help for command
--ide                                 Automatically connect to IDE on startup
if exactly one valid IDE is available
--include-hook-events                 Include all hook lifecycle events in the
output stream (only works with
--output-format=stream-json)
--include-partial-messages            Include partial message chunks as they
arrive (only works with --print and
--output-format=stream-json)
--input-format <format>               Input format (only works with --print):
"text" (default), or "stream-json"
(realtime streaming input) (choices:
"text", "stream-json")
--json-schema <schema>                JSON Schema for structured output
validation. Example:
{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}
--max-budget-usd <amount>             Maximum dollar amount to spend on API
calls (only works with --print)
--mcp-config <configs...>             Load MCP servers from JSON files or
strings (space-separated)
--mcp-debug                           [DEPRECATED. Use --debug instead] Enable
MCP debug mode (shows MCP server errors)
--model <model>                       Model for the current session. Provide
an alias for the latest model (e.g.
'fable', 'opus', or 'sonnet') or a
model's full name (e.g.
'claude-fable-5').
-n, --name <name>                     Set a display name for this session
(shown in the prompt box, /resume
picker, and terminal title)
--no-chrome                           Disable Claude in Chrome integration
--no-session-persistence              Disable session persistence - sessions
will not be saved to disk and cannot be
resumed (only works with --print)
--output-format <format>              Output format (only works with --print):
"text" (default), "json" (single
result), or "stream-json" (realtime
streaming) (choices: "text", "json",
"stream-json")
--permission-mode <mode>              Permission mode to use for the session
(choices: "acceptEdits", "auto",
"bypassPermissions", "default",
"dontAsk", "plan")
--plugin-dir <path>                   Load a plugin from a directory or .zip
for this session only (repeatable:
--plugin-dir A --plugin-dir B.zip)
(default: [])
--plugin-url <url>                    Fetch a plugin .zip from a URL for this
session only (repeatable: --plugin-url A
--plugin-url B) (default: [])
-p, --print                           Print response and exit (useful for
pipes). Note: The workspace trust dialog
is skipped when Claude is run in
non-interactive mode (via -p, or when
stdout is not a TTY, e.g. piped or
redirected output). Only use this in
directories you trust. Settings files
that fail validation are silently
ignored in this mode (no error dialog is
shown).
--prompt-suggestions [value]          Enable prompt suggestions. In print/SDK
mode, emits a prompt_suggestion message
after each turn with a predicted next
user prompt (choices: "true", "false",
"1", "0", "yes", "no", "on", "off",
preset: "true")
--remote-control [name]               Start an interactive session with Remote
Control enabled (optionally named)
--remote-control-session-name-prefix <prefix>
Prefix for auto-generated Remote Control session names (default: hostname)
--replay-user-messages                Re-emit user messages from stdin back on
stdout for acknowledgment (only works
with --input-format=stream-json and
--output-format=stream-json)
-r, --resume [value]                  Resume a conversation by session ID, or
open interactive picker with optional
search term
--safe-mode                           Start with all customizations
(CLAUDE.md, skills, plugins, hooks, MCP
servers, custom commands and agents,
output styles, workflows, custom themes,
keybindings, and more) disabled — useful
for troubleshooting a broken
configuration. Admin-managed (policy)
settings still apply. Auth, model
selection, built-in tools, and
permissions work normally. Sets
CLAUDE_CODE_SAFE_MODE=1.
--session-id <uuid>                   Use a specific session ID for the
conversation (must be a valid UUID)
--setting-sources <sources>           Comma-separated list of setting sources
to load (user, project, local).
--settings <file-or-json>             Path to a settings JSON file or a JSON
string to load additional settings from
--strict-mcp-config                   Only use MCP servers from --mcp-config,
ignoring all other MCP configurations
--system-prompt <prompt>              System prompt to use for the session
--tmux                                Create a tmux session for the worktree
(requires --worktree). Uses iTerm2
native panes when available; use
--tmux=classic for traditional tmux.
--tools <tools...>                    Specify the list of available tools from
the built-in set. Use "" to disable all
tools, "default" to use all tools, or
specify tool names (e.g.
"Bash,Edit,Read").
--verbose                             Override verbose mode setting from
config
-v, --version                         Output the version number
-w, --worktree [name]                 Create a new git worktree for this
session (optionally specify a name)
Commands:
agents [options]                      Manage background agents
auth                                  Manage authentication
auto-mode                             Inspect auto mode classifier
configuration
doctor                                Check the health of your Claude Code
auto-updater. Note: The workspace trust
dialog is skipped and stdio servers from
.mcp.json are spawned for health checks.
Only use this command in directories you
trust.
install [options] [target]            Install Claude Code native build. Use
[target] to specify version (stable,
latest, or specific version)
mcp                                   Configure and manage MCP servers
plugin|plugins                        Manage Claude Code plugins
project                               Manage Claude Code project state
setup-token                           Set up a long-lived authentication token
(requires Claude subscription)
ultrareview [options] [target]        Run a cloud-hosted multi-agent code
review of the current branch (or a PR
number / base branch) and print the
findings
update|upgrade                        Check for updates and install if
available
```

## `jobs` {#jobs}

Create and manage one-off jobs

**Compatibility:** Verified working (`[x]`)

```bash
bex jobs <subcommand> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List jobs for a service
  bex jobs list srv-abc123

  # Create a job for a service
  bex jobs create srv-abc123 --start-command "bundle exec rake task"
```

### `jobs cancel` {#jobs-cancel}

Cancel a running job

**Compatibility:** Verified working (`[x]`)

```bash
bex jobs cancel <serviceID> <jobID> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Cancel a running job
  bex jobs cancel srv-abc123 job-xyz789
```

### `jobs create` {#jobs-create}

Create a new job for a service

**Compatibility:** Verified working (`[x]`)

```bash
bex jobs create [serviceID] [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--plan-id` |  | `PLAN_ID` |  | Set the plan ID for the job (Optional) |
| `--start-command` |  | `COMMAND` |  | Set the job start command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Create a job for a service
  bex jobs create srv-abc123 --start-command "bundle exec rake task"

  # Create a job with a specific plan
  # See https://render.com/docs/one-off-jobs for available job plans
  bex jobs create srv-abc123 --start-command "npm run worker" --plan-id plan-srv-006
```

### `jobs list` {#jobs-list}

List jobs for a service

**Compatibility:** Verified working (`[x]`)

```bash
bex jobs list [serviceID] [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List jobs for a service
  bex jobs list srv-abc123

  # Browse jobs interactively
  bex jobs list
```

## `keyvalues` {#keyvalues}

Manage Bex Key Value instances (alias: kv)

**Compatibility:** Verified working (`[x]`)

```bash
bex keyvalues <subcommand> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

### `keyvalues create` {#keyvalues-create}

Create a new Bex Key Value instance

**Compatibility:** Verified working (`[x]`)

```bash
bex keyvalues create [flags]
```

Create a new Bex Key Value instance.

In interactive mode, a prompt guides you through each option one at a time.
In non-interactive mode (--output text/json/yaml), flags use defaults if not
supplied.
Use --confirm to skip all prompts (including final confirmation) and create
immediately.
Output will be human-readable; use --output json/yaml/text for machine-readable
output.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Set the environment to create the Key Value in (ID or name, optional). Example: Production or evm-abc123def456 |
| `--help` | `-h` |  |  | Show help for this command |
| `--ip-allow-list` |  | `CIDR_DESCRIPTION` |  | Restrict inbound traffic to specific IP ranges (format: cidr=`<range>`,description=`<label>`). Repeat the flag for multiple entries |
| `--memory-policy` |  | `MAXMEMORY_POLICY` |  | Set the eviction policy used when the instance runs out of memory. |
| `--name` |  | `NAME` |  | Set the Key Value instance name (generated if not provided) |
| `--persistence-mode` |  | `PERSISTENCE_MODE` |  | Set the on-disk persistence mode: journal_snapshot \| snapshot \| off (off loses data on restart; omit to use the plan default) |
| `--plan` |  | `PLAN` |  | Set the plan to one of: free \| 256mb \| 1g \| 5g \| 10g \| 20g \| 40g. Custom enterprise plan names are also accepted |
| `--project` |  | `PROJECT` |  | Scope environment lookup to a project (ID or name, optional); if the project has exactly one environment it is used automatically |
| `--region` |  | `REGION` |  | Set the region: frankfurt \| ohio \| oregon \| singapore \| virginia |
| `--workspace` |  | `WORKSPACE` |  | Set the workspace to create the Key Value in (ID or name). Defaults to the active workspace (set via 'bex workspace set') |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Interactive wizard (guided prompts for each option)
  bex kv create

  # Specify all options; wizard still asks for confirmation before creating
  bex kv create --name my-cache --plan 256mb --region oregon

  # Skip all prompts and create immediately (no confirmation)
  bex kv create --name my-cache --plan free --confirm

  # Machine-readable output (non-interactive, no prompts)
  bex kv create --name my-cache --plan 256mb --output json

  # Use as a cache with no on-disk persistence
  bex kv create --name my-cache --plan 256mb --persistence-mode off

  # With IP allow-listing (repeat the flag for multiple entries)
  bex kv create --name my-cache \
    --ip-allow-list "cidr=203.0.113.5/32,description=office" \
    --ip-allow-list "cidr=10.0.0.0/8,description=internal"
```

### `keyvalues delete` {#keyvalues-delete}

Delete a Bex Key Value instance

**Compatibility:** Verified working (`[x]`)

```bash
bex keyvalues delete <keyValueID|keyValueName> [flags]
```

Delete a Bex Key Value instance.

Without --confirm, this command previews what would be deleted and makes no
changes. Pass --confirm to actually delete the instance.

The positional argument accepts either a Key Value ID (red-...) or a name.
If the name matches more than one instance, narrow the search with
--environment `<id|name>`, or pass the Key Value ID directly.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set `<name|ID>`' and try again, or pass the
Key Value ID instead (which works across workspaces).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Key Value name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Preview deletion (no changes made)
  bex kv delete red-abc123def456ghi789jkl0

  # Delete by ID
  bex kv delete red-abc123def456ghi789jkl0 --confirm

  # Delete by name
  bex kv delete my-cache --confirm

  # Disambiguate a name that exists in multiple environments
  bex kv delete my-cache --environment production --confirm

  # JSON output
  bex kv delete red-abc123def456ghi789jkl0 --confirm --output json
```

### `keyvalues get` {#keyvalues-get}

Get details of a Bex Key Value instance

**Compatibility:** Verified working (`[x]`)

```bash
bex keyvalues get <keyValueID|keyValueName> [flags]
```

Get details and connection info for a Bex Key Value instance.

The positional argument accepts either a Key Value ID (red-...) or a name.
If the name matches more than one instance, narrow the search with
--project `<id|name>`, --environment `<id|name>`, or pass the Key Value ID
directly.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set `<name|ID>`' and try again, or pass the
Key Value ID instead (which works across workspaces).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Key Value name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--include-sensitive-connection-info` |  |  |  | Include connection strings and credentials in the output |
| `--project` |  | `PROJECT` |  | Narrow lookup to a project (ID or name, optional) within the active workspace |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Get by ID
  bex kv get red-abc123def456ghi789jkl0

  # Get by name
  bex kv get my-cache

  # Include connection strings (contains credentials)
  bex kv get my-cache --include-sensitive-connection-info

  # Disambiguate by project
  bex kv get my-cache --project my-project

  # Disambiguate a name that exists in multiple environments
  bex kv get my-cache --environment production

  # JSON output
  bex kv get red-abc123def456ghi789jkl0 --output json
```

### `keyvalues list` {#keyvalues-list}

List Bex Key Value instances

**Compatibility:** Verified working (`[x]`)

```bash
bex keyvalues list [flags]
```

List Bex Key Value instances in the active workspace.

Use --project to narrow results to a single project, --environment to narrow
to a single environment, or both — when both are supplied, the environment is
resolved within that project.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow results to a single environment (ID or name, optional) |
| `--help` | `-h` |  |  | Show help for this command |
| `--project` |  | `PROJECT` |  | Narrow results to environments in a project (ID or name, optional) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List all Key Value instances in the active workspace
  bex kv list

  # List all Key Value instances in a project
  bex kv list --project my-project

  # Filter by environment name
  bex kv list --environment production

  # Disambiguate an environment name by project
  bex kv list --project my-project --environment production

  # JSON output
  bex kv list --output json
```

### `keyvalues resume` {#keyvalues-resume}

Resume a suspended Bex Key Value instance

**Compatibility:** Verified working (`[x]`)

```bash
bex keyvalues resume <keyValueID|keyValueName> [flags]
```

Resume a suspended Bex Key Value instance.

The positional argument accepts either a Key Value ID (red-...) or a name.
If the name matches more than one instance, narrow the search with
--environment `<id|name>`, or pass the Key Value ID directly.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set `<name|ID>`' and try again, or pass the
Key Value ID instead (which works across workspaces).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Key Value name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Resume by ID
  bex kv resume red-abc123def456ghi789jkl0

  # Resume by name
  bex kv resume my-cache

  # Disambiguate a name that exists in multiple environments
  bex kv resume my-cache --environment production

  # JSON output
  bex kv resume red-abc123def456ghi789jkl0 --output json
```

### `keyvalues suspend` {#keyvalues-suspend}

Suspend a Bex Key Value instance

**Compatibility:** Verified working (`[x]`)

```bash
bex keyvalues suspend <keyValueID|keyValueName> [flags]
```

Suspend a Bex Key Value instance.

Without --confirm, this command previews what would be suspended and makes no
changes. Pass --confirm to actually suspend the instance.

The positional argument accepts either a Key Value ID (red-...) or a name.
If the name matches more than one instance, narrow the search with
--environment `<id|name>`, or pass the Key Value ID directly.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set `<name|ID>`' and try again, or pass the
Key Value ID instead (which works across workspaces).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Key Value name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Preview suspension (no changes made)
  bex kv suspend red-abc123def456ghi789jkl0

  # Suspend by ID
  bex kv suspend red-abc123def456ghi789jkl0 --confirm

  # Suspend by name
  bex kv suspend my-cache --confirm

  # Disambiguate a name that exists in multiple environments
  bex kv suspend my-cache --environment production --confirm

  # JSON output
  bex kv suspend red-abc123def456ghi789jkl0 --confirm --output json
```

### `keyvalues update` {#keyvalues-update}

Update a Bex Key Value instance

**Compatibility:** Verified working (`[x]`)

```bash
bex keyvalues update <keyValueID|keyValueName> [flags]
```

```text
Update an existing Bex Key Value instance.

The positional argument is the target Key Value (ID red-... or name). At least
one mutating flag must be supplied. Use --name to rename the instance; the
positional argument always identifies the target and is never the new name.

Environment, project, workspace, and region are immutable. A Key Value instance
cannot be moved between them; the --environment flag is for name disambiguation
only.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set <name|ID>' and try again, or pass the
Key Value ID instead (which works across workspaces). If a name matches more
than one instance, narrow the search with --environment <id|name>.

The --ip-allow-list flag replaces the server-side list; pass it once per entry.
To remove all allow-list entries, pass --clear-ip-allow-list. The two flags are
mutually exclusive.
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--clear-ip-allow-list` |  |  |  | Remove all IP allow-list entries. Mutually exclusive with --ip-allow-list |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Key Value name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--ip-allow-list` |  | `CIDR_DESCRIPTION` |  | Replace the IP allow-list with the supplied entries (format: cidr=`<range>`,description=`<label>`). Repeat the flag for multiple entries |
| `--memory-policy` |  | `MAXMEMORY_POLICY` |  | Set the eviction policy used when the instance runs out of memory. |
| `--name` |  | `NAME` |  | Rename the Key Value instance |
| `--persistence-mode` |  | `PERSISTENCE_MODE` |  | Set the on-disk persistence mode: journal_snapshot \| snapshot \| off (off loses data on restart) |
| `--plan` |  | `PLAN` |  | Set the plan to one of: free \| 256mb \| 1g \| 5g \| 10g \| 20g \| 40g. Custom enterprise plan names are also accepted |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Rename
  bex kv update red-abc123def456ghi789jkl0 --name new-cache-name

  # Change plan
  bex kv update my-cache --plan 1g

  # Replace the IP allow-list (entire list, not append)
  bex kv update my-cache \
    --ip-allow-list "cidr=203.0.113.5/32,description=office" \
    --ip-allow-list "cidr=10.0.0.0/8,description=internal"

  # Clear the IP allow-list
  bex kv update my-cache --clear-ip-allow-list

  # Disambiguate a name that exists in multiple environments
  bex kv update my-cache --environment production --memory-policy queue

  # Turn off on-disk persistence
  bex kv update my-cache --persistence-mode off

  # JSON output
  bex kv update red-abc123def456ghi789jkl0 --plan 5g --output json
```

## `kimi` {#kimi}

Usage: claude [options] [command] [prompt]

**Compatibility:** Native Bex command (`[bex]`)

```text
Claude Code - starts an interactive session by default, use -p/--print for
non-interactive output
Arguments:
prompt                                Your prompt
Options:
--add-dir <directories...>            Additional directories to allow tool
access to
--agent <agent>                       Agent for the current session. Overrides
the 'agent' setting.
--agents <json>                       JSON object defining custom agents (e.g.
'{"reviewer": {"description": "Reviews
code", "prompt": "You are a code
reviewer"}}')
--allow-dangerously-skip-permissions  Enable bypassing all permission checks
as an option, without it being enabled
by default. Recommended only for
sandboxes with no internet access.
--allowedTools, --allowed-tools <tools...>
Comma or space-separated list of tool names to allow (e.g. "Bash(git *)
Edit")
--append-system-prompt <prompt>       Append a system prompt to the default
system prompt
--ax-screen-reader                    Render screen-reader friendly output
(flat text, no decorative borders or
animations).
--bg, --background                    Start the session as a background agent
and return immediately (manage with
`claude agents`)
--bare                                Minimal mode: skip hooks, LSP, plugin
sync, attribution, auto-memory,
background prefetches, keychain reads,
and CLAUDE.md auto-discovery. Sets
CLAUDE_CODE_SIMPLE=1. Anthropic auth is
strictly ANTHROPIC_API_KEY or
apiKeyHelper via --settings (OAuth and
keychain are never read). 3P providers
(Bedrock/Vertex/Foundry) use their own
credentials. Skills still resolve via
/skill-name. Explicitly provide context
via: --system-prompt[-file],
--append-system-prompt[-file], --add-dir
(CLAUDE.md dirs), --mcp-config,
--settings, --agents, --plugin-dir.
--betas <betas...>                    Beta headers to include in API requests
(API key users only)
--brief                               Enable SendUserMessage tool for
agent-to-user communication
--chrome                              Enable Claude in Chrome integration
-c, --continue                        Continue the most recent conversation in
the current directory
--dangerously-skip-permissions        Bypass all permission checks.
Recommended only for sandboxes with no
internet access.
-d, --debug [filter]                  Enable debug mode with optional category
filtering (e.g., "api,hooks" or
"!1p,!file")
--debug-file <path>                   Write debug logs to a specific file path
(implicitly enables debug mode)
--disable-slash-commands              Disable all skills
--disallowedTools, --disallowed-tools <tools...>
Comma or space-separated list of tool names to deny (e.g. "Bash(git *)
Edit")
--effort <level>                      Effort level for the current session
(low, medium, high, xhigh, max)
--exclude-dynamic-system-prompt-sections
Move per-machine sections (cwd, env info, memory paths, git status) from
the system prompt into the first user message. Improves cross-user
prompt-cache reuse. Only applies with the default system prompt (ignored
with --system-prompt). (default: false)
--fallback-model <model>              Enable automatic fallback to specified
model(s) when the default model is
overloaded or not available. Accepts a
comma-separated list to try each in
order. Re-tries the primary at the start
of each user turn. (only works with
--print)
--file <specs...>                     File resources to download at startup.
Format: file_id:relative_path (e.g.,
--file file_abc:doc.txt
file_def:img.png)
--fork-session                        When resuming, create a new session ID
instead of reusing the original (use
with --resume or --continue)
--from-pr [value]                     Resume a session linked to a PR by PR
number/URL, or open interactive picker
with optional search term
-h, --help                            Display help for command
--ide                                 Automatically connect to IDE on startup
if exactly one valid IDE is available
--include-hook-events                 Include all hook lifecycle events in the
output stream (only works with
--output-format=stream-json)
--include-partial-messages            Include partial message chunks as they
arrive (only works with --print and
--output-format=stream-json)
--input-format <format>               Input format (only works with --print):
"text" (default), or "stream-json"
(realtime streaming input) (choices:
"text", "stream-json")
--json-schema <schema>                JSON Schema for structured output
validation. Example:
{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}
--max-budget-usd <amount>             Maximum dollar amount to spend on API
calls (only works with --print)
--mcp-config <configs...>             Load MCP servers from JSON files or
strings (space-separated)
--mcp-debug                           [DEPRECATED. Use --debug instead] Enable
MCP debug mode (shows MCP server errors)
--model <model>                       Model for the current session. Provide
an alias for the latest model (e.g.
'fable', 'opus', or 'sonnet') or a
model's full name (e.g.
'claude-fable-5').
-n, --name <name>                     Set a display name for this session
(shown in the prompt box, /resume
picker, and terminal title)
--no-chrome                           Disable Claude in Chrome integration
--no-session-persistence              Disable session persistence - sessions
will not be saved to disk and cannot be
resumed (only works with --print)
--output-format <format>              Output format (only works with --print):
"text" (default), "json" (single
result), or "stream-json" (realtime
streaming) (choices: "text", "json",
"stream-json")
--permission-mode <mode>              Permission mode to use for the session
(choices: "acceptEdits", "auto",
"bypassPermissions", "default",
"dontAsk", "plan")
--plugin-dir <path>                   Load a plugin from a directory or .zip
for this session only (repeatable:
--plugin-dir A --plugin-dir B.zip)
(default: [])
--plugin-url <url>                    Fetch a plugin .zip from a URL for this
session only (repeatable: --plugin-url A
--plugin-url B) (default: [])
-p, --print                           Print response and exit (useful for
pipes). Note: The workspace trust dialog
is skipped when Claude is run in
non-interactive mode (via -p, or when
stdout is not a TTY, e.g. piped or
redirected output). Only use this in
directories you trust. Settings files
that fail validation are silently
ignored in this mode (no error dialog is
shown).
--prompt-suggestions [value]          Enable prompt suggestions. In print/SDK
mode, emits a prompt_suggestion message
after each turn with a predicted next
user prompt (choices: "true", "false",
"1", "0", "yes", "no", "on", "off",
preset: "true")
--remote-control [name]               Start an interactive session with Remote
Control enabled (optionally named)
--remote-control-session-name-prefix <prefix>
Prefix for auto-generated Remote Control session names (default: hostname)
--replay-user-messages                Re-emit user messages from stdin back on
stdout for acknowledgment (only works
with --input-format=stream-json and
--output-format=stream-json)
-r, --resume [value]                  Resume a conversation by session ID, or
open interactive picker with optional
search term
--safe-mode                           Start with all customizations
(CLAUDE.md, skills, plugins, hooks, MCP
servers, custom commands and agents,
output styles, workflows, custom themes,
keybindings, and more) disabled — useful
for troubleshooting a broken
configuration. Admin-managed (policy)
settings still apply. Auth, model
selection, built-in tools, and
permissions work normally. Sets
CLAUDE_CODE_SAFE_MODE=1.
--session-id <uuid>                   Use a specific session ID for the
conversation (must be a valid UUID)
--setting-sources <sources>           Comma-separated list of setting sources
to load (user, project, local).
--settings <file-or-json>             Path to a settings JSON file or a JSON
string to load additional settings from
--strict-mcp-config                   Only use MCP servers from --mcp-config,
ignoring all other MCP configurations
--system-prompt <prompt>              System prompt to use for the session
--tmux                                Create a tmux session for the worktree
(requires --worktree). Uses iTerm2
native panes when available; use
--tmux=classic for traditional tmux.
--tools <tools...>                    Specify the list of available tools from
the built-in set. Use "" to disable all
tools, "default" to use all tools, or
specify tool names (e.g.
"Bash,Edit,Read").
--verbose                             Override verbose mode setting from
config
-v, --version                         Output the version number
-w, --worktree [name]                 Create a new git worktree for this
session (optionally specify a name)
Commands:
agents [options]                      Manage background agents
auth                                  Manage authentication
auto-mode                             Inspect auto mode classifier
configuration
doctor                                Check the health of your Claude Code
auto-updater. Note: The workspace trust
dialog is skipped and stdio servers from
.mcp.json are spawned for health checks.
Only use this command in directories you
trust.
install [options] [target]            Install Claude Code native build. Use
[target] to specify version (stable,
latest, or specific version)
mcp                                   Configure and manage MCP servers
plugin|plugins                        Manage Claude Code plugins
project                               Manage Claude Code project state
setup-token                           Set up a long-lived authentication token
(requires Claude subscription)
ultrareview [options] [target]        Run a cloud-hosted multi-agent code
review of the current branch (or a PR
number / base branch) and print the
findings
update|upgrade                        Check for updates and install if
available
```

## `kv-cli` {#kv-cli}

Open a session for a Bex Key Value instance

**Compatibility:** Verified working (`[x]`)

```bash
bex kv-cli [keyValueID|keyValueName] [flags]
```

Open a redis-cli or valkey-cli session for a Bex Key Value instance. This
command only supports interactive mode.

You can optionally pass the key value ID or name as an argument. To pass
arguments to redis-cli or valkey-cli, use:
  bex kv-cli [keyValueID|keyValueName] -- [redis-cli args]

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Open an interactive kv-cli session
  bex kv-cli kv-abc123

  # Pass through redis-cli arguments
  bex kv-cli kv-abc123 -- --scan
```

## `login` {#login}

Log in to Bex using the Bex dashboard

**Compatibility:** Verified working (`[x]`)

```bash
bex login [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Authenticate with Bex
  bex login
```

## `logout` {#logout}

Log out of Bex

**Compatibility:** Verified working (`[x]`)

```bash
bex logout [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

## `logs` {#logs}

View logs for services and datastores

**Compatibility:** Verified working (`[x]`)

```bash
bex logs [flags]
```

View logs for services and datastores.

Use flags to filter logs by resource, instance, time, text, level, type, host,
status code, method, or path. Unlike in the Bex dashboard, you can view logs for
multiple resources at once.

In interactive mode you can update the filters and view logs in real time, or
set --tail=true to stream new logs.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--direction` |  | `LOG_DIRECTION` |  | Set log query direction (backward or forward) |
| `--end` |  | `TIME` |  | Filter logs at or before the specified end time |
| `--help` | `-h` |  |  | Show help for this command |
| `--host` |  | `HOSTS` |  | Filter logs by comma-separated host values |
| `--instance` |  | `INSTANCE_IDS` |  | Filter logs by comma-separated instance IDs |
| `--level` |  | `LOG_LEVEL` |  | Filter logs by comma-separated log levels |
| `--limit` |  | `COUNT` | `100` | Limit the number of logs returned |
| `--method` |  | `HTTP_METHOD` |  | Filter logs by comma-separated HTTP methods |
| `--path` |  | `PATHS` |  | Filter logs by comma-separated request paths |
| `--resources` | `-r` | `RESOURCE_IDS` |  | Filter logs by comma-separated resource IDs (Required in non-interactive mode) |
| `--start` |  | `TIME` |  | Filter logs at or after the specified start time |
| `--status-code` |  | `STATUS_CODES` |  | Filter logs by comma-separated status codes |
| `--tail` |  |  |  | Stream new logs |
| `--task-id` |  | `TASK_IDS` |  | Filter logs by comma-separated task IDs |
| `--task-run-id` |  | `TASK_RUN_IDS` |  | Filter logs by comma-separated task run IDs |
| `--text` |  | `QUERY_TEXT` |  | Filter logs by comma-separated text values |
| `--type` |  | `LOG_TYPE` |  | Filter logs by comma-separated log types |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Tail logs for a service
  bex logs --resources srv-abc123 --tail

  # Query logs in a time range
  bex logs --resources srv-abc123 --start 2026-03-01T00:00:00Z --end 2026-03-01T01:00:00Z

  # Output logs as JSON in non-interactive mode
  bex logs --resources srv-abc123 --output json
```

## `muse` {#muse}

Usage: claude [options] [command] [prompt]

**Compatibility:** Native Bex command (`[bex]`)

```text
Claude Code - starts an interactive session by default, use -p/--print for
non-interactive output
Arguments:
prompt                                Your prompt
Options:
--add-dir <directories...>            Additional directories to allow tool
access to
--agent <agent>                       Agent for the current session. Overrides
the 'agent' setting.
--agents <json>                       JSON object defining custom agents (e.g.
'{"reviewer": {"description": "Reviews
code", "prompt": "You are a code
reviewer"}}')
--allow-dangerously-skip-permissions  Enable bypassing all permission checks
as an option, without it being enabled
by default. Recommended only for
sandboxes with no internet access.
--allowedTools, --allowed-tools <tools...>
Comma or space-separated list of tool names to allow (e.g. "Bash(git *)
Edit")
--append-system-prompt <prompt>       Append a system prompt to the default
system prompt
--ax-screen-reader                    Render screen-reader friendly output
(flat text, no decorative borders or
animations).
--bg, --background                    Start the session as a background agent
and return immediately (manage with
`claude agents`)
--bare                                Minimal mode: skip hooks, LSP, plugin
sync, attribution, auto-memory,
background prefetches, keychain reads,
and CLAUDE.md auto-discovery. Sets
CLAUDE_CODE_SIMPLE=1. Anthropic auth is
strictly ANTHROPIC_API_KEY or
apiKeyHelper via --settings (OAuth and
keychain are never read). 3P providers
(Bedrock/Vertex/Foundry) use their own
credentials. Skills still resolve via
/skill-name. Explicitly provide context
via: --system-prompt[-file],
--append-system-prompt[-file], --add-dir
(CLAUDE.md dirs), --mcp-config,
--settings, --agents, --plugin-dir.
--betas <betas...>                    Beta headers to include in API requests
(API key users only)
--brief                               Enable SendUserMessage tool for
agent-to-user communication
--chrome                              Enable Claude in Chrome integration
-c, --continue                        Continue the most recent conversation in
the current directory
--dangerously-skip-permissions        Bypass all permission checks.
Recommended only for sandboxes with no
internet access.
-d, --debug [filter]                  Enable debug mode with optional category
filtering (e.g., "api,hooks" or
"!1p,!file")
--debug-file <path>                   Write debug logs to a specific file path
(implicitly enables debug mode)
--disable-slash-commands              Disable all skills
--disallowedTools, --disallowed-tools <tools...>
Comma or space-separated list of tool names to deny (e.g. "Bash(git *)
Edit")
--effort <level>                      Effort level for the current session
(low, medium, high, xhigh, max)
--exclude-dynamic-system-prompt-sections
Move per-machine sections (cwd, env info, memory paths, git status) from
the system prompt into the first user message. Improves cross-user
prompt-cache reuse. Only applies with the default system prompt (ignored
with --system-prompt). (default: false)
--fallback-model <model>              Enable automatic fallback to specified
model(s) when the default model is
overloaded or not available. Accepts a
comma-separated list to try each in
order. Re-tries the primary at the start
of each user turn. (only works with
--print)
--file <specs...>                     File resources to download at startup.
Format: file_id:relative_path (e.g.,
--file file_abc:doc.txt
file_def:img.png)
--fork-session                        When resuming, create a new session ID
instead of reusing the original (use
with --resume or --continue)
--from-pr [value]                     Resume a session linked to a PR by PR
number/URL, or open interactive picker
with optional search term
-h, --help                            Display help for command
--ide                                 Automatically connect to IDE on startup
if exactly one valid IDE is available
--include-hook-events                 Include all hook lifecycle events in the
output stream (only works with
--output-format=stream-json)
--include-partial-messages            Include partial message chunks as they
arrive (only works with --print and
--output-format=stream-json)
--input-format <format>               Input format (only works with --print):
"text" (default), or "stream-json"
(realtime streaming input) (choices:
"text", "stream-json")
--json-schema <schema>                JSON Schema for structured output
validation. Example:
{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}
--max-budget-usd <amount>             Maximum dollar amount to spend on API
calls (only works with --print)
--mcp-config <configs...>             Load MCP servers from JSON files or
strings (space-separated)
--mcp-debug                           [DEPRECATED. Use --debug instead] Enable
MCP debug mode (shows MCP server errors)
--model <model>                       Model for the current session. Provide
an alias for the latest model (e.g.
'fable', 'opus', or 'sonnet') or a
model's full name (e.g.
'claude-fable-5').
-n, --name <name>                     Set a display name for this session
(shown in the prompt box, /resume
picker, and terminal title)
--no-chrome                           Disable Claude in Chrome integration
--no-session-persistence              Disable session persistence - sessions
will not be saved to disk and cannot be
resumed (only works with --print)
--output-format <format>              Output format (only works with --print):
"text" (default), "json" (single
result), or "stream-json" (realtime
streaming) (choices: "text", "json",
"stream-json")
--permission-mode <mode>              Permission mode to use for the session
(choices: "acceptEdits", "auto",
"bypassPermissions", "default",
"dontAsk", "plan")
--plugin-dir <path>                   Load a plugin from a directory or .zip
for this session only (repeatable:
--plugin-dir A --plugin-dir B.zip)
(default: [])
--plugin-url <url>                    Fetch a plugin .zip from a URL for this
session only (repeatable: --plugin-url A
--plugin-url B) (default: [])
-p, --print                           Print response and exit (useful for
pipes). Note: The workspace trust dialog
is skipped when Claude is run in
non-interactive mode (via -p, or when
stdout is not a TTY, e.g. piped or
redirected output). Only use this in
directories you trust. Settings files
that fail validation are silently
ignored in this mode (no error dialog is
shown).
--prompt-suggestions [value]          Enable prompt suggestions. In print/SDK
mode, emits a prompt_suggestion message
after each turn with a predicted next
user prompt (choices: "true", "false",
"1", "0", "yes", "no", "on", "off",
preset: "true")
--remote-control [name]               Start an interactive session with Remote
Control enabled (optionally named)
--remote-control-session-name-prefix <prefix>
Prefix for auto-generated Remote Control session names (default: hostname)
--replay-user-messages                Re-emit user messages from stdin back on
stdout for acknowledgment (only works
with --input-format=stream-json and
--output-format=stream-json)
-r, --resume [value]                  Resume a conversation by session ID, or
open interactive picker with optional
search term
--safe-mode                           Start with all customizations
(CLAUDE.md, skills, plugins, hooks, MCP
servers, custom commands and agents,
output styles, workflows, custom themes,
keybindings, and more) disabled — useful
for troubleshooting a broken
configuration. Admin-managed (policy)
settings still apply. Auth, model
selection, built-in tools, and
permissions work normally. Sets
CLAUDE_CODE_SAFE_MODE=1.
--session-id <uuid>                   Use a specific session ID for the
conversation (must be a valid UUID)
--setting-sources <sources>           Comma-separated list of setting sources
to load (user, project, local).
--settings <file-or-json>             Path to a settings JSON file or a JSON
string to load additional settings from
--strict-mcp-config                   Only use MCP servers from --mcp-config,
ignoring all other MCP configurations
--system-prompt <prompt>              System prompt to use for the session
--tmux                                Create a tmux session for the worktree
(requires --worktree). Uses iTerm2
native panes when available; use
--tmux=classic for traditional tmux.
--tools <tools...>                    Specify the list of available tools from
the built-in set. Use "" to disable all
tools, "default" to use all tools, or
specify tool names (e.g.
"Bash,Edit,Read").
--verbose                             Override verbose mode setting from
config
-v, --version                         Output the version number
-w, --worktree [name]                 Create a new git worktree for this
session (optionally specify a name)
Commands:
agents [options]                      Manage background agents
auth                                  Manage authentication
auto-mode                             Inspect auto mode classifier
configuration
doctor                                Check the health of your Claude Code
auto-updater. Note: The workspace trust
dialog is skipped and stdio servers from
.mcp.json are spawned for health checks.
Only use this command in directories you
trust.
install [options] [target]            Install Claude Code native build. Use
[target] to specify version (stable,
latest, or specific version)
mcp                                   Configure and manage MCP servers
plugin|plugins                        Manage Claude Code plugins
project                               Manage Claude Code project state
setup-token                           Set up a long-lived authentication token
(requires Claude subscription)
ultrareview [options] [target]        Run a cloud-hosted multi-agent code
review of the current branch (or a PR
number / base branch) and print the
findings
update|upgrade                        Check for updates and install if
available
```

## `pgcli` {#pgcli}

Open a pgcli session to a Bex Postgres database instance

**Compatibility:** Verified working (`[x]`)

```bash
bex pgcli [postgresID|postgresName] [flags]
```

Open a pgcli session to a Bex Postgres database instance. This command only
supports interactive mode.

You can optionally pass a database ID or name as an argument. To pass arguments
to pgcli, use:
  bex pgcli [postgresID|postgresName] -- [pgcli args]

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Open an interactive pgcli session
  bex pgcli pg-abc123

  # Pass through pgcli arguments
  bex pgcli pg-abc123 -- --csv -q
```

## `postgres` {#postgres}

Manage Bex Postgres databases (alias: pg)

**Compatibility:** Verified working (`[x]`)

```bash
bex postgres <subcommand> [flags]
```

Manage Bex Postgres databases.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

### `postgres create` {#postgres-create}

Create a new Bex Postgres database

**Compatibility:** Verified working (`[x]`)

```bash
bex postgres create [flags]
```

Create a new Bex Postgres database.

In interactive mode, a wizard guides you through the core choices for the
database. The wizard owns those prompted values. Flag-only settings, such as
--disk-size-gb, --database-name, --database-user, --ip-allow-list, and
--read-replica,
are still included in the create request.

Use --confirm to skip the wizard and create immediately from flags and defaults.
When --confirm is used with the default interactive output mode, output is
printed as text. Use --output json, yaml, or text for non-interactive output.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--connection-pool` |  | `CONNECTION_POOL` | `none` | Set connection pool to 'none' or 'pgbouncer' |
| `--database-name` |  | `DATABASE_NAME` |  | Set the Postgres database name (server generates one if unset) |
| `--database-user` |  | `DATABASE_USER` |  | Set the Postgres database user (server generates one if unset) |
| `--datadog-api-key` |  | `DATADOG_API_KEY` |  | Set the Datadog API key for monitoring |
| `--datadog-site` |  | `DATADOG_SITE` |  | Set the Datadog region/site (e.g. US1, US3, EU). Server default is US1 |
| `--disk-autoscaling` |  |  |  | Enable disk autoscaling |
| `--disk-size-gb` |  | `DISK_SIZE_GB` | `0` | Set the disk size in GB. Must be 1 or a multiple of 5. Server picks a sensible default based on compute size if unset |
| `--environment` |  | `ENVIRONMENT` |  | Set the environment to create the database in (ID or name, optional). Example: Production or evm-abc123def456 |
| `--help` | `-h` |  |  | Show help for this command |
| `--high-availability` |  |  |  | Enable high availability (available for plans with at least 1 CPU) |
| `--ip-allow-list` |  | `CIDR_DESCRIPTION` |  | Restrict inbound traffic to specific IP ranges (format: cidr=`<range>`,description=`<label>`). Repeat the flag for multiple entries |
| `--name` |  | `NAME` |  | Set the database name (generated if not provided) |
| `--plan` |  | `PLAN` |  | Set the plan to one of: free \| 0.1c-256mb \| 0.5c-1g \| 1c-2g \| 1c-4g \| 2c-4g \| 2c-8g \| 2c-16g \| 4c-16g \| 4c-32g \| 8c-32g \| 8c-64g \| 16c-64g \| 16c-128g \| 32c-128g \| 32c-256g \| 48c-192g \| 48c-384g \| 64c-256g \| 64c-512g \| 96c-384g \| 96c-768g \| 128c-512g \| 128c-1024g. Custom enterprise plan names are also accepted |
| `--project` |  | `PROJECT` |  | Scope environment lookup to a project (ID or name, optional); if the project has exactly one environment it is used automatically |
| `--read-replica` |  | `NAME` |  | Create a read replica with the given name alongside the primary. Repeat the flag for multiple replicas |
| `--region` |  | `REGION` |  | Set the region: frankfurt \| ohio \| oregon \| singapore \| virginia (server picks if unset) |
| `--version` |  | `VERSION` | `0` | Set the Postgres major version. Defaults to 18 |
| `--workspace` |  | `WORKSPACE` |  | Set the workspace to create the database in (ID or name). Defaults to the active workspace (set via 'bex workspace set') |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Launch the interactive wizard
  bex pg create

  # Create immediately with defaults and text output
  bex pg create --confirm

  # Create immediately with explicit values
  bex pg create --confirm --name analytics --plan 2c-8g --version 17 --region ohio

  # Include flag-only settings while using the wizard for prompted values
  bex pg create \
    --ip-allow-list "cidr=203.0.113.5/32,description=office" \
    --ip-allow-list "cidr=10.0.0.0/8,description=internal"

  # Machine-readable output
  bex pg create --output json
```

### `postgres delete` {#postgres-delete}

Delete a Bex Postgres database

**Compatibility:** Verified working (`[x]`)

```bash
bex postgres delete <postgresID|postgresName> [flags]
```

Delete a Bex Postgres database.

Without --confirm, this command previews what would be deleted and makes no
changes. Pass --confirm to actually delete the database.

The positional argument accepts either a Postgres ID (dpg-...) or a name.
If the name matches more than one database, narrow the search with
--project `<id|name>`, --environment `<id|name>`, or pass the Postgres ID directly.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set `<name|ID>`' and try again, or pass the
Postgres ID instead (which works across workspaces).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Postgres database name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--project` |  | `PROJECT` |  | Narrow lookup to a project (ID or name, optional) when the same Postgres database name exists in multiple projects |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Preview deletion (no changes made)
  bex pg delete dpg-abc123def456ghi789jkl0

  # Delete by ID
  bex pg delete dpg-abc123def456ghi789jkl0 --confirm

  # Delete by name
  bex pg delete my-db --confirm

  # Disambiguate a name that exists in multiple environments
  bex pg delete my-db --environment production --confirm

  # Disambiguate a name that exists in multiple projects
  bex pg delete my-db --project analytics --confirm

  # JSON output
  bex pg delete dpg-abc123def456ghi789jkl0 --confirm --output json
```

### `postgres get` {#postgres-get}

Get details of a Bex Postgres database

**Compatibility:** Verified working (`[x]`)

```bash
bex postgres get <postgresID|postgresName> [flags]
```

Get details and connection info for a Bex Postgres database.

The positional argument accepts either a Postgres ID (dpg-...) or a name.
If the name matches more than one database, narrow the search with
--project `<id|name>`, --environment `<id|name>`, or pass the Postgres ID directly.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set `<name|ID>`' and try again, or pass the
Postgres ID instead (which works across workspaces).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Postgres database name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--include-sensitive-connection-info` |  |  |  | Include connection strings and credentials in the output |
| `--project` |  | `PROJECT` |  | Narrow lookup to a project (ID or name, optional) within the active workspace |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Get by ID
  bex pg get dpg-abc123def456ghi789jkl0

  # Get by name
  bex pg get my-db

  # Include connection strings (contains credentials)
  bex pg get my-db --include-sensitive-connection-info

  # Disambiguate by project
  bex pg get my-db --project my-project

  # Disambiguate a name that exists in multiple environments
  bex pg get my-db --environment production

  # JSON output
  bex pg get dpg-abc123def456ghi789jkl0 --output json
```

### `postgres list` {#postgres-list}

List Bex Postgres databases

**Compatibility:** Verified working (`[x]`)

```bash
bex postgres list [flags]
```

List Bex Postgres databases in the active workspace.

Use --project to narrow results to a single project, --environment to narrow
to a single environment, or both — when both are supplied, the environment is
resolved within that project.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow results to a single environment (ID or name, optional) |
| `--help` | `-h` |  |  | Show help for this command |
| `--project` |  | `PROJECT` |  | Narrow results to environments in a project (ID or name, optional) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List all Postgres databases in the active workspace
  bex pg list

  # List all Postgres databases in a project
  bex pg list --project my-project

  # Filter by environment name
  bex pg list --environment production

  # Disambiguate an environment name by project
  bex pg list --project my-project --environment production

  # JSON output
  bex pg list --output json
```

### `postgres resume` {#postgres-resume}

Resume a suspended Bex Postgres database

**Compatibility:** Verified working (`[x]`)

```bash
bex postgres resume <postgresID|postgresName> [flags]
```

Resume a suspended Bex Postgres database.

The positional argument accepts either a Postgres ID (dpg-...) or a name.
If the name matches more than one database, narrow the search with
--project `<id|name>`, --environment `<id|name>`, or pass the Postgres ID directly.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set `<name|ID>`' and try again, or pass the
Postgres ID instead (which works across workspaces).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Postgres database name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--project` |  | `PROJECT` |  | Narrow lookup to a project (ID or name, optional) when the same Postgres database name exists in multiple projects |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Resume by ID
  bex pg resume dpg-abc123def456ghi789jkl0

  # Resume by name
  bex pg resume my-db

  # Disambiguate a name that exists in multiple environments
  bex pg resume my-db --environment production

  # Disambiguate a name that exists in multiple projects
  bex pg resume my-db --project analytics

  # JSON output
  bex pg resume dpg-abc123def456ghi789jkl0 --output json
```

### `postgres suspend` {#postgres-suspend}

Suspend a Bex Postgres database

**Compatibility:** Verified working (`[x]`)

```bash
bex postgres suspend <postgresID|postgresName> [flags]
```

Suspend a Bex Postgres database.

Without --confirm, this command previews what would be suspended and makes no
changes. Pass --confirm to actually suspend the database.

The positional argument accepts either a Postgres ID (dpg-...) or a name.
If the name matches more than one database, narrow the search with
--project `<id|name>`, --environment `<id|name>`, or pass the Postgres ID directly.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set `<name|ID>`' and try again, or pass the
Postgres ID instead (which works across workspaces).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Postgres database name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--project` |  | `PROJECT` |  | Narrow lookup to a project (ID or name, optional) when the same Postgres database name exists in multiple projects |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Preview suspension (no changes made)
  bex pg suspend dpg-abc123def456ghi789jkl0

  # Suspend by ID
  bex pg suspend dpg-abc123def456ghi789jkl0 --confirm

  # Suspend by name
  bex pg suspend my-db --confirm

  # Disambiguate a name that exists in multiple environments
  bex pg suspend my-db --environment production --confirm

  # Disambiguate a name that exists in multiple projects
  bex pg suspend my-db --project analytics --confirm

  # JSON output
  bex pg suspend dpg-abc123def456ghi789jkl0 --confirm --output json
```

### `postgres update` {#postgres-update}

Update a Bex Postgres database

**Compatibility:** Verified working (`[x]`)

```bash
bex postgres update <postgresID|postgresName> [flags]
```

```text
Update an existing Bex Postgres database.

The positional argument is the target database (ID dpg-... or name). At least
one mutating flag must be supplied. Use --name to rename the database; the
positional argument always identifies the target and is never the new name.

Environment, project, workspace, and region are immutable. A database cannot be
moved between them; the --project and --environment flags are for name
disambiguation only.

Only the fields you pass are changed; everything else is left untouched.

Name lookup is scoped to your active workspace. If a name isn't found, switch
workspaces with 'bex workspace set <name|ID>' and try again, or pass the
Postgres ID instead (which works across workspaces). If a name matches more
than one database, narrow the search with --project <id|name> or
--environment <id|name>.

The --ip-allow-list flag replaces the server-side list; pass it once per entry.
To remove all allow-list entries, pass --clear-ip-allow-list. The two flags are
mutually exclusive.
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--clear-ip-allow-list` |  |  |  | Remove all IP allow-list entries. Mutually exclusive with --ip-allow-list |
| `--connection-pool` |  | `CONNECTION_POOL` | `none` | Set connection pool to 'none' or 'pgbouncer' |
| `--datadog-api-key` |  | `DATADOG_API_KEY` |  | Set the Datadog API key for monitoring. Pass an empty string to remove |
| `--datadog-site` |  | `DATADOG_SITE` |  | Set the Datadog region/site (e.g. US1, US3, EU) |
| `--disk-autoscaling` |  |  |  | Enable disk autoscaling. Pass --disk-autoscaling=false to disable |
| `--disk-size-gb` |  | `DISK_SIZE_GB` | `0` | Set the disk size in GB. Must be 1 or a multiple of 5 |
| `--environment` |  | `ENVIRONMENT` |  | Narrow lookup to an environment (ID or name, optional) when the same Postgres database name exists in multiple environments |
| `--help` | `-h` |  |  | Show help for this command |
| `--high-availability` |  |  |  | Enable high availability (available for plans with at least 1 CPU). Pass --high-availability=false to disable |
| `--ip-allow-list` |  | `CIDR_DESCRIPTION` |  | Replace the IP allow-list with the supplied entries (format: cidr=`<range>`,description=`<label>`). Repeat the flag for multiple entries |
| `--name` |  | `NAME` |  | Rename the database |
| `--plan` |  | `PLAN` |  | Set the plan to one of: free \| 0.1c-256mb \| 0.5c-1g \| 1c-2g \| 1c-4g \| 2c-4g \| 2c-8g \| 2c-16g \| 4c-16g \| 4c-32g \| 8c-32g \| 8c-64g \| 16c-64g \| 16c-128g \| 32c-128g \| 32c-256g \| 48c-192g \| 48c-384g \| 64c-256g \| 64c-512g \| 96c-384g \| 96c-768g \| 128c-512g \| 128c-1024g. Custom enterprise plan names are also accepted |
| `--project` |  | `PROJECT` |  | Narrow lookup to a project (ID or name, optional) when the same Postgres database name exists in multiple projects |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Rename
  bex pg update dpg-abc123def456ghi789jkl0 --name application_db

  # Change plan
  bex pg update my-db --plan 1c-4g

  # Grow the disk and enable autoscaling
  bex pg update my-db --disk-size-gb 50 --disk-autoscaling

  # Replace the IP allow-list (entire list, not append)
  bex pg update my-db \
    --ip-allow-list "cidr=203.0.113.5/32,description=office" \
    --ip-allow-list "cidr=10.0.0.0/8,description=internal"

  # Clear the IP allow-list
  bex pg update my-db --clear-ip-allow-list

  # Disambiguate a name that exists in multiple environments
  bex pg update my-db --environment production --plan 2c-8g

  # JSON output
  bex pg update dpg-abc123def456ghi789jkl0 --plan 1c-4g --output json
```

## `projects` {#projects}

List projects in the active workspace

**Compatibility:** Verified working (`[x]`)

```bash
bex projects [flags]
```

Browse projects in the active workspace. In interactive mode, select a project
to view its environments.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List projects in JSON
  bex projects --output json
```

## `psql` {#psql}

Open a psql session to a Bex Postgres database

**Compatibility:** Verified working (`[x]`)

```bash
bex psql [postgresID|postgresName] [flags]
```

Open a psql session to a Bex Postgres database.

Optionally pass the database ID or name as an argument. To pass arguments to
psql, use:
  bex psql [postgresID|postgresName] -- [psql args]

For non-interactive usage, use the --command flag:
  bex psql [postgresID|postgresName] -c "SELECT * FROM users;" -o text

Additional psql flags can be passed after --:
  bex psql [postgresID|postgresName] -c "SELECT 1;" -o json -- --csv -q

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--command` | `-c` | `SQL` |  | Execute a SQL command in non-interactive mode |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Open an interactive psql session
  bex psql pg-abc123

  # Execute a SQL command in non-interactive mode
  bex psql pg-abc123 --command "SELECT * FROM users;" --output text

  # Pass through psql arguments
  bex psql pg-abc123 -- --csv -q
```

## `restart` {#restart}

Restart a service by resource ID

**Compatibility:** Verified working (`[x]`)

```bash
bex restart <resourceID> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Restart a service
  bex restart srv-abc123

  # Restart a service without confirmation prompts
  bex restart srv-abc123 --confirm
```

## `services` {#services}

List services and datastores for the active workspace

**Compatibility:** Verified working (`[x]`)

```bash
bex services [subcommand] [flags]
```

Lists all services and datastores for the active workspace. In interactive mode,
you can view logs, restart services, trigger deploys, SSH into instances, and
connect to Bex Postgres databases and Bex Key Value instances.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--environment-ids` | `-e` | `ENV_IDS` |  | Filter services by comma-separated environment IDs |
| `--help` | `-h` |  |  | Show help for this command |
| `--include-previews` |  |  |  | Include preview environments |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List all services
  bex services

  # Output as JSON
  bex services --output json

  # Filter by environment
  bex services -e env-abc123

  # Include preview environments
  bex services --include-previews

  # Combine filters
  bex services -e env-abc123,env-def456 --include-previews --output json
```

### `services create` {#services-create}

Create a new service or clone an existing one

**Compatibility:** Verified working (`[x]`)

```bash
bex services create [flags]
```

Create a new service on Bex. This command only runs in non-interactive modes.
Provide configuration options with flags.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--auto-deploy` |  |  | `true` | Enable auto-deploy |
| `--branch` |  | `BRANCH` |  | Set the Git branch |
| `--build-command` |  | `COMMAND` |  | Set the build command |
| `--build-filter-ignored-path` |  | `PATHS` |  | Set build filter ignored paths (can be specified multiple times) |
| `--build-filter-path` |  | `PATHS` |  | Set build filter paths (can be specified multiple times) |
| `--cron-command` |  | `COMMAND` |  | Set the cron command |
| `--cron-schedule` |  | `SCHEDULE` |  | Set the cron schedule |
| `--env-var` |  | `KEY_VALUE` |  | Set environment variables in KEY=VALUE format (can be specified multiple times) |
| `--environment-id` |  | `ENVIRONMENT_ID` |  | Set the environment ID |
| `--from` |  | `SERVICE_ID` |  | Clone configuration from an existing service ID or name and override cloned values with other flags |
| `--health-check-path` |  | `PATH` |  | Set the health check path |
| `--help` | `-h` |  |  | Show help for this command |
| `--image` |  | `IMAGE_URL` |  | Set the Docker image URL |
| `--ip-allow-list` |  | `CIDR_DESCRIPTION` |  | Set IP allow list entries in cidr=..., description=... format (can be specified multiple times) |
| `--maintenance-mode` |  |  |  | Enable maintenance mode |
| `--maintenance-mode-uri` |  | `URI` |  | Set the maintenance mode URI |
| `--max-shutdown-delay` |  | `SECONDS` | `0` | Set max shutdown delay in seconds |
| `--name` |  | `NAME` |  | Set the service name |
| `--num-instances` |  | `COUNT` | `0` | Set the number of instances |
| `--plan` |  | `PLAN` |  | Set the service plan |
| `--pre-deploy-command` |  | `COMMAND` |  | Set the pre-deploy command |
| `--previews` |  | `PREVIEWS` |  | Set preview generation mode |
| `--publish-directory` |  | `PATH` |  | Set the publish directory |
| `--region` |  | `REGION` |  | Set the deployment region |
| `--registry-credential` |  | `CREDENTIAL` |  | Set the registry credential |
| `--repo` |  | `REPO_URL` |  | Set the Git repository URL |
| `--root-directory` |  | `PATH` |  | Set the root directory |
| `--runtime` |  | `RUNTIME` |  | Set the runtime environment |
| `--secret-file` |  | `NAME_PATH` |  | Set secret files in NAME:LOCAL_PATH format (can be specified multiple times) |
| `--start-command` |  | `COMMAND` |  | Set the start command |
| `--type` |  | `TYPE` |  | Set the service type |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Create a service from repository configuration
  bex services create --name my-api --type web_service --repo https://github.com/org/repo --runtime node --build-command "npm install" --start-command "npm start" --output json

  # Clone configuration from an existing service
  bex services create --from srv-abc123 --name my-api-clone --output json
```

### `services delete` {#services-delete}

Delete a service

**Compatibility:** Verified working (`[x]`)

```bash
bex services delete <serviceID|serviceName> [flags]
```

Delete a service on Bex.

Without --confirm, this command previews what would be deleted and makes no
changes. Pass --confirm to actually delete the service.

The positional argument accepts a service ID (including srv- or crn- IDs) or a
name. Name lookup is scoped to your active workspace. If the name matches more
than one service, pass the service ID directly.

This command only runs non-interactively. If --output interactive is requested,
it falls back to text output.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Preview deletion (no changes made)
  bex services delete srv-abc123def456ghi789jkl0

  # Delete by ID
  bex services delete srv-abc123def456ghi789jkl0 --confirm

  # Delete by name
  bex services delete my-api --confirm

  # JSON output
  bex services delete srv-abc123def456ghi789jkl0 --confirm --output json
```

### `services instances` {#services-instances}

List instances for a service

**Compatibility:** Verified working (`[x]`)

```bash
bex services instances [serviceID] [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List instances for a service
  bex services instances srv-abc123

  # Browse instances interactively
  bex services instances
```

### `services update` {#services-update}

Update configuration for an existing service

**Compatibility:** Verified working (`[x]`)

```bash
bex services update <service> [flags]
```

Update a service on Bex. This command only runs in non-interactive modes.

Provide configuration updates with flags.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--auto-deploy` |  |  |  | Enable auto-deploy |
| `--branch` |  | `string` |  | Git branch |
| `--build-command` |  | `string` |  | Build command |
| `--build-filter-ignored-path` |  | `stringArray` |  | Build filter ignored path (can be specified multiple times) |
| `--build-filter-path` |  | `stringArray` |  | Build filter path (can be specified multiple times) |
| `--cron-command` |  | `string` |  | Cron command |
| `--cron-schedule` |  | `string` |  | Cron schedule |
| `--health-check-path` |  | `string` |  | Health check path |
| `--help` | `-h` |  |  | Show help for this command |
| `--image` |  | `string` |  | Docker image URL |
| `--ip-allow-list` |  | `stringArray` |  | IP allow list entry in cidr=..., description=... format (can be specified multiple times) |
| `--maintenance-mode` |  |  |  | Enable maintenance mode |
| `--maintenance-mode-uri` |  | `string` |  | Maintenance mode URI |
| `--max-shutdown-delay` |  | `int` | `0` | Max shutdown delay in seconds |
| `--name` |  | `string` |  | Service name |
| `--plan` |  | `string` |  | Service plan |
| `--pre-deploy-command` |  | `string` |  | Pre-deploy command |
| `--previews` |  | `enum` |  | Preview generation mode |
| `--publish-directory` |  | `string` |  | Publish directory |
| `--registry-credential` |  | `string` |  | Registry credential |
| `--repo` |  | `string` |  | Git repository URL |
| `--root-directory` |  | `string` |  | Root directory |
| `--runtime` |  | `enum` |  | Runtime environment |
| `--start-command` |  | `string` |  | Start command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Rename a service
  bex services update my-service --name my-new-name --output json

  # Change a service plan
  bex services update srv-abc123 --plan 2c-4g --output json
```

## `skills` {#skills}

Manage Bex agent skills for AI coding tools

**Compatibility:** Works with a documented limitation (`[~]`)

:::note Limitation

manage Render agent skills for AI coding tools (client-side; no bex dependency)

:::
```bash
bex skills [subcommand] [flags]
```

Install and manage Bex agent skills for AI coding tools such as Claude Code,
Codex, OpenCode, and Cursor. Skills add deployment, debugging, and monitoring
capabilities to your AI coding assistant.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

### `skills install` {#skills-install}

Install Bex skills to AI coding tools

**Compatibility:** Verified working (`[x]`)

```bash
bex skills install [flags]
```

```text
Install Bex agent skills from https://github.com/render-oss/skills to detected
AI coding tools.

Supported tools: Claude Code, Codex, OpenCode, Cursor.

Skills can be installed at two scopes:
  - user:    Install to ~/.{tool}/skills/ (default, current user only)
  - project: Install to ./.{tool}/skills/ (committed to Git, all collaborators)

By default an interactive prompt lets you pick scope, tools, and skills. Use
--scope, --tool, and --skill flags to skip the prompts (useful for CI).
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--dry-run` |  |  |  | Show what would be installed without making changes |
| `--help` | `-h` |  |  | Show help for this command |
| `--scope` |  | `SCOPE` |  | Set installation scope to user or project (defaults to user) |
| `--skill` |  | `SKILL` |  | Install specific skills only (use --skill multiple times) |
| `--tool` |  | `TOOL` |  | Install skills to a specific tool only (claude, codex, opencode, or cursor) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Install skills interactively
  bex skills install

  # Install for a specific tool and scope
  bex skills install --tool cursor --scope project

  # Preview install changes
  bex skills install --dry-run
```

### `skills list` {#skills-list}

List installed Bex skills and detected tools

**Compatibility:** Not working / not verified (`[ ]`)

:::warning Not working on Bex

**upstream CLI panic** (nil-pointer) in every non-TTY output mode

:::
```bash
bex skills list [flags]
```

List installed Bex skills and the AI tools they've been installed in. This reads
from local state only, so the command doesn't require network access.

Use --scope to filter by installation scope (user or project).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--scope` |  | `SCOPE` |  | Filter skills by installation scope (user or project) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List all installed skills
  bex skills list

  # List project-scoped skills only
  bex skills list --scope project
```

### `skills remove` {#skills-remove}

Remove installed Bex skills from AI coding tools

**Compatibility:** Verified working (`[x]`)

```bash
bex skills remove [flags]
```

Remove previously installed Bex skills from detected AI coding tools.

By default an interactive prompt lets you pick which skills to remove. Use
--skill and --all flags to skip the prompts.

Use --scope to remove from a specific scope (user or project).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--all` |  |  |  | Remove all installed Bex skills |
| `--help` | `-h` |  |  | Show help for this command |
| `--scope` |  | `SCOPE` |  | Remove skills from the specified scope (user or project) |
| `--skill` |  | `SKILL` |  | Remove specific skills only (use --skill multiple times) |
| `--tool` |  | `TOOL` |  | Remove skills from a specific tool only (claude, codex, opencode, or cursor) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Remove skills interactively
  bex skills remove

  # Remove specific skills
  bex skills remove --skill render-deploy --skill render-debug

  # Remove all project-scoped skills
  bex skills remove --all --scope project
```

### `skills update` {#skills-update}

Update previously installed Bex skills

**Compatibility:** Not working / not verified (`[ ]`)

:::warning Not working on Bex

same upstream non-TTY panic; no `--dry-run`

:::
```bash
bex skills update [flags]
```

Reinstall Bex skills using the tool and skill selections saved by a previous
"render skills install" run.

This fetches the latest version of each selected skill from the skills
repository, compares with installed versions, and updates any that have changed.

Use --scope to update skills at a specific scope (user or project).

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--force` |  |  |  | Reinstall all skills even if already up to date |
| `--help` | `-h` |  |  | Show help for this command |
| `--scope` |  | `SCOPE` |  | Update skills at the specified scope (user or project) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Update installed skills
  bex skills update

  # Force reinstall all skills
  bex skills update --force

  # Update project-scoped skills
  bex skills update --scope project
```

## `ssh` {#ssh}

SSH into a service instance

**Compatibility:** Verified working (`[x]`)

```bash
bex ssh [serviceID|serviceName|instanceID] [flags]
```

SSH into a service instance. This command only supports interactive mode.

You can specify the service ID, service name, or specific instance ID as an
argument. To pass arguments to ssh, use:
  bex ssh [serviceID|serviceName|instanceID] -- [ssh args]

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--ephemeral` | `-e` |  |  | Connect to an ephemeral instance |
| `--help` | `-h` |  |  | Show help for this command |
| `--plan` |  | `string` |  | Plan name to use for the ephemeral instance (e.g. 0.5c-512mb, 1c-2g, 2c-4g). Only valid with --ephemeral |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Open an SSH session for a service
  bex ssh srv-abc123

  # Connect to an ephemeral instance
  bex ssh srv-abc123 --ephemeral

  # Connect to an ephemeral instance with a specific plan
  bex ssh srv-abc123 --ephemeral --plan 1c-2g

  # Pass through ssh arguments
  bex ssh srv-abc123 -- -L 5432:localhost:5432
```

## `upgrade` {#upgrade}

Update bex to the latest release

**Compatibility:** Native Bex command (`[bex]`)

```bash
bex upgrade [flags]
```

Downloads the newest bex-cli release, verifies its cosign signature and
checksum, and replaces the running binary in place. Installs managed by a
package manager (e.g. Homebrew) are left untouched with an upgrade hint.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--check` | `-n` |  |  | report whether an upgrade is available without installing it |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

## `whoami` {#whoami}

Display information about the current user

**Compatibility:** Verified working (`[x]`)

```bash
bex whoami [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Show the currently authenticated user
  bex whoami
```

## `workflows` {#workflows}

Manage Bex Workflows in your workspace

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

Render Workflows (deliberate bex non-goal; `GET /v1/workflows` is a `200 []` stub, everything else `404`/`405`/TTY-blocked)

:::
```bash
bex workflows <subcommand> [flags]
```

Manage workflow services for the active workspace. List workflows, browse
versions and tasks, start task runs, and trigger releases.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List workflows
  bex workflows list

  # Start local workflow development server
  bex workflows dev -- "python main.py"
```

### `workflows cancel` {#workflows-cancel}

Cancel a workflow task run (shortcut for `tasks runs cancel`)

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

shortcuts; `404` / TTY-blocked

:::
```bash
bex workflows cancel <taskRunID> [flags]
```

Cancel an in-progress task run.

Use --local to cancel a task run in the local workflow development server.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--local` |  |  |  | Run against the local workflow development server |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Cancel a remote task run
  bex workflows cancel trn-abc123

  # Cancel a task run in the local dev server
  bex workflows cancel --local trn-xyz789
```

### `workflows create` {#workflows-create}

Create a new workflow service

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`405 Method Not Allowed`

:::
```bash
bex workflows create [flags]
```

Create a new workflow service on Bex.

In interactive mode, a form guides you through the required fields.
In non-interactive mode, provide all required config with flags.

Environment variables (non-interactive only for now):
  • Pass individual vars with --env-var KEY=VALUE (repeatable).
  • Load from one or more .env files with --env-file PATH (repeatable). Every
    listed file must exist.
  • Inline --env-var values override values from --env-file.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--auto-deploy-trigger` |  | `enum` |  | Autodeploy behavior (commit, off, checksPass; default: commit) |
| `--branch` |  | `string` |  | Git branch (Optional) |
| `--build-command` |  | `string` |  | Build command. Required in non-interactive mode |
| `--env-file` |  | `PATH` |  | Path to an env file to load. Repeat to load multiple files (later files override earlier ones). Every listed file must exist |
| `--env-var` |  | `KEY_VALUE` |  | Set environment variables in KEY=VALUE format (can be specified multiple times). Inline values override values loaded from --env-file |
| `--help` | `-h` |  |  | Show help for this command |
| `--name` |  | `string` |  | Workflow name. Required in non-interactive mode |
| `--region` |  | `enum` | `oregon` | Deployment region |
| `--repo` |  | `string` |  | Git repository URL, or a local directory path (e.g. '.') to resolve via the repo's origin remote. Required in non-interactive mode |
| `--root-directory` |  | `string` |  | Root directory in the repository (Optional) |
| `--run-command` |  | `string` |  | Command to run the workflow. Required in non-interactive mode |
| `--runtime` |  | `enum` |  | Runtime (node, python, go, ruby, elixir). Required in non-interactive mode |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
bex workflows create
  bex workflows create --name my-workflow --repo https://github.com/org/repo --build-command "npm install" --runtime node --run-command "npm start" --region oregon -o json
  bex workflows create --repo . --name my-workflow --build-command "npm install" --runtime node --run-command "npm start"
  bex workflows create --repo . --name my-workflow --build-command "pip install -r requirements.txt" --runtime python --run-command ".venv/bin/python main.py" --env-file .env.production --env-var LOG_LEVEL=debug
```

### `workflows dev` {#workflows-dev}

Start a workflow service in development mode

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

client-side dev server, no bex call

:::
```bash
bex workflows dev -- <command to start a workflow service> [flags]
```

```text
Start a workflow service in development mode for local testing.
Required input: -- <command to start a workflow service>

This command runs your workflow service locally on port 8120, allowing you to
list and run tasks without deploying to Bex. Task runs and their logs are stored
in memory, so you can query them after tasks complete.

The command will spawn a new subprocess with your specified command whenever it
needs to run a task or list the defined tasks.

To interact with the local task server:
  • Use the --local flag with other task commands (e.g., 'render workflows tasks list --local')
  • Or set RENDER_USE_LOCAL_DEV=true when using the workflow client SDK

To use a different port:
  • Specify --port when starting the dev server
  • Then use --port with other task commands, or set RENDER_LOCAL_DEV_URL in the SDK

Environment variables:
  • A .env file in the current directory is loaded automatically if present
  • Use --env-file to load one or more specific files (later files override earlier ones)
  • Loaded values override variables inherited from the parent shell
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--debug` |  |  |  | Print detailed workflow task execution events |
| `--env-file` |  | `PATH` | `[.env]` | Path to an env file to load into the workflow subprocess. Repeat to load multiple files (later files override earlier ones) |
| `--help` | `-h` |  |  | Show help for this command |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Start local workflow development server
  bex workflows dev -- "python main.py"

  # Start local workflow development server on a custom port
  bex workflows dev --port 9000 -- "npm start"

  # Load environment variables from custom files
  bex workflows dev --env-file .env --env-file .env.local -- "python main.py"

  # List local tasks from another terminal
  bex workflows tasks list --local
```

### `workflows init` {#workflows-init}

Scaffold a new Bex Workflows project

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

client-side scaffolding works, no bex call

:::
```bash
bex workflows init [flags]
```

Scaffold a new Bex Workflows project with example tasks.

Creates a working example project with task definitions, dependencies, and a
README with instructions for local development and Client SDK integration.

In interactive mode you'll be prompted to select a language, template, output
directory, and optional features. Use --confirm to skip all prompts and accept
defaults, or pass individual flags to skip specific prompts.

With --confirm or non-interactive output (-o text/json/yaml), dependencies are
installed and Git is initialized by default. Pass --install-deps=false or
--git=false to opt out.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--dir` |  | `string` | `./workflows-demo` | Output directory |
| `--git` |  |  |  | Initialize a Git repository (default true with --confirm) |
| `--help` | `-h` |  |  | Show help for this command |
| `--install-agent-skill` |  |  |  | Install the Workflows agent skill for detected AI coding tools |
| `--install-deps` |  |  |  | Install dependencies after scaffolding (default true with --confirm) |
| `--language` |  | `string` |  | Language for the Bex Workflows project (python, node) |
| `--template` |  | `string` |  | Template to scaffold (defaults to the repo's default template) |
| `--confirm` |  |  |  | Skip all confirmation prompts |

```bash
# Scaffold with default settings
  bex workflows init

  # Skip prompts and use Python
  bex workflows init --confirm --language python

  # Skip prompts and disable Git initialization
  bex workflows init --confirm --language python --git=false

  # Customize output directory and enable optional features
  bex workflows init --language python --dir my-project --install-deps --git

  # Use Node.js with a custom directory
  bex workflows init --language node --dir my-project
```

### `workflows list` {#workflows-list}

List workflow services in your workspace

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

returns empty from the stub (exit 0)

:::
```bash
bex workflows list [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List workflows in the active workspace
  bex workflows list
```

### `workflows start` {#workflows-start}

Start a workflow task run (shortcut for `tasks runs start`)

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

shortcuts; `404` / TTY-blocked

:::
```bash
bex workflows start [taskSlug] [flags]
```

Start a task with the provided input. In non-interactive mode, provide input
with --input or --input-file.

You can specify the task by its workflow slug and task name (e.g.,
my-workflow/my-task), either as a positional argument or with --task.

Input Format:
The input should be a JSON array where each element is an argument to the task.
For example, if your task takes two arguments, provide: ["arg1", "arg2"]

You can provide input via:
  • --input with inline JSON
  • --input-file with a path to a JSON file

In interactive mode, you will be prompted to select the task and provide the
input.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--input` |  | `JSON` |  | Provide task input as a JSON array |
| `--input-file` |  | `PATH` |  | Read task input from a JSON file path |
| `--local` |  |  |  | Run against the local workflow development server |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |
| `--task` |  | `TASK` |  | ID or slug of the task to run (alternative to the positional argument) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Start a task run by task slug
  bex workflows start my-workflow/my-task --input='["arg1"]'

  # Start a task run with --task
  bex workflows start --task tsk-1234 --input='["arg1", "arg2"]'

  # Start a task run with input from a file
  bex workflows start my-task --input-file=input.json

  # Start against the local workflow development server
  bex workflows start my-task --local --input='["test"]'
```

### `workflows tasks` {#workflows-tasks}

List tasks and manage their runs

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`tasks list` / `tasks runs \{start,list,show,cancel\}` all `404` / TTY-blocked

:::
```bash
bex workflows tasks <subcommand> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--local` |  |  |  | Run against the local workflow development server |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List tasks in a workflow version
  bex workflows tasks list wfv-1234

  # Start a task run
  bex workflows tasks runs start --task my-task --input='["arg1"]'

  # List task runs for a task
  bex workflows tasks runs list --task my-task
```

#### `workflows tasks list` {#workflows-tasks-list}

List tasks in a workflow version

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`tasks list` / `tasks runs \{start,list,show,cancel\}` all `404` / TTY-blocked

:::
```bash
bex workflows tasks list [workflowVersionID] [flags]
```

List all tasks defined in a workflow version.

Tasks are user-defined functions registered with the Bex Workflows SDK. Each
time you release a workflow service, Render creates a new workflow version and
registers all tasks it finds in that version.

In interactive mode, you will be prompted to select a workflow if not provided.

Local Development:
When using the --local flag, you don't need to provide a workflow version ID.
Instead, the command connects to your local dev server (default port 8120) to
list tasks from your running workflow service. Start the dev server first with:
  bex workflows dev -- "`<your command>`"

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Run against the local workflow development server |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |

```bash
# List tasks for a workflow version
  bex workflows tasks list wfv-1234

  # List tasks from local workflow development server
  bex workflows tasks list --local
```

#### `workflows tasks runs` {#workflows-tasks-runs}

Start, list, and inspect task runs

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`tasks list` / `tasks runs \{start,list,show,cancel\}` all `404` / TTY-blocked

:::
```bash
bex workflows tasks runs <subcommand> [flags]
```

Manage runs of workflow tasks.

A task run represents a single execution of a task with specific input
parameters. Use these commands to start new runs, view task run history, inspect
details, and cancel in-progress runs.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Run against the local workflow development server |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |

```bash
# Start a task run
  bex workflows tasks runs start --task my-task --input='["arg1"]'

  # List task runs for a task
  bex workflows tasks runs list --task my-task

  # Show details for a task run
  bex workflows tasks runs show trn-1234

  # Cancel a task run
  bex workflows tasks runs cancel trn-1234
```

#### `workflows tasks runs cancel` {#workflows-tasks-runs-cancel}

Cancel a running task run

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`tasks list` / `tasks runs \{start,list,show,cancel\}` all `404` / TTY-blocked

:::
```bash
bex workflows tasks runs cancel [taskRunID] [flags]
```

Cancel an in-progress task run.

Use --local to cancel a task run in the local workflow development server.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Run against the local workflow development server |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |

```bash
# Cancel a remote task run
  bex workflows tasks runs cancel trn-abc123

  # Use the top-level shortcut
  bex workflows cancel trn-abc123

  # Cancel a task run in the local dev server
  bex workflows tasks runs cancel --local trn-xyz789
```

#### `workflows tasks runs list` {#workflows-tasks-runs-list}

List all execution runs for a specific task

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`tasks list` / `tasks runs \{start,list,show,cancel\}` all `404` / TTY-blocked

:::
```bash
bex workflows tasks runs list [taskID] [flags]
```

List all execution runs for a specific task.

A task run represents a single execution of a task with specific input
parameters. This command shows the history of all runs for a given task.

You can specify the task by its workflow slug and task name (e.g.,
my-workflow/my-task), either as a positional argument or with --task.

In interactive mode, you will be prompted to select a task if not provided.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--task` |  | `TASK` |  | ID or slug of the task whose runs to list (alternative to the positional argument) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Run against the local workflow development server |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |

```bash
# List task runs by task ID
  bex workflows tasks runs list --task tsk-1234

  # List task runs by task slug
  bex workflows tasks runs list --task my-workflow/my-task

  # List task runs by passing the task as a positional argument
  bex workflows tasks runs list my-workflow/my-task

  # List task runs from local workflow development server
  bex workflows tasks runs list --local --task my-task
```

#### `workflows tasks runs show` {#workflows-tasks-runs-show}

Show detailed information about a task run

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`tasks list` / `tasks runs \{start,list,show,cancel\}` all `404` / TTY-blocked

:::
```bash
bex workflows tasks runs show [taskRunID] [flags]
```

Display detailed information about a specific task run execution.

This command shows comprehensive information about a task run, including:
  • Task run ID and status
  • Input parameters provided
  • Output or error result
  • Start and completion timestamps

The task run ID is returned when you execute a task with:
  bex workflows tasks runs start

In interactive mode, you will be prompted to select a task run if not provided.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Run against the local workflow development server |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |

```bash
# Show details for a task run
  bex workflows tasks runs show trn-1234

  # Show details from local workflow development server
  bex workflows tasks runs show --local trn-5678
```

#### `workflows tasks runs start` {#workflows-tasks-runs-start}

Start a task run with the provided input

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`tasks list` / `tasks runs \{start,list,show,cancel\}` all `404` / TTY-blocked

:::
```bash
bex workflows tasks runs start [taskSlug] [flags]
```

Start a task with the provided input. In non-interactive mode, provide input
with --input or --input-file.

You can specify the task by its workflow slug and task name (e.g.,
my-workflow/my-task), either as a positional argument or with --task.

Input Format:
The input should be a JSON array where each element is an argument to the task.
For example, if your task takes two arguments, provide: ["arg1", "arg2"]

You can provide input via:
  • --input with inline JSON
  • --input-file with a path to a JSON file

In interactive mode, you will be prompted to select the task and provide the
input.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--input` |  | `JSON` |  | Provide task input as a JSON array |
| `--input-file` |  | `PATH` |  | Read task input from a JSON file path |
| `--task` |  | `TASK` |  | ID or slug of the task to run (alternative to the positional argument) |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--local` |  |  |  | Run against the local workflow development server |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |
| `--port` |  | `PORT` | `8120` | Set the port of the local task server |

```bash
# Start a task run with inline JSON input
  bex workflows tasks runs start --task tsk-1234 --input='["arg1", "arg2"]'

  # Start a task run by passing the task as a positional argument
  bex workflows tasks runs start my-workflow/my-task --input='["arg1"]'

  # Start a task run with input from a file
  bex workflows tasks runs start --task my-task --input-file=input.json

  # Start a task run against local workflow development server
  bex workflows tasks runs start --task my-task --local --input='["test"]'
```

### `workflows versions` {#workflows-versions}

List and release workflow versions

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`versions list` / `versions release` `404`

:::
```bash
bex workflows versions <subcommand> [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List versions for a workflow
  bex workflows versions list wf-abc123

  # Release a new workflow version
  bex workflows versions release wf-abc123
```

#### `workflows versions list` {#workflows-versions-list}

List versions of a workflow

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`versions list` / `versions release` `404`

:::
```bash
bex workflows versions list [workflowID] [flags]
```

List all versions of a workflow service.

Each time you release a workflow service, Render creates a new workflow version.
A version represents a specific snapshot of your workflow service code and its
registered tasks at the time of release.

This command displays all versions for a workflow, showing:
  • Version ID
  • Creation timestamp
  • Associated tasks

In interactive mode, you will be prompted to select a workflow if not provided.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List versions by workflow ID
  bex workflows versions list wf-1234

  # List versions by workflow slug
  bex workflows versions list my-workflow-slug
```

#### `workflows versions release` {#workflows-versions-release}

Release a new workflow version

**Compatibility:** Deliberate non-goal on Bex (`[-]`)

:::warning Non-goal on Bex

`versions list` / `versions release` `404`

:::
```bash
bex workflows versions release [workflowID] [flags]
```

Release a new version of a workflow service.

This command triggers a new release of your workflow service on Bex. With a new
release, Render:
  1. Pulls the latest code from your repository (or a specific commit)
  2. Builds your workflow service
  3. Registers all tasks it finds in the service
  4. Creates a new workflow version

You can optionally specify a commit ID to release a specific version of your
code.

In interactive mode, you will be prompted to:
  • Select a workflow if not provided
  • Confirm the release

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--commit` |  | `COMMIT_ID` |  | Release the specified commit ID |
| `--help` | `-h` |  |  | Show help for this command |
| `--wait` |  |  |  | Wait for release completion and exit non-zero if release fails |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Release a new version
  bex workflows versions release wf-1234

  # Release from a specific commit
  bex workflows versions release wf-1234 --commit abc123

  # Wait for release completion
  bex workflows versions release wf-1234 --wait
```

## `workspace` {#workspace}

Manage the CLI's active workspace

**Compatibility:** Verified working (`[x]`)

```bash
bex workspace <subcommand> [flags]
```

Manage the CLI's active workspace. All CLI commands run against the active
workspace.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Show the active workspace
  bex workspace current

  # Set the active workspace
  bex workspace set ws-abc123
```

### `workspace current` {#workspace-current}

Show the currently selected workspace

**Compatibility:** Verified working (`[x]`)

```bash
bex workspace current [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# Show the active workspace
  bex workspace current
```

### `workspace set` {#workspace-set}

Set the CLI's active workspace

**Compatibility:** Verified working (`[x]`)

```bash
bex workspace set [workspaceName|workspaceID] [flags]
```

Set the CLI's active workspace. All CLI commands run against the active
workspace.

The active workspace is saved in $HOME/.bex/cli.yaml by default. Set
BEX_CLI_CONFIG_DIR to use cli.yaml in another directory, or BEX_CLI_CONFIG_PATH
to use an exact file path (takes precedence over BEX_CLI_CONFIG_DIR).
An explicit, non-empty RENDER_CLI_CONFIG_PATH overrides both Bex inputs and
the default. Empty values are treated as unset.

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

## `workspaces` {#workspaces}

List workspaces available to your account

**Compatibility:** Verified working (`[x]`)

```bash
bex workspaces [flags]
```

| Flag | Short | Type | Default | Description |
| --- | --- | --- | --- | --- |
| `--help` | `-h` |  |  | Show help for this command |
| `--confirm` |  |  |  | Skip all confirmation prompts |
| `--output` | `-o` | `FORMAT` | `interactive` | Set output format to interactive, json, yaml, or text. Auto-switches to text on non-TTY |

```bash
# List workspaces available to the current user
  bex workspaces
```