> ## Documentation Index
> Fetch the complete documentation index at: https://docs.plungeai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# ocean-cli — every command and flag (generated)

> Reference page of the ocean-cli skill.


<!-- sources-of-truth: apps/ocean-cli/src/index.ts apps/ocean-cli/src/commands/ | generated by apps/ocean-skills/scripts/build-ocean-cli-reference.mjs — do not edit -->

## ocean-cli

```
Usage: ocean-cli [options] [command]

Ocean CLI — search, research, run agents and workflows, schedule, and manage
your PlungeAI Ocean account from the terminal.

Options:
  -V, --version                   output the version number
  -q, --quiet                     Suppress status lines on stderr
  -h, --help                      display help for command

Commands:
  login [options]                 Sign in through the browser and store your
                                  account key (ozk_…), which opens every plane,
                                  or with --session the optional Studio session.
  logout [options]                Remove stored credentials.
  auth [options]                  Check authentication status.
  whoami [options]                Show the identity, tier and rate window behind
                                  the API key.
  doctor [options]                Live connectivity and credential checks (exit
                                  4 when any fails).
  config [options] [key] [value]  View or set CLI configuration.
  search [options] [objective]    Search the web with PlungeAI's search agents
                                  (Parallel by default).
  extract [options] <urls...>     Extract content from URLs as clean markdown.
  answer [options] [question]     A reasoning-enhanced, cited answer from the
                                  web (Parallel Answer).
  research                        Deep research for open-ended questions
                                  (Parallel Task API).
  findall                         FindAll: discover entities from the web using
                                  natural language.
  monitor                         Monitor: continuously track the web for
                                  changes.
  enrich                          Data enrichment: add web-researched columns to
                                  a list of rows.
  agents                          Registry agents: list, inspect and run them
                                  (agents plane).
  tools                           Structured tool agents: contracts and typed
                                  calls (tools plane).
  workflows                       Saved workflows (CNL): list, create, run,
                                  versions.
  bot-groups                      Bot groups: named sets of 2 to 6 of your saved
                                  bots (message_bot to=group:<name>).
  executions                      Runs: list, status, poll, output, continue,
                                  steer, files, export.
  missions                        Bounded autonomous agent runs with memory
                                  (type: harness).
  schedules                       Scheduled jobs (cron): agents, queries,
                                  workflows, heartbeats.
  memory                          Long-term platform memory: recall, remember,
                                  past runs.
  learn                           Distil a URL or text into a private skill.
  templates                       Workflow templates.
  chat                            One-shot platform chat turns (non-interactive;
                                  use conversation ids to continue).
  discovery                       The registry: search cards, get
                                  recommendations, read a card.
  models                          The models plane (your ozk_ key): catalog,
                                  chat completions, embeddings.
  mcp                             MCP: the platform tool list, and outbound runs
                                  against connected MCP servers.
  traces                          Execution traces: spans and gateway requests
                                  by trace id.
  keys                            One API keys (ozk_) — needs a Studio session.
  balance [options]               Prepaid credit balance (needs a Studio
                                  session).
  usage [options]                 Usage and cost rollups (needs a Studio
                                  session).
  nodes                           Local nodes (device daemons) — needs a Studio
                                  session.
  campaigns                       Campaign ledgers on a workflow — needs a
                                  Studio session.
  connections                     Provider connections (API keys, OAuth) — needs
                                  a Studio session.
  secrets                         Developer secrets (encrypted at rest, scoped
                                  to a company, team or project) — needs a
                                  Studio session.
  documents                       Stored documents — needs a Studio session.
  teams                           Teams — needs a Studio session.
  projects                        Projects — needs a Studio session.
  skills                          Install, update and manage PlungeAI agent
                                  skills from skills.plungeai.com.
  completion                      Shell completion for bash, zsh and fish.
  update [options]                Update to the latest published version (npm).
```

## ocean-cli login

```
Usage: ocean-cli login [options]

Sign in through the browser and store your account key (ozk_…), which opens
every plane, or with --session the optional Studio session.

Options:
  --key <source>       Read the secret from "-" (stdin) or a file; omitted =
                       sign in through the browser in a terminal
  --session            Store the Studio auth-session cookie value instead of an
                       API key
  --no-browser         Paste a key at a hidden prompt instead of signing in
                       through the browser
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli login                          # opens the browser to sign in, stores your account key
  ocean-cli login --no-browser             # paste a key from https://dashboard.plungeai.com (One API → Keys)
  echo "$OCEAN_API_KEY" | ocean-cli login --key -
  ocean-cli login --session --key cookie.txt
```

## ocean-cli logout

```
Usage: ocean-cli logout [options]

Remove stored credentials.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli logout
```

## ocean-cli auth

```
Usage: ocean-cli auth [options]

Check authentication status.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli auth --json
```

## ocean-cli whoami

```
Usage: ocean-cli whoami [options]

Show the identity, tier and rate window behind the API key.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli whoami --json
```

## ocean-cli doctor

```
Usage: ocean-cli doctor [options]

Live connectivity and credential checks (exit 4 when any fails).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli doctor
```

## ocean-cli config

```
Usage: ocean-cli config [options] [key] [value]

View or set CLI configuration.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Keys: api_url, mcp_url, studio_url, dashboard_url, default_provider
Examples:
  ocean-cli config                        # show all settings
  ocean-cli config default_provider tavily
  ocean-cli config api_url https://api.plungeai.com
```

## ocean-cli search

```
Usage: ocean-cli search [options] [objective]

Search the web with PlungeAI's search agents (Parallel by default).

Options:
  -q, --query <text>                  Keyword search query (can be repeated)
                                      (default: [])
  --mode <mode>                       Search mode (Parallel) (choices: "turbo",
                                      "fast", "basic", "advanced")
  --max-results <n>                   Maximum results
  --include-domains <list>            Only search these domains (comma-separated
                                      or repeated) (default: [])
  --exclude-domains <list>            Exclude these domains (comma-separated or
                                      repeated) (default: [])
  --after-date <date>                 Only results after this date (YYYY-MM-DD)
  --excerpt-max-chars-per-result <n>  Max characters per result for excerpts
                                      (min 1000)
  --excerpt-max-chars-total <n>       Max total characters for excerpts
  --max-age-seconds <n>               Max age in seconds before fetching live
                                      content (min 600)
  --timeout-seconds <n>               Timeout in seconds for fetching live
                                      content
  --disable-cache-fallback            Return an error instead of stale cached
                                      content
  --location <cc>                     ISO 3166-1 alpha-2 country code for
                                      geo-targeted results (e.g. us, gb, de)
  --provider <name>                   Search agent (default: config
                                      default_provider or parallel) (choices:
                                      "parallel", "tavily", "firecrawl",
                                      "serper", "brave", "exa")
  --dry-run                           Show what would be sent without making API
                                      calls
  --session-id <id>                   Session ID to group related search/extract
                                      calls
  --client-model <model>              The model generating this request and
                                      consuming the results
  --json                              Output as JSON
  -o, --output <path>                 Also save the JSON result to this file
  --force                             Overwrite an existing output file
  -h, --help                          display help for command

Examples:
  ocean-cli search "Who is the current Head of Sales at Adyen?" --max-results 3
  ocean-cli search -q "adyen head of sales" -q "adyen VP sales" --json
  echo "latest Cloudflare Workers pricing" | ocean-cli search - --provider tavily
```

## ocean-cli extract

```
Usage: ocean-cli extract [options] <urls...>

Extract content from URLs as clean markdown.

Options:
  --objective <text>                  Focus extraction on a specific goal
  -q, --query <text>                  Keywords to prioritize (can be repeated)
                                      (default: [])
  --full-content                      Include complete page content
  --full-content-max-chars <n>        Max characters per result for full content
  --excerpt-max-chars-per-result <n>  Max characters per result for excerpts
                                      (min 1000)
  --excerpt-max-chars-total <n>       Max total characters for excerpts across
                                      all URLs
  --max-age-seconds <n>               Max age in seconds before fetching live
                                      content (min 600)
  --timeout-seconds <n>               Timeout in seconds for fetching live
                                      content
  --disable-cache-fallback            Return an error instead of stale cached
                                      content
  --provider <name>                   Extraction agent (default: config
                                      default_provider when it can extract, else
                                      parallel) (choices: "parallel", "tavily",
                                      "firecrawl")
  --dry-run                           Show what would be sent without making API
                                      calls
  --session-id <id>                   Session ID to group related search/extract
                                      calls
  --client-model <model>              The model generating this request and
                                      consuming the results
  --json                              Output as JSON
  -o, --output <path>                 Also save the JSON result to this file
  --force                             Overwrite an existing output file
  -h, --help                          display help for command

Examples:
  ocean-cli extract https://docs.parallel.ai/integrations/cli --objective "install steps"
  ocean-cli extract https://a.com https://b.com --full-content --json
  ocean-cli extract https://a.com --provider firecrawl
```

## ocean-cli answer

```
Usage: ocean-cli answer [options] [question]

A reasoning-enhanced, cited answer from the web (Parallel Answer).

Options:
  --effort <level>          Reasoning effort (choices: "low", "medium", "high")
  --instructions <text>     Additional instructions for the response
  --include-domains <list>  Only cite these domains (comma-separated or
                            repeated) (default: [])
  --exclude-domains <list>  Never cite these domains (comma-separated or
                            repeated) (default: [])
  --max-cost <usd>          Cost cap in USD (default 2.00)
  --dry-run                 Show what would be sent without making API calls
  --session-id <id>         Session ID to group related search/extract calls
  --client-model <model>    The model generating this request and consuming the
                            results
  --json                    Output as JSON
  -o, --output <path>       Also save the JSON result to this file
  --force                   Overwrite an existing output file
  -h, --help                display help for command

Examples:
  ocean-cli answer "What changed in Cloudflare Workers pricing in 2026?" --effort medium
  echo "question" | ocean-cli answer - --json
```

## ocean-cli research

```
Usage: ocean-cli research [options] [command]

Deep research for open-ended questions (Parallel Task API).

Options:
  -h, --help                 display help for command

Commands:
  run [options] [query]      Run deep research on a question or topic. Results
                             are always saved to disk (default
                             ./ocean-research/<run_id>.json).
  status [options] <run_id>  Check the status of a research task.
  poll [options] <run_id>    Poll an existing research task until completion and
                             save the result (default
                             ./ocean-research/<run_id>.json).
  result [options] <run_id>  Fetch the result of a completed research task (no
                             file written unless -o).
  processors [options]       List available research processors and their
                             characteristics.
```

## ocean-cli research run

```
Usage: ocean-cli research run [options] [query]

Run deep research on a question or topic. Results are always saved to disk
(default ./ocean-research/<run_id>.json).

Options:
  -f, --input-file <path>         Read the query from a file
  -p, --processor <tier>          Processor tier (higher = more thorough but
                                  slower) (choices: "lite-fast", "base-fast",
                                  "core-fast", "core2x-fast", "pro-fast",
                                  "ultra-fast", "ultra2x-fast", "ultra4x-fast",
                                  "ultra8x-fast", "lite", "base", "core",
                                  "core2x", "pro", "ultra", "ultra2x",
                                  "ultra4x", "ultra8x", default: "pro-fast")
  --text                          Return a markdown report (text schema) instead
                                  of structured JSON
  --text-description <text>       Steering description for the markdown report
                                  (implies --text, e.g. 'Keep under 1000 words')
  --output-schema <json>          JSON schema for structured output (inline, -
                                  for stdin, @file)
  --include-domains <list>        Only use these domains (comma-separated or
                                  repeated) (default: [])
  --exclude-domains <list>        Exclude these domains (comma-separated or
                                  repeated) (default: [])
  --after-date <date>             Only results after this date (YYYY-MM-DD)
  --location <cc>                 ISO 3166-1 alpha-2 country code
  --previous-interaction-id <id>  Continue from a prior run
  --memory-scope-key <key>        Memory scope for this run
  --max-cost <usd>                Cost cap in USD (default 2.00)
  --no-wait                       Return immediately with the id (don't poll)
  --timeout <seconds>             Max wait time in seconds (default: 3600)
  --poll-interval <seconds>       Seconds between status checks (default: 45)
  --dry-run                       Show what would be sent without making API
                                  calls
  --json                          Output as JSON
  -o, --output <path>             Base path — writes <base>.json (and <base>.md
                                  with --text)
  --force                         Overwrite an existing output file
  -h, --help                      display help for command

Examples:
  ocean-cli research run "What are the latest developments in quantum computing?"
  ocean-cli research run --text "Market analysis of HVAC industry" -o report
  ocean-cli research run -f question.txt --processor ultra --text -o report
  echo "My research question" | ocean-cli research run - --json
  ocean-cli research run "Follow-up?" --previous-interaction-id trun_abc123
```

## ocean-cli research status

```
Usage: ocean-cli research status [options] <run_id>

Check the status of a research task.

Options:
  --json               Output as JSON
  -o, --output <path>  Base path — writes <base>.json
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli research status trun_abc123
```

## ocean-cli research poll

```
Usage: ocean-cli research poll [options] <run_id>

Poll an existing research task until completion and save the result (default
./ocean-research/<run_id>.json).

Options:
  --timeout <seconds>        Max wait time in seconds (default: 3600)
  --poll-interval <seconds>  Seconds between status checks (default: 45)
  --json                     Output as JSON
  -o, --output <path>        Base path — writes <base>.json
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Example:
  ocean-cli research poll trun_abc123 -o report
```

## ocean-cli research result

```
Usage: ocean-cli research result [options] <run_id>

Fetch the result of a completed research task (no file written unless -o).

Options:
  --json               Output as JSON
  -o, --output <path>  Base path — writes <base>.json
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli research result trun_abc123 --json
```

## ocean-cli research processors

```
Usage: ocean-cli research processors [options]

List available research processors and their characteristics.

Options:
  --json               Output as JSON
  -o, --output <path>  Base path — writes <base>.json
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli research processors
```

## ocean-cli findall

```
Usage: ocean-cli findall [options] [command]

FindAll: discover entities from the web using natural language.

Options:
  -h, --help                           display help for command

Commands:
  run [options] <objective>            Run a FindAll query to discover and match
                                       entities from the web. Results are always
                                       saved to disk (default
                                       ./ocean-findall/<findall_id>.json).
  status [options] <findall_id>        Check the status of a FindAll run.
  poll [options] <findall_id>          Poll a FindAll run until completion, save
                                       and show the results (default
                                       ./ocean-findall/<findall_id>.json).
  result [options] <findall_id>        Fetch results of a completed FindAll run.
  cancel [options] <findall_id>        Cancel a running FindAll run.
  ingest [options] <objective>         Convert a natural language objective into
                                       a FindAll schema (preview before
                                       running).
  entity-search [options] <objective>  Return ranked entities matching a natural
                                       language objective (best-effort, low
                                       latency).
  extend [options] <findall_id>        Extend a finished FindAll run to get more
                                       matches.
  enrich [options] <findall_id>        Add an enrichment to every match of a
                                       FindAll run.
  schema [options] <findall_id>        Read a FindAll run's current spec.
```

## ocean-cli findall run

```
Usage: ocean-cli findall run [options] <objective>

Run a FindAll query to discover and match entities from the web. Results are
always saved to disk (default ./ocean-findall/<findall_id>.json).

Options:
  -g, --generator <tier>         Generator tier (higher = more thorough but
                                 slower/costlier) (choices: "preview", "base",
                                 "core", "pro", default: "core")
  -n, --match-limit <n>          Maximum number of matched candidates (5-1000)
                                 (default: 10)
  --entity-type <type>           Entity type (default companies)
  --exclude <json>               Entities to exclude as JSON array of {name,
                                 url} objects (inline, - or @file)
  --enrichment-schema <json>     JSON schema for per-match enrichment (inline, -
                                 or @file)
  --enrichment-processor <tier>  Processor for enrichment tasks
  --include-unmatched            Also return every candidate that did not match
  --memory-scope-key <key>       Memory scope for this run
  --metadata <json>              Metadata as JSON string
  --max-cost <usd>               Cost cap in USD (default 2.00)
  --no-wait                      Return immediately with the id (don't poll)
  --timeout <seconds>            Max wait time in seconds (default: 3600)
  --poll-interval <seconds>      Seconds between status checks (default: 30)
  --dry-run                      Show what would be sent without making API
                                 calls
  --json                         Output as JSON
  -o, --output <path>            Also save the JSON result to this file
  --force                        Overwrite an existing output file
  -h, --help                     display help for command

Examples:
  ocean-cli findall run "Find all AI companies that raised Series A in 2026"
  ocean-cli findall run "Find roofing companies in Charlotte NC" -g base -n 25
  ocean-cli findall run "Find YC companies in developer tools" --no-wait --json
  ocean-cli findall run "Find AI startups" --exclude '[{"name": "OpenAI", "url": "openai.com"}]'
```

## ocean-cli findall status

```
Usage: ocean-cli findall status [options] <findall_id>

Check the status of a FindAll run.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli findall status findall_abc
```

## ocean-cli findall poll

```
Usage: ocean-cli findall poll [options] <findall_id>

Poll a FindAll run until completion, save and show the results (default
./ocean-findall/<findall_id>.json).

Options:
  --timeout <seconds>        Max wait time in seconds (default: 3600)
  --poll-interval <seconds>  Seconds between status checks (default: 30)
  --json                     Output as JSON
  -o, --output <path>        Also save the JSON result to this file
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Example:
  ocean-cli findall poll findall_abc -o out.json
```

## ocean-cli findall result

```
Usage: ocean-cli findall result [options] <findall_id>

Fetch results of a completed FindAll run.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli findall result findall_abc --json
```

## ocean-cli findall cancel

```
Usage: ocean-cli findall cancel [options] <findall_id>

Cancel a running FindAll run.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli findall cancel findall_abc
```

## ocean-cli findall ingest

```
Usage: ocean-cli findall ingest [options] <objective>

Convert a natural language objective into a FindAll schema (preview before
running).

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli findall ingest "Find all AI companies that raised Series A in 2026"
```

## ocean-cli findall entity-search

```
Usage: ocean-cli findall entity-search [options] <objective>

Return ranked entities matching a natural language objective (best-effort, low
latency).

Options:
  -t, --entity-type <type>  Entity type to search for (choices: "companies",
                            "people")
  -n, --match-limit <n>     Maximum entities to return (5-1000) (default: 10)
  --dry-run                 Show what would be sent without making API calls
  --json                    Output as JSON
  -o, --output <path>       Also save the JSON result to this file
  --force                   Overwrite an existing output file
  -h, --help                display help for command

Examples:
  ocean-cli findall entity-search "AI startups in San Francisco" -t companies
  ocean-cli findall entity-search "Senior PMs at AI startups" -t people -n 25
```

## ocean-cli findall extend

```
Usage: ocean-cli findall extend [options] <findall_id>

Extend a finished FindAll run to get more matches.

Options:
  -n, --additional <n>  Additional matches to find
  --dry-run             Show what would be sent without making API calls
  --json                Output as JSON
  -o, --output <path>   Also save the JSON result to this file
  --force               Overwrite an existing output file
  -h, --help            display help for command

Example:
  ocean-cli findall extend findall_abc -n 20
```

## ocean-cli findall enrich

```
Usage: ocean-cli findall enrich [options] <findall_id>

Add an enrichment to every match of a FindAll run.

Options:
  --schema <json>      Enrichment JSON schema (inline, - or @file)
  --processor <tier>   Processor for the enrichment tasks
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli findall enrich findall_abc --schema '{"type":"object","properties":{"ceo":{"type":"string"}}}'
```

## ocean-cli findall schema

```
Usage: ocean-cli findall schema [options] <findall_id>

Read a FindAll run's current spec.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli findall schema findall_abc --json
```

## ocean-cli monitor

```
Usage: ocean-cli monitor [options] [command]

Monitor: continuously track the web for changes.

Options:
  -h, --help                      display help for command

Commands:
  create [options] [query]        Create a monitor. QUERY is the search query
                                  for type=event_stream (default); for
                                  type=snapshot omit QUERY and pass
                                  --task-run-id.
  list [options]                  List monitors (newest first).
  get [options] <monitor_id>      Get details of a specific monitor.
  update [options] <monitor_id>   Update an existing monitor (query and
                                  task_run_id are immutable — create a new
                                  monitor to change them).
  cancel [options] <monitor_id>   Cancel a monitor (irreversible).
  trigger [options] <monitor_id>  Trigger an immediate one-off (billed) run of a
                                  monitor.
  events [options] <monitor_id>   List events for a monitor (newest first).
```

## ocean-cli monitor create

```
Usage: ocean-cli monitor create [options] [query]

Create a monitor. QUERY is the search query for type=event_stream (default); for
type=snapshot omit QUERY and pass --task-run-id.

Options:
  -f, --frequency <spec>  How often to run: <n><unit> with unit h/d/w (e.g. 1h,
                          6h, 1d, 2w) or hourly/daily/weekly (default: "1d")
  --type <type>           Monitor type (choices: "event_stream", "snapshot",
                          default: "event_stream")
  --task-run-id <id>      Required for type=snapshot: the Task Run whose output
                          to track
  --processor <tier>      Monitor processor (default lite; 'base' is more
                          thorough at higher cost) (choices: "lite", "base")
  --webhook <url>         Webhook URL for event delivery
  --metadata <json>       Metadata as JSON (inline, - or @file)
  --output-schema <json>  Output schema as JSON (event_stream only)
  --include-backfill      event_stream only: include a sample of historical
                          events on first run
  --dry-run               Show what would be sent without making API calls
  --json                  Output as JSON
  -o, --output <path>     Also save the JSON result to this file
  --force                 Overwrite an existing output file
  -h, --help              display help for command

Examples:
  ocean-cli monitor create "Track price changes for iPhone 16"
  ocean-cli monitor create "New AI funding announcements" --frequency 1h
  ocean-cli monitor create --type snapshot --task-run-id trun_abc --frequency 1d
Note: monitor creation is a gated (billed, recurring) operation — the unattended API refuses it (HTTP 403, reported as
      approval_required, exit 4) until the owner approves it.
```

## ocean-cli monitor list

```
Usage: ocean-cli monitor list [options]

List monitors (newest first).

Options:
  -n, --limit <n>      Maximum number of monitors to return (1-10000)
  --cursor <token>     Pagination token from a previous response
  --status <status>    Filter by status (repeatable). Defaults to active only.
                       (choices: "active", "cancelled")
  --type <type>        Filter by monitor type (repeatable) (choices:
                       "event_stream", "snapshot")
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli monitor list
  ocean-cli monitor list --limit 10 --json
  ocean-cli monitor list --status active --status cancelled
```

## ocean-cli monitor get

```
Usage: ocean-cli monitor get [options] <monitor_id>

Get details of a specific monitor.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli monitor get mon_abc
```

## ocean-cli monitor update

```
Usage: ocean-cli monitor update [options] <monitor_id>

Update an existing monitor (query and task_run_id are immutable — create a new
monitor to change them).

Options:
  -f, --frequency <spec>  Updated frequency (e.g. 1h, 6h, 1d, 2w, or
                          hourly/daily/weekly)
  --processor <tier>      Updated processor (choices: "lite", "base")
  --webhook <url>         Updated webhook URL
  --metadata <json>       Updated metadata as JSON (inline, - or @file)
  --dry-run               Show what would be sent without making API calls
  --json                  Output as JSON
  -o, --output <path>     Also save the JSON result to this file
  --force                 Overwrite an existing output file
  -h, --help              display help for command

Examples:
  ocean-cli monitor update mon_abc --frequency 1h
  ocean-cli monitor update mon_abc --webhook https://example.com/hook
```

## ocean-cli monitor cancel

```
Usage: ocean-cli monitor cancel [options] <monitor_id>

Cancel a monitor (irreversible).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli monitor cancel mon_abc
```

## ocean-cli monitor trigger

```
Usage: ocean-cli monitor trigger [options] <monitor_id>

Trigger an immediate one-off (billed) run of a monitor.

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli monitor trigger mon_abc
```

## ocean-cli monitor events

```
Usage: ocean-cli monitor events [options] <monitor_id>

List events for a monitor (newest first).

Options:
  --limit <n>          Maximum number of events to return (1-100, default 20)
  --cursor <token>     Pagination token from a previous response
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli monitor events mon_abc
  ocean-cli monitor events mon_abc --limit 50 --json
```

## ocean-cli enrich

```
Usage: ocean-cli enrich [options] [command]

Data enrichment: add web-researched columns to a list of rows.

Options:
  -h, --help                       display help for command

Commands:
  run [options] [config]           Run data enrichment from a YAML config or CLI
                                   arguments (rows from --data, --source
                                   CSV/JSON, or the config).
  suggest [options] <intent>       Use AI to suggest output columns for an
                                   enrichment.
  status [options] <taskgroup_id>  Check the status of an enrichment task group.
  poll [options] <taskgroup_id>    Poll an enrichment task group until
                                   completion and save its runs (default
                                   ./ocean-enrich/<taskgroup_id>.json; rows come
                                   back without the source columns).
```

## ocean-cli enrich run

```
Usage: ocean-cli enrich run [options] [config]

Run data enrichment from a YAML config or CLI arguments (rows from --data,
--source CSV/JSON, or the config).

Options:
  --source <path>            Source rows: a .csv or .json file
  --target <path>            Write the enriched rows here (.json writes JSON,
                             anything else CSV)
  --data <json>              Inline JSON array of rows, - or @file (alternative
                             to --source)
  --intent <text>            Natural-language description; AI suggests the
                             output columns when --enriched-columns is omitted
  --enriched-columns <json>  Output columns as JSON:
                             [{"name","description","type"}]
  --source-columns <json>    Source columns as JSON: [{"name","description"}]
                             (default: inferred from the rows)
  --processor <tier>         Processor to use (default base) (choices:
                             "lite-fast", "base-fast", "core-fast",
                             "core2x-fast", "pro-fast", "ultra-fast",
                             "ultra2x-fast", "ultra4x-fast", "ultra8x-fast",
                             "lite", "base", "core", "core2x", "pro", "ultra",
                             "ultra2x", "ultra4x", "ultra8x")
  --no-wait                  Return immediately with the id (don't poll)
  --timeout <seconds>        Max wait time in seconds (default: 3600)
  --poll-interval <seconds>  Seconds between status checks (default: 5)
  --dry-run                  Show what would be sent without making API calls
  --json                     Output as JSON
  -o, --output <path>        Also save the full JSON result here (default
                             ./ocean-enrich/<taskgroup_id>.json without
                             --target)
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Examples:
  ocean-cli enrich run config.yaml
  ocean-cli enrich run --source data.csv --intent "Find the CEO" --target out.csv
  ocean-cli enrich run --data '[{"company": "Google"}, {"company": "Apple"}]' --enriched-columns '[{"name":"ceo","description":"CEO name"}]'
YAML config keys: source_type, source, target, processor, intent, source_columns, enriched_columns
```

## ocean-cli enrich suggest

```
Usage: ocean-cli enrich suggest [options] <intent>

Use AI to suggest output columns for an enrichment.

Options:
  --source-columns <json>  Source columns as JSON: [{"name","description"}]
  --dry-run                Show what would be sent without making API calls
  --json                   Output as JSON
  -o, --output <path>      Also save the JSON result to this file
  --force                  Overwrite an existing output file
  -h, --help               display help for command

Example:
  ocean-cli enrich suggest "Find the CEO and founding year" --source-columns '[{"name":"company"}]'
```

## ocean-cli enrich status

```
Usage: ocean-cli enrich status [options] <taskgroup_id>

Check the status of an enrichment task group.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli enrich status tgrp_abc
```

## ocean-cli enrich poll

```
Usage: ocean-cli enrich poll [options] <taskgroup_id>

Poll an enrichment task group until completion and save its runs (default
./ocean-enrich/<taskgroup_id>.json; rows come back without the source columns).

Options:
  --timeout <seconds>        Max wait time in seconds (default: 3600)
  --poll-interval <seconds>  Seconds between status checks (default: 5)
  --json                     Output as JSON
  -o, --output <path>        Also save the JSON result to this file
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Example:
  ocean-cli enrich poll tgrp_abc --json
```

## ocean-cli agents

```
Usage: ocean-cli agents [options] [command]

Registry agents: list, inspect and run them (agents plane).

Options:
  -h, --help                                display help for command

Commands:
  list [options]                            List active agents (with --search/--category the discovery index is used).
  categories [options]                      List agent categories with counts.
  get [options] <agent_id>                  Show an agent's card (markdown with YAML frontmatter).
  run [options] <agent_id> [prompt]         Run one agent with a prompt (sync; --stream for live tokens). Async agent work: missions run, tools call --async.
  result [options] <workflow_id> [task_id]  Read the stored result of an agent execution (task_id defaults to t1).
```

## ocean-cli agents list

```
Usage: ocean-cli agents list [options]

List active agents (with --search/--category the discovery index is used).

Options:
  --search <q>         Free-text search
  --category <name>    Filter by category
  --limit <n>          Page size (max 100) (default: 50)
  --offset <n>         Page offset (default: 0)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli agents list
  ocean-cli agents list --search "web search" --category search --json
```

## ocean-cli agents categories

```
Usage: ocean-cli agents categories [options]

List agent categories with counts.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli agents categories
```

## ocean-cli agents get

```
Usage: ocean-cli agents get [options] <agent_id>

Show an agent's card (markdown with YAML frontmatter).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli agents get one-agent
```

## ocean-cli agents run

```
Usage: ocean-cli agents run [options] <agent_id> [prompt]

Run one agent with a prompt (sync; --stream for live tokens). Async agent work:
missions run, tools call --async.

Options:
  --model <id>                Model id (send --provider with it)
  --provider <name>           Provider (google is normalised to gemini)
  --persona <id>              Persona card id
  --system <text>             System prompt
  --max-tokens <n>            Max output tokens
  --temperature <n>           Sampling temperature (0-2)
  --top-p <n>                 Nucleus sampling (0-1)
  --reasoning-effort <level>  Reasoning effort (choices: "low", "medium",
                              "high", "xhigh")
  --stream                    Stream tokens as they arrive (OpenAI chunk format;
                              --json prints one chunk per line)
  --no-context                Do not send your time zone and locale
                              (user_context)
  --dry-run                   Show what would be sent without making API calls
  --json                      Output as JSON
  -o, --output <path>         Also save the JSON result to this file (with
                              --stream: the assembled content)
  --force                     Overwrite an existing output file
  -h, --help                  display help for command

Examples:
  ocean-cli agents run one-agent "Summarise the Cloudflare Workers pricing page in 3 bullets"
  ocean-cli agents run one-agent "hello" --model claude-sonnet-4-6 --provider anthropic --stream
  echo "prompt" | ocean-cli agents run research-agent - --json
```

## ocean-cli agents result

```
Usage: ocean-cli agents result [options] <workflow_id> [task_id]

Read the stored result of an agent execution (task_id defaults to t1).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli agents result <workflow_id>
  ocean-cli agents result <workflow_id> t1 --json
```

## ocean-cli tools

```
Usage: ocean-cli tools [options] [command]

Structured tool agents: contracts and typed calls (tools plane).

Options:
  -h, --help                             display help for command

Commands:
  list [options]                         List callable tool agents.
  get [options] <agent_id>               Show a tool agent's invocation contract (operations, required params, examples).
  call [options] <agent_id> [operation]  Execute one operation of a tool agent with typed params.
```

## ocean-cli tools list

```
Usage: ocean-cli tools list [options]

List callable tool agents.

Options:
  --limit <n>          Page size (max 100) (default: 50)
  --offset <n>         Page offset (default: 0)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli tools list
  ocean-cli tools list --limit 100 --json
```

## ocean-cli tools get

```
Usage: ocean-cli tools get [options] <agent_id>

Show a tool agent's invocation contract (operations, required params, examples).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli tools get parallel-agent
```

## ocean-cli tools call

```
Usage: ocean-cli tools call [options] <agent_id> [operation]

Execute one operation of a tool agent with typed params.

Options:
  --params <json>      Params as a JSON object (inline, - for stdin, @file)
  --prompt <text>      Free-text prompt for agents that take one
  --async              Dispatch through MCP and return an execution id (poll
                       with executions status)
  --no-context         With --async: do not send your time zone and locale
                       (user_context)
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli tools call parallel-agent search --params '{"query":"Head of Sales at Adyen","max_results":3}'
  ocean-cli tools call serper-agent news --params @params.json --json
  ocean-cli tools call tavily-agent research --params '{"query":"x"}' --async
```

## ocean-cli workflows

```
Usage: ocean-cli workflows [options] [command]

Saved workflows (CNL): list, create, run, versions.

Options:
  -h, --help                                display help for command

Commands:
  list [options]                            List your workflows.
  get [options] <id>                        Show one workflow (or its YAML with --yaml).
  create [options] <name> <file>            Save a workflow from a YAML file (validated and policy-linted first).
  update [options] <id>                     Update a workflow (YAML file, name, description, kind or folder).
  delete [options] <id>                     Delete a workflow.
  versions [options] <id>                   List saved versions.
  restore [options] <id> <version_id>       Restore a saved version.
  validate [options] <file>                 Validate a workflow YAML locally (CNL schema + save-time policy lint).
  run [options] <target>                    Run a saved workflow by id, or a YAML file inline. Waits for the result by default.
  result [options] <workflow_id> <task_id>  Read a stored task result.
  cancel [options] <execution_id>           Cancel a running execution (cooperative).
  permissions                               A bot's permission presets, admin locks and spend caps.
  files [options] <id>                      A bot's persistent workspace files; --download PATH fetches one.
  inbox [options] <id>                      A bot's queued bot-to-bot messages, newest first (read-only).
  bindings                                  Paired chats (Telegram, WhatsApp, Discord, Teams) that talk to a bot.
  save-version [options] <id>               Save the current YAML as a new version.
  build [options]                           Have the platform design a workflow from a goal, or edit one from an instruction.
```

## ocean-cli workflows list

```
Usage: ocean-cli workflows list [options]

List your workflows.

Options:
  --search <q>         Name search
  --folder <name>      Folder
  --kind <kind>        Only this kind (filters the fetched rows) (choices:
                       "workflow", "agent", "bot", "campaign")
  --limit <n>          Max rows (1-100) (default: 50)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli workflows list --search market --json
  ocean-cli workflows list --kind bot
```

## ocean-cli workflows get

```
Usage: ocean-cli workflows get [options] <id>

Show one workflow (or its YAML with --yaml).

Options:
  --yaml               Print the workflow YAML
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli workflows get <id>
  ocean-cli workflows get <id> --yaml > flow.yaml
```

## ocean-cli workflows create

```
Usage: ocean-cli workflows create [options] <name> <file>

Save a workflow from a YAML file (validated and policy-linted first).

Options:
  --description <text>  Description
  --kind <kind>         Kind (choices: "workflow", "agent", "bot")
  --folder <name>       Folder
  --dry-run             Show what would be sent without making API calls
  --json                Output as JSON
  -o, --output <path>   Also save the JSON result to this file
  --force               Overwrite an existing output file
  -h, --help            display help for command

Examples:
  ocean-cli workflows create "Market Monitor" flow.yaml --kind workflow
  ocean-cli workflows create "Market Monitor" flow.yaml --dry-run
```

## ocean-cli workflows update

```
Usage: ocean-cli workflows update [options] <id>

Update a workflow (YAML file, name, description, kind or folder).

Options:
  -f, --file <path>     New YAML
  --name <text>         New name
  --description <text>  New description
  --kind <kind>         New kind (choices: "workflow", "agent", "bot")
  --folder <name>       Move into this folder ("none" clears it)
  --dry-run             Show what would be sent without making API calls
  --json                Output as JSON
  -o, --output <path>   Also save the JSON result to this file
  --force               Overwrite an existing output file
  -h, --help            display help for command

Examples:
  ocean-cli workflows update <id> -f flow.yaml
  ocean-cli workflows update <id> --name "Market Monitor v2" --dry-run
  ocean-cli workflows update <id> --kind bot --folder Bots
```

## ocean-cli workflows delete

```
Usage: ocean-cli workflows delete [options] <id>

Delete a workflow.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows delete <id> --yes
```

## ocean-cli workflows versions

```
Usage: ocean-cli workflows versions [options] <id>

List saved versions.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows versions <id>
```

## ocean-cli workflows restore

```
Usage: ocean-cli workflows restore [options] <id> <version_id>

Restore a saved version.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows restore <id> <version_id> --yes
```

## ocean-cli workflows validate

```
Usage: ocean-cli workflows validate [options] <file>

Validate a workflow YAML locally (CNL schema + save-time policy lint).

Options:
  --kind <kind>        Kind (choices: "workflow", "agent", "bot", "campaign")
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows validate flow.yaml --kind bot
```

## ocean-cli workflows run

```
Usage: ocean-cli workflows run [options] <target>

Run a saved workflow by id, or a YAML file inline. Waits for the result by
default.

Options:
  -i, --input <text>         Single input value ("-" reads stdin)
  --inputs <file.json>       Named inputs: a flat JSON object of strings
  --stream                   Stream the live engine events on stdout, then the
                             result (with --json: one JSON document per line)
  --no-context               Do not send your time zone and locale
                             (user_context)
  --no-wait                  Return immediately with the id (don't poll)
  --timeout <seconds>        Max wait time in seconds (default: 3600)
  --poll-interval <seconds>  Seconds between status checks (default: 5)
  --dry-run                  Show what would be sent without making API calls
  --json                     Output as JSON
  -o, --output <path>        Also save the JSON result to this file
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Examples:
  ocean-cli workflows run <id> -i "AI startups"
  ocean-cli workflows run flow.yaml --inputs inputs.json --json
  ocean-cli workflows run <id> -i "x" --stream
  ocean-cli workflows run <id> -i "x" --no-wait
```

## ocean-cli workflows result

```
Usage: ocean-cli workflows result [options] <workflow_id> <task_id>

Read a stored task result.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows result <workflow_id> <task_id>
```

## ocean-cli workflows cancel

```
Usage: ocean-cli workflows cancel [options] <execution_id>

Cancel a running execution (cooperative).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows cancel <execution_id>
```

## ocean-cli workflows permissions

```
Usage: ocean-cli workflows permissions [options] [command]

A bot's permission presets, admin locks and spend caps.

Options:
  -h, --help          display help for command

Commands:
  get [options] <id>  Show the stored policy.
  set [options] <id>  Set presets, locks and spend caps; every flag changes only
                      what it names.
```

## ocean-cli workflows permissions get

```
Usage: ocean-cli workflows permissions get [options] <id>

Show the stored policy.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows permissions get <bot_id> --json
```

## ocean-cli workflows permissions set

```
Usage: ocean-cli workflows permissions set [options] <id>

Set presets, locks and spend caps; every flag changes only what it names.

Options:
  --class <class=preset>     Preset for a class, repeatable: class
                             send|write|pay|delete, preset
                             allow|ask|deny|hand_off (default: [])
  --lock <class>             Lock a class (team admins only): the bot's own
                             allow is forced up to ask; repeatable (default: [])
  --unlock <class>           Release a lock (team admins only); repeatable
                             (default: [])
  --budget-run <usd|none>    Per-run spend cap in USD ("none" clears it)
  --budget-month <usd|none>  Monthly spend cap in USD ("none" clears it)
  --dry-run                  Show what would be sent without making API calls
  --json                     Output as JSON
  -o, --output <path>        Also save the JSON result to this file
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Examples:
  ocean-cli workflows permissions set <bot_id> --class pay=ask --class send=allow
  ocean-cli workflows permissions set <bot_id> --lock pay --budget-run 0.5 --budget-month 20
  ocean-cli workflows permissions set <bot_id> --budget-run none --dry-run
```

## ocean-cli workflows files

```
Usage: ocean-cli workflows files [options] <id>

A bot's persistent workspace files; --download PATH fetches one.

Options:
  --download <path>    Fetch this listed file (raw bytes) instead of listing
  --out <file>         With --download: write the file here (without it the
                       bytes go to stdout when it is not a terminal)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli workflows files <bot_id>
  ocean-cli workflows files <bot_id> --download notes/a.md --out a.md
```

## ocean-cli workflows inbox

```
Usage: ocean-cli workflows inbox [options] <id>

A bot's queued bot-to-bot messages, newest first (read-only).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows inbox <bot_id>
```

## ocean-cli workflows bindings

```
Usage: ocean-cli workflows bindings [options] [command]

Paired chats (Telegram, WhatsApp, Discord, Teams) that talk to a bot.

Options:
  -h, --help             display help for command

Commands:
  list [options] <id>    Chats bound to the bot.
  bind [options] <id>    Bind a paired chat to the bot (a chat talks to one bot:
                         binding it again moves it).
  unbind [options] <id>  Release a chat from the bot.
```

## ocean-cli workflows bindings list

```
Usage: ocean-cli workflows bindings list [options] <id>

Chats bound to the bot.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows bindings list <bot_id>
```

## ocean-cli workflows bindings bind

```
Usage: ocean-cli workflows bindings bind [options] <id>

Bind a paired chat to the bot (a chat talks to one bot: binding it again moves
it).

Options:
  --channel <name>     telegram, whatsapp, discord or teams
  --sender <id>        The paired chat's sender id (from the pairing)
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows bindings bind <bot_id> --channel telegram --sender <sender_id>
```

## ocean-cli workflows bindings unbind

```
Usage: ocean-cli workflows bindings unbind [options] <id>

Release a chat from the bot.

Options:
  --channel <name>     telegram, whatsapp, discord or teams
  --sender <id>        The bound chat's sender id
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows bindings unbind <bot_id> --channel telegram --sender <sender_id> --yes
```

## ocean-cli workflows save-version

```
Usage: ocean-cli workflows save-version [options] <id>

Save the current YAML as a new version.

Options:
  --label <text>       A label for the version (up to 200 characters)
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli workflows save-version <id> --label "before the Slack change"
```

## ocean-cli workflows build

```
Usage: ocean-cli workflows build [options]

Have the platform design a workflow from a goal, or edit one from an
instruction.

Options:
  --goal <text>         What the workflow should do
  --workflow-id <id>    Existing workflow to edit
  --instruction <text>  What to change
  --dry-run             Show what would be sent without making API calls
  --json                Output as JSON
  -o, --output <path>   Also save the JSON result to this file
  --force               Overwrite an existing output file
  -h, --help            display help for command

Examples:
  ocean-cli workflows build --goal "watch AI funding news and email me daily"
  ocean-cli workflows build --workflow-id <id> --instruction "add a summary step"
```

## ocean-cli bot-groups

```
Usage: ocean-cli bot-groups [options] [command]

Bot groups: named sets of 2 to 6 of your saved bots (message_bot
to=group:<name>).

Options:
  -h, --help             display help for command

Commands:
  list [options]         List your bot groups.
  create [options]       Create a bot group.
  update [options] <id>  Replace a bot group (name and members).
  delete [options] <id>  Delete a bot group (the member bots are untouched).
  thread [options] <id>  A bot group's shared thread, oldest first.
```

## ocean-cli bot-groups list

```
Usage: ocean-cli bot-groups list [options]

List your bot groups.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli bot-groups list --json
```

## ocean-cli bot-groups create

```
Usage: ocean-cli bot-groups create [options]

Create a bot group.

Options:
  --name <name>        1-40 letters, digits, "_", "." or "-"; unique per account
  --members <ids>      Your saved-bot ids, 2 to 6 (comma-separated or repeated)
                       (default: [])
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli bot-groups create --name research-crew --members <bot_id>,<bot_id>
```

## ocean-cli bot-groups update

```
Usage: ocean-cli bot-groups update [options] <id>

Replace a bot group (name and members).

Options:
  --name <name>        New name
  --members <ids>      Your saved-bot ids, 2 to 6 (comma-separated or repeated)
                       (default: [])
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli bot-groups update <group_id> --name research-crew --members <bot_id>,<bot_id>,<bot_id>
```

## ocean-cli bot-groups delete

```
Usage: ocean-cli bot-groups delete [options] <id>

Delete a bot group (the member bots are untouched).

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli bot-groups delete <group_id> --yes
```

## ocean-cli bot-groups thread

```
Usage: ocean-cli bot-groups thread [options] <id>

A bot group's shared thread, oldest first.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli bot-groups thread <group_id>
```

## ocean-cli executions

```
Usage: ocean-cli executions [options] [command]

Runs: list, status, poll, output, continue, steer, files, export.

Options:
  -h, --help                        display help for command

Commands:
  list [options]                    List recent executions.
  get [options] <id>                Execution metadata (the status record).
  conversation [options] <id>       The full multi-turn thread.
  cancel [options] <id>             Cancel a running execution.
  output [options] <id>             The result of an execution (platform
                                    markdown).
  delete [options] <id>             Delete an execution and its stored result.
  status [options] <id>             Current status (and any pending question or
                                    approval).
  poll [options] <id>               Wait until the execution ends, then print
                                    its result.
  continue [options] <id>           Answer a pending question (--message) or
                                    approve a pending action (--approve).
  followup [options] <id> <prompt>  Ask a follow-up on a completed run (a
                                    running run gets the message queued).
  steer [options] <id> <text>       Queue a message for a running execution (the
                                    live loop takes it at its next turn; a
                                    finished run is refused).
  files [options] <id>              Files the run produced (spreadsheets,
                                    documents, decks).
  export [options] <id>             Export the result as a document (needs a
                                    Studio session). Writes execution-<id>.<ext>
                                    unless -o.
```

## ocean-cli executions list

```
Usage: ocean-cli executions list [options]

List recent executions.

Options:
  --workflow <id>      Only runs of this workflow
  --source <name>      Only runs started from this source, e.g. mcp, api,
                       studio, cli (filters the fetched rows)
  --limit <n>          Max rows (1-100) (default: 20)
  --offset <n>         Rows to skip (0-100000) (default: 0)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli executions list --limit 5 --json
  ocean-cli executions list --source cli
```

## ocean-cli executions get

```
Usage: ocean-cli executions get [options] <id>

Execution metadata (the status record).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions get <id> --json
```

## ocean-cli executions conversation

```
Usage: ocean-cli executions conversation [options] <id>

The full multi-turn thread.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions conversation <id>
```

## ocean-cli executions cancel

```
Usage: ocean-cli executions cancel [options] <id>

Cancel a running execution.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions cancel <id>
```

## ocean-cli executions output

```
Usage: ocean-cli executions output [options] <id>

The result of an execution (platform markdown).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions output <id>
```

## ocean-cli executions delete

```
Usage: ocean-cli executions delete [options] <id>

Delete an execution and its stored result.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions delete <id> --yes
```

## ocean-cli executions status

```
Usage: ocean-cli executions status [options] <id>

Current status (and any pending question or approval).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions status <id> --json
```

## ocean-cli executions poll

```
Usage: ocean-cli executions poll [options] <id>

Wait until the execution ends, then print its result.

Options:
  --timeout <seconds>        Max wait time in seconds (default: 3600)
  --poll-interval <seconds>  Seconds between status checks (default: 5)
  --json                     Output as JSON
  -o, --output <path>        Also save the JSON result to this file
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Example:
  ocean-cli executions poll <id> --timeout 600 -o result.json
```

## ocean-cli executions continue

```
Usage: ocean-cli executions continue [options] <id>

Answer a pending question (--message) or approve a pending action (--approve).

Options:
  --message <text>     Answer ("-" reads stdin)
  --approve            Approve the pending action
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli executions continue <id> --message "EU region"
  ocean-cli executions continue <id> --approve
```

## ocean-cli executions followup

```
Usage: ocean-cli executions followup [options] <id> <prompt>

Ask a follow-up on a completed run (a running run gets the message queued).

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions followup <id> "Summarise the top three in one line each"
```

## ocean-cli executions steer

```
Usage: ocean-cli executions steer [options] <id> <text>

Queue a message for a running execution (the live loop takes it at its next
turn; a finished run is refused).

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions steer <id> "Focus on the EU market"
```

## ocean-cli executions files

```
Usage: ocean-cli executions files [options] <id>

Files the run produced (spreadsheets, documents, decks).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli executions files <id> --json
```

## ocean-cli executions export

```
Usage: ocean-cli executions export [options] <id>

Export the result as a document (needs a Studio session). Writes
execution-<id>.<ext> unless -o.

Options:
  -f, --format <format>  Format (choices: "docx", "pptx", "xlsx", "finmodel",
                         "pdf", "package", "google-docs")
  --models <list>        FinModel types (comma-separated; -f finmodel only)
  --dry-run              Show what would be sent without making API calls
  --json                 Output as JSON
  -o, --output <path>    The file to write (google-docs: save the link JSON
                         here)
  --force                Overwrite an existing output file
  -h, --help             display help for command

Examples:
  ocean-cli executions export <id> -f docx -o report.docx
  ocean-cli executions export <id> -f finmodel --models dcf,lbo
  ocean-cli executions export <id> -f google-docs
```

## ocean-cli missions

```
Usage: ocean-cli missions [options] [command]

Bounded autonomous agent runs with memory (type: harness).

Options:
  -h, --help             display help for command

Commands:
  run [options] <goal>   Start a mission (async) and wait for it; the result is
                         saved to ./ocean-missions/<id>.json (or -o).
  status [options] <id>  Mission status (and any pending question or approval).
  poll [options] <id>    Wait for a mission, then save and print its result
                         (default ./ocean-missions/<id>.json).
  result [options] <id>  The mission result (no file written unless -o).
```

## ocean-cli missions run

```
Usage: ocean-cli missions run [options] <goal>

Start a mission (async) and wait for it; the result is saved to
./ocean-missions/<id>.json (or -o).

Options:
  --mission <text>           Mission purpose statement
  --agent <id>               Loop runtime agent (default one-agent)
  --tools <list>             Allowed tools (comma-separated or repeated)
                             (default: [])
  --max-iterations <n>       Iteration cap (1-50)
  --criteria <text>          Success criterion (repeatable) (default: [])
  --persona <id>             Persona card id
  --skills <list>            Skill card ids (comma-separated or repeated)
                             (default: [])
  --sync                     Run on one connection and print the answer, instead
                             of start + poll (a mission that pauses prints the
                             executions continue hint)
  --no-context               Do not send your time zone and locale
                             (user_context)
  --no-wait                  Return immediately with the id (don't poll)
  --timeout <seconds>        Max wait time in seconds (default: 600)
  --poll-interval <seconds>  Seconds between status checks (default: 5)
  --dry-run                  Show what would be sent without making API calls
  --json                     Output as JSON
  -o, --output <path>        The result file (default
                             ./ocean-missions/<id>.json)
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Examples:
  ocean-cli missions run "Find three AI news items from today with links" --tools web_search,web_fetch,task_complete --max-iterations 5
  ocean-cli missions run "Audit our pricing page" --criteria "lists every plan" --no-wait
  ocean-cli missions run "Which of these two plans suits a 5-person team?" --sync
```

## ocean-cli missions status

```
Usage: ocean-cli missions status [options] <id>

Mission status (and any pending question or approval).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli missions status <id>
```

## ocean-cli missions poll

```
Usage: ocean-cli missions poll [options] <id>

Wait for a mission, then save and print its result (default
./ocean-missions/<id>.json).

Options:
  --timeout <seconds>        Max wait time in seconds (default: 600)
  --poll-interval <seconds>  Seconds between status checks (default: 5)
  --json                     Output as JSON
  -o, --output <path>        The result file (default
                             ./ocean-missions/<id>.json)
  --force                    Overwrite an existing output file
  -h, --help                 display help for command

Example:
  ocean-cli missions poll <id> -o mission.json
```

## ocean-cli missions result

```
Usage: ocean-cli missions result [options] <id>

The mission result (no file written unless -o).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli missions result <id> --json
```

## ocean-cli schedules

```
Usage: ocean-cli schedules [options] [command]

Scheduled jobs (cron): agents, queries, workflows, heartbeats.

Options:
  -h, --help                  display help for command

Commands:
  stats [options]             Job counts (active, paused).
  list [options]              List jobs.
  get [options] <job_id>      One job including delivery targets.
  runs [options] [job_id]     Run history (all jobs, or one).
  pause [options] <job_id>    Pause the job.
  resume [options] <job_id>   Resume the job.
  run-now [options] <job_id>  Run the job now and wait for the outcome (prints
                              the execution id).
  delete [options] <job_id>   Delete a job (soft delete; run history is kept).
  create [options] <name>     Create a scheduled job.
  update [options] <job_id>   Update a job. Delivery targets are kept unless
                              --deliver is passed (which replaces them).
  wake [options] <job_id>     Fire the schedule's saved workflow once, now; the
                              schedule itself is untouched.
  triggers                    What starts or watches a schedule's runs: inbound
                              webhook and email triggers, outbound signed hooks.
```

## ocean-cli schedules stats

```
Usage: ocean-cli schedules stats [options]

Job counts (active, paused).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules stats
```

## ocean-cli schedules list

```
Usage: ocean-cli schedules list [options]

List jobs.

Options:
  --limit <n>          Max rows (1-100) (default: 50)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules list --json
```

## ocean-cli schedules get

```
Usage: ocean-cli schedules get [options] <job_id>

One job including delivery targets.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules get <job_id>
```

## ocean-cli schedules runs

```
Usage: ocean-cli schedules runs [options] [job_id]

Run history (all jobs, or one).

Options:
  --limit <n>          Max rows (1-100) (default: 20)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules runs <job_id> --limit 5
```

## ocean-cli schedules pause

```
Usage: ocean-cli schedules pause [options] <job_id>

Pause the job.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules pause <job_id>
```

## ocean-cli schedules resume

```
Usage: ocean-cli schedules resume [options] <job_id>

Resume the job.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules resume <job_id>
```

## ocean-cli schedules run-now

```
Usage: ocean-cli schedules run-now [options] <job_id>

Run the job now and wait for the outcome (prints the execution id).

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules run-now <job_id>
```

## ocean-cli schedules delete

```
Usage: ocean-cli schedules delete [options] <job_id>

Delete a job (soft delete; run history is kept).

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules delete <job_id> --yes
```

## ocean-cli schedules create

```
Usage: ocean-cli schedules create [options] <name>

Create a scheduled job.

Options:
  --type <type>            Job type (choices: "agent", "query", "workflow",
                           "heartbeat")
  --cron <expr>            Cron expression, or @once together with --at
  --target <id>            Agent id (agent), {"agent","query"} JSON (query) or
                           workflow id (workflow)
  --prompt <text>          What the agent does each run
  --timezone <iana>        IANA timezone the cron is read in, e.g. Europe/Berlin
                           (default UTC)
  --deliver <channel:to>   Delivery target, repeatable: telegram:<chat>
                           whatsapp:<num> discord:<chat> slack:<C… or handle>
                           teams:<chat> email:<addr> inapp (default: [])
  --mission-ref <id>       Pre-built agent card id (schedules a harness wrapper)
  --check-agent <id>       heartbeat: agent to check
  --condition <prompt>     heartbeat: condition prompt
  --trigger <workflow_id>  heartbeat: workflow to trigger
  --notify <channel>       heartbeat: notify channel (choices: "telegram",
                           "whatsapp", "discord", "slack", "teams", "email")
  --notify-to <target>     heartbeat: notify target
  --description <text>     Description
  --at <iso>               With --cron @once: when to run, an ISO-8601 time with
                           a UTC offset in the future (workflow or heartbeat
                           jobs)
  --ends-at <iso>          The schedule stops after this ISO-8601 time or ms
                           epoch (workflow or heartbeat jobs)
  --dry-run                Show what would be sent without making API calls
  --json                   Output as JSON
  -o, --output <path>      Also save the JSON result to this file
  --force                  Overwrite an existing output file
  -h, --help               display help for command

Examples:
  ocean-cli schedules create "Weekday brief" --type agent --target research-agent --prompt "top AI news, 5 bullets" --cron "0 9 * * 1-5" --deliver slack:C0123 --deliver email:me@example.com
  ocean-cli schedules create "Nightly run" --type workflow --target <workflow_id> --cron "0 2 * * *" --dry-run
  ocean-cli schedules create "Reminder" --type workflow --target <workflow_id> --cron @once --at 2026-10-06T09:00:00Z
  ocean-cli schedules create "Campaign sweep" --type workflow --target <workflow_id> --cron "0 * * * *" --ends-at 2026-11-01T00:00:00Z
```

## ocean-cli schedules update

```
Usage: ocean-cli schedules update [options] <job_id>

Update a job. Delivery targets are kept unless --deliver is passed (which
replaces them).

Options:
  --cron <expr>           New schedule
  --timezone <iana>       IANA timezone the cron is read in, e.g. Europe/Berlin
  --name <text>           New name
  --description <text>    New description
  --prompt <text>         New prompt
  --deliver <channel:to>  Replace the delivery targets, repeatable:
                          telegram:<chat> whatsapp:<num> discord:<chat>
                          slack:<C… or handle> teams:<chat> email:<addr> inapp
                          (default: [])
  --status <status>       active (resume) or paused (pause) (choices: "active",
                          "paused")
  --dry-run               Show what would be sent without making API calls
  --json                  Output as JSON
  -o, --output <path>     Also save the JSON result to this file
  --force                 Overwrite an existing output file
  -h, --help              display help for command

Examples:
  ocean-cli schedules update <job_id> --cron "0 8 * * 1-5" --timezone America/Los_Angeles
  ocean-cli schedules update <job_id> --prompt "top AI news, 3 bullets" --status active
```

## ocean-cli schedules wake

```
Usage: ocean-cli schedules wake [options] <job_id>

Fire the schedule's saved workflow once, now; the schedule itself is untouched.

Options:
  --note <text>        Why this run exists; it becomes the run's input
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules wake <job_id> --note "the customer just replied"
```

## ocean-cli schedules triggers

```
Usage: ocean-cli schedules triggers [options] [command]

What starts or watches a schedule's runs: inbound webhook and email triggers,
outbound signed hooks.

Options:
  -h, --help      display help for command

Commands:
  webhook         A schedule's inbound webhooks: mint, list, delete.
  email           A schedule's inbound email addresses: mint, list, delete.
  hooks           A schedule's outbound lifecycle hooks: mint, list, delete.
```

## ocean-cli schedules triggers webhook

```
Usage: ocean-cli schedules triggers webhook [options] [command]

A schedule's inbound webhooks: mint, list, delete.

Options:
  -h, --help                         display help for command

Commands:
  mint [options] <job_id>            Mint an inbound webhook; a secret is shown
                                     once.
  list [options] <job_id>            List the schedule's inbound webhooks
                                     (secrets are never listed).
  delete [options] <job_id> <token>  Revoke an inbound webhook.
```

## ocean-cli schedules triggers webhook mint

```
Usage: ocean-cli schedules triggers webhook mint [options] <job_id>

Mint an inbound webhook; a secret is shown once.

Options:
  --prompt-template <text>  Text for the run input; {dotted.path} fills in a
                            field of the JSON payload, e.g. {pull_request.title}
  --scheme <scheme>         Signature scheme (default generic) (choices:
                            "generic", "github", "gitlab", "standard-webhooks")
  --filters <json>          {"all":[…],"any":[…]} rules on the payload or
                            headers (inline JSON, "-" for stdin, @FILE)
  --dry-run                 Show what would be sent without making API calls
  --json                    Output as JSON
  -o, --output <path>       Also save the JSON result to this file
  --force                   Overwrite an existing output file
  -h, --help                display help for command

Example:
  ocean-cli schedules triggers webhook mint <job_id> --scheme github --prompt-template "PR: {pull_request.title}"
```

## ocean-cli schedules triggers webhook list

```
Usage: ocean-cli schedules triggers webhook list [options] <job_id>

List the schedule's inbound webhooks (secrets are never listed).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules triggers webhook list <job_id>
```

## ocean-cli schedules triggers webhook delete

```
Usage: ocean-cli schedules triggers webhook delete [options] <job_id> <token>

Revoke an inbound webhook.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules triggers webhook delete <job_id> <token> --yes
```

## ocean-cli schedules triggers email

```
Usage: ocean-cli schedules triggers email [options] [command]

A schedule's inbound email addresses: mint, list, delete.

Options:
  -h, --help                         display help for command

Commands:
  mint [options] <job_id>            Mint an inbound email address; a secret is
                                     shown once.
  list [options] <job_id>            List the schedule's inbound email addresses
                                     (secrets are never listed).
  delete [options] <job_id> <token>  Revoke an inbound email address.
```

## ocean-cli schedules triggers email mint

```
Usage: ocean-cli schedules triggers email mint [options] <job_id>

Mint an inbound email address; a secret is shown once.

Options:
  --allowed-from <list>  Comma-separated sender addresses or domains (default:
                         anyone)
  --dry-run              Show what would be sent without making API calls
  --json                 Output as JSON
  -o, --output <path>    Also save the JSON result to this file
  --force                Overwrite an existing output file
  -h, --help             display help for command

Example:
  ocean-cli schedules triggers email mint <job_id> --allowed-from alice@example.com,example.org
```

## ocean-cli schedules triggers email list

```
Usage: ocean-cli schedules triggers email list [options] <job_id>

List the schedule's inbound email addresses (secrets are never listed).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules triggers email list <job_id>
```

## ocean-cli schedules triggers email delete

```
Usage: ocean-cli schedules triggers email delete [options] <job_id> <token>

Revoke an inbound email address.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules triggers email delete <job_id> <token> --yes
```

## ocean-cli schedules triggers hooks

```
Usage: ocean-cli schedules triggers hooks [options] [command]

A schedule's outbound lifecycle hooks: mint, list, delete.

Options:
  -h, --help                      display help for command

Commands:
  mint [options] <job_id>         Mint an outbound lifecycle hook; a secret is
                                  shown once.
  list [options] <job_id>         List the schedule's outbound lifecycle hooks
                                  (secrets are never listed).
  delete [options] <job_id> <id>  Revoke an outbound lifecycle hook.
```

## ocean-cli schedules triggers hooks mint

```
Usage: ocean-cli schedules triggers hooks mint [options] <job_id>

Mint an outbound lifecycle hook; a secret is shown once.

Options:
  --url <https-url>    https URL that receives the signed run events
  --events <list>      run.started, run.finished, run.failed, run.needs_approval
                       (comma-separated; default: all)
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules triggers hooks mint <job_id> --url https://example.com/hook --events run.finished,run.failed
```

## ocean-cli schedules triggers hooks list

```
Usage: ocean-cli schedules triggers hooks list [options] <job_id>

List the schedule's outbound lifecycle hooks (secrets are never listed).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules triggers hooks list <job_id>
```

## ocean-cli schedules triggers hooks delete

```
Usage: ocean-cli schedules triggers hooks delete [options] <job_id> <id>

Revoke an outbound lifecycle hook.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli schedules triggers hooks delete <job_id> <id> --yes
```

## ocean-cli memory

```
Usage: ocean-cli memory [options] [command]

Long-term platform memory: recall, remember, past runs.

Options:
  -h, --help                     display help for command

Commands:
  recall [options] [query]       Read memory. The platform currently returns the
                                 whole memory; QUERY is advisory.
  remember [options]             Edit memory: --add TEXT | --replace OLD NEW |
                                 --remove TEXT.
  search-runs [options] <query>  Search past run results ("-" reads the query
                                 from stdin).
  get-run [options] <run_id>     One remembered run.
```

## ocean-cli memory recall

```
Usage: ocean-cli memory recall [options] [query]

Read memory. The platform currently returns the whole memory; QUERY is advisory.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli memory recall "pricing"
```

## ocean-cli memory remember

```
Usage: ocean-cli memory remember [options]

Edit memory: --add TEXT | --replace OLD NEW | --remove TEXT.

Options:
  --add <text>           Append an entry
  --replace <values...>  Replace the entry containing OLD with NEW (exactly two
                         values)
  --remove <text>        Remove the entry containing TEXT
  --target <store>       Which store (choices: "user", "memory", default:
                         "user")
  --dry-run              Show what would be sent without making API calls
  --json                 Output as JSON
  -o, --output <path>    Also save the JSON result to this file
  --force                Overwrite an existing output file
  -h, --help             display help for command

Examples:
  ocean-cli memory remember --add "We ship on Fridays"
  ocean-cli memory remember --replace "Fridays" "Thursdays"
  ocean-cli memory remember --remove "Thursdays" --target memory
```

## ocean-cli memory search-runs

```
Usage: ocean-cli memory search-runs [options] <query>

Search past run results ("-" reads the query from stdin).

Options:
  --limit <n>          Max rows (1-100)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli memory search-runs "adyen" --limit 5
```

## ocean-cli memory get-run

```
Usage: ocean-cli memory get-run [options] <run_id>

One remembered run.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli memory get-run <run_id>
```

## ocean-cli learn

```
Usage: ocean-cli learn [options] [command]

Distil a URL or text into a private skill.

Options:
  -h, --help               display help for command

Commands:
  add [options] <source>   Learn from a URL or literal text (waits for the
                           distillation).
  list [options]           List learned skills.
  forget [options] <name>  Delete a learned skill.
```

## ocean-cli learn add

```
Usage: ocean-cli learn add [options] <source>

Learn from a URL or literal text (waits for the distillation).

Options:
  --name <id>          Kebab-case skill id
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli learn add https://docs.example.com/guide --name example-guide
```

## ocean-cli learn list

```
Usage: ocean-cli learn list [options]

List learned skills.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli learn list
```

## ocean-cli learn forget

```
Usage: ocean-cli learn forget [options] <name>

Delete a learned skill.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli learn forget example-guide --yes
```

## ocean-cli templates

```
Usage: ocean-cli templates [options] [command]

Workflow templates.

Options:
  -h, --help                   display help for command

Commands:
  list [options]               List templates.
  get [options] <template_id>  One template (with its YAML).
  use [options] <template_id>  Instantiate a template as a saved workflow.
```

## ocean-cli templates list

```
Usage: ocean-cli templates list [options]

List templates.

Options:
  --category <name>    Category
  --limit <n>          Max rows (1-100)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli templates list --category sales
```

## ocean-cli templates get

```
Usage: ocean-cli templates get [options] <template_id>

One template (with its YAML).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli templates get <id>
```

## ocean-cli templates use

```
Usage: ocean-cli templates use [options] <template_id>

Instantiate a template as a saved workflow.

Options:
  --name <text>        Workflow name
  --folder <name>      Folder
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli templates use <id> --name "My flow" --folder Sales
```

## ocean-cli chat

```
Usage: ocean-cli chat [options] [command]

One-shot platform chat turns (non-interactive; use conversation ids to
continue).

Options:
  -h, --help                           display help for command

Commands:
  send [options] <message>             Send one message; the reply is printed
                                       verbatim.
  new [options]                        Start a new conversation (prints its id).
  sessions [options]                   List conversations.
  history [options] <conversation_id>  Messages of one conversation.
```

## ocean-cli chat send

```
Usage: ocean-cli chat send [options] <message>

Send one message; the reply is printed verbatim.

Options:
  --conversation-id <id>  Continue this conversation
  --no-context            Do not send your time zone and locale (user_context)
  --dry-run               Show what would be sent without making API calls
  --json                  Output as JSON
  -o, --output <path>     Also save the JSON result to this file
  --force                 Overwrite an existing output file
  -h, --help              display help for command

Examples:
  ocean-cli chat send "show my last three runs"
  echo "and export the first one as docx" | ocean-cli chat send - --conversation-id <id>
```

## ocean-cli chat new

```
Usage: ocean-cli chat new [options]

Start a new conversation (prints its id).

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli chat new --json
```

## ocean-cli chat sessions

```
Usage: ocean-cli chat sessions [options]

List conversations.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli chat sessions
```

## ocean-cli chat history

```
Usage: ocean-cli chat history [options] <conversation_id>

Messages of one conversation.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli chat history <id>
```

## ocean-cli discovery

```
Usage: ocean-cli discovery [options] [command]

The registry: search cards, get recommendations, read a card.

Options:
  -h, --help                  display help for command

Commands:
  search [options] [q]        Search registry cards.
  recommend [options] <task>  The best card for a task, with a score.
  card [options] <type> <id>  One card as markdown with YAML frontmatter.
```

## ocean-cli discovery search

```
Usage: ocean-cli discovery search [options] [q]

Search registry cards.

Options:
  --kind <kind>        Card kind (choices: "agents", "skills", "plugins",
                       "mcp-servers", "connectors", "models", "providers",
                       "workflows", "experts", "backgrounds", "personas",
                       "digital-twins")
  --type <type>        Singular type filter (agent, skill, …)
  --category <name>    Category
  --status <status>    Status (default active)
  --tier <tier>        Tier (choices: "verified", "community")
  --mode <mode>        Search mode (choices: "hybrid", "keyword", "vector")
  --fields <fields>    Field projection per card (choices: "list", "summary",
                       "commands", "full")
  --limit <n>          Page size (max 100) (default: 20)
  --offset <n>         Page offset (default: 0)
  --quality            Include quality scores
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli discovery search "web search" --kind agents
  ocean-cli discovery search --kind skills --limit 50 --json
```

## ocean-cli discovery recommend

```
Usage: ocean-cli discovery recommend [options] <task>

The best card for a task, with a score.

Options:
  --type <type>        Card type to recommend (plural accepted)
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli discovery recommend "summarise a PDF" --type agents
```

## ocean-cli discovery card

```
Usage: ocean-cli discovery card [options] <type> <id>

One card as markdown with YAML frontmatter.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli discovery card agent one-agent
```

## ocean-cli models

```
Usage: ocean-cli models [options] [command]

The models plane (your ozk_ key): catalog, chat completions, embeddings.

Options:
  -h, --help               display help for command

Commands:
  list [options]           List models with context, pricing per 1M tokens and
                           capabilities.
  chat [options] <prompt>  One chat completion.
  embed [options] <text>   Create an embedding (OpenAI models only).
```

## ocean-cli models list

```
Usage: ocean-cli models list [options]

List models with context, pricing per 1M tokens and capabilities.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli models list --json
```

## ocean-cli models chat

```
Usage: ocean-cli models chat [options] <prompt>

One chat completion.

Options:
  --model <id>         Model id (e.g. openai/gpt-5, @preset/fast)
  --system <text>      System prompt
  --max-tokens <n>     Max output tokens
  --temperature <n>    Sampling temperature (0-2)
  --stream             Stream tokens (with --json: one chunk per line)
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file (with --stream:
                       the assembled content)
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli models chat "hello" --model openai/gpt-5
  echo "prompt" | ocean-cli models chat - --model anthropic/claude-sonnet-5 --stream
```

## ocean-cli models embed

```
Usage: ocean-cli models embed [options] <text>

Create an embedding (OpenAI models only).

Options:
  --model <id>         Embedding model id
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli models embed "hello world" --model openai/text-embedding-3-small --json
```

## ocean-cli mcp

```
Usage: ocean-cli mcp [options] [command]

MCP: the platform tool list, and outbound runs against connected MCP servers.

Options:
  -h, --help       display help for command

Commands:
  tools [options]  List the platform MCP tools.
  runs             Outbound MCP runs: connect servers, list tools, call one,
                   close.
```

## ocean-cli mcp tools

```
Usage: ocean-cli mcp tools [options]

List the platform MCP tools.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli mcp tools
```

## ocean-cli mcp runs

```
Usage: ocean-cli mcp runs [options] [command]

Outbound MCP runs: connect servers, list tools, call one, close.

Options:
  -h, --help                      display help for command

Commands:
  create [options]                Open a run against connected servers.
  tools [options] <run_id>        Tools available in a run.
  call [options] <run_id> <name>  Call one tool (name is mcp__<server>__<tool>).
  delete [options] <run_id>       Close a run (releases the connections; no data
                                  is deleted).
```

## ocean-cli mcp runs create

```
Usage: ocean-cli mcp runs create [options]

Open a run against connected servers.

Options:
  --server <id>        Server id (repeatable)
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli mcp runs create --server github --server slack --json
```

## ocean-cli mcp runs tools

```
Usage: ocean-cli mcp runs tools [options] <run_id>

Tools available in a run.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli mcp runs tools <run_id>
```

## ocean-cli mcp runs call

```
Usage: ocean-cli mcp runs call [options] <run_id> <name>

Call one tool (name is mcp__<server>__<tool>).

Options:
  --args <json>        Arguments as a JSON object (inline, - or @file)
  --timeout-ms <n>     Per-call timeout
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli mcp runs call <run_id> mcp__github__search --args '{"q":"ocean"}'
```

## ocean-cli mcp runs delete

```
Usage: ocean-cli mcp runs delete [options] <run_id>

Close a run (releases the connections; no data is deleted).

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli mcp runs delete <run_id> --yes
```

## ocean-cli traces

```
Usage: ocean-cli traces [options] [command]

Execution traces: spans and gateway requests by trace id.

Options:
  -h, --help                display help for command

Commands:
  get [options] <trace_id>  Spans and gateway requests of one trace (an unknown
                            id returns empty lists, never 404).
```

## ocean-cli traces get

```
Usage: ocean-cli traces get [options] <trace_id>

Spans and gateway requests of one trace (an unknown id returns empty lists,
never 404).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli traces get <execution_id>
```

## ocean-cli keys

```
Usage: ocean-cli keys [options] [command]

One API keys (ozk_) — needs a Studio session.

Options:
  -h, --help                 display help for command

Commands:
  list [options]             List your API keys (redacted).
  create [options] <name>    Create a key; the secret is shown once.
  revoke [options] <key_id>  Revoke a key.
```

## ocean-cli keys list

```
Usage: ocean-cli keys list [options]

List your API keys (redacted).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli keys list
```

## ocean-cli keys create

```
Usage: ocean-cli keys create [options] <name>

Create a key; the secret is shown once.

Options:
  --expires-in-days <n>  One of 7, 30, 90, 180, 365 (default: never)
  --dry-run              Show what would be sent without making API calls
  --json                 Output as JSON
  -o, --output <path>    Also save the JSON result to this file
  --force                Overwrite an existing output file
  -h, --help             display help for command

Example:
  ocean-cli keys create ci --expires-in-days 90
```

## ocean-cli keys revoke

```
Usage: ocean-cli keys revoke [options] <key_id>

Revoke a key.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli keys revoke <key_id> --yes
```

## ocean-cli balance

```
Usage: ocean-cli balance [options]

Prepaid credit balance (needs a Studio session).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli balance --json
```

## ocean-cli usage

```
Usage: ocean-cli usage [options]

Usage and cost rollups (needs a Studio session).

Options:
  --by <dim>           Group by (default: user) (choices: "user", "workflow",
                       "model", "channel")
  --range <range>      Range (default: 30d) (choices: "7d", "30d", "90d")
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli usage --by model --range 30d
```

## ocean-cli nodes

```
Usage: ocean-cli nodes [options] [command]

Local nodes (device daemons) — needs a Studio session.

Options:
  -h, --help                               display help for command

Commands:
  list [options]                           List your nodes, or a team fleet.
  get [options] <node_id>                  One of your nodes (metrics in --json).
  update-mode [options] <node_id> <mode>   Daemon update mode: auto, off, or pin (needs --version). A connected node installs the target version in this call.
  command [options] <node_id> <command>    Send ping or restart over the live socket.
  network-role [options] <node_id> <role>  master or member within the node’s network.
  revoke [options] <node_id>               Block this node and close its socket.
  delete [options] <node_id>               Forget an offline node record.
```

## ocean-cli nodes list

```
Usage: ocean-cli nodes list [options]

List your nodes, or a team fleet.

Options:
  --scope <scope>      team = a team's fleet (owner/admin) (choices: "team")
  --team-id <id>       Team id with --scope team
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli nodes list
  ocean-cli nodes list --scope team --team-id <id>
```

## ocean-cli nodes get

```
Usage: ocean-cli nodes get [options] <node_id>

One of your nodes (metrics in --json).

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli nodes get <node_id> --json
```

## ocean-cli nodes update-mode

```
Usage: ocean-cli nodes update-mode [options] <node_id> <mode>

Daemon update mode: auto, off, or pin (needs --version). A connected node
installs the target version in this call.

Arguments:
  node_id
  mode                 auto | off | pin (choices: "auto", "off", "pin")

Options:
  --version <x.y.z>    The published version to pin
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli nodes update-mode <node_id> auto
  ocean-cli nodes update-mode <node_id> pin --version 1.3.0
```

## ocean-cli nodes command

```
Usage: ocean-cli nodes command [options] <node_id> <command>

Send ping or restart over the live socket.

Arguments:
  node_id
  command              ping | restart (choices: "ping", "restart")

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli nodes command <node_id> ping
```

## ocean-cli nodes network-role

```
Usage: ocean-cli nodes network-role [options] <node_id> <role>

master or member within the node’s network.

Arguments:
  node_id
  role                 master | member (choices: "master", "member")

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli nodes network-role <node_id> master
```

## ocean-cli nodes revoke

```
Usage: ocean-cli nodes revoke [options] <node_id>

Block this node and close its socket.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli nodes revoke <node_id> --yes
```

## ocean-cli nodes delete

```
Usage: ocean-cli nodes delete [options] <node_id>

Forget an offline node record.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli nodes delete <node_id> --yes
```

## ocean-cli campaigns

```
Usage: ocean-cli campaigns [options] [command]

Campaign ledgers on a workflow — needs a Studio session.

Options:
  -h, --help                        display help for command

Commands:
  status [options] <workflow_id>    Ledger status, counts and cost of the
                                    campaign.
  setup [options] <workflow_id>     Arm the campaign ledger on a workflow from a
                                    campaign config.
  complete [options] <workflow_id>  Complete a human task row of the campaign.
  resume [options] <workflow_id>    Resume the campaign.
  pause [options] <workflow_id>     Pause the campaign.
  stop [options] <workflow_id>      Stop the campaign and release its leases.
```

## ocean-cli campaigns status

```
Usage: ocean-cli campaigns status [options] <workflow_id>

Ledger status, counts and cost of the campaign.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli campaigns status <workflow_id>
```

## ocean-cli campaigns setup

```
Usage: ocean-cli campaigns setup [options] <workflow_id>

Arm the campaign ledger on a workflow from a campaign config.

Options:
  --config <json>      The campaign config: inline JSON, "-" for stdin, or @FILE
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli campaigns setup <workflow_id> --config @campaign.json
```

## ocean-cli campaigns complete

```
Usage: ocean-cli campaigns complete [options] <workflow_id>

Complete a human task row of the campaign.

Options:
  --item <key>         Ledger item key of the human task
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli campaigns complete <workflow_id> --item <key>
```

## ocean-cli campaigns resume

```
Usage: ocean-cli campaigns resume [options] <workflow_id>

Resume the campaign.

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli campaigns resume <workflow_id>
```

## ocean-cli campaigns pause

```
Usage: ocean-cli campaigns pause [options] <workflow_id>

Pause the campaign.

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli campaigns pause <workflow_id>
```

## ocean-cli campaigns stop

```
Usage: ocean-cli campaigns stop [options] <workflow_id>

Stop the campaign and release its leases.

Options:
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli campaigns stop <workflow_id>
```

## ocean-cli connections

```
Usage: ocean-cli connections [options] [command]

Provider connections (API keys, OAuth) — needs a Studio session.

Options:
  -h, --help                    display help for command

Commands:
  list [options]                Your connections.
  providers [options]           Providers that can be connected.
  get [options] <provider>      One connection.
  add-key [options] <provider>  Connect a provider with an API key (probed live;
                                a rejected key is a 400). The key comes from
                                --key - (stdin), --key FILE, or a hidden prompt
                                — never from argv.
  remove [options] <provider>   Disconnect a provider.
```

## ocean-cli connections list

```
Usage: ocean-cli connections list [options]

Your connections.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli connections list
```

## ocean-cli connections providers

```
Usage: ocean-cli connections providers [options]

Providers that can be connected.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli connections providers --json
```

## ocean-cli connections get

```
Usage: ocean-cli connections get [options] <provider>

One connection.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli connections get tavily
```

## ocean-cli connections add-key

```
Usage: ocean-cli connections add-key [options] <provider>

Connect a provider with an API key (probed live; a rejected key is a 400). The
key comes from --key - (stdin), --key FILE, or a hidden prompt — never from
argv.

Options:
  --key <source>       "-" for stdin or a file path; omitted = hidden prompt
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  printf '%s' "$TAVILY_KEY" | ocean-cli connections add-key tavily --key -
```

## ocean-cli connections remove

```
Usage: ocean-cli connections remove [options] <provider>

Disconnect a provider.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli connections remove tavily --yes
```

## ocean-cli secrets

```
Usage: ocean-cli secrets [options] [command]

Developer secrets (encrypted at rest, scoped to a company, team or project) —
needs a Studio session.

Options:
  -h, --help             display help for command

Commands:
  list [options]         List secret names in a scope (never values).
  set [options] <name>   Create a secret. The value comes from --value -
                         (stdin), --value FILE, or a hidden prompt — never from
                         argv.
  delete [options] <id>  Delete a secret.
  audit [options]        Secret access audit log of a scope.
```

## ocean-cli secrets list

```
Usage: ocean-cli secrets list [options]

List secret names in a scope (never values).

Options:
  --team-id <id>       Team scope
  --project-id <id>    Project scope
  --company-id <id>    Company scope
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli secrets list --team-id <id>
```

## ocean-cli secrets set

```
Usage: ocean-cli secrets set [options] <name>

Create a secret. The value comes from --value - (stdin), --value FILE, or a
hidden prompt — never from argv.

Options:
  --value <source>      "-" for stdin or a file path; omitted = hidden prompt
  --description <text>  Description
  --dry-run             Show what would be sent without making API calls
  --team-id <id>        Team scope
  --project-id <id>     Project scope
  --company-id <id>     Company scope
  --json                Output as JSON
  -o, --output <path>   Also save the JSON result to this file
  --force               Overwrite an existing output file
  -h, --help            display help for command

Example:
  printf '%s' "$VALUE" | ocean-cli secrets set MY_KEY --value - --team-id <id>
```

## ocean-cli secrets delete

```
Usage: ocean-cli secrets delete [options] <id>

Delete a secret.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli secrets delete <id> --yes
```

## ocean-cli secrets audit

```
Usage: ocean-cli secrets audit [options]

Secret access audit log of a scope.

Options:
  --team-id <id>       Team scope
  --project-id <id>    Project scope
  --company-id <id>    Company scope
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli secrets audit --team-id <id> --json
```

## ocean-cli documents

```
Usage: ocean-cli documents [options] [command]

Stored documents — needs a Studio session.

Options:
  -h, --help               display help for command

Commands:
  list [options]           List documents.
  get [options] <id>       Document metadata.
  download [options] <id>  Download the file (default name: the document's
                           filename).
  delete [options] <id>    Delete a document.
```

## ocean-cli documents list

```
Usage: ocean-cli documents list [options]

List documents.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli documents list
```

## ocean-cli documents get

```
Usage: ocean-cli documents get [options] <id>

Document metadata.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli documents get <id>
```

## ocean-cli documents download

```
Usage: ocean-cli documents download [options] <id>

Download the file (default name: the document's filename).

Options:
  --json               Output as JSON
  -o, --output <path>  The file to write (default: the document's filename here)
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli documents download <id>
  ocean-cli documents download <id> -o report.pdf --force
```

## ocean-cli documents delete

```
Usage: ocean-cli documents delete [options] <id>

Delete a document.

Options:
  --yes                Confirm
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli documents delete <id> --yes
```

## ocean-cli teams

```
Usage: ocean-cli teams [options] [command]

Teams — needs a Studio session.

Options:
  -h, --help              display help for command

Commands:
  list [options]          Your teams.
  get [options] <id>      One team.
  members [options] <id>  Team members.
```

## ocean-cli teams list

```
Usage: ocean-cli teams list [options]

Your teams.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli teams list
```

## ocean-cli teams get

```
Usage: ocean-cli teams get [options] <id>

One team.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli teams get <id>
```

## ocean-cli teams members

```
Usage: ocean-cli teams members [options] <id>

Team members.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli teams members <id>
```

## ocean-cli projects

```
Usage: ocean-cli projects [options] [command]

Projects — needs a Studio session.

Options:
  -h, --help          display help for command

Commands:
  list [options]      Your projects.
  get [options] <id>  One project.
```

## ocean-cli projects list

```
Usage: ocean-cli projects list [options]

Your projects.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli projects list
```

## ocean-cli projects get

```
Usage: ocean-cli projects get [options] <id>

One project.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Example:
  ocean-cli projects get <id>
```

## ocean-cli skills

```
Usage: ocean-cli skills [options] [command]

Install, update and manage PlungeAI agent skills from skills.plungeai.com.

Options:
  -h, --help           display help for command

Commands:
  list [options]       List available skills.
  install [options]    Install or update skills. --skill adds just those to the
                       managed set; a full install also removes managed skills
                       that left the catalog. Unmanaged skills are never
                       touched.
  uninstall [options]  Remove the skills this CLI installed (listed in
                       .ocean-cli-skills.json); unmanaged skills stay.
```

## ocean-cli skills list

```
Usage: ocean-cli skills list [options]

List available skills.

Options:
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli skills list
  ocean-cli skills list --json
```

## ocean-cli skills install

```
Usage: ocean-cli skills install [options]

Install or update skills. --skill adds just those to the managed set; a full
install also removes managed skills that left the catalog. Unmanaged skills are
never touched.

Options:
  --project            Install into the project root (.agents/skills, plus
                       .claude/skills when present) instead of globally
  --skill <name>       Skill to install or update, added to the managed set
                       (repeatable); default: the whole catalog (default: [])
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli skills install
  ocean-cli skills install --project --skill plungeai-workflows --skill plungeai-in-cursor
  ocean-cli skills install --dry-run
```

## ocean-cli skills uninstall

```
Usage: ocean-cli skills uninstall [options]

Remove the skills this CLI installed (listed in .ocean-cli-skills.json);
unmanaged skills stay.

Options:
  --project            Project targets instead of global
  --skill <name>       Managed skill to remove (repeatable); default: all
                       managed (default: [])
  --dry-run            Show what would be sent without making API calls
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli skills uninstall
  ocean-cli skills uninstall --project --skill plungeai-in-cursor --dry-run
```

## ocean-cli completion

```
Usage: ocean-cli completion [options] [command]

Shell completion for bash, zsh and fish.

Options:
  -h, --help         display help for command

Commands:
  show [options]     Print the completion script to stdout (--json: {shell,
                     script}).
  install [options]  Append the completion loader to your shell rc file (safe to
                     run twice).
```

## ocean-cli completion show

```
Usage: ocean-cli completion show [options]

Print the completion script to stdout (--json: {shell, script}).

Options:
  --shell <shell>      Shell type (auto-detected from $SHELL) (choices: "bash",
                       "zsh", "fish")
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli completion show --shell zsh
  ocean-cli completion show --shell bash > /usr/local/etc/bash_completion.d/ocean-cli
```

## ocean-cli completion install

```
Usage: ocean-cli completion install [options]

Append the completion loader to your shell rc file (safe to run twice).

Options:
  --shell <shell>      Shell type (auto-detected from $SHELL) (choices: "bash",
                       "zsh", "fish")
  --json               Output as JSON
  -o, --output <path>  Also save the JSON result to this file
  --force              Overwrite an existing output file
  -h, --help           display help for command

Examples:
  ocean-cli completion install
  ocean-cli completion install --shell fish
```

## ocean-cli update

```
Usage: ocean-cli update [options]

Update to the latest published version (npm).

Options:
  --json      Output as JSON
  --check     Check for updates without installing
  --force     Reinstall even if already at the latest version
  --dry-run   Show what would be sent without making API calls
  -h, --help  display help for command

Examples:
  ocean-cli update --check
  ocean-cli update
  ocean-cli update --dry-run
```
