CLI reference

Look up shell commands, their flags, and commands available inside chat.

Find a command

Help

jazz --help
jazz help
jazz help run
jazz run --help
jazz workflow --help
jazz workflow run --help

jazz --help and jazz help show global options and top-level commands. jazz help run and jazz run --help show run arguments and flags. For a nested command, use its full path followed by --help. Inside chat, /help lists chat commands and /help loop shows the forms of one command.

Global options

Available on every command.

jazz

With no arguments, opens the home screen. Choose an agent and type a message to start work. Use /new to start a fresh conversation, /create to create an agent, /agents to manage agents, /resume to continue a conversation, and /settings to configure providers, display, and limits.

The slash menu ranks command-name prefixes first, then substring matches. On home, /re offers /resume before /create; Enter runs the highlighted command.

Global options work here too: jazz --debug and jazz --data-dir ~/work open the same home. The home needs a terminal. Without one (stdin or stdout piped, cron, CI), or with --no-tui, it prints what to run instead and exits 2 without touching your configuration. On a terminal that is too limited for the full-screen interface (TERM=dumb, CI set, a screen reader via JAZZ_A11Y=1 or INK_SCREEN_READER=1, or a window under 32 columns by 10 rows), Jazz uses the classic inline interface, which prompts the same way.

jazz run: headless, one-shot

Runs one agent turn from a prompt. The answer goes to stdout; status messages and progress go to stderr.

jazz run --agent <id> [prompt]

The prompt comes from the positional argument, from an --input-stdin frame, or from piped stdin when neither is given and stdin is not a TTY. Only a positional or framed prompt may back a memory write; plain piped stdin is treated as untrusted text.

With --input-stdin, send the prompt as JSON on the first line. Subsequent lines are available for interactive replies.

--max-cost-usd and --max-tokens are soft checkpoints, checked between iterations. --max-duration-ms is a deadline: it interrupts the run wherever it is and still returns a result. Whatever stops a run, the agent gets one last request without tools to answer from what it gathered. See Configuration → run budgets for the enforcement model and how they differ from --timeout.

Exit codes: 0 on success; 1 on failure, including a run that finishes without a usable answer (an empty zero-token completion, a non-stop finish with no text, or a content-filtered answer); 2 when --park parks the run on an approval; 130 or 143 when SIGINT or SIGTERM stops it. In plain mode stdout is empty on failure and the message goes to stderr; in --json mode stdout always carries exactly one object, with a code on failures (failed, empty_response, no_answer, content_filtered, interrupted). A cut-off answer (truncated), an iteration limit (iterationLimited) and dropped tools (toolsDisabled) are flagged in the envelope and warned about on stderr. See Headless → JSON.

Full contract, examples, and a complete bridge implementation: Surfaces → Headless.

jazz agent

agent chat accepts --stream / --no-stream, --max-iterations <n>, --max-subagent-iterations <n>, and --ephemeral.

Without a terminal, agent chat reads messages from stdin, one per line, and ends when stdin does:

echo "What is on my calendar today?" | jazz agent chat assistant

Slash commands work the same way (/exit ends early). Tool calls that need approval are declined, since nobody can answer the prompt. If stdin ends before any message arrives, agent chat says so and exits 2. For one scripted turn with a parseable result, use jazz run.

agent create and agent edit need a terminal. Without one they exit 2 and point at the agent’s JSON file under $JAZZ_HOME/agents/, which you can write by hand (see Configure → Agents). persona create, persona edit, and workflow create behave the same way.

jazz workflow

add prints the whole WORKFLOW.md, frontmatter included, and asks before writing it: the frontmatter decides what the workflow may do unattended, so non-interactive runs must pass --yes. The catalog is cached under <jazz home>/cache/workflow-registry.json and keeps working offline; JAZZ_LIBRARY_URL points Jazz at a self-hosted library.

jazz workflow run flags

A workflow run that finishes without a usable answer (an empty zero-token completion, a non-stop finish with no text, or a content-filtered answer) is recorded as failed in jazz workflow history and exits 1, with the same code in its --json envelope as jazz run.

Several schedules for one workflow

A workflow is a definition; a schedule binds it to a cron. schedule <name> installs <name>/default from the frontmatter schedule: line. schedule <name> --cron "0 9 1 * *" --as monthly adds <name>/monthly beside it, so the same recap runs weekly and monthly. Each schedule keeps its own last-run marker, and the prompt can read {schedule.label}, {schedule.cron}, {schedule.lastRunAt}, and {run.startedAt}. See Workflows.

Frontmatter fields: Workflow frontmatter.

jazz mcp

See MCP configuration.

jazz hosts

To set up a server and move a conversation step by step, see Continue on your server.

The SSH target is a configured SSH alias. The remote workspace must exist and be writable. Pass --allow-file-secrets to hosts add for a server without an OS keyring (libsecret); without it, a handoff to such a server stops before anything moves. See Detach hosts for the host checks and credential scope.

jazz computer

Experimental. Commands for computer use: letting an agent look at and act in desktop apps you grant. It runs on macOS with Apple Silicon only, and these commands may change or break between releases.

Enabling computer tools authorizes their use. The first successful session pins the driver’s digest. If that build later changes, the agent offers in-chat approval for the new build. A missing driver can be installed through an in-chat computer_install_driver approval. See computer use.

grant and apps refuse to run inside a process a Jazz agent started, so an agent cannot give itself reach. doctor exits 0 when ready, 1 when something needs attention, and 2 when computer use cannot run here.

jazz detach

unknown means the host could not be reached; it does not mean the remote run stopped. For a parked tool approval, status shows the tool and its approval message before offering approve or reject. Other interactive input is reported as unsupported in this version. attach replays everything the remote run has done so far, then follows it live. When a turn finishes it prompts for your next message; when the run parks it asks to approve or reject. An empty answer or Ctrl+C leaves; the remote run keeps going, and attaching again picks up where you left off.

reclaim freezes the remote job so the host never runs it again, downloads its final state, applies the remote file changes to your working tree, and restores the conversation locally with the remote turns included. Continue it with /resume in chat. If a file changed both locally and remotely, nothing is written: commit or stash your edits and rerun, or pass --overwrite to let the remote version win. A reclaim that fails part way leaves the conversation fenced; rerunning it continues where it stopped.

pull downloads and verifies the completed result, then lists changed paths and conflicts with local changes, without touching the working tree.

In interactive chat, /detach <host> asks for a continuation instruction, previews the files and state to transfer, and asks for confirmation. When entered while the agent is busy, it runs after the current turn. A failure before remote ownership leaves the local chat available. Once transfer begins, the local chat closes if the remote run acknowledges the handoff or ownership cannot be resolved safely. Register and check hosts with jazz hosts first.

jazz runs

Inspect runs still in flight, including your own parked ones, and, once a daemon started one, runs begun from somewhere else entirely.

A run parks when it hits something needing your approval and nobody is there to give it: see Daemon for answering one from a different process than the one that started it. With a notify target the approval request reaches your phone, and a Telegram or Discord bridge can answer it with /approve <runId>.

jazz spend

What every run on this machine cost today and this month, from the machine-wide ledger under $JAZZ_HOME/spend, with a breakdown by source (chat, workflows, goals, loops, bots, …) and by agent, what unattended runs spent today, and where each daemon spend cap stands. --json emits { ok, day, month, today, thisMonth, caps, unreadableLines }. See Budgets.

jazz notify

Where results, reminders, parked approvals, failures and pauses reach you while you are away: the notify.targets list. See Notifications.

jazz daemon

Runs background goals and loops and accepts HTTP requests to start work, inspect runs, and answer parked approvals from another machine. It backgrounds itself by default; use --foreground under your own supervisor. jazz daemon install creates the systemd/launchd service for you.

A bearer token authenticates every route except /health on every bind, including loopback. On first start Jazz generates one, stores it in the OS keyring or its protected local fallback, and prints it once. A non-loopback daemon refuses to start if no token can be supplied or stored. When keyring storage is deliberately disabled, loopback alone may warn and continue without one. /peer/ask uses separate per-peer credentials; see jazz peers.

A request that grants authority (accepting or resuming a goal, starting or resuming a loop, approving or answering a parked run, and any write to an agent or persona) also needs the operator token in X-Jazz-Operator-Token. It lives only in the OS keyring, so an agent that read the daemon token from disk cannot use it to grant itself more. Without one the daemon grants nothing over HTTP, and the CLI on the machine decides instead. See Daemon.

Set $JAZZ_DAEMON_TOKEN yourself instead of letting Jazz generate one when the value needs to be known ahead of time: a client config written before the daemon has ever run, or an ephemeral container whose $JAZZ_HOME doesn’t survive to the next deploy.

See Setting up peers for a full walkthrough, and Agent-to-agent for the tier model this exists to serve.

A background daemon writes its output to $JAZZ_HOME/logs/daemon.log. Without an installed service, nothing restarts it after a reboot; jazz goal and jazz loop say so when they hand it work. See Running it persistently.

jazz wake-trigger fire --agent <agentId> --id <id> is internal plumbing, not something you run by hand: it’s what register_trigger schedules with launchd/at to fire a wake trigger without jazz daemon running. See Wake Triggers. jazz reminder fire and jazz job run are the same kind of plumbing for reminders and job batches.

jazz reminders, jazz triggers, jazz jobs

What agents have scheduled to happen later, across every agent unless --agent <id-or-name> narrows it.

--json prints one envelope: {"ok":true,"reminders":[…]}, {"ok":true,"triggers":[…]}, or {"ok":true,"batches":[…]}.

jazz goal

Goals are objectives Jazz keeps working toward across runs until verified evidence shows they are done. Each goal has a short name, like detach-to-prod, that every command accepts in place of its id. In chat, a goal you accept runs in the chat, asking its approvals there; see Goals in chat. From a shell, the daemon does the work: accepting or starting a goal launches jazz daemon in the background when none is serving this Jazz home.

jazz goal draft --agent assistant "Get every recipe into the new format until ./check.sh passes"
jazz goal start --agent assistant --yes --max-cycles 20 "…"
jazz goal list
jazz goal show <goal>
jazz goal accept <goal> --approval-policy low-risk   # start a proposed goal; work begins now
jazz goal decline <goal>
jazz goal approve <goal>             # allow the step it waits on
jazz goal reject <goal> [why]        # refuse that step; the reason goes to the agent
jazz goal answer <goal> <answer>     # answer its question
jazz goal pause <goal>
jazz goal resume <goal> [note]       # the note steers the next cycle
jazz goal cancel <goal>

--approval-policy on accept and start is what the goal may run while you are away without asking: read-only, low-risk, or high-risk (everything). Above it, a cycle waits for your approval. Without the flag nothing runs unasked, so every gated call waits for you. approve, reject, and answer run the rest of that cycle in the shell; the daemon carries on after. A Jazz agent cannot approve or answer a parked run itself.

draft prints the plan, or the questions it needs answered first, without creating anything. start drafts and, with --yes, starts the plan; without --yes it only shows it. --max-cycles caps the cycles (no limit by default). Each cycle is an ordinary run, held to the agent loop’s own limits (maxIterations, maxTokens, maxCostUSD, maxDurationMs in config); the goal adds no spend cap of its own. A read-only pass over the current directory informs the plan, as it would in chat; --no-inspect drafts from the request alone. With --json each command prints one JSON envelope. Exit codes: 0 done, 1 refused or failed, 2 the request needs answers before a plan.

Goals in chat

/goal <objective> starts working toward the objective right away, in the same conversation. Nothing is drafted or confirmed first, and the turns look like any other: the same streaming, approvals under the chat’s safe or yolo mode, and questions asked inline. When a turn ends, the next one starts on its own, with a ↻ Goal <name> · turn n line, until the agent reports the goal done. A done report is accepted only when it quotes the tool output that shows the objective holds; otherwise the goal goes on with the reason. If it stops for you (a question, a blocker), the chat asks right there and carries on with your answer.

Esc pauses the goal. Anything you type meanwhile goes first and the goal picks up after it. /goal shows where it stands, /goal pause, /goal resume [note], and /goal clear control it, and /goal help lists the rest, including approve, reject, and answer for a goal left waiting in the background. A conversation has one goal at a time; setting another offers to drop the current one.

Leaving a chat with a goal unfinished asks whether Jazz should finish it in the background, and what it may do there without asking: reading only, low-risk changes, or everything. It carries on in the same conversation, and anything above that authority waits for you. The next jazz then lists the conversation first under Resume conversation (N waiting for you), marked with what it waits on. In that picker, choose End · goal name to stop a waiting goal and keep the conversation history; choose the conversation itself to resume it. Reopening keeps the conversation’s original identity, so its goal controls remain available in chat.

jazz loop

A loop reruns a prompt for an agent on a schedule, on one conversation of its own, until it ends: “every 10 minutes, check whether the deploy finished and tell me”. Each loop has a short name, taken from --name or the start of its prompt, that every command accepts in place of its id. Loops run in the daemon, never in the terminal that started them: starting or resuming one launches jazz daemon in the background when none is serving this Jazz home.

jazz loop start --agent assistant --every 10m "Check whether the deploy finished and tell me"
jazz loop start --agent assistant --every "0 9 * * mon-fri" --until 2026-10-31 --name standup "Summarize yesterday's PRs"
jazz loop list
jazz loop show <loop>
jazz loop approve <loop>             # allow the step its run waits on
jazz loop reject <loop> [why]        # refuse that step; the reason goes to the agent
jazz loop answer <loop> <answer>     # answer its run's question
jazz loop pause <loop>
jazz loop resume <loop>              # a budget-limited loop gets one more default budget
jazz loop cancel <loop>

--every takes a duration (10m, 1h, 1h30m, at least a minute) or a five- or six-field cron expression. Six fields add seconds first: --every '*/10 * * * * *' schedules every ten seconds. Cron is read in --tz (default: this machine’s timezone). An interval loop runs right away; a cron loop waits for its first scheduled time. Runs missed while the daemon was down collapse into one, and a loop never overlaps itself, including while a run waits for an approval. Intervals are measured from the previous run’s completion. Actual starts depend on the daemon’s polling.

A loop ends when its run calls end_loop (it gets that tool, and only loop runs do), when it reaches --max-runs or --until, or when you cancel it. Three failed runs in a row stop it for you to look at; resume starts it again. Budget flags cover all runs together: --max-tokens, --max-minutes, and --max-cost-usd (enforced when pricing is known), and each run is held to the agent loop’s own limits like any run. A loop that hits one of its budgets is budget-limited until you resume it.

--approval-policy is what its runs may do without asking: read-only, low-risk, or high-risk (everything). Above it, the run waits; approve, reject, and answer finish that run in the shell, under what the loop’s budget has left. Pausing or canceling a loop whose run is waiting drops that run. A Jazz agent cannot start, resume, approve, or answer a loop. With --json each command prints one JSON envelope. Exit codes: 0 done, 1 refused or failed.

Loops in chat

/loop 10m <prompt> (or /loop every 10m <prompt>, or /loop cron 0 9 * * mon-fri <prompt>) starts a loop for the chat’s agent in its current directory, after asking what its runs may do without asking. /loop help lists the commands; they mirror jazz loop. Opening a conversation shows its loops that wait for you, and the next jazz counts them under Resume conversation.

10m means every ten minutes; 1h means every hour. /loop 10s is refused: chat intervals must be at least one minute, and chat cron takes exactly five fields. See the full loop syntax for interval units, cron fields, examples, and every chat control.

jazz imessage

Reach the agent from Messages. The bare command uses a hosted Photon line and can run on any supported host. --local instead uses the Apple account signed into a Mac (macOS 14+) and walks through installing imsg, granting Full Disk Access, and optionally installing a background service.

Who it answers is IMESSAGE_ALLOWED_HANDLES, deny-by-default; with nothing set, an interactive first run answers only you, via a jazz prefix in a chat with yourself. The background service’s environment is snapshotted into its plist at install time: see Reaching your agent from a chat app for changing it afterwards, and packages/imessage-bot/README.md for every variable.

jazz whatsapp

Reach the agent from WhatsApp. The bridge links to your account as a device, the way WhatsApp Web does, and runs in the foreground: there is no service installer.

The first run asks whose messages to answer and remembers it in wa-allowed.json; WHATSAPP_ALLOWED_NUMBERS skips the question and is required where there is no terminal to ask. Pairing is a QR code, or an 8-character code with WHATSAPP_PAIR_NUMBER on a headless machine, and happens once: credentials live in WHATSAPP_AUTH_DIR. See Reaching your agent from a chat app for the walkthrough and packages/whatsapp-bot/README.md for every variable.

jazz secrets

Secrets saved for every agent on this Jazz home. Values live in the OS keyring (or $JAZZ_HOME/secrets.json where there is none); names and descriptions live in $JAZZ_HOME/saved-secrets.json. Agents see the names with list_saved_secrets and load one into a run with use_saved_secret, which you approve every time unless the run was started with --dangerously-allow-reading-secrets. Every secret an agent asks for with ask_user_secret is saved here too, under the name the agent gives it. See Secrets the person types.

jazz peers

Other people’s agents this machine talks to, and what has been said to or by them.

Peers can be added by invite: jazz peers invite create/accept , or by editing ~/.jazz/config.json directly. See Setting up peers for both paths.

jazz peers invite

jazz persona

add prints the full system prompt and asks before writing it: a persona becomes an agent’s instructions, so non-interactive runs must pass --yes. The catalog is cached under <jazz home>/cache/persona-registry.json and keeps working offline; JAZZ_LIBRARY_URL points Jazz at a self-hosted library.

See Personas.

jazz skill

Marketplace skills are instruction-only. Installation prints the complete file, asks for confirmation, writes only SKILL.md, and never executes or imports the downloaded text. Non- interactive installs must pass --yes. The catalog is cached under <jazz home>/cache/skill-registry.json, works offline after a successful fetch, and uses JAZZ_LIBRARY_URL when you host a compatible library yourself.

Skills can influence an agent’s behavior but grant no tools, credentials, network access, or approval authority. Read the source for prompt injection or unsafe guidance before installing. See Skills.

jazz plugin

Every command below that takes <id> also accepts the owner/repo (or GitHub URL) you installed from — it resolves to the installed plugin. Trust and enable prompt for a plain yes/no confirmation.

Without --yes, trust and consent require a local interactive terminal, because a headless run cannot show the confirmation prompt; --yes is the consent itself and works from a script, a pipe, or CI. This includes explicit consent for a classify.command-risk policy hook: it may send bounded command text to its declared destination and its validated verdict can affect whether an eligible execute_command call needs approval. Static tool risks, allowlists, approval tiers, and the shell denylist remain enforced by Jazz. See Plugins.

jazz config

config validate also checks every agent file: one that cannot be read, or names a provider or reasoning level Jazz does not know, fails the check with exit code 1; a tool name no built-in provides is a warning, since an MCP server, plugin, or custom tool may supply it. config set refuses a key Jazz does not read, including an API key for a provider that does not exist (llm.opneai.api_key), and trims pasted keys. jazz config set <provider> with no value prompts for the key, so it never lands in your shell history, and checks it with the provider where there is a free endpoint to ask.

See Configuration.

jazz memory

Memory is shared by every agent, so these commands address scopes and paths directly.

Conversation history and current working state are separate. See Conversations, working state, and memory.

jazz webhook

Webhook definitions live in Jazz configuration. See Webhooks.

jazz update

Both exit 1 when the version check or the install fails, so a script can tell a failed update from “already up to date”.

Command-specific flags

The jazz run and jazz workflow run flag tables appear above. The following table lists the options for every other public command that accepts them. Commands without their own options still accept global options and -h, --help.

In-chat commands

Available inside an interactive session. /help lists them, then your skills, MCP prompts, and plugin commands in their own sections, then the keys of the interface you are in. /help <command> shows every form of one command. The table below is generated from the same list (bun run docs:chat-commands).

Configured peer tools are registered when chat starts, so /tools can list them before the first message. After editing an agent from another process, reload it with /switch <agent> to use the updated tool selection.

/new starts a fresh conversation with that agent. /create creates a new agent. Chat bridges have independent command contracts described in their surface guides.

/rename <title> sets the current conversation’s title, preserving internal whitespace and Unicode without an artificial length limit. Bare /rename edits the current title; Escape cancels. Naming a conversation before its first message saves it too. Later turns, resumes, and compaction preserve the title. Ephemeral sessions keep it only in memory. A conversation you never renamed starts out named after your first message, and each compaction renames it after what the conversation has become. Renaming never calls the model, and a save failure is reported without changing the title.

Only /exit (or /quit) ends the chat; exit or quit typed alone is sent to the agent as a message. A message that starts with a file path, which is what dragging a file into the terminal inserts (/Users/me/shot.png what is this?), is sent to the agent rather than read as a command. An unknown command stays in the composer so you can fix it, and Jazz suggests the closest command.

/model changes the model for the rest of this session on the agent’s own provider: /model opens a picker, /model <model-id> sets it directly. The agent file keeps its model; use jazz agent edit to change that for good. /reasoning works the same way for the reasoning level.

Mentioning files with @

Type @ to pick a file or folder under the current directory. A picked path with spaces is quoted for you (@"my notes.md"). When you send the message:

• An image, PDF, audio, or video file is attached, if the model accepts that kind of input.
• A text file of up to 256 KiB is read and sent along with your message, so the agent sees its contents.
• Anything else (a folder, a binary file, a larger file) is sent as its path only. Jazz says so for a binary or oversized file; the agent can still open it with its file tools.

Keyboard shortcuts

The fullscreen interface is the default on a capable terminal. The classic inline interface runs with JAZZ_FULLSCREEN=0, and on terminals the fullscreen one cannot use. The two bind different keys. In both, interrupting work takes a double Esc or one Ctrl+C.

Fullscreen:

Classic:

Sending a tool call to the background

Once a tool call has been running for 3 seconds, its row shows ctrl+b to background beside the elapsed time (ctrl+b to background all when several calls are running, since the key backgrounds all of them). Ctrl+B leaves the call running and lets the agent carry on: it is told the call is still going and that it will hear back. When the call finishes, the chat shows one line naming it, and the agent gets its result at its next step. If the chat is idle by then, the result starts a turn on its own, so you do not have to send a message to get the agent to read it.

Commands that answer right away

Commands that only show something open in a panel centered over the chat as soon as you press Enter, even while the agent is working: /info, /cost, /context, /help, /tools, /peers, /theme, and the plain forms of /mcp, /work, /memory and /waits. The agent keeps going behind the panel; Esc closes it, and Up and Down scroll a long one. Nothing in the panel is added to the conversation. Commands that change the conversation, the agent or a setting the agent reads (/compact, /model, /mcp reconnect, /memory forget, …) still wait in the queue for the current turn to end.

Watching and steering sub-agents

When the agent delegates with spawn_subagent, the turn’s sub-agents are listed under the composer with what each one is doing right now. With the composer empty, press Down to move into the list, Up and Down to pick one, and Enter to open it: the transcript is replaced by that sub-agent’s brief, reasoning, tool calls, and answer, and keeps updating while it works. Esc returns to the main conversation.

While a sub-agent is open, Enter sends your draft to it instead of to the main chat. The sub-agent reads it between tool calls, the same point where the main agent picks up queued messages, and treats it as guidance on its current task. If it finishes before reaching another tool call, Jazz says the message was not delivered. Finished sub-agents stay in the list until your next message. The agent can steer its sub-agents too: its messages appear in the sub-agent’s log as ↳ parent: …, and a pause shows as ⏸ Paused by the parent agent until it resumes. Companions started by analyze_media and generate_media are listed too, but take no messages: each makes a single model call with no tool calls to pause between.

With output.streaming.enabled: false, completed model responses and tool calls still appear in the sub-agent’s detail log. A message queued during the final tool batch stays marked undelivered when the child reaches its iteration or run budget before another model call.

Shell escapes

In the interactive terminal, type ! <command> when the agent asks you to run a command yourself. Jazz executes the command in the current session directory and sends its bounded stdout, stderr, and exit code to the agent as context for the next response:

> ! ssh user@test rm -r folder
> Did that remove the folder successfully?

The ! must be followed by a space (or tab). A message such as !!! call the bank today or !important is prose and goes to the agent. In the fullscreen interface, typing ! on an empty line inserts the ! and a space for you; typing a second ! straight away takes the space back.

The command is executed because you entered it explicitly; it does not wait for the model to call execute_command. The built-in shell denylist, sanitized environment, timeout, process interruption, and 256 KiB per-stream output cap still apply. Output is treated as command data, not as instructions. A non-zero exit code is still passed to the agent so it can explain or suggest the next step. ! is an interactive terminal feature and is not interpreted by jazz run, scheduled jobs, CI, or chat bridges.

Output modes

--output controls formatting; it does not change what goes to stdout vs stderr.

Math

LaTeX in a reply is shown as Unicode text in rendered and hybrid output: $x^2$, \(x^2\), $$…$$, \[…\], a math fence and bare align / equation blocks. Greek letters and operators become their glyphs, ^ and _ become super- and subscripts where Unicode has them (x², aᵢ, otherwise x^(a+b)), \frac becomes a/b, and matrices and cases become aligned rows. A command Jazz does not know is printed as typed. A lone $ stays a dollar sign, so costs $5 and $10 is untouched. In hybrid output, the default for plain terminal output, the delimiters ($, $$, \\() stay visible, dimmed, around the rendered formula, as ** does around bold text.

Set NO_COLOR to any non-empty value (see no-color.org) to turn colour off everywhere: the classic interface and plain output print no colour codes at all, and the fullscreen interface paints in its neutral greys, keeping bold and dim for emphasis.

Related

• Surfaces → Headless: the jazz run contract in depth
• Configuration: config file and environment variables
• Tools: every tool and its risk tier
• Workflow frontmatter: the WORKFLOW.md fields