Real isolation. Your keys never leave the box.

Mount the jurniti CLI as an MCP server so your own agent drives your fleet with the same verbs you use in the terminal. Complements the dashboard.

Give your agent the same commands

Human operators can stay on the dashboard. This page is for when your own agent should drive the fleet: provision, list, stop, capture, fork — under your account.

The jurniti binary is also an MCP stdio server. Mount it once and your agent — Claude Code, Codex, or anything that speaks MCP — gets the same operations as tools for fleet work (list, provision, fork, run, …). One vocabulary across CLI, REST, and MCP — not every CLI meta verb is an MCP tool (login, shell, keys, skills, upgrade, and docs stay CLI-only). This is the customer server (jurniti mcp), not the founder/operator MCP.

You need the CLI installed on the machine that hosts the MCP server (usually your laptop or CI runner). Discovery card (stdio, not a hosted Streamable HTTP endpoint): https://www.jurniti.com/.well-known/mcp.json. If you cannot spawn the binary, call the REST API instead (OpenAPI).

Mount it

claude mcp add jurniti -- jurniti mcp

That registers the CLI's built-in server (jurniti mcp) with your agent. From then on your agent can provision, list, inspect, stop, capture, and fork VMs by calling the same commands you would type.

Same verbs, now as tools

The verbs from the CLI reference are exposed as MCP tools, named for the object they act on: jurniti up is the vm_provision tool, jurniti vms ls is vms_list, jurniti run is vm_run, jurniti cp is vm_cp. Your agent authenticates as you (the API key on the machine), so it operates strictly within your tenant.

Discover and fork a public template

Tool	CLI equivalent	Notes
`templates_list`	`jurniti templates ls`	Optional args: `q`, `harness`, `sort`, `tag`, `limit`, `offset`. Paged — `total` is the whole matching catalog, so keep calling with `offset` = `next_offset` while `has_more` is true
`template_get`	`jurniti templates get`	`id` = template id (`tpl_…`) or public/owned slug
`template_fork`	`jurniti fork`	Charges the card on file — no free fork
`vm_get`	`jurniti vms get` / poll like `jurniti wait`	Use after fork until `running` / harness ready

Plan work and run agents

Tool	CLI equivalent	Does
`harnesses_list`	`jurniti harnesses`	which agent types are available
`vm_provision`	`jurniti up`	bring a new agent up (paid)
`vm_env_set` / `vm_env_list`	`jurniti env set` / `env ls`	BYOK / config in the box
`vm_run`	`jurniti run`	one headless task; wait for result
`vm_cp`	`jurniti cp`	copy a file out of the VM
`vms_list` / `vm_get`	`jurniti vms ls` / `vms get`	list / inspect your fleet
`vm_auth`	`jurniti auth`	how to sign a box in (BYOK or subscription)
`mcp_connections_list` / `mcp_connection_grant` / `mcp_connection_revoke`	`jurniti memory ls` / `grant` / `revoke`	attach hosted memory (or other MCP) to an agent — Memory
`observability_grants_list` / `observability_grant` / `observability_revoke`	`jurniti observability ls` / `grant` / `revoke`	attach a Latitude/Langfuse sidecar — Observability
`communication_relays_list` / `communication_grants_list` / `communication_grant` / `communication_revoke`	`jurniti communication ls` / `grants` / `grant` / `revoke`	list Buzz relays and grant/revoke agents — Communication

Full attach walkthroughs (dashboard + CLI + MCP): Memory · Observability · Communication.

vm_run takes optional model and provider, so a planner can route each agent to whichever model suits the task.

Lifecycle

Tool	CLI equivalent
`vm_stop` / `vm_start` / `vm_restart`	`jurniti stop` / `start` / `restart`
`vm_reprovision`	`jurniti reprovision` (rebuild guest, keep data)

Money, templates, and account (same gates as CLI)

Tool	CLI equivalent	Does
`billing_status`	`jurniti billing status`	card on file?
`credits_balance` / `credits_buy` / `credits_history` / `credits_refund`	`jurniti credits …`	prepaid credits
`template_capture` / `template_publish`	`jurniti capture` / `publish`	snapshot / gallery visibility
`whoami` / `usage`	`jurniti whoami` / `usage`	identity and fleet spend (VM counts / MRR)
`token_usage`	`jurniti token-usage`	advisory model-token meter (session\|week; BYOK est. — not a jurniti charge)
`vm_token_usage`	`jurniti token-usage --vm`	same meter scoped to one owned VM

usage and token_usage are different products: fleet/compute vs model tokens. Full guide (dashboard + CLI + MCP): Token usage.

Automations

automations_packs_list, automations_list, automations_enable, automations_patch, automations_remove, automations_run, automations_runs_list, automations_reviews_list, automations_review_done — same surface as jurniti automations … (packs, enable/pause, run now, history, review queue).

The full tool catalog is whatever jurniti mcp registers (locked by the CLI boundary tests). Prefer object-grouped names (templates_list, not a bare list).

Your agent inherits your gate

The MCP server runs under your identity and your card. Provisioning tools (vm_provision, template_fork) still start real, billed VMs — the same no-free-tier gate applies whether a human or your agent invokes them.

Scope it with API keys

Mint a read-only key (jurniti keys issue) for an agent that should only observe, or a read-write key for one that provisions. Rotate or revoke any key with jurniti keys rotate / jurniti keys revoke.

Demo / docs

Live terminal demos of CLI and dual-surface flows live in the repo under docs/assets/demos/ (for example swarm, multi-harness, and template discover paths). For dual-surface recordings, mount MCP in a real harness UI and show tool name + args + live results — do not fake the tool list with echo.

MCP

On this page