Skip to content
Strata/Docs

CLI Command Reference

Complete reference for all 55 strata commands, generated directly from the CLI itself. What you read here is exactly what --help prints.

Looking for install instructions? See CLI Installation.

Commands

Global flags

Accepted by every command, in any position.

ArgumentValuesDescription
--api-url <API_URL>?default: https://api.prod.us-east-2.strata.spaceStrata API base URL

Environment variable: STRATA_API_URL

--token <TOKEN>?-Authentication token (overrides keychain)

Environment variable: STRATA_TOKEN

--json?-Output as JSON (for CI pipelines)

#strata login

strata login [OPTIONS]

Log in to Strata via browser-based OAuth.

Opens your default browser to complete authentication. Detects SSO from your email domain and routes to your IdP if configured.

On a remote, SSH, or headless host (no local browser), prints a URL and prompts you to paste back the code shown in the browser. Pass --no-browser to force that flow.

Examples:

strata login
strata login --email you@company.com
strata login --no-browser
ArgumentValuesDescription
--email <EMAIL>?-Email address (used to detect SSO and skip the Cognito login page)
--no-browser?-Print a URL and paste the code manually instead of opening a local browser and listening on a loopback port. Use on remote/SSH/headless hosts where the browser cannot reach this machine

#strata logout

strata logout [OPTIONS]

Log out of Strata and remove the stored OAuth token.

Clears the token from the OS keychain. Does not affect tokens passed via --token or the STRATA_TOKEN env var.

Example:

strata logout

#strata status

strata status [OPTIONS] [FOLDER]

Show the current state: logged-in user, API URL, active mounts, and linked folders.

Pass a folder to show that folder's live-sync detail instead.

Examples:

strata status
strata status ~/notes
ArgumentValuesDescription
[FOLDER]?-Synced folder to show detailed live-sync status for (omit for the overview)

#strata spaces

strata spaces [OPTIONS]

List accessible Spaces.

Without any flags, lists all Spaces you have access to.

Examples:

strata spaces                              # all your Spaces
strata spaces --scope personal              # all personal Spaces
strata spaces --scope org --scope-id tenant_01JAB...     # Spaces in one org
ArgumentValuesDescription
--scope <LEVEL>?company | org | team | personalFilter by scope level
--scope-id <SCOPE_ID>?-Scope entity ID (requires --scope)
--limit <LIMIT>?default: 50Maximum results per page

#strata sync

strata sync [OPTIONS] <COMMAND>

One-time pull or push of Space documents to/from a local directory as Markdown files. Each invocation copies the current state and exits — no background process, no live updates. For a live, two-way folder kept in sync, use strata link.

By default, push is flat: newly created documents land at the Space root, regardless of local subdirectories (existing documents are updated in place and keep their current folder). Pass --folders to recreate the directory tree as Strata folders and file new documents into them. (Pull always materializes server folders as local subdirectories, so a pull/edit/push round-trip without --folders flattens the result.)

Examples:

strata sync pull <space_id> ./notes          # download Space as .md files
strata sync push <space_id> ./notes          # upload changed files (flat)
strata sync push <space_id> ./notes --folders # upload, preserving folders

#strata sync pull

strata sync pull [OPTIONS] <SPACE> <DIR>

One-time download of Space documents as .md files

ArgumentValuesDescription
<SPACE>-Space ID
<DIR>-Output directory
--force?-Overwrite existing files

#strata sync push

strata sync push [OPTIONS] <SPACE> <DIR>

One-time upload of changed .md files back to a Space

ArgumentValuesDescription
<SPACE>-Space ID
<DIR>-Directory containing .md files
--force?-Skip confirmation prompt
--folders?-Recreate local subdirectories as Strata folders and file new documents into them. Without this, newly created documents land at the Space root regardless of local subdirectories

#strata sync pause

strata sync pause [OPTIONS] [FOLDER]

Pause background syncing without removing any link.

Pass a synced folder to pause just that link, or --all to pause every linked folder at once (each link keeps its own pause state, so resume --all restores exactly what was running before).

Pass --for to auto-resume after a preset window; the agent resumes on its own, even across restarts.

Examples:

strata sync pause ./notes
strata sync pause --all
strata sync pause --all --for 1h
ArgumentValuesDescription
[FOLDER]?-The synced folder to pause (omit with --all)
--all?-Pause every linked folder
--for <WINDOW>?30m | 1h | tomorrowAuto-resume after this window instead of pausing indefinitely
  • 30m 30 minutes
  • 1h One hour
  • tomorrow Until the next local midnight

#strata sync resume

strata sync resume [OPTIONS] [FOLDER]

Resume background syncing, or confirm a held bulk deletion.

For a paused folder (or --all for the global pause), resumes syncing. For a running folder whose mass-delete guard tripped — deleting many files at once would unlink a large fraction of the Space's documents — confirms the held deletions and lets sync continue. Unlinking removes documents from the Space only; they still exist and can be re-added.

Examples:

strata sync resume ./notes
strata sync resume --all
ArgumentValuesDescription
[FOLDER]?-The synced folder to resume (omit with --all)
--all?-Clear the global pause

#strata mount

strata mount [OPTIONS] <SPACE> <MOUNTPOINT>

Mount a Space as a live filesystem (FUSE on Linux, FSKit on macOS).

Documents appear as Markdown files; edits sync to the API as you make them and remote changes appear locally. Runs in the background until you strata unmount. For a one-time snapshot in either direction, use strata sync instead.

Defaults to read-write. Pass --readonly to mount read-only.

Examples:

strata mount <space_id> ~/strata
strata mount <space_id> ~/strata --readonly
strata mount <space_id> ~/strata --foreground
ArgumentValuesDescription
<SPACE>-Space ID to mount
<MOUNTPOINT>-Mountpoint directory
--foreground?-Run in the foreground (blocks until unmounted)
--readonly?-Mount read-only (default: read-write)

#strata unmount

strata unmount [OPTIONS] [TARGET]

Unmount a previously-mounted Space.

With no argument, unmounts the only active mount. Otherwise accepts either a Space ID or the mountpoint path.

Examples:

strata unmount                 (when exactly one Space is mounted)
strata unmount <space_id>
strata unmount ~/strata
ArgumentValuesDescription
[TARGET]?-Space ID or mountpoint path. Omit to unmount the only active mount

#strata agent

strata agent [OPTIONS] <COMMAND>

Manage the Strata background agent.

One per-user agent supervises every linked folder (and keeps the login session fresh); link commands install and start it automatically. This group is the explicit lifecycle surface.

Examples:

strata agent status
strata agent restart
strata agent run --replace      (attached to this terminal, for debugging)

#strata agent status

strata agent status [OPTIONS]

Show agent liveness, version, and supervision state

#strata agent install

strata agent install [OPTIONS]

Install (or repair) the agent and its login supervision unit

#strata agent upgrade

strata agent upgrade [OPTIONS]

Upgrade an already-installed agent to this CLI's version (no-op when none is installed)

#strata agent restart

strata agent restart [OPTIONS]

Restart the agent (the one-click repair)

#strata agent uninstall

strata agent uninstall [OPTIONS]

Stop the agent and remove its supervision unit (links and credentials are kept)

#strata agent run

strata agent run [OPTIONS]

Run the agent attached to this terminal (debugging)

ArgumentValuesDescription
--replace?-Stop the supervised agent first and hand back on exit

#strata memory

strata memory [OPTIONS] <COMMAND>

Use a Strata Space as a coding agent's long-term memory.

Bind a repository to a Space, then let the agent's lifecycle hooks (the strata-memory plugin for Claude Code / Codex) drive the loop: hybrid-search recall on every prompt, plus a stop-time nudge when session work changed files but no relied-upon memory document was updated.

Human verbs:

strata memory init                 # pick a Space interactively
strata memory bind <space_id>      # bind this repo (add --scope project to commit)
strata memory status               # show binding + effective config
strata memory unbind               # remove the binding

Hook verbs (preflight, recall, check, observe) read the host's hook JSON from stdin, print hook-protocol JSON, and always exit 0.

#strata memory bind

strata memory bind [OPTIONS] <SPACE>

Bind this repository to a Space as its agent memory

ArgumentValuesDescription
<SPACE>-Space ID (space_...)
--scope <SCOPE>?user | projectWhere the binding persists: personal (user) or committed (project)
  • user Personal, machine-local binding (nothing committed)
  • project Committed `.strata/memory.json` at the repo root, shared with the team
--strictness <STRICTNESS>?off | nudge-once | strictStop-nudge strictness override for this binding

#strata memory init

strata memory init [OPTIONS]

Interactively pick an accessible Space and bind it

#strata memory unbind

strata memory unbind [OPTIONS]

Remove this repository's memory binding

ArgumentValuesDescription
--scope <SCOPE>?user | projectRemove only this scope (default: project first, then user)
  • user Personal, machine-local binding (nothing committed)
  • project Committed `.strata/memory.json` at the repo root, shared with the team

#strata memory status

strata memory status [OPTIONS]

Show the resolved binding and effective memory-loop config

#strata memory preflight

strata memory preflight [OPTIONS]

SessionStart hook: verify auth + binding, seed the session ledger (stdin: hook JSON)

#strata memory recall

strata memory recall [OPTIONS]

UserPromptSubmit hook: search the bound Space, inject candidates (stdin: hook JSON)

#strata memory check

strata memory check [OPTIONS]

Stop hook: nudge once if memory was not reconciled (stdin: hook JSON)

#strata memory observe

strata memory observe [OPTIONS]

PostToolUse hook: record memory documents the agent read (stdin: hook JSON)

#strata api

strata api [OPTIONS] <COMMAND>

Direct API access for scripts, automation, and LLM agents.

Three layers:

- Typed subcommands (documents, spaces) wrap common operations.
- Discovery (list, describe, openapi) walks the embedded OpenAPI
  spec so an agent with no prior knowledge can find any endpoint.
- `api raw` then executes any endpoint by method + path.

Discover-then-call workflow:

strata api list                            # all tags
strata api list Documents                  # operations in a tag
strata api describe update_document        # full schema for one op
strata api raw PATCH /api/v1/documents/doc_01J... --body @edit.json

Typed shortcuts:

strata api documents list
strata api documents create --title "Notes" --content "# Hello"

#strata api documents

strata api documents [OPTIONS] <COMMAND>

Document operations

#strata api documents list

strata api documents list [OPTIONS]

List documents

ArgumentValuesDescription
--folder-id <FOLDER_ID>?-Folder ID (optional)
--limit <LIMIT>?default: 20Maximum results

#strata api documents get

strata api documents get [OPTIONS] <DOC_ID>

Get a document by ID

ArgumentValuesDescription
<DOC_ID>-Document ID

#strata api documents content

strata api documents content [OPTIONS] <DOC_ID>

Get document content (markdown)

ArgumentValuesDescription
<DOC_ID>-Document ID
--format <FORMAT>?default: markdownOutput format

#strata api documents create

strata api documents create [OPTIONS]

Create a new document

ArgumentValuesDescription
--title <TITLE>-Document title
--content <CONTENT>?-Content (markdown). Accepts an inline string, @path/to/file.md (read from file), or - / @- (read from stdin)
--folder-id <FOLDER_ID>?-Folder to create the document in. Omit to use your personal (owner-only) folder; pass a tier folder to share with its members. List options with strata api folders list

#strata api documents edit

strata api documents edit [OPTIONS] <DOC_ID>

Edit a document (replace all content)

ArgumentValuesDescription
<DOC_ID>-Document ID
--content <CONTENT>?-New content (markdown). Accepts an inline string, @path/to/file.md (read from file), or - / @- (stdin). Omit the flag to read from stdin (back-compat shorthand)

#strata api documents move

strata api documents move [OPTIONS] <DOC_ID>

Move a document to a different folder, changing who can see it.

A document's audience is its folder: a personal folder is owner-only, a tier folder is visible to that tier's members.

ArgumentValuesDescription
<DOC_ID>-Document ID
--folder-id <FOLDER_ID>?-Destination folder ID (audience becomes that folder's scope)
--to-root?-Move to the space root instead of a folder

#strata api documents delete

strata api documents delete [OPTIONS] <DOC_ID>

Delete (trash) a document

ArgumentValuesDescription
<DOC_ID>-Document ID

#strata api folders

strata api folders [OPTIONS] <COMMAND>

Folder operations (a document's audience is its folder)

#strata api folders list

strata api folders list [OPTIONS]

List folders and their scopes (the audience a document gets in each)

ArgumentValuesDescription
--parent-folder-id <PARENT_FOLDER_ID>?-Only list the children of this folder
--limit <LIMIT>?default: 50Maximum results

#strata api folders create

strata api folders create [OPTIONS]

Create a new folder

ArgumentValuesDescription
--name <NAME>-Folder name
--parent-folder-id <PARENT_FOLDER_ID>?-Parent folder ID (omit for a top-level folder)

#strata api spaces

strata api spaces [OPTIONS] <COMMAND>

Space operations

#strata api spaces list

strata api spaces list [OPTIONS]

List spaces

ArgumentValuesDescription
--scope-type <SCOPE_TYPE>?-Scope type (personal, team, org, company)
--scope-id <SCOPE_ID>?-Scope entity ID
--limit <LIMIT>?default: 50Maximum results

#strata api spaces get

strata api spaces get [OPTIONS] <SPACE_ID>

Get space info

ArgumentValuesDescription
<SPACE_ID>-Space ID

#strata api spaces documents

strata api spaces documents [OPTIONS] <SPACE_ID>

List documents in a space

ArgumentValuesDescription
<SPACE_ID>-Space ID
--limit <LIMIT>?default: 50Maximum results

#strata api spaces add-documents

strata api spaces add-documents [OPTIONS] <SPACE_ID> <DOCUMENT_IDS>...

Add documents to a space

ArgumentValuesDescription
<SPACE_ID>-Space ID
<DOCUMENT_IDS>...-Document IDs to add

#strata api list

Aliases: ls

strata api list [OPTIONS] [TAG]

List API surface — tags, or operations within a tag.

strata api list — every tag with operation count strata api list <tag> — operations under that tag

ArgumentValuesDescription
[TAG]?-Optional tag name. Omit to list every tag

#strata api describe

Aliases: show

strata api describe [OPTIONS] [QUERY]...

Show the full schema for one operation: parameters, request body, responses.

Accepts either an operationId or a "METHOD /path" pair.

Response schemas are inlined shallowly by default to keep output small; pass --full to deep-resolve them.

Examples:

strata api describe update_document
strata api describe "GET /api/v1/spaces"
strata api describe list_comments --full
ArgumentValuesDescription
[QUERY]...?-operationId, or "METHOD /path" (quote because it contains a space)
--full?-Deep-resolve response schemas too (default: response $refs are left as named references to keep output bounded)

#strata api openapi

strata api openapi [OPTIONS]

Dump the embedded OpenAPI spec to stdout (for offline tooling)

#strata api raw

strata api raw [OPTIONS] [METHOD] [PATH]

Send a raw HTTP request to any API endpoint.

Use this when the typed subcommands don't cover the endpoint you need. Discover available endpoints first with:

strata api list                            # all tags
strata api list Documents                  # operations under a tag
strata api describe update_document        # full schema for one op
strata api describe "GET /api/v1/spaces"   # or by route

Body sources (--body accepts three forms, avoids shell-quoting pain):

--body '{"k":"v"}'   inline JSON string
--body @file.json     read from file (curl-style)
--body -              read from stdin (also @-)

Examples:

strata api raw GET /api/v1/spaces
strata api raw GET /api/v1/documents/doc_01J...
strata api raw POST /api/v1/spaces --body '{"name":"Notes"}'
strata api raw POST /api/v1/spaces --body @space.json
echo '{"name":"Notes"}' | strata api raw POST /api/v1/spaces --body -
strata api raw DELETE /api/v1/documents/doc_01J...

Output is the response body. JSON is pretty-printed; non-JSON is passed through. Non-2xx responses exit non-zero and print the error body.

ArgumentValuesDescription
[METHOD]?-HTTP method (GET, POST, PUT, PATCH, DELETE). Omit to see the discovery hint instead of a clap "required argument" error — helpful for first-time / agent invocations
[PATH]?-API path (e.g. /api/v1/spaces)
--body <BODY>?-Request body. Accepts an inline JSON string, @path/to/file.json (curl-style file ref), or - / @- (read from stdin). Skip the flag for an empty body

#strata completions

strata completions [OPTIONS] <SHELL>

Print a shell completion script to stdout.

Install per your shell's convention. Examples:

strata completions fish > ~/.config/fish/completions/strata.fish
strata completions zsh  > ~/.zsh/completions/_strata
strata completions bash > /etc/bash_completion.d/strata
ArgumentValuesDescription
<SHELL>bash | elvish | fish | powershell | zshTarget shell