Z Engine

Appearance

Glossary ​

Part of How Z Engine works. Short, plain-language definitions of the terms used on these pages, in alphabetical order. Each entry links to the section that explains the idea in full.

A ​

Agent ​

The model working in a loop with tools: it reads code, runs commands and edits files for you, then reports what it did. The agent you chat with is the main agent. See What an AI coding agent is.

API key ​

A secret string that lets Z Engine use your account at a provider. Keys are kept in auth.json in your config folder or read from environment variables, and each is sent only to its own host. See Providers and models.

Approval ​

A card that asks you before an action runs, with Allow once, Always allow… (in this chat or in this project) and Deny…. It appears in the composer, in place of the text box, when the permission check answers ask. See Permissions.

B ​

Background agent ​

A subagent started with run_in_background: true. It runs as a background job while the main agent keeps working, survives Esc, and sends a reminder when it finishes. See Background jobs.

C ​

Check ​

A project command that proves something about the code: a test, build, typecheck, lint or format run. Checks are found by reading build files or set in settings, and every run is recorded as evidence. See Verification.

Checkpoint ​

A snapshot of your project's files, taken before each of your messages and stored in a hidden git repository outside the project. Rewind uses it to put files back. See Checkpoints and rewind.

Command (protocol) ​

A typed request the app sends to the engine, such as submit (send a message), steer, resolveApproval or cancel. Commands go in and events come out. See z-engine-protocol.

Compaction ​

Replacing the older part of a long conversation with a summary so it fits the context window again. It happens automatically near the limit, or when you run /compact. See Compaction.

Context window ​

The most text, counted in tokens, that a model can read in one request: instructions, tool list and conversation together. Unknown models are assumed to have 128,000 tokens. See The context window.

Crate ​

A Rust package, the unit the code is split into. Z Engine has one crate per responsibility, such as z-engine-host for everything that touches the operating system. See Crates.

D ​

Decision model ​

A small, fast model on your computer (a server, a sidecar or the native runtime) that experimental decision features ask short questions. Its answer counts only when it is confident. See The decision layer.

Decision use ​

The code behind one decision feature: it asks the decision model at a seam and may act on a confident answer. This version has 21. See Decision uses.

E ​

Effort and thinking ​

Some models reason step by step before they answer; that reasoning is thinking, shown as a collapsible section. Effort (low, medium, high or max) sets how much thinking to ask for. See Providers and models.

Event ​

A typed message the engine sends to the app when something happens, such as textDelta, toolStarted or turnFinished. The window is drawn from events. See From events to a screen.

Experimental feature ​

A new feature that stays optional, and off unless you turn it on in Settings → Experimental, until it meets a measured bar and graduates. See Experimental features and graduation.

F ​

Fallback (decision) ​

When the decision model is unset, fails, is slow or is unsure, the feature does exactly what it does when Off. See The decision layer.

Fallback model ​

A backup model tried, in order, when a request to the main model still fails after retries and before any answer text arrived. They are listed in model.fallbacks. See Providers and models.

Feature flag ​

An experimental feature's mode in [experimental]: Off (the default), Shadow or On. See Experimental features and graduation.

Fingerprint ​

A short digest of the size and modification time of every project file. If it changed after a check ran, that check's evidence is stale. See Verification.

G ​

Graduation ​

An experimental feature that met its bar becomes Stable and always on; the next release removes the old behavior and its flag. See Experimental features and graduation.

H ​

Hook ​

Your own script that Z Engine runs at a fixed moment, such as before a tool runs (PreToolUse) or when the agent wants to stop (Stop). A hook can add context, block an action or send the agent back to work. See Hooks.

I ​

Inbox ​

The app's list of what happened while you looked elsewhere: what needs you in every chat, chats that finished in the background, and every notice in full. See The project home, the Inbox and first run.

Instruction file ​

A markdown file of standing instructions the agent reads in every chat: AGENTS.md and AGENTS.local.md in the project (CLAUDE.md and CLAUDE.local.md are read too), and your own AGENTS.md in the config folder. See Instruction files.

Island ​

The pill in the middle of the title bar: the pet and one line about what the agent is doing, which opens into a card with the details. While a chat needs you it offers Approve, Answer or Review. A ring beside it shows how full the context is. See The island and the pet.

L ​

Language server ​

A program that understands one programming language the way a code editor does: where things are defined, who uses them, what does not compile. Z Engine starts one when the agent works on a matching file. See Language servers.

LSP ​

Language Server Protocol, the standard way editors talk to language servers. It is also the name of the tool the agent uses to ask them questions. See Language servers.

M ​

MCP ​

Model Context Protocol, an open standard for plugging extra tools, data and prompts into AI apps. See MCP servers.

MCP server ​

A program, started locally or reached at a URL, that offers tools, resources and prompts over MCP. Its tools appear to the agent as mcp__<server>__<tool>. See MCP servers.

Merge-back ​

Bringing an isolated agent's changes from its worktree into your project. Apply tries a clean patch, then a three-way merge; Discard throws the changes away. See Worktree isolation and merge-back.

Model ​

The AI program that reads text and writes text, such as Claude or GPT. On its own it cannot open a file or run a command; the engine does that for it. See What an AI coding agent is.

N ​

Native runtime ​

Running the decision model inside the app instead of as a separate server, from files downloaded once in Settings and checked against pinned checksums (decisions.runtime = "native"). See Reaching the decision model.

P ​

Permission mode ​

The chat-wide setting for how much runs without asking: Ask, Auto-accept edits, Plan (read-only) or Bypass. See Permissions.

Pet ​

The small 3D creature in the title bar's island (named Zen unless you rename it; it replaced the older "companion" orb). It shows the agent's state as body language, may roam onto the composer, the sidebar and the side panel while nothing needs you (the island then shows a small portrait of it), and levels up as turns finish. See The desktop pet.

Prompt ​

Text given to a model to act on. Your message is a prompt, and so are the instructions the engine writes, which are kept as markdown files in one crate. See z-engine-prompts.

Prompt cache ​

The provider's short-term memory of the unchanged beginning of a request, so the next request can read it at a lower price instead of paying for it again. See Prompt caching.

Protocol ​

The shared dictionary of commands and events between the app and the engine, written once in Rust and generated as TypeScript for the window. See One dictionary for both languages.

Provider ​

The service that runs the model, such as Anthropic, OpenRouter, OpenAI or Ollama on your own computer. See Providers and models.

R ​

Repo map ​

A short table of contents of your code (the main functions and types, most important first) added to the system prompt so the agent knows where to look. See The repository map.

Rewind ​

Going back to the moment before one of your messages: the code, the conversation, or both, from Rewind at the end of that turn. See Checkpoints and rewind.

Round ​

One model response inside a turn, together with the tool calls it asks for and their results. A turn has one or more rounds. See Conversations, turns and rounds.

Rule ​

A pattern that allows, asks for or denies an action, such as Bash(npm test:*) or Read(./.env). Rules come from settings or from an approval's Always allow…. See Permissions.

Rule file ​

A markdown file under a rules/ folder with extra instructions for the agent. One with globs joins the context only once the agent works with a matching file. See Glob-scoped rules.

S ​

Sandbox ​

An operating-system fence around shell commands: they may write only in the project and a few safe folders, and can be kept off the network. It is off by default. See The sandbox.

Seam ​

One of the fixed points of a turn where a decision use may give advice, each with limits; at the tool gate it can only turn an allow into an ask. See Seams.

Session ​

One chat: its messages, turns, approvals and checks, stored in its own folder so it can be reopened and resumed. See Sessions and persistence.

Shadow mode ​

A feature flag setting where the feature runs and records what it would have done, but never changes a turn. See Seams.

Side panel ​

The panel beside the chat with four tabs: Changes (what changed in your files), Plan, Agents (helpers and background jobs) and Context (the last prompt sent to the model). It can be resized or cover the whole stage. See The side panel.

Sidecar ​

The decision model server Z Engine starts itself from decisions.sidecar.command, once for the whole app, and stops on quit. See Reaching the decision model.

Skill ​

A folder with a SKILL.md file of instructions for one kind of task. The agent sees a short list of skills and loads one with the Skill tool when it fits. See Slash commands, custom commands and skills.

Slash command ​

A command you type in the composer, starting with /, such as /compact or /model. Some are built in; custom ones are markdown files, and MCP prompts appear as /mcp__<server>__<prompt>. See Slash commands, custom commands and skills.

Steering ​

A message you type while the agent is still working. It does not wait for the turn to end: it reaches the model with the next tool results, so you can change course midway. See Steering, interrupt and cancel.

Stop boundary ​

The moment the model answers without asking for tools. Before the turn ends, Stop hooks, waiting steering messages and verification may send it back for another round. See Conversations, turns and rounds.

Subagent ​

A helper agent the main agent starts with the Agent tool for one job. It works with its own clean context and brings back a short report. See Subagents.

System prompt ​

The standing instructions at the start of every request: base rules, your environment, instruction files, the list of skills and the repo map. See One turn at a glance.

T ​

Task view ​

The working set a decision feature gives the model at a new task: earlier exchanges the task doesn't need are set aside, saved to files and listed in one index, while your transcript keeps everything. See Task-scoped history.

Token ​

The unit models read and charge by: a piece of text a few characters long (Z Engine estimates about four characters per token). Context windows and prices are counted in tokens. See The context window.

Tool ​

An action the engine offers the model, with a name and an input format, such as Read, Edit, Bash or Grep. The engine, not the model, carries it out. See Tools and tool batches.

Tool call ​

The part of a model's reply that asks for a tool to run with given input, for example Read on src/auth.ts. See Tools and tool batches.

Tool result ​

What goes back to the model after a tool call: the tool's output, or why it was denied, failed or cancelled. Every call gets exactly one result. See Tools and tool batches.

Transcript ​

The written record of a conversation: what you see in the chat, and the file that keeps each subagent's own conversation (agents/<id>.jsonl). See The transcript and tool cards.

Turn ​

Everything between your message and the agent's final answer, made of one or more rounds. It ends with an outcome, its cost and a verification badge. See Conversations, turns and rounds.

V ​

Verification badge ​

The verdict on a turn's receipt: Verified, Unverified, Failed or Not applicable (shown only in the detailed receipt view). It comes from recorded checks, never from what the model claims. See Verification.

W ​

Workspace trust ​

Your decision that a project folder may use its own settings, hooks, MCP servers and extensions in full. Until you trust it, the project can only make things stricter. See Settings layers and workspace trust.

Worktree ​

A second working copy of your git repository, in its own folder, where an isolated agent can change files without touching yours. See Worktree isolation and merge-back.

See also: How Z Engine works · Crates · User guide