The kadmo commands

Every command of the kadmo CLI, as kadmo --help prints it for version 0.1.0. Install it first: Install the runtime.

Command	What it does
kadmo serve	Start the agent service with the dashboard (bare kadmo does the same)
kadmo mcp	Run the MCP server over stdio, for an MCP client
kadmo status	Ask the running service for its status and the browser's
kadmo list	List the workflows the runtime has
kadmo run <workflow>	Start a workflow on the running service
kadmo install [source]	Install a pack, refresh the agent ops, or list what is installed
kadmo uninstall <domain>	Remove an installed pack
kadmo search [query]	Search your registries and the public catalogue
kadmo registry	Add, list, update and remove pack registries
kadmo init <domain>	Scaffold a new pack
kadmo validate [path]	Check a pack's structure
kadmo login --token <token>	Store a personal API token from the Kadmo app
kadmo publish [source]	Publish a pack to the Kadmo app, or into a local registry
kadmo plugin	List, install and remove plugins

Every command takes -h, --help. kadmo -V (or --version) prints the version, and kadmo help <command> prints a command's help.

Run the runtime

kadmo serve

kadmo serve [-p <port>] [--host <host>]

Starts the agent service: the dashboard, the REST API, the extension's WebSocket on /ws and the HTTP MCP endpoint on /mcp. It runs until you stop it. kadmo with no command, or with only options, runs kadmo serve.

Option	Default	Meaning
-p, --port <port>	9876	The port to listen on. The Kadmo extension always connects to 9876, so another port runs without a browser.
--host <host>	127.0.0.1 (or KADMO_HOST)	The bind address. Any other address requires KADMO_AGENT_TOKEN, or the service refuses to start.
--headless		Printed by the help, but it changes nothing in this release: the dashboard is always served.

At start the service fetches the agent ops once when none are installed and an agent token is set (on an agent's machine).

kadmo mcp

kadmo mcp [-p <port>]

The MCP server over stdio: stdin and stdout carry the protocol's JSON-RPC messages, and diagnostics go to stderr. An MCP client starts it and talks to it; you do not run it by hand. Beside it, it opens the extension's socket on 127.0.0.1.

Option	Default	Meaning
-p, --port <port>	9876	The port of the extension's socket. The extension connects only to 9876.

When the port is taken (for example by a running kadmo serve), it warns on stderr and serves MCP without a browser. Registration recipes for each client are on The MCP server.

kadmo status

kadmo status

Asks http://localhost:9876/health and prints whether the service runs, whether the browser is connected, and the service's version. It always asks port 9876, and it exits 0 whether or not a service answers, so read its output rather than its exit code.

  Server Status

  Server: Running
  Browser: Connected
  Version: 0.1.0

Workflows

kadmo list

kadmo list [--json]

Lists the workflows the runtime has, read from disk: ~/.kadmo/actions/, ~/.kadmo/workflows/ and every installed pack (one copy per workflow id among the packs, by layer). An id in ~/.kadmo/actions/ or ~/.kadmo/workflows/ that a pack also has is listed twice; the file of your own is the one that runs. It prints each workflow's id, title and parameter names. --json prints an array of id, title and params instead. It needs no running service.

kadmo run

kadmo run <workflow> [--param key=value ...] [-p <port>]

Starts a workflow on the running service. kadmo serve must be running; otherwise the command prints Server is not running. and exits 1.

Option	Default	Meaning
--param <params...>		Parameters, each as key=value; repeat the values after one --param or give --param again
-p, --port <port>	9876	The port of the running service

The command does not wait for the run: it prints Status: started and the run id, and exits 0. The run's steps and result are in the dashboard's run logs, or in the get_run_log MCP tool. A workflow with browser steps needs the extension connected; without it, this release prints Status: undefined, still exits 0, and starts nothing.

kadmo run read_heading --param url=https://example.com

Packs

kadmo install

kadmo install <source> [--force]
kadmo install agents [--force]
kadmo install --list

Installs a skill pack. <source> is tried in this order:

Source	Example	Installed at layer
A git URL (contains ://, starts with git@ or ends in .git)	kadmo install https://github.com/org/packs.git	account, or override when the pack's skill-pack.json says so
A local directory (starts with ., / or ~, or exists)	kadmo install ./my-pack	account, or override when the pack's skill-pack.json says so
A pack in one of your registries, by its exact domain, else its exact name	kadmo install app.example.com	account, or override when the pack's skill-pack.json says so
A pack in the public catalogue at catalogue_url, by domain	kadmo install app.example.com	library

A git repository is searched one level deep: every top-level directory with a skill-pack.json is installed. A repository whose root is itself the pack installs nothing (No skill packs found in the repository.); clone it and install the directory instead. When nothing matches, the command prints Pack not found: <source> and exits 1.

Option	Meaning
--force	Reinstall a pack already installed at the same layer, or install another version of it. A pack a higher layer holds is kept even with --force.
--list	List the installed packs: each one's domain, layer, name, version, title and install date, and the ops version beside an ops pack

Each install prints what it did: Installed, Updated, already installed (same version) or kept with the reason. Which copy wins is explained on The Kadmo runtime.

kadmo install agents is for an agent's machine. It asks the Kadmo app for the agent ops with the agent's token (KADMO_AGENT_TOKEN, else AGENT_TOKEN, else either one from ~/.agent-env), sending the stored ETag so an unchanged set answers at once. --force asks without the ETag. It exits 0 when the ops are current or refreshed, and 1 on a failure, for example no agent token on your own computer. The domain agents comes only from the app: a registry, git repository, directory or catalogue pack with that domain is refused.

kadmo uninstall

kadmo uninstall <domain>

Removes the installed pack of that domain from ~/.kadmo/skills/ and from the install record.

kadmo search

kadmo search [query]

Lists the packs your registries hold and the packs the public catalogue offers, matching the query against each pack's name, domain, title and description; without a query it lists all of them. A pack in a registry hides a catalogue pack of the same domain. Install one with kadmo install <domain>.

kadmo registry

A registry is a collection of packs: a directory on your computer or a git repository, with an index.json at its root. Adding one installs every pack it holds at the account layer; updating it reinstalls them.

kadmo registry add <url> [--name <name>] [--type local|git]
kadmo registry list
kadmo registry update [name]
kadmo registry remove <name>

Subcommand	What it does
add <url>	Adds a registry and installs its packs. A git URL is cloned (shallow) to ~/.kadmo/registries/<name>/; git must be installed. --name sets the registry's name (default: derived from the URL), --type forces local or git (default: detected).
list	Shows each registry with its type, URL, whether it is enabled, and its pack count
update [name]	Runs git pull in a git registry (a local one is read again) and reinstalls its packs with --force; without a name, every registry
remove <name>	Removes the registry, uninstalls the packs installed from it, and deletes its clone

Registries are stored in ~/.kadmo/settings.json.

Make a pack

How a pack is structured is on Creating packs. These commands scaffold, check and publish one.

kadmo init

kadmo init <domain>

Creates a directory named after the domain with skill-pack.json, a _skill.md template and _roles/qa.md. It refuses when the directory exists.

kadmo validate

kadmo validate [path]

Checks the pack in path (default: the current directory): skill-pack.json must exist with name, version and a valid domain, _skill.md must exist, and every YAML file must parse (errors, exit 1); a missing _roles/ directory is a warning.

kadmo login

kadmo login --token <token>

Stores a personal API token from the Kadmo app for kadmo publish. --token is required. The token is checked against the app at app_url first and then written, with the app's address, to ~/.kadmo/auth.json (readable only by you).

kadmo publish

kadmo publish [source] [--registry <dir>] [--dry-run]

Without --registry, publishes a pack to the Kadmo app at app_url. source is a pack directory, the domain of an installed pack, or a pack in one of your registries. The pack is validated first; publishing needs kadmo login for the same app, and the app answers 403 when your account does not own the domain.

With --registry <dir>, publishes into a local registry instead: it copies the pack into <dir>/<domain>/, regenerates the registry's index.json, and commits when <dir> is a git repository. With --registry and no source, it validates every pack in the registry and regenerates index.json.

Option	Meaning
--registry <dir>	Publish into this local registry directory instead of the app
--dry-run	Validate and print what would be published, without writing anything

Plugins

kadmo plugin

kadmo plugin list
kadmo plugin install <source>
kadmo plugin remove <name>

Subcommand	What it does
list	Lists the installed plugins with their version, description and tools
install <source>	Installs a plugin from a local directory into ~/.kadmo/plugins/<name>/
remove <name>	Removes an installed plugin

Plugins add MCP tools; restart kadmo serve and your MCP client to load a change. See Plugins and Creating a plugin.