Commands - Guild

Global options

These options are accepted by every guild command.

Option	Description
`--mode <format>`	Output format: `interactive` (default), `json`, or `jsonl`. Use `json` or `jsonl` for machine-readable output in scripts and CI pipelines.
`--debug`	Enable debug mode with verbose logging.
`--quiet`, `-q`	Suppress progress and log messages.
`--non-interactive`	Disable interactive prompts, for CI, scripts, and coding agents.

--mode is read from the full command line, so it can go before or after the subcommand, and --mode=json works as well as --mode json:

guild --mode json agent list
guild agent list --mode json

--json is a hidden backward-compatible alias for --mode json. It still works but does not appear in guild --help. Use --mode json in new scripts.

Event filtering

guild chat, guild workspace chat, guild agent test, and guild session events accept --events <types> to choose which session event types to show. The flag requires a value.

Value	Shows
`user`	User-facing events. This is the default.
`system`	System and debug events only.
`all`	Both groups.
`none`	No events.
`<type>,<type>`	Only the named types, for example `agent_console,llm_start`.

Whatever you pass replaces the default entirely, so --events system hides user-facing events rather than adding to them. User events, shown by default: user_message, agent_notification_message, agent_notification_progress, agent_notification_error, container_log, credentials_request, agent_install_request, trigger_message, system_error System and debug events, hidden by default: agent_console, runtime_start, runtime_running, runtime_waiting, runtime_error, runtime_done, llm_start, llm_done These two groups mirror the Filter by type modal in the web UI.

auth

Manage authentication.

guild auth login              # Log in via browser OAuth
guild auth logout             # Remove stored token
guild auth status             # Show authentication state
guild auth token              # Print the current auth token

guild auth login stores your token in the OS keyring when one is available. On a headless host with no keyring, it falls back to a file named auth-token.json in the global config directory (GUILD_CONFIG_DIR, or ~/.guild when unset). The CLI writes the file with 0600 permissions and keys each entry by host, so several hosts can share one config directory. guild auth logout removes the token from both the keyring and the fallback file.On a headless host there is also no browser to launch. guild auth login prints the verification code and URL and keeps polling rather than failing, so the flow still completes from another machine. Pass --non-interactive to skip the browser launch outright.

agent

Build and manage agents.

Development workflow

# Initialize the current directory as a new agent
guild agent init
guild agent init --name my-agent
guild agent init --name my-agent --template LLM
guild agent init --name my-agent --agent-type GUILD_NATIVE
guild agent init --fork <agent-id>        # Start from an existing agent
guild agent init --owner <owner>          # Specify owner by name or ID
guild agent init --name my-agent --category development --tags "code-review,testing"

Templates: LLM (default), AUTO_MANAGED_STATE, BLANK Agent types: GUILD_TYPESCRIPT, GUILD_NATIVE, GOOSE, OPENCLAW. Values are case-insensitive. Each type scaffolds a different entry point:

Agent type	Entry point
`GUILD_TYPESCRIPT`	`agent.ts`
`GUILD_NATIVE`	`PROMPT.md`
`GOOSE`	`recipe.yaml`
`OPENCLAW`	`AGENTS.md`

--agent-type appears only on accounts that have more than one agent type available. Omit the flag in a terminal and the CLI prompts you to choose from the types you have available. In non-interactive mode the flag is required, and omitting it exits with Error: --agent-type is required in non-interactive mode.

--template is only supported for GUILD_TYPESCRIPT. Passing it with any other agent type exits with Error: --template is not supported for agent type <agent-type>.

In non-interactive mode, --owner is required when your account belongs to one or more organizations. Use guild config set default_owner <name-or-id> to set a default and avoid passing --owner on every invocation. In interactive mode, the CLI always prompts for owner selection.

# Save changes (commits code and syncs with Guild)
guild agent save --message "Add rate limiting"
guild agent save --message "Fix bug" --wait       # Wait for validation
guild agent save --message "Ship it" --wait --publish  # Save and publish
guild agent save --message "Breaking change" --publish --bump major  # Bump the major version when publishing
guild agent save --message "Ship it" --publish --timeout 600  # Wait up to 600s for validation and publish

# Pull remote changes into the local directory
guild agent pull

# Test the agent in the current directory
guild agent test
guild agent test "Summarize this PR: github.com/org/repo/pull/42"

# Chat with the agent you're developing
guild agent chat

--publish implies --wait: it always waits for validation and publish to finish, then prints Version is now published and available in the catalog. Use --timeout <seconds> (default: 300) to bound that wait. The value must be a positive integer, otherwise the command prints Invalid --timeout value and exits with status 1. If validation is still running when the timeout elapses, the CLI tells you how to finish the job:

Validation is still running. Publish once it completes:
  guild agent publish <agent-id> --wait

Forking

Fork a published agent version into a new independent agent with its own repository.

guild agent fork <identifier>                        # Fork latest published version
guild agent fork <identifier>:<version-id>           # Fork a specific version
guild agent fork <identifier> --name my-fork         # Name the forked agent
guild agent fork <identifier> --owner <owner>        # Assign to owner (name or ID)
guild agent fork <identifier> --directory ./my-fork  # Clone into a specific directory
guild agent fork <identifier> --category <name>       # Change the forked agent's category
guild agent fork <identifier> --tags a,b             # Set tags on the fork

A fork inherits the source agent’s category, and its tags along with it. Pass --category to change it — the source tags are then dropped, and any --tags you pass are validated against the new category’s allowed set. Inherited tags exclude Guild’s own guild:-prefixed ones. Run guild agent categories <category> to see the allowed tags for a category. <identifier> is an agent ID or name. If omitted, the command reads guild.json in the current directory.

guild agent save -A/--all commits only modified tracked files. New files are untracked and are not saved — stage them with git add <file> (or git add .) first.

save

Commit your code and create a new version. Versions start as drafts until you publish them.

guild agent save --message "Add rate limiting"
guild agent save --message "Ship it" --wait --publish            # Save and publish
guild agent save --message "Pin release" --version-number 2.1.0  # Set the version explicitly

Option	Description
`--version-number <version>`	Set the version explicitly, overriding the default `package.json` version. Applies when saving and when publishing.

TypeScript agents derive their version from package.json. Goose agents (recipe.yaml) and Guild Native agents (PROMPT.md) do not use a package.json, so guild agent save skips the package.json version-bump checks for them. --bump and the default bump are no-ops for these agent types. When you run guild agent save --publish on a Goose or Guild Native agent without --version-number, the CLI derives the next version automatically as a patch increment of the latest published version, or 1.0.0 when no published version exists.

test

Test the agent in the current directory. guild agent test polls for the agent’s response and prints it. Use --timeout to override how long the CLI waits before the poll times out.

guild agent test                             # Test the current directory's agent
guild agent test "Summarize this PR"         # Send an initial prompt
guild agent test --timeout 300               # Wait up to 300 seconds for the response
guild agent test --resume <session-id>       # Resume an existing session
guild agent test --events all                # Include system and debug events

Option	Description
`--timeout <seconds>`	Seconds to wait when polling for the agent’s response (default: 180). Must be a positive integer, otherwise the command exits with code `1` and prints `Error: Invalid --timeout value: <value>`.
`--resume <session-id>`	Resume an existing session, such as one whose response poll timed out.
`--events <types>`	Event types to show (default: `user`). See Event filtering.

A poll timeout is recoverable: the session is not discarded when polling times out, so you can resume it. In --mode json, the error output includes the session ID and the resume hint guild agent test --resume <session-id>. In --mode jsonl, the timeout output includes the session ID and the same resume hint, and the command continues to the next input line.

guild agent test runs any agent the workspace already trusts — one your account owns, or one installed in the workspace, including a public or third-party agent you added from the Hub. See Agent-test session authorization.

Before it runs, the CLI checks that the files required for the agent’s type are present: agent.ts and package.json for Guild TypeScript, PROMPT.md for Guild Native, recipe.yaml for Goose, and AGENTS.md for OpenClaw. It resolves the type from guild.json or the Guild API and names the file missing for that type.

chat

Chat with the agent you’re developing from inside the agent directory. By default, guild agent chat creates an ephemeral build from your local files and starts a new session.

guild agent chat                             # Interactive chat using an ephemeral build
guild agent chat "Summarize this PR"         # Start with an initial prompt
guild agent chat --resume <session-id>       # Resume an existing session
guild agent chat --mode json                 # Use JSON input/output mode
guild agent chat --mode jsonl                # Use JSONL input/output mode
guild agent chat --agent-version <id>        # Chat with a specific existing version
guild agent chat --no-cache                  # Force a fresh ephemeral build

Ephemeral builds are the default. guild agent chat builds an agent version from your local files, and unchanged files reuse the cached ephemeral build.

Ephemeral builds include only files tracked by Git. guild agent test and guild agent chat upload files that are already committed or staged with git add. New untracked files are ignored until you stage them with git add. Modified tracked files still upload their working-tree content, so you can test uncommitted changes to existing files without committing them first.

Option	Description
`--resume <session-id>`	Resume an existing session. Works in interactive, `--mode json`, and `--mode jsonl` modes.
`--mode <format>`	Set the input and output mode. Accepts `json` or `jsonl`.
`--agent-version <id>`	Chat with a specific existing version, given as a UUID or version number, instead of the default ephemeral build.
`--no-cache`	Skip the ephemeral build cache and force a fresh build.

--resume <session-id> works in all modes: interactive, --mode json, and --mode jsonl. Resuming a session skips version resolution and ephemeral builds entirely, because the resumed session already pins its agent version and workspace. --workspace and --agent-version are ignored when you resume. In --mode json and --mode jsonl, resuming appends your input to the specified session as a new user message instead of creating a new session. The CLI reports the resumed session’s ID, and response polling only considers events created after your message. If the session ID does not exist or you cannot access it, guild agent chat exits with code 1 without building the agent and prints:

Cannot resume session '<id>': it does not exist or you do not have access to it. List your sessions with: guild session list

Publishing

guild agent publish              # Publish the latest draft version
guild agent publish --wait       # Wait for validation before publishing
guild agent publish --wait --timeout 300  # Specify validation/publish wait timeout (default: 300s)
guild agent unpublish            # Unpublish the latest published version
guild agent versions             # List all versions
guild agent logs                 # Build/validation step logs for the latest version
guild agent logs <identifier> <version-id>  # Logs for a specific version

Option	Description
`--timeout <seconds>`	Seconds to wait for validation/publish to complete when using `--wait` (default: 300). Must be a positive integer.

Version history

Render an agent’s version history as git-log-style blocks, each showing the commit SHA, version number, status, validation status, relative date, and summary.

guild agent log                              # History for the agent in the current directory
guild agent log <agent-id>                   # History for a specific agent
guild agent log --limit 10                   # Show at most 10 versions
guild agent log --offset 20                  # Skip the first 20 versions

The agent argument is optional and accepts an agent ID or a full name such as myorg~my-agent; omit it to use the agent in the current directory.

Option	Description
`--limit <n>`	Maximum number of versions to return (default: 20).
`--offset <n>`	Number of versions to skip, for pagination (default: 0).

diff

Show what changed between your local files and a published version, as a colored unified diff.

guild agent diff             # Compare against the latest published version
guild agent diff 1.0.4       # Compare against a specific version

The version argument is optional and defaults to the latest published version. Run this from inside an agent directory — the command requires a guild.json and compares the same git-tracked working-tree files that guild agent save uploads.

Discovery and management

guild agent list                             # List your agents
guild agent list --workspace <id>            # List agents installed in a specific workspace
guild agent search "code review"             # Search published agents
guild agent get <agent-id>                   # Get agent details
guild agent update <agent-id> --public       # Change visibility (--public or --private)
guild agent clone <agent-id>                 # Clone an agent's code locally
guild agent code <agent-id>                  # Fetch published code
guild agent code <agent-id> --draft          # Include draft versions

# Archive an agent, removing it from every workspace and stopping new runs
guild agent archive                          # Archive the agent in the current directory
guild agent archive <agent-id>               # Archive a specific agent
guild agent unarchive <agent-id>             # Restore an archived agent

Passing --workspace <id> to guild agent list lists the agents installed in that workspace rather than the platform-wide public roster. The agent argument is optional for both commands. It accepts an agent ID or a full name like myorg~my-agent, and defaults to the agent in guild.json in the current directory. See Disabling an agent for what archiving changes. When you pass --workspace, guild agent list returns the agents installed in that workspace, identified by ID or name. This set is specific to the workspace and excludes unrelated public agents.

The --published flag is ignored when combined with --workspace, because installed agents already reference committed versions.

capabilities

Show an agent’s resolved tools, grouped by their source unit — integrations, sub-agents, and built-in or legacy services. Each tool is marked read, write, or unknown. The unknown marker is shown separately from read because an unclassified tool may write.

guild agent capabilities                       # Show tools for the current directory's agent
guild agent capabilities <identifier>          # Show tools for a specific agent (ID or myorg~my-agent)
guild agent capabilities --version <id>        # Use a specific version instead of the latest published
guild agent capabilities --mode json           # Emit the raw JSON payload

The [identifier] argument is optional. It accepts an agent ID or a full name like myorg~my-agent, and defaults to the agent in the current directory. --version <id> overrides the default latest published version. --mode json emits the raw payload with version_id, tools, and access fields. The command requires authentication; run guild auth login first. Example output:

Integration: github
  read     github_pulls_get
  write    github_issues_create

Sub-agent: guildai/triage-agent
  unknown  run_triage

Built-in: ui
  unknown  ui_prompt

With --output json, the command emits a machine-readable payload instead:

{
  "version_id": "ver_01ABCDEF",
  "tools": [ ... ],
  "access": {
    "github_pulls_get": "read",
    "github_issues_create": "write",
    "run_triage": "unknown"
  }
}

Workspaces

Manage workspaces and their contents.

guild workspace list                              # List all accessible workspaces
guild workspace create <name>                     # Create a new workspace
guild workspace create <name> --owner <owner>     # Create for a specific owner (name or ID)
guild workspace get <identifier>                  # Get workspace details
guild workspace select                            # Set the default workspace (interactive)
guild workspace select <id-or-name>               # Set the default workspace directly
guild workspace current                           # Show current default workspace
guild workspace clear                             # Remove the default workspace setting

After a successful global workspace selection, guild workspace select prints to stderr: To clear the default, run: guild workspace clear. Pass --quiet to suppress it.

chat

Start a conversation with an agent.

guild workspace chat                                   # Interactive chat with the Guild assistant
guild workspace chat "Summarize my open PRs"           # Start with an initial message
guild workspace chat --agent <identifier>              # Chat with a specific agent
guild workspace chat --workspace <identifier>          # Use a specific workspace
guild workspace chat --once "What is 2 + 2?"           # One-shot: send message and exit
guild workspace chat --resume <session-id>             # Resume a previous session (interactive or --once mode)
guild workspace chat --once --resume <session-id> "Another question"   # Resume a session in one-shot mode
guild workspace chat --events all                      # Include system and debug events

To chat with the agent you’re currently developing, use guild agent chat from inside the agent directory.

Workspace agents

guild workspace agent list                    # List agents installed in workspace
guild workspace agent add <identifier>        # Install an agent
guild workspace agent remove <identifier>     # Remove an agent

Workspace context

guild workspace context list <workspace-id>                      # List context versions
guild workspace context get <workspace-id> <context-id>          # Get a version
guild workspace context edit <workspace-id>                      # Edit in $EDITOR, creates draft
guild workspace context edit <workspace-id> --from <context-id>  # Edit from a specific version
guild workspace context publish <workspace-id> <context-id>      # Publish a draft

clear

Remove the default workspace setting from configuration.

guild workspace clear

Behavior depends on where you run the command:

In an agent directory (contains guild.json): removes workspace_id from guild.json and prints ✓ Cleared workspace setting for this agent.
Outside an agent directory: removes default_workspace and default_workspace_name from ~/.guild/config.json and prints ✓ Default workspace cleared.

If no default workspace is set, the command prints No default workspace was set. to stderr and exits successfully — it is not an error. Exit codes: 0 on success or no-op; 1 on filesystem error only.

chat

Open The Smith, Guild’s built-in support agent, in an interactive chat session.

guild chat                    # Open The Smith
guild chat --events all       # Include system and debug events

To chat with the generic workspace assistant instead, use guild workspace chat.

session

Inspect sessions in a workspace.

guild session list                           # List sessions in the default workspace
guild session list --workspace <id>          # Specify a workspace
guild session list --type chat               # Filter by type: chat, webhook, time, agent_test
guild session get <session-id>               # Get session details
guild session events <session-id>            # List events in a session
guild session events <session-id> --events all        # Include system and debug events
guild session events <session-id> --limit 50 --offset 50   # Paginate (default limit: 100)
guild session tasks <session-id>             # List tasks in a session
guild session send <session-id> <message>    # Send a user message to a session

api

Call any Guild REST API endpoint directly. guild api is an authenticated escape hatch that mirrors guild session get and acts as a CLI counterpart to the MCP data tools. Use it to reach endpoints that do not have a dedicated command yet.

guild api GET /me                            # Retrieve your user details
guild api GET /workspaces                    # List your workspaces
guild api POST /workspaces --data '{"name":"demo"}'  # Send a JSON request body

The command validates your session token, checks the HTTP method, and parses any --data JSON before calling the Guild REST API. It prints the raw JSON response to stdout.

Argument	Description
`<method>`	HTTP method. One of `GET`, `POST`, `PATCH`, `PUT`, or `DELETE`.
`<path>`	API endpoint path, such as `/me` or `/workspaces`.

Option	Description
`--data <json>`	Request body as a JSON string.

trigger

Automate agent execution. See Triggers for a full guide, or Event triggers, Schedule triggers, and API triggers for type-specific details.

guild trigger list                           # List triggers in the default workspace
guild trigger get <trigger-id>               # Get trigger details
guild trigger sessions <trigger-id>          # List sessions spawned by a trigger

# Create a webhook trigger
guild trigger create --type webhook --integration slack --event app_mention --agent <identifier>

# Create a time trigger
guild trigger create --type time --frequency DAILY --time 09:00 --agent <identifier>

guild trigger update <trigger-id> --time 10:00
guild trigger activate <trigger-id>
guild trigger deactivate <trigger-id>

integration

Build and manage custom integrations.

Discovery and management

guild integration list                        # List integrations
guild integration list --search "deploy"      # Search by name or description
guild integration list --published            # Only show published integrations
guild integration search <query>              # Search integrations
guild integration search <query> --sort newest  # Sort by: updated, newest, name
guild integration search <query> --published  # Only show published integrations
guild integration search <query> --limit 10 --offset 20  # Paginate results
guild integration get <id_or_name>            # Get integration details

Creating and updating

guild integration create also registers an initial draft version and prints its ID, so you can define operations without running guild integration version create first.

# Create a new integration with API key auth
guild integration create my-service \
  --base-url https://api.example.com \
  --auth-scheme api-key \
  --description "Connect to the Acme API"

# Create with OAuth
guild integration create my-oauth-service \
  --base-url https://api.example.com \
  --auth-scheme oauth \
  --install-url https://example.com/oauth/authorize \
  --token-url https://example.com/oauth/token \
  --client-id <id> --client-secret <secret> \
  --scopes "read,write"

# Update an existing integration
guild integration update myorg~my-service --description "Updated description"

Publishing freezes the endpoint URL, and the OAuth authorization and token URLs with it. Until the integration’s first version is published, the owner can still change them — nothing is installed against the integration yet. Once a version is published, users install credentials against those URLs, so Guild refuses to let the owner repoint them at another server. The whole update is rejected with a 403, not just the URL field, so a request that changes a URL alongside other settings saves none of them. To serve a different endpoint, create a new integration.

Guild validates the --base-url, --install-url, and --token-url values to prevent server-side request forgery (SSRF). Private network ranges, loopback addresses (such as localhost or 127.0.0.1), and internal DNS names are blocked. For local development, expose your service using a tunneling tool such as ngrok or Localtunnel and use the public URL.

Connecting credentials

guild integration connect myorg~my-service                  # Interactive prompt
guild integration connect myorg~my-service --token <value>  # Non-interactive

versions

guild integration version list <id_or_name>                 # List versions
guild integration version create <id_or_name>               # Create a draft version
guild integration version get <id_or_name>                  # Get latest version details
guild integration version get <id_or_name> --version-number 1.0.0

guild integration version build <id_or_name> --version-number 1.0.0   # Validate a draft
guild integration version publish <id_or_name> --version-number 1.0.0 # Publish a built version

Operations (endpoints)

# List operations on a version
guild integration operation list <id_or_name>
guild integration operation list <id_or_name> --version-number 1.0.0

# Add operations manually
guild integration operation create myorg~my-service \
  --operation list_users \
  --method GET \
  --path /users \
  --summary "List all users"

# Import operations from an OpenAPI spec
guild integration operation create myorg~my-service --openapi ./openapi.yaml

Testing

guild integration version test myorg~my-service \
  --operation list_users \
  --account my-account \
  --input-query '{"limit": 10}'

container-image

Manage container images. An image is identified by its owner and name, both passed as flags — these commands take no positional arguments.

guild container-image list                                    # List container images
guild container-image get --owner acme --name base            # Show one image
guild container-image create --owner acme --name base \
  --image us-docker.pkg.dev/project/repo/image --tag latest   # Register an image
guild container-image modify --owner acme --name base --tag v2  # Change the tag

list

Option	Description
`--owner <name>`	Account name or ID to list images for. Defaults to the authenticated user.
`--limit <number>`	Number of results to return (default: 20).
`--offset <number>`	Offset for pagination (default: 0).

get

Shows an image, including its setup script. --owner and --name are both required.

create

--owner, --name, --image, and --tag are all required.

Option	Description
`--owner <name>`	Owner account name or ID.
`--name <name>`	Image name. Lowercase letters, digits, hyphens, dots, and underscores; 1–100 characters.
`--image <image>`	Docker image path, without a tag — for example `us-docker.pkg.dev/project/repo/image`.
`--tag <tag>`	Docker tag, for example `latest`.

modify

--owner and --name identify the image; pass at least one of the remaining options.

Option	Description
`--image <image>`	New Docker image path.
`--tag <tag>`	New Docker tag.
`--public`	Make the image public. One-way door — this cannot be undone.
`--yes`	Skip the confirmation prompt for `--public`.

runtime-environment

Manage runtime environments. A runtime environment pairs a base container image with an optional setup script. Like container-image, every command identifies its target with --owner and --name flags rather than a positional argument.

guild runtime-environment list                                      # List environments
guild runtime-environment get --owner acme --name build             # Show one, with its setup script
guild runtime-environment create --owner acme --name build \
  --image acme~base --setup @setup.sh                               # Create from an image and a script
guild runtime-environment modify --owner acme --name build --clear-setup
guild runtime-environment test --owner acme --name build            # Provision a throwaway container

list

Option	Description
`--owner <name>`	Owner account name or ID. Without this flag, lists your configured default owner, then falls back to your personal account.
`--limit <number>`	Number of results to return (default: 20).
`--offset <number>`	Offset for pagination (default: 0).

get

Shows an environment, including its setup script. --owner and --name are both required.

create

--owner and --name are required. Supply the base image with --image, or omit it in a terminal to pick from a searchable list.

Option	Description
`--owner <name>`	Owner account name or ID.
`--name <name>`	Environment name. Lowercase letters, digits, hyphens, dots, and underscores; 1–100 characters.
`--image <id_or_name>`	Base container image, as an ID or a full name such as `guildai~experimental-coding`.
`-i, --interactive`	Pick the base image from a searchable list of the images you own plus all public images.
`--setup <script>`	Setup script, given inline or as `@path` to read from a file — for example `--setup @setup.sh`.

modify

--owner and --name identify the environment; pass at least one of the remaining options.

Option	Description
`--image <id_or_name>`	Set a new base container image.
`-i, --interactive`	Pick the new base image from the searchable list.
`--setup <script>`	Replace the setup script, inline or as `@path`.
`--clear-setup`	Remove the setup script.
`--public`	Make the environment public. One-way door — this cannot be undone.
`--yes`	Skip the confirmation prompt for `--public`.

test

Provisions a throwaway container from the environment, streams the setup script’s logs, and reports whether the container came up. Use it to check a setup script before an agent depends on it.

Option	Description
`--owner <name>`	Owner account name or ID. Defaults to your configured default owner, falling back to your personal account.
`--name <name>`	Environment name. Required.

--image and -i, --interactive cannot be combined. --interactive needs a terminal and is rejected in machine-readable mode, so in a script or CI job pass --image explicitly. On modify, --setup and --clear-setup are likewise mutually exclusive.

skill

Create and manage reusable skill packages. See Skills for a full guide.

guild skill create <name>                    # Create a new skill
guild skill create <name> --overview "..."   # Create with description
guild skill get <identifier>                 # Get skill details (name or UUID)
guild skill list                             # List skills (unarchived only)
guild skill list --archived                  # List only archived skills
guild skill list --search "tone"             # Search skills
guild skill search "compliance"              # Search skills by keyword
guild skill search "tone" --published        # Only show published skills
guild skill update <identifier> --overview "New description"
guild skill update <identifier> --public     # Make public (requires admin)
guild skill archive <identifier>             # Archive the skill
guild skill unarchive <identifier>           # Restore an archived skill

versions

guild skill version create <identifier> \
  --version-number 1.0.0 \
  --description "Runtime description" \
  --body-file content.md                     # Create a version from file

guild skill version list <identifier>        # List versions
guild skill version get <version-id>         # Get version details

llm

Manage LLM credentials and model policies from the CLI. See LLM settings for the full model gateway guide.

Credentials

List an account’s LLM credentials and the access each grants. Use it to find the credential ID that guild llm policy create binds to.

guild llm credential list <account>              # List an account's LLM credentials
guild llm credential list <account> --archived   # Show archived credentials instead of live ones

Argument or option	Description
`<account>`	Account ID or name. Required.
`--limit <number>`	Number of results to return.
`--offset <number>`	Offset for pagination.
`--archived`	Show archived credentials instead of live ones.

The output has one row per credential, ending with the credential UUID to pass to guild llm policy create --credential.

Policies

View and create model policies for a workspace, agent, or workspace-agent target. A policy binds a credential access to a target with an optional model allowlist.

guild llm policy list <account>                                              # List an account's model policies
guild llm policy list <account> --target-id <id>                             # Show only one target's rules
guild llm policy create --credential <id> --target-id <id>                   # Allow all models
guild llm policy create --credential <id> --target-id <id> --models "haiku-*,sonnet-*"  # Restrict models

Command	Description
`guild llm policy list <account>`	List an account’s model policies. Add `--target-id <id>` to show only the rules on one workspace, agent, or workspace-agent.
`guild llm policy create --credential <id> [--publisher <publisher>] --target-id <id> [--models <patterns>]`	Create a policy. `--credential` is the LLM credential ID. `--publisher` names the model publisher on it (case-insensitive, e.g. `ANTHROPIC`); omit it when the credential serves a single publisher and Guild infers it. Omit `--models` to allow all models; pass comma-separated globs (e.g. `haiku-,sonnet-`) to restrict.

config

Read and write global CLI configuration.

guild config list               # Show all config values
guild config get <key>          # Read a value
guild config set <key> <value>  # Write a value
guild config path               # Show path to config file

Keys: default_workspace, default_owner, debug, json, quiet, telemetry, auto_update The json key is the config-file equivalent of --mode json. Setting guild config set json true applies JSON output to every command without passing the flag each time.

Utilities

guild doctor     # Diagnose setup issues (auth, server, workspace, git)
guild setup      # Install coding assistant skills in the current project
guild version    # Show the CLI version

guild setup previews the files it will create, overwrite, or skip and asks for confirmation before making changes, then prompts you to choose a coding assistant — Claude Code, Codex, or Gemini. Pass --provider <claude|codex|gemini> to select one non-interactively, -y/--yes to accept the preview without confirming, and --force to overwrite existing skill files. Add --claude-md, --agents-md, or --gemini-md to also generate a project instructions template for the chosen assistant. Use the --simple flag with guild version to print only the bare version number followed by a newline, with no additional decoration. This makes the output easy to capture in scripts.

guild version --simple                     # Output only the version number, e.g. 0.16.0
GUILD_VERSION=$(guild version --simple)    # Capture the version in a script

​Global options

​Event filtering

​auth

​agent

​Development workflow

​Forking

​save

​test

​chat

​Publishing

​Version history

​diff

​Discovery and management

​capabilities

​tags

​categories

​Workspaces

​chat

​Workspace agents

​Workspace context

​clear

​chat

​session

​api

​trigger

​integration

​Discovery and management

​Creating and updating

​Connecting credentials

​versions

​Operations (endpoints)

​Testing

​container-image

​list

​get

​create

​modify

​runtime-environment

​list

​get

​create

​modify

​test

​skill

​versions

​llm

​Credentials

​Policies

​config

​Utilities

Global options

Event filtering

auth

agent

Development workflow

Forking

save

test

chat

Publishing

Version history

diff

Discovery and management

capabilities

tags

categories

Workspaces

chat

Workspace agents

Workspace context

clear

chat

session

api

trigger

integration

Discovery and management

Creating and updating

Connecting credentials

versions

Operations (endpoints)

Testing

container-image

list

get

create

modify

runtime-environment

list

get

create

modify

test

skill

versions

llm

Credentials

Policies

config

Utilities