# KazoCode Docs > KazoCode is a free AI code editor for Windows, macOS and Linux with a coding agent built in, and an alternative to Cursor and Claude Code that works with Claude, GPT, Gemini and local models. These docs cover installing it, working with the agent, customizing it with instructions, skills, MCP servers and hooks, the editor, your account, and the SDK for building on KazoCode. # KazoCode documentation > Learn KazoCode, the desktop code editor with a built-in AI coding agent. Install it, work with the agent, customize it, and build on it with the SDK. KazoCode is a desktop code editor with an AI coding agent built in. The agent reads your project, edits files, runs commands in the terminal, browses the web and checks its own work, while you review every change in the editor you already use to write code. The agent sees exactly what you see. It works through the same file explorer, editor, terminal and browser tabs as you, so its changes land in your tabs, show up in Source Control, and can be undone one by one. ## Start here - [Quickstart](https://kazocode.app/docs/quickstart.md): open a project and give the agent its first task in a few minutes. - [Install KazoCode](https://kazocode.app/docs/install.md): system requirements and the first launch. - [Sign in and sync](https://kazocode.app/docs/account.md): connect your account to sync settings and shortcuts across computers. ## Work with the agent - [Chat and modes](https://kazocode.app/docs/agent/chat.md): Agent, Plan, Edit and Ask, and how to steer a running task. - [Adding context](https://kazocode.app/docs/agent/context.md): attach files, folders, code, docs, a selection or terminal output with `@`. - [Permissions](https://kazocode.app/docs/agent/permissions.md): decide what the agent may do without asking. - [Reviewing and undoing changes](https://kazocode.app/docs/agent/changes.md): keep or undo each change, or rewind the conversation. - [Models and providers](https://kazocode.app/docs/agent/models.md): use your own API keys or a local model. ## Make it yours - [Instructions and rules](https://kazocode.app/docs/customize/instructions.md): `KAZO.md`, `AGENTS.md` and rules scoped to parts of your project. - [Skills](https://kazocode.app/docs/customize/skills.md), [MCP servers](https://kazocode.app/docs/customize/mcp.md) and [hooks](https://kazocode.app/docs/customize/hooks.md) extend what the agent knows and can do. - [The SDK](https://kazocode.app/docs/sdk/overview.md) runs the same agent from Node and lets you write extensions, plugins and mods. ## Docs for AI tools Every page here is also plain Markdown. Add `.md` to any docs address, use **Copy page** at the top of a page to paste it into an AI chat, or point a tool at [llms.txt](/llms.txt) for the index and [llms-full.txt](/llms-full.txt) for every page in one file. Source: https://kazocode.app/docs --- # Quickstart > Open a project in KazoCode, choose a model, and have the AI agent make its first change, then review, keep or undo what it did. This guide takes you from a fresh install to a change made by the agent and reviewed by you. ## 1. Open a project Open KazoCode and choose **Open Folder** (`Ctrl+K Ctrl+O`), or **Clone Repository** (`Ctrl+Shift+K`) to clone one from Git. The explorer shows the folder, and the agent works inside it. ## 2. Choose a model The agent needs a model. Open **Settings › Models** (`Ctrl+,`) and add an API key for a provider such as Anthropic, OpenAI, Google or OpenRouter, or point KazoCode at a model running on your computer. See [Models and providers](https://kazocode.app/docs/agent/models.md). ## 3. Ask for something Open the chat with `Ctrl+Shift+I`, make sure the mode is **Agent**, and describe the task in plain words: ```text Add a --version flag to the CLI that prints the version from package.json, with a test. ``` The agent reads the files it needs, plans, edits, and runs commands such as your tests. Each file it changes appears in the chat as a change row. > [!TIP] > Mention exactly what you mean with `@`. Typing `@` opens **Add Context**, where you can attach files, folders, a piece of code, a selection or terminal output. See [Adding context](https://kazocode.app/docs/agent/context.md). ## 4. Approve what it needs When the agent wants to do something your [permission mode](https://kazocode.app/docs/agent/permissions.md) doesn't cover, such as running a command, KazoCode asks first. Approve once, approve for the session, or decline and say what to do instead. ## 5. Review the result Click a change row to open its diff. For each file you can **Keep** the change or **Undo** it, and **Undo All** reverts the whole reply. If the answer went the wrong way, edit your earlier message: the conversation rewinds to that point and the files go back to how they were. See [Reviewing and undoing changes](https://kazocode.app/docs/agent/changes.md). ## Next steps - Teach the agent your project's conventions with a [`KAZO.md` file](https://kazocode.app/docs/customize/instructions.md). - Plan bigger work first with [Plan mode](https://kazocode.app/docs/agent/chat.md#modes). - Run several tasks at once with [sub-agents and the Agent Workspace](https://kazocode.app/docs/agent/agents.md). Source: https://kazocode.app/docs/quickstart --- # Install KazoCode > Install the KazoCode desktop app on Windows, macOS or Linux, what it needs to run, and how updates reach you. KazoCode is a desktop app for Windows, macOS and Linux. It is built with Tauri, so it is small, starts fast and uses the system's own web view. ## Requirements | System | Needs | | --- | --- | | Windows | Windows 10 or 11 with Microsoft Edge WebView2, which Windows 11 already includes | | macOS | A recent version of macOS | | Linux | WebKitGTK, which most desktop distributions include | Some features use tools from your system when they're there: - **Git** for Source Control, Bugbot reviews and agent worktrees. - **The GitHub CLI** (`gh`) for pull request reviews and comments. - **Language servers** for code intelligence. KazoCode finds them for you and offers to install a missing one. See [Language features](https://kazocode.app/docs/editor/languages.md). - **SSH** for [remote projects](https://kazocode.app/docs/editor/remote.md). ## First launch 1. Run the installer for your system and open KazoCode. 2. Open a folder, or clone a repository. 3. Add a model in **Settings › Models**. See [Models and providers](https://kazocode.app/docs/agent/models.md). 4. Optionally [sign in](https://kazocode.app/docs/account.md) to sync your settings and keyboard shortcuts. ## Updates KazoCode checks for updates 15 seconds after it starts and every six hours after that. When a new version is out, **Update** appears in the status bar; click it to get the new version. ## Where KazoCode keeps things | What | Where | | --- | --- | | Your settings | `~/.kazocode/settings.json` | | Global instructions for the agent | `~/.kazocode/KAZO.md` | | Your skills, plugins and mods | `~/.kazocode/skills`, `~/.kazocode/plugins`, `~/.kazocode/mods` | | Settings for one project | `.kazo/settings.json` in the project | | Permission rules for one project | `.kazo/permissions.json` in the project | Source: https://kazocode.app/docs/install --- # Sign in and sync > Sign in to KazoCode from the desktop app to sync settings and keyboard shortcuts between computers, and manage the computers signed in to your account. You can use KazoCode without an account. Signing in adds settings sync, the [Usage](https://kazocode.app/docs/account/usage.md) page and [teams](https://kazocode.app/docs/account/teams.md). ## Sign in from the app 1. Open **Settings › General** and choose **Sign In**. 2. Your browser opens kazocode.app. Sign in with email and password, GitHub or Google, or create an account. 3. The browser hands you back to the app, which is now signed in. The app keeps its sign-in in your system's key store (Windows Credential Manager, macOS Keychain or the Secret Service on Linux), never in a plain file. ## What syncs When **Sync Settings and Shortcuts** is on, your settings and keyboard shortcuts follow you to every computer you sign in on. If you change the same setting on two computers before they sync, the change from the computer you're using wins, and settings changed only on the other one are kept. Settings that only make sense on one machine, such as folder paths and window layout, never sync. ## Manage your computers Every computer you sign in on is listed under **Computers** on kazocode.app and under **Settings › General** in the app, with when it was last active. Choose **Sign Out** next to one to sign it out; the next time it reaches the account server it is signed out for good. ## Your account on the web At [kazocode.app](https://kazocode.app) you can change your name and password, connect GitHub or Google for signing in, see which browsers are signed in, and delete your account. Deleting it signs out every computer and browser and removes your synced settings and usage history. Source: https://kazocode.app/docs/account --- # Chat and modes > Talk to the KazoCode agent in the chat panel. Pick Agent, Plan, Edit or Ask mode, stop or steer a running task, and rewind by editing a message. The chat panel is where you work with the agent. Open or hide it with `Ctrl+Shift+I`. Each chat is a conversation with its own history, so you can keep one per task and pick an earlier one up again with `/resume`. ## Modes Pick a mode from the menu under the message box. The mode decides what the agent is trying to do and which tools it is offered. | Mode | Use it to | What the agent does | | --- | --- | --- | | **Agent** | Describe what to build | Reads, edits, runs commands and checks its work until the task is done | | **Plan** | Break the work into steps first | Researches the code and writes a plan for you to review before anything changes | | **Edit** | Edit or refactor selected code | Focuses on the code you point it at | | **Ask** | Explore and understand your code | Answers questions and reads code without changing files | Plan mode is the safest way to start large changes: read the plan, ask for changes to it, and approve it when it's right. The agent then carries it out. ## Sending a message Type in the message box and press `Enter`. `Shift+Enter` adds a new line. Add files and other context with `@` (see [Adding context](https://kazocode.app/docs/agent/context.md)), or paste an image. Commands start with `/`; see [Slash commands](https://kazocode.app/docs/agent/commands.md). While the agent works, the chat shows what it is doing: the files it reads, the commands it runs, and each file it changes as a change row you can open as a diff. ## Stop and steer - **Stop** ends the current task. Changes already made stay in the chat, where you can keep or undo them. - `/stop` cancels every running agent, including [sub-agents](https://kazocode.app/docs/agent/agents.md). - To change direction, stop and send a new message, or edit an earlier one. ## Edit a message to rewind Editing one of your earlier messages rewinds the conversation to that point. Every later turn is removed and the files the agent changed after it go back to how they were, so you can try the request again a different way. ## Long conversations KazoCode keeps track of how much of the model's context window the conversation uses; `/context` shows it. When a conversation gets long it is summarized automatically so the agent can keep going, and `/compact` does that on demand. A summary always ends with your latest request word for word, so nothing you asked for is lost. ## Export a conversation `/export` saves the conversation as Markdown to a file or the clipboard, and `/rename` gives it a name you'll recognize later. Source: https://kazocode.app/docs/agent/chat --- # Adding context > Give the KazoCode agent the right context with @ mentions for files, folders, code, docs, a selection, open editors, terminal output and images, plus automatic codebase search. The agent can find most things itself, but pointing it at the right files makes it faster and more accurate. Type `@` in the message box to open **Add Context**. ## What you can add | Item | What it attaches | | --- | --- | | **Files…** | One or more files, searched by name | | **Folders…** | A folder, so the agent knows where to look | | **Code…** | Specific lines found with codebase search | | **Docs…** | Passages from a documentation site you've indexed | | **Selection** | The text selected in the editor | | **Open Editors** | The files open in your tabs | | **Terminal** | Recent output from a terminal | | **Image from Clipboard** | An image you copied, such as a screenshot | Attached items appear as chips above the message box. Remove one with its close button before you send. You can also drag files from the explorer into the chat, or paste an image directly. ## Codebase search KazoCode indexes your project so the agent can find code by meaning, not only by exact text. The index splits files at declarations and ranks matches with keyword search over identifiers; add an embedding model in **Settings › Agent** for semantic search on top of that. The most relevant code is added to each request automatically, and the agent can search the index itself whenever it needs to. To share embeddings with teammates who use the same embedding model, turn on sharing and the index is written to `.kazo/index/embeddings.json` in the project. ## Documentation sites Choose **Docs… › Add Docs...** and enter the address of a documentation site. KazoCode reads up to 80 pages under that address, splits them into passages and indexes them. After that, `@` › **Docs…** attaches the passages that match your message, and the agent can search the docs on its own. Manage your docs sources in **Settings › Agent**. ## Instructions and memory Some context is always there: your [instructions and rules](https://kazocode.app/docs/customize/instructions.md) (`KAZO.md`, `AGENTS.md` and others) and what the agent [remembers](https://kazocode.app/docs/customize/memory.md) about you and the project. You don't need to attach those. Source: https://kazocode.app/docs/agent/context --- # Permissions > Control what the KazoCode agent can do without asking. Choose a permission mode, save allow and deny rules, approve folders, and see which actions always ask. Every tool the agent uses has a risk level: **read**, **write**, **execute** (commands) or **network**. Reading inside your project never asks. For everything else, your permission mode and saved rules decide whether KazoCode asks you first. ## Permission modes Choose a mode from the menu under the message box. | Mode | What it does | | --- | --- | | **Default permissions** | Uses your saved rules and asks for anything they don't cover | | **Assisted permissions** | The current model reviews each tool call. Safe, reversible steps inside the project run without asking; anything else still asks you | | **Accept edits** | File changes in the project are approved automatically and stay undoable. Commands, web access and other actions still ask | | **Allow all** | Approves every tool call and retries on errors | | **Autopilot** | Approves every tool call and keeps going until the task is done. This can use more of your model budget | > [!WARNING] > **Allow all** and **Autopilot** run commands without asking. Use them in projects you trust, and keep the work in Git so you can review it afterwards. ## Approving a request When the agent asks, the prompt says exactly what it wants to do, such as the command it will run, and shows the diff for a file change. Choose **Allow** to let it run this once, or **Decline** (`Escape`) to say no. When KazoCode can tell what similar requests look like, a third button allows this one and stops asking for matching requests from now on, by saving a rule. After declining, send a message to tell the agent what to do instead. ## Saved rules Rules you save live in the project's `.kazo/permissions.json` (shared with anyone who uses the project) or in your user settings (just for you). A deny rule always wins over an allow rule. Use `/permissions` to list, remove or clear them. ## Actions that always ask Some actions ask no matter which mode you're in: - Deleting files and overwriting documents. - Destructive commands, such as `rm -rf`, `git reset --hard`, `git push --force`, `git clean`, `git branch -D` and their equivalents on Windows. - Working outside the project folder. Approve a folder once to let the agent work there. Deleted files go to the Recycle Bin or Trash when your system has one. ## Sandboxed commands `/sandbox` runs the agent's shell commands confined to the workspace, with or without network access, so even approved commands can't reach the rest of your computer. ## Audit log Every tool call the agent makes is written to an audit log, so you can see afterwards exactly what ran and what was approved. Source: https://kazocode.app/docs/agent/permissions --- # Reviewing and undoing changes > Review every file the KazoCode agent changes as a diff, keep or undo each change or the whole reply, and rewind a conversation with its files. Every file the agent creates, edits, moves or deletes is recorded, so nothing it does is final until you say so. ## Change rows Each change appears in the chat as a row under the reply that made it, with how many lines were added and removed. Click a row to open the diff in a tab, side by side or inline. On each row: - **Keep** accepts the change. - **Undo** puts the file back exactly as it was before the reply, covering every change that reply made to it. At the end of a reply, **Undo All** reverts every file the reply touched. A change is only marked undone once the file really is restored. ## Changes made by commands When the agent runs a command that writes files, such as a code generator or a formatter, KazoCode notices which files the command changed and adds them as change rows too. That includes background jobs, like a dev server or a watcher, for as long as they run. ## Rewind the conversation Edit one of your earlier messages to go back to that point. The later turns are removed and the files they changed are restored, then your edited message is sent. If a task is still running, KazoCode stops it and waits for it to finish before restoring anything. ## Changes from sub-agents [Sub-agents](https://kazocode.app/docs/agent/agents.md) record their changes the same way. When one finishes, its changes are handed to the reply that started it, so you review and undo them in one place. A sub-agent that works in its own Git worktree leaves its changes there instead, and tells you how to merge them. ## Source Control The agent's changes are ordinary changes to your files, so they also show up in [Source Control](https://kazocode.app/docs/editor/git.md), where you can stage them by file, hunk or line and commit them like your own. Source: https://kazocode.app/docs/agent/changes --- # Models and providers > Connect KazoCode to Anthropic, OpenAI, Google, xAI, Mistral, OpenRouter, dozens of other providers, or a local model with your own API keys. KazoCode works with the models you choose. Add a provider once in **Settings › Models** and its models appear in the model picker under the message box. `/model` shows which model a chat is using. ## Add a provider 1. Open **Settings › Models** (`Ctrl+,`). 2. Pick a provider and paste its API key. 3. Choose which of its models appear in the picker. API keys are stored in your system's key store, not in the settings file, and are sent only to the provider they belong to. Supported providers include **Anthropic**, **OpenAI**, **Google**, **xAI** and **Mistral**, gateways such as **OpenRouter**, **Vercel AI Gateway**, **LiteLLM Proxy**, **Cloudflare** and **Kilo Gateway**, and hosts such as **DeepSeek**, **Fireworks**, **Together AI**, **Cohere**, **SambaNova**, **Baseten**, **Z.ai** and many more. A provider's model list comes from the provider itself, so new models show up without an update. ## Local models Choose **Local runtime** to use a model running on your computer through any OpenAI-compatible server, such as Ollama (the default address is `http://127.0.0.1:11434/v1`) or LM Studio. No key is needed. Pick a model that supports tool calls, or the agent can only chat. ## Choosing a model - Large models plan and reason better on hard, multi-step work. - Small models are faster and cheaper for quick questions and small edits. - A model's context window limits how much of your project and conversation it can hold. `/context` shows how full it is. You can switch the model at any point in a conversation; the next message uses the new one. ## Costs When you use your own key, the provider bills you directly; KazoCode never adds a charge. `/cost` estimates the tokens and cost of the current conversation, and `/usage` reports tokens, cost, requests and tool calls per day and per model. Source: https://kazocode.app/docs/agent/models --- # Slash commands > Every KazoCode chat slash command, from /compact, /context and /remember to /ultrareview, /workflow and /autofix-pr, and how to add your own commands. Type `/` in the message box to see every command with a short description. `/help` lists them too. ## Conversation | Command | What it does | | --- | --- | | `/clear` | Start a fresh conversation in this chat | | `/compact` | Summarize the conversation to free context | | `/context` | Show how much of the context window is used | | `/resume` | Continue an earlier conversation | | `/rename` | Rename this conversation | | `/export` | Export the conversation as Markdown to a file or the clipboard | | `/stop` | Cancel every running agent and sub-agent | ## Agent and tools | Command | What it does | | --- | --- | | `/model` | Show the active model | | `/tools` | List the tools the agent can call | | `/agents` | List sub-agents and their results | | `/permissions` | List, remove or clear saved allow and deny rules | | `/sandbox` | Run shell commands confined to the workspace, with or without network | | `/output-style` | Choose how the agent writes: default, explanatory, learning or a custom style | ## Memory, skills and customization | Command | What it does | | --- | --- | | `/remember ` | Save a note to project or user memory | | `/memory` | Show memory and instruction files, or open one to edit | | `/skills` | List installed skills | | `/hooks` | List the hooks that run in this workspace | | `/mods` | List, reload or create mods that customize KazoCode | | `/prompt-audit` | Check instruction files, skills, agents and output styles for outdated prompting patterns | ## Deep work and review | Command | What it does | | --- | --- | | `/ultracode` | Deep coding: research, a plan you approve, implementation, independent verification, tests and review | | `/ultrareview` | A multi-agent review of the current changes, with every finding verified | | `/workflow` | Run, watch, resume or cancel multi-agent workflows (audit, migrate, port, test, security, or your own) | | `/autofix-pr` | Watch a pull request and fix failing CI and new review comments automatically | | `/install-github-app` | Set up GitHub Actions that answer mentions and review pull requests | ## Usage and diagnostics | Command | What it does | | --- | --- | | `/cost` | Show token usage and estimated cost for this conversation | | `/usage` | Report tokens, cost, requests and tool calls per day and per model | | `/stats` | Live performance and failures since KazoCode started | | `/telemetry` | Show telemetry settings, send a test export or open the telemetry folder | ## Connections and app | Command | What it does | | --- | --- | | `/browser` | Open the in-app browser | | `/chrome` | Connect KazoCode in Chrome, or make a new pairing code | | `/ide` | Connect to VS Code, Cursor or a JetBrains IDE, or disconnect | | `/channel` | Talk to KazoCode from Telegram, or send updates to Slack or Discord | | `/theme` | Switch between the dark, light and system color theme | | `/vim` | Turn Vim keybindings on or off in the editor and the chat box | ## Your own commands A Markdown file in a [plugin's](https://kazocode.app/docs/sdk/plugins.md) `commands/` folder becomes a command named after the file, so `commands/standup.md` adds `/standup`. Its text is the prompt the agent receives. [Skills](https://kazocode.app/docs/customize/skills.md) can be run as commands too, and [mods](https://kazocode.app/docs/sdk/plugins.md#mods) can register commands written in code. Source: https://kazocode.app/docs/agent/commands --- # Sub-agents and parallel work > Split big tasks across KazoCode sub-agents, run them in their own Git worktrees, and run several tasks side by side in the Agent Workspace. For large or parallel work, the agent can hand pieces of a task to **sub-agents**: separate agents with their own context that report back when they're done. You can also run several independent tasks at once in the **Agent Workspace**. ## Sub-agents The agent starts sub-agents on its own when a task splits naturally, for example researching three parts of a codebase at once, or you can ask for it: "use three agents to update each service". A sub-agent: - Starts with a fresh context, so the main conversation stays short. - Gets only the tools it needs. A research agent can read but not edit. - Follows the same [permissions](https://kazocode.app/docs/agent/permissions.md) and [hooks](https://kazocode.app/docs/customize/hooks.md) as the main agent. - Runs in the foreground, where the main agent waits for it, or in the background while the main agent keeps working. `/agents` lists every sub-agent in the chat with its result, and `/stop` stops all of them. ### Custom sub-agents Define your own specialists as Markdown files with frontmatter in `.kazocode/agents/` (one project) or `~/.kazocode/agents/` (every project). Claude Code agents in `.claude/agents/` load too. ```md title=".kazocode/agents/reviewer.md" --- name: reviewer description: Reviews a diff for bugs and missing tests. Use after making changes. tools: read_file, search_text, git_diff --- You review code changes. Report concrete bugs with file and line, and missing tests. Don't comment on style. ``` ## Isolated worktrees A sub-agent can work in its own Git worktree, so several agents edit the same repository without colliding. The worktree is created under `~/.kazocode/worktrees/` on a new branch named `kazo/`. When the agent finishes without changes, the worktree and branch are removed; otherwise the result says where they are and how to merge them. ## Agent Workspace The Agent Workspace (`Ctrl+Alt+A`) runs one agent per task, side by side in lanes. Pick a repository, describe the task, and each agent works in its own worktree by default. For each lane you can follow progress, send a follow-up, stop it, open the changed files as diffs, and **Merge** the work when it's ready. ## Workflows `/workflow` runs multi-agent workflows: an audit, a migration, a port, a test pass, a security review, or one you define in `.kazo/workflows/`. A workflow splits the work across agents, tracks each step, and can be watched, resumed or cancelled. Source: https://kazocode.app/docs/agent/agents --- # Instructions and rules > Tell the KazoCode agent how your project works with KAZO.md, AGENTS.md or CLAUDE.md, personal instructions, imports, and rules that apply only to matching files. Instruction files tell the agent what it can't learn from the code: how to build and test, the conventions you follow, and what to avoid. KazoCode reads them at the start of every conversation. See and edit them in **Settings › Rules & Memories**, or with `/memory`. ## Where instructions come from | Scope | File | Use it for | | --- | --- | --- | | Organization | Set up by your administrator | Policies for everyone on the computer | | You | `~/.kazocode/KAZO.md` | Your preferences in every project | | Project | `KAZO.md`, `AGENTS.md` or `CLAUDE.md` at the project root, or `.kazo/KAZO.md` | Conventions shared with your team; commit it | | Parent folders | `KAZO.md`, `AGENTS.md` or `CLAUDE.md` in folders above the project | Shared rules for a monorepo or a group of projects | | Subfolders | `KAZO.md`, `AGENTS.md` or `CLAUDE.md` inside the project | Read when the agent works on files in that folder | | Private | `KAZO.local.md` or `CLAUDE.local.md` | Notes just for you; add it to `.gitignore` | Because KazoCode reads `AGENTS.md` and `CLAUDE.md`, a project already set up for other coding agents works in KazoCode without changes. ## Writing good instructions Keep them short and specific. The agent follows concrete rules far better than general advice. ```md title="KAZO.md" # Acme API - Package manager is pnpm. Run `pnpm test` before finishing a change. - Routes live in `src/routes/`, one file per resource, validated with Zod. - Never edit files in `generated/`; run `pnpm codegen` instead. - Commit messages are in the imperative: "Add rate limiting", not "Added". ``` ## Importing other files Write `@path/to/file` to pull another file into the instructions, for example `@docs/architecture.md` or `@~/.kazocode/style.md`. Imports can nest up to five levels deep. ## Rules for parts of a project Put rule files in `.kazo/rules/` (or `.claude/rules/`). A rule without frontmatter always applies. Add `paths` to apply a rule only when the agent works on matching files: ```md title=".kazo/rules/migrations.md" --- paths: - "db/migrations/**" --- Migrations are append-only. Never edit a migration that has been merged; add a new one instead. ``` ## Output styles An output style changes how the agent writes, not what it knows. Choose one with `/output-style`: the default, **Explanatory** (explains its choices as it works), **Learning** (leaves small pieces for you to write), or your own style in `.kazo/output-styles/` or `~/.kazocode/output-styles/`. Source: https://kazocode.app/docs/customize/instructions --- # Memory > How the KazoCode agent remembers your preferences, corrections and project decisions across conversations, and how to add, edit and remove memories. Memory lets the agent carry what it learns from one conversation to the next: your preferences, corrections you've made, and decisions about the project that aren't written down anywhere in the code. ## What gets remembered The agent saves a memory when you correct it, state a preference, or confirm an approach that wasn't obvious. Each memory has a type: | Type | Example | | --- | --- | | **user** | "Prefers small commits with tests in the same commit." | | **feedback** | "Don't add code comments unless they're needed. Why: the team reads the code, not the comments." | | **project** | "The billing rewrite ships on March 3; don't touch `billing/` until then." | | **reference** | "Bugs are tracked in the Platform board on Linear." | It deliberately doesn't save what the repository already says, such as code structure, file paths or Git history, and it checks that a remembered file or function still exists before relying on it. ## Scopes - **User** memories follow you into every project. - **Project** memories apply only to the current project. ## Managing memories - `/remember ` saves a note yourself, for example `/remember the staging database is read-only`. - `/memory` lists memories and instruction files and opens one to edit. - **Settings › Rules & Memories** shows everything the agent remembers about you and the project; edit or delete any of it there. When a memory turns out to be wrong, the agent updates or removes it rather than keeping a contradiction. > [!NOTE] > Memory is for facts that change how the agent should work. Project conventions everyone should follow belong in a [`KAZO.md` file](https://kazocode.app/docs/customize/instructions.md), where your team can read and review them. Source: https://kazocode.app/docs/customize/memory --- # Skills > Teach the KazoCode agent repeatable know-how with skills, folders with a SKILL.md file that load only when a task needs them. Compatible with Claude Code skills. A skill is a folder of instructions, and optionally scripts and reference files, that teaches the agent how to do one kind of task: release a version, write a migration, follow your design system. Only each skill's name and description sit in the agent's context; the full instructions load when a task calls for them, so you can install many skills without slowing anything down. ## Create a skill Make a folder with a `SKILL.md` file: ```md title=".kazocode/skills/release/SKILL.md" --- name: release description: Cut a release. Use when asked to publish, release or tag a new version. --- 1. Make sure the working tree is clean and `pnpm test` passes. 2. Bump the version in package.json following semver. 3. Update CHANGELOG.md with the changes since the last tag. 4. Commit as "Release vX.Y.Z", tag it, and push the tag. ``` The `description` is what the agent uses to decide when a skill applies, so say both what it does and when to use it. Files next to `SKILL.md`, such as templates or scripts, can be referenced from it; the agent reads them when it follows the skill. ## Where skills are found | Folder | Scope | | --- | --- | | `.kazocode/skills/`, `.claude/skills/` or `.agents/skills/` in the project | This project; commit them for your team | | `~/.kazocode/skills/`, `~/.claude/skills/` or `~/.agents/skills/` | Every project, just for you | | Plugins | Every project where the plugin is on | | An organization folder set by your administrator | Everyone on the computer | Claude Code skills work as they are. ## Using skills The agent picks a skill when your request matches its description. You can also run one directly as a slash command by its name, such as `/release`. `/skills` lists every installed skill. Source: https://kazocode.app/docs/customize/skills --- # MCP servers > Connect the KazoCode agent to tools and data with Model Context Protocol (MCP) servers, configured for you or for a project in .mcp.json. The [Model Context Protocol](https://modelcontextprotocol.io) (MCP) is an open standard for giving AI agents tools and data. An MCP server can let the agent query a database, read issues from your tracker, or control a design tool. KazoCode supports local servers that run as a command and remote servers reached over HTTP. ## Add a server Browse, add and turn servers on or off in the **MCP** tab of the Extensions view (`Ctrl+Shift+X`). Servers you add there are yours, in every project. For a project, list servers in a `.mcp.json` file at its root, which you can commit so everyone on the project gets the same servers. ```json title=".mcp.json" { "mcpServers": { "postgres": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/dev"] }, "linear": { "url": "https://mcp.linear.app/mcp" } } } ``` | Field | For | | --- | --- | | `command`, `args` | A local server started as a program | | `env` | Environment variables for a local server | | `cwd` | The folder a local server starts in | | `url` | A remote server | | `headers` | Headers sent to a remote server, such as an API key | | `disabled` | Keep a server configured but off | The same file works in Claude Code, so an existing `.mcp.json` needs no changes. > [!IMPORTANT] > Servers in a project's `.mcp.json` run programs on your computer. The first time you open a project that has one, KazoCode asks before starting them, and asks again if the set of servers changes. ## Sign in to a server Remote servers that need an account show a sign-in prompt the first time the agent uses them. Once you've signed in, the agent can use the server's tools like any other. ## What the agent gets Each server's tools appear next to KazoCode's own and follow the same [permissions](https://kazocode.app/docs/agent/permissions.md). Servers can also offer resources (data the agent can read) and prompts. Ask the agent which servers are connected, or open the **MCP** tab in the Extensions view to see each server's state, scope and tools. ## Scopes | Scope | Where it's configured | | --- | --- | | User | The **MCP** tab in the Extensions view, for every project | | Project | `.mcp.json` or `.kazocode/mcp.json` in the project | | Organization | A managed file set by your administrator | | Plugin | Added by an enabled [plugin](https://kazocode.app/docs/sdk/plugins.md) | Source: https://kazocode.app/docs/customize/mcp --- # Hooks > Run your own commands, HTTP calls, prompts or agents at fixed points of a KazoCode agent session, to block tool calls, add context, format code or send notifications. Hooks run your own logic at fixed points in a session, every time, without relying on the model to remember. Use them to block risky commands, format files after each edit, add context to every prompt, or notify you when a task finishes. ## Where hooks live | File | Scope | | --- | --- | | `~/.kazocode/hooks.json` | You, in every project | | `.kazo/hooks.json` | This project. KazoCode asks you to trust a project's hooks before running them | | A plugin's `hooks/hooks.json` | Wherever the plugin is on | `/hooks` lists every hook that runs in the current workspace. ## Example Block force pushes, and format TypeScript after every edit: ```json title=".kazo/hooks.json" { "hooks": { "PreToolUse": [ { "matcher": "shell", "hooks": [{ "type": "command", "command": "node .kazo/check-push.js" }] } ], "PostToolUse": [ { "matcher": "edit_file|write_file", "hooks": [{ "type": "command", "command": "pnpm prettier --write ." }] } ] } } ``` This is the same layout Claude Code uses, and Claude Code tool names in a `matcher` also match KazoCode's tools. ## Events | Event | Runs | | --- | --- | | `SessionStart` | When a conversation starts | | `UserPromptSubmit` | When you send a message, before the agent sees it | | `PreToolUse` | Before a tool runs; can block it or change its input | | `PermissionRequest` | When the agent asks for approval; can allow or deny | | `PostToolUse` | After a tool succeeds | | `PostToolUseFailure` | After a tool fails | | `Notification` | When KazoCode would notify you | | `SubagentStart`, `SubagentStop` | When a sub-agent starts or finishes | | `Stop` | When the agent finishes its reply | | `TaskCompleted`, `TeammateIdle` | When a task in a team finishes or a teammate is idle | | `PreCompact` | Before a conversation is summarized | | `WorktreeCreate`, `WorktreeRemove` | When an agent worktree is made or removed | | `ConfigChange` | When settings, rules or servers change | `matcher` is a tool name, a `|`-separated list, or a regular expression. Leave it out to match everything. ## Hook types | `type` | Runs | | --- | --- | | `command` | A shell command. The event arrives as JSON on standard input | | `http` | A POST of the event to a `url`, with optional `headers` | | `prompt` | A prompt for a model, which judges the event | | `agent` | A sub-agent that checks the event with tools | ## What a hook can do A command hook answers with its exit code and output: - **Exit 0**: carry on. For `UserPromptSubmit` and `SessionStart`, plain output is added as context for the agent. - **Exit 2**: block. The action is stopped and the hook's error output tells the agent why; for `PreToolUse` the tool call is denied. - **Other exit codes**: the hook failed. The session carries on and the failure is noted. For finer control, print JSON: `{"continue": false, "stopReason": "…"}` stops the turn, and `systemMessage` adds a message for the agent. Source: https://kazocode.app/docs/customize/hooks --- # Editing basics > Find your way around the KazoCode editor. Open files and folders, use quick open and the command palette, split editors, search and replace across a project, and set per-project settings. KazoCode's editor works the way you expect if you've used VS Code: an explorer on the left, tabs in the middle, a panel for the terminal below, and the agent's chat beside them. ## Moving around | To | Press | | --- | --- | | Run any command | `Ctrl+Shift+P` | | Open a file by name | `Ctrl+P` | | Go to a symbol in the file | `Ctrl+Shift+O` | | Go to a symbol in the project | `Ctrl+T` | | Go to a line | `Ctrl+G` | | Open a recent folder | `Ctrl+R` | | Go back or forward | `Alt+Left`, `Alt+Right` | See every shortcut in [Keyboard shortcuts](https://kazocode.app/docs/editor/shortcuts.md), or change them in **Settings › Keyboard Shortcuts**. ## Files and tabs - A single click in the explorer opens a **preview tab** (in italics) that the next file replaces; a double click, or editing it, keeps it open. - Split the editor with `Ctrl+\` and move tabs between groups with `Ctrl+Alt+Left` and `Ctrl+Alt+Right`. - `Ctrl+Shift+T` reopens the tab you just closed. - Unsaved changes are kept as a draft while you type, so they survive a crash or a dropped remote connection. The explorer has a filter box, a button to show or hide hidden files, and dims files ignored by Git. Hide more with `files.exclude`, which takes the same patterns as VS Code (`*.min.js`, `build/`, `src/**/*.test.ts`). ## Editing - Multiple cursors: `Ctrl+Alt+Up` and `Ctrl+Alt+Down` add a cursor above or below. - `Shift+Alt+Right` and `Shift+Alt+Left` grow and shrink the selection. - `Shift+Alt+F` formats the document; turn on **Format on Save** to do it on every save. - Snippets and Emmet abbreviations appear as completions; add your own snippets in `snippets.json` (VS Code format) or `.kazo/snippets.json`. - `Ctrl+Shift+V` shows a live Markdown preview with an outline. ## Search across the project `Ctrl+Shift+F` searches every file, with regular expressions, whole-word and case options, include and exclude patterns, and replace (with `$1` groups for regular expressions). **Open in Multi-Buffer** gathers every match into one editable view. ## Projects and windows - `Ctrl+Shift+N` opens a new window. - Each folder remembers its open tabs and expanded folders, so switching projects puts you back where you were. - **View: Save Layout** saves where the sidebar, chat and panel sit, to apply again later. ## Per-project settings Settings in `.kazo/settings.json` apply only to that project and win over your own settings. Pin a setting to the project from **Settings** with its pin button. Language-specific settings, such as a different tab size for Python, go in a `[python]` section. Source: https://kazocode.app/docs/editor/basics --- # Tab predictions > KazoCode predicts your next edit as you type, around the cursor and further down the file. Press Tab to accept, jump to the next edit, or take one word at a time. Tab predictions suggest the edit you're about to make. After a short pause in typing, KazoCode sends the lines around the cursor, your recent edits and the files this one imports to a model, which rewrites the region the way it expects you to continue. ## Using suggestions - A suggestion on the cursor's line appears as faded **ghost text**. Press `Tab` to accept it. - An edit elsewhere in the file shows a **Tab to line N** hint. Press `Tab` to jump there, then `Tab` again to accept. - `Ctrl+Right` accepts one word at a time. - `Escape` dismisses the suggestion. Predictions learn from you: suggestions you dismiss aren't offered again, and if you dismiss many, KazoCode waits longer before suggesting. ## Settings Find these in **Settings › Editor › Tab**: | Setting | What it does | | --- | --- | | **Tab Predictions** (`editor.tabPredictions`) | Turns predictions on or off | | **Tab Model** (`editor.tabModel`) | The model that makes predictions. A small, fast model works best | Predictions use a model you've added in [Models and providers](https://kazocode.app/docs/agent/models.md), billed by that provider. Source: https://kazocode.app/docs/editor/tab --- # Language features > Code intelligence in KazoCode through language servers - completions, hover, go to definition, references, rename, code actions, formatting and diagnostics, plus an interactive REPL. KazoCode speaks the Language Server Protocol, so it gets completions, errors and refactoring from the same language servers other editors use. It finds the right server for each file type and, when one is missing, offers to install it. ## What you get | Feature | How | | --- | --- | | Completions with documentation | As you type | | Hover information | Point at a symbol | | Signature help | Inside a call's parentheses | | Go to definition, implementations | `F12`, `Ctrl+F12` | | Find all references | `Shift+F12` | | Rename a symbol everywhere | `F2` | | Code actions and quick fixes | `Ctrl+.`, `Ctrl+Shift+.` | | Format the document | `Shift+Alt+F` | | Next and previous problem | `F8`, `Shift+F8` | | Next and previous warning | `F9`, `Shift+F9` | Errors and warnings show in the gutter, inline under the code, and in the **Problems** view (`Ctrl+Shift+M`). ## Language servers Run **Language Servers...** from the command palette to see which servers are ready, and **Install Missing Language Servers...** to install the rest; KazoCode asks before running each install command. Configure a server for one project in `.kazo/lsp.json`. ## Per-language settings Override editor settings for one language with a `[language]` section in your settings, for example a tab size of 4 and format on save for Python only. `tabSize`, `insertSpaces`, `rulers`, `wordWrap`, `formatOnSave` and `detectIndentation` can be set per language. Map other file names to a language with `files.associations`, such as `*.foo=rust`. ## Interactive REPL Run code without leaving the editor. The REPL keeps one running session per language, for Python, TypeScript (Deno), JavaScript (Node), R, Julia and shell. | To run | Press | | --- | --- | | The selection, or the current line | `Ctrl+Enter` | | The cell around the cursor (cells start with `# %%`) | `Ctrl+Alt+Enter` | | The whole file | `Ctrl+Shift+Enter` | The output appears in the REPL panel and under the line that ran. Open the panel with **Run: Open REPL**. Source: https://kazocode.app/docs/editor/languages --- # Source Control and Bugbot > Use Git in KazoCode - stage files, hunks or single lines, commit, read history and blame, resolve conflicts - and have Bugbot review your changes and pull requests for bugs. The Source Control view (`Ctrl+Shift+G`) shows your branch, how far ahead or behind it is, and every staged, unstaged, untracked and conflicted file. ## Stage and commit - Stage a whole file, a single hunk, or individual lines. Open a file's changes to see each hunk with stage buttons and a checkbox per line. - Write a message and press `Ctrl+Enter` to commit. - **Discard Changes** restores tracked files and moves untracked ones to the trash. Changed lines are marked in the editor's gutter. Jump between them with `Alt+F3` and `Shift+Alt+F3`. Changed files are colored in the explorer too. ## History and blame The **History** list shows recent commits; open one to see its full diff. **Git: Show File History** and **Git: Show File Blame** show who changed the current file and when. ## Merge conflicts Conflicted files appear under **Merge Changes**. Jump between conflicts with **Go to Next Merge Conflict**, and resolve each with your version, theirs, or by editing. You can also ask the agent to resolve them. ## Bugbot Bugbot is a reviewer agent that reads your changes and reports likely bugs, each tied to a file and line. Open it from the Source Control view to review: - your uncommitted changes, - your branch compared with the default branch, or - a pull request. Findings on a pull request are posted as one GitHub review with inline comments on the changed lines (this needs the GitHub CLI, `gh`; GitLab works through `glab`). Bugbot can run before every push (`bugbot.beforePush`), and can review your open pull requests automatically every 10 minutes (`bugbot.autoReview`). Source: https://kazocode.app/docs/editor/git --- # Terminal > Use the integrated terminal in KazoCode, see what the agent runs, follow background jobs like dev servers, and change the terminal's font, cursor and behavior. The terminal panel runs your system's shell inside KazoCode. Toggle it with `` Ctrl+` `` and open another terminal with `` Ctrl+Shift+` ``. ## The agent and the terminal When the agent runs a command, it uses a real terminal session in the project, so you can watch it and read the full output. Long-running commands, such as a dev server or a test watcher, run as **background jobs**: the agent starts them, reads their output while it works, and stops them when it's done. Files a command changes are recorded as [change rows](https://kazocode.app/docs/agent/changes.md), so you can undo what a script or a code generator did. To give the agent the output of one of your own terminals, type `@` in the chat and choose **Terminal**. ## Settings Find these in **Settings › Terminal**: | Setting | What it does | | --- | --- | | Font family, size and line height | How text looks | | Cursor style and blinking | The cursor's shape and whether it blinks | | Scrollback | How many lines are kept | | Copy on select | Copies text as soon as you select it | Font size and scrollback apply right away without restarting the shell. Source: https://kazocode.app/docs/editor/terminal --- # Browser and Design Mode > Preview your app in KazoCode's built-in browser, let the agent test pages, and point at elements with Design Mode to tell the agent exactly what to change. KazoCode has a browser built in, so you can run your app next to its code and the agent can test it the way a person would. Open it with `/browser` or from the browser button. ## What the agent can do With the browser, the agent can open pages, click, type into and submit forms, wait for content, read what's on the page and take screenshots, then fix what it finds. Ask for it in plain words: "open localhost:3000, sign up with a test account and check the welcome email link works". Each workspace has its own browser profile, so being signed in to a site in one project doesn't leak into another. ## Design Mode Design Mode lets you show the agent what you mean instead of describing it. 1. Turn on **Design Mode** with the inspect button in the browser bar. 2. Hover to highlight elements, click to pick one, or drag to pick an area. `ArrowUp` and `ArrowDown` move to the parent or child element. 3. Add a note to each pick, such as "make this button match the header". 4. Send the picks to the chat, or attach them as context to your next message. Each pick carries a screenshot of the element, its place in the page and, for React and Vue apps, the component and source file it comes from, so the agent knows exactly which code to change. ## Your own Chrome To let the agent work in a Chrome profile, use `/chrome` to connect the KazoCode extension in Chrome or make a new pairing code. Source: https://kazocode.app/docs/editor/browser --- # Remote development over SSH > Open a project on another machine over SSH in KazoCode. The explorer, editor, search, terminal, language servers and the agent all work on the remote files. KazoCode can open a project that lives on another machine, such as a cloud server or a workstation, over SSH. Everything works on the remote files: the explorer, the editor, search, quick open, the terminal, language servers and the agent. ## Connect 1. Run **Connect to Host...** (`Ctrl+Shift+Alt+C`). 2. Enter the host and folder as `user@host:/path/to/project`. 3. KazoCode connects and opens the folder. A remote badge in the status bar shows which host you're on. A remote project's address looks like `ssh://user@host:22/path/to/project`. Remote projects appear in your recent folders, so switching between them is the same as switching local folders. > [!NOTE] > KazoCode signs in with your SSH keys, using your normal SSH configuration. Password sign-in isn't supported, so make sure `ssh user@host` works from a terminal without a password prompt first. ## How it works - File reads and writes, the file tree and search run as commands on the host over SSH. - The terminal opens a login shell on the host in the project folder. - Language servers run on the host, so code intelligence uses the host's toolchain. KazoCode checks that each server is installed there first. - **Run Command on Host** runs a one-off command; background jobs such as a dev server run there too. While you type, unsaved changes are kept on your computer as drafts, so a dropped connection doesn't lose your work. Reopening the file restores the draft. **Disconnect Remote** closes the connection. Source: https://kazocode.app/docs/editor/remote --- # Voice input > Dictate messages to the KazoCode agent. Speech is turned into text in real time on your computer with local Whisper, or with OpenAI, Mistral or Windows speech recognition. Talk to the agent instead of typing. Click the microphone next to the send button, speak, and your words appear in the message box as you talk. ## Local Whisper When you haven't added an OpenAI or Mistral key, speech is recognized on your computer with Whisper, so your voice never leaves it and it works offline. The Whisper model isn't part of the KazoCode download. The first time you use the microphone, KazoCode asks whether to download it and shows the progress. Nothing is downloaded until you agree. While you speak, the phrase so far is transcribed about every 0.6 seconds, so words appear almost as you say them; a pause settles the phrase. ## Choosing the engine With an OpenAI or Mistral API key in [Models and providers](https://kazocode.app/docs/agent/models.md), KazoCode uses that provider's speech recognition. Without one, it uses the engine you choose in **Settings › General › Voice Input**: | Engine | Where speech is recognized | | --- | --- | | **Local Whisper** | On your computer (the default) | | **Windows Speech** | By Windows' built-in speech recognition | Source: https://kazocode.app/docs/editor/voice --- # Keyboard shortcuts > The default KazoCode keyboard shortcuts for files, navigation, editing, the agent, Source Control and the REPL, and how to change them. Open **Settings › Keyboard Shortcuts** (`Ctrl+K Ctrl+S`) to see every shortcut, search them, and set your own. Shortcuts sync between computers when you're [signed in](https://kazocode.app/docs/account.md). On macOS, use `Cmd` where this page says `Ctrl`. ## General | Action | Shortcut | | --- | --- | | Show all commands | `Ctrl+Shift+P` | | Open settings | `Ctrl+,` | | Toggle the agent panel | `Ctrl+Shift+I` | | Open the Agent Workspace | `Ctrl+Alt+A` | | Toggle the sidebar | `Ctrl+B` | | Toggle the panel | `Ctrl+J` | | Toggle the terminal | `` Ctrl+` `` | | New terminal | `` Ctrl+Shift+` `` | | New window | `Ctrl+Shift+N` | | Full screen | `F11` | | Zoom in, out, reset | `Ctrl+=`, `Ctrl+-`, `Ctrl+Numpad0` | ## Files | Action | Shortcut | | --- | --- | | Go to file | `Ctrl+P` | | Open file | `Ctrl+O` | | Open folder | `Ctrl+K Ctrl+O` | | Open recent folder | `Ctrl+R` | | Clone repository | `Ctrl+Shift+K` | | New file | `Ctrl+N` | | Save, save all | `Ctrl+S`, `Ctrl+Shift+S` | | Close editor, close all | `Ctrl+W`, `Ctrl+K Ctrl+W` | | Reopen closed editor | `Ctrl+Shift+T` | | Next, previous editor | `Ctrl+Tab`, `Ctrl+Shift+Tab` | | Split editor | `Ctrl+\` | | Reveal file in explorer | `Ctrl+K E` | ## Navigation | Action | Shortcut | | --- | --- | | Go to symbol in file | `Ctrl+Shift+O` | | Go to symbol in project | `Ctrl+T` | | Go to line | `Ctrl+G` | | Go to definition | `F12` or `Ctrl`+click | | Go to implementations | `Ctrl+F12` | | Find all references | `Shift+F12` | | Go back, forward | `Alt+Left`, `Alt+Right` | | Go to bracket | `Ctrl+Shift+\` | | Next, previous problem | `F8`, `Shift+F8` | | Next, previous change | `Alt+F3`, `Shift+Alt+F3` | ## Editing | Action | Shortcut | | --- | --- | | Find, replace | `Ctrl+F`, `Ctrl+H` | | Search the project | `Ctrl+Shift+F` | | Add cursor above, below | `Ctrl+Alt+Up`, `Ctrl+Alt+Down` | | Select next occurrence | `Ctrl+D` | | Expand, shrink selection | `Shift+Alt+Right`, `Shift+Alt+Left` | | Rename symbol | `F2` | | Code actions, quick fix | `Ctrl+.`, `Ctrl+Shift+.` | | Format document | `Shift+Alt+F` | | Toggle word wrap | `Alt+Z` | | Fold all, unfold all | `Ctrl+K Ctrl+0`, `Ctrl+K Ctrl+J` | | Markdown preview | `Ctrl+Shift+V` | ## Views | Action | Shortcut | | --- | --- | | Explorer | `Ctrl+Shift+E` | | Search | `Ctrl+Shift+F` | | Source Control | `Ctrl+Shift+G` | | Extensions | `Ctrl+Shift+X` | | Problems | `Ctrl+Shift+M` | | Output | `Ctrl+Shift+U` | ## REPL and remote | Action | Shortcut | | --- | --- | | Run selection or line | `Ctrl+Enter` | | Run cell | `Ctrl+Alt+Enter` | | Run file | `Ctrl+Shift+Enter` | | Connect to host | `Ctrl+Shift+Alt+C` | ## Tab predictions | Action | Shortcut | | --- | --- | | Accept, or jump to the next edit | `Tab` | | Accept one word | `Ctrl+Right` | | Dismiss | `Escape` | Source: https://kazocode.app/docs/editor/shortcuts --- # Usage and limits > How KazoCode measures model usage, the 5-hour window and weekly limit, and where to see your spend by day, model and app on kazocode.app. KazoCode models share one usage pool across every KazoCode app. The **Usage** page on [kazocode.app](https://kazocode.app/usage) shows how much of it you've used. > [!NOTE] > Limits apply only to KazoCode models. Models you use with your own API key or a local runtime never count toward them; those providers bill you directly. ## How usage is measured Each request to a KazoCode model is priced from the tokens it uses at that model's rates, so a large model uses more of your limit than a small one, and long, multi-step agent work uses more than a short question. Cached input costs less than fresh input, and that saving counts in your favor. ## Two limits 1. **A 5-hour window.** The window opens with your first request and closes five hours later. The next request after that opens a new window. 2. **A weekly limit.** A rolling seven days of usage, so steady daily use fits comfortably. The Overview page on kazocode.app shows the current window as a ring, and both limits as bars with when each one resets. ## The Usage page | Section | Shows | | --- | --- | | **Spend** | Daily spend over the last 7 or 30 days | | **Breakdown** | Spend by model and by app (desktop, CLI, mobile, chat), and a table of models with their tokens and cost | | **Requests** | Every recent request with its time, model, app, tokens and cost | Every number on the page is the number that counts toward your limits. ## In the app For conversations that use your own keys, `/cost` estimates the current conversation and `/usage` reports tokens, cost, requests and tool calls per day and per model on your computer. Source: https://kazocode.app/docs/account/usage --- # Teams > Create a KazoCode team, invite people by email as members or admins, change roles, and manage or delete the team from kazocode.app. A team groups KazoCode accounts so they can share a plan and its usage. Everyone keeps their own account, computers and settings. Manage teams on the **Members** page at [kazocode.app](https://kazocode.app/members). ## Create a team On **Members**, enter a team name and choose **Create Team**. You become its owner. You can belong to several teams; switch between them with the team menu at the top of the page. ## Invite people 1. Choose **Invite**. 2. Enter their email and pick a role. 3. Choose **Send Invitation**. They get an email with a link to join. If they don't have an account yet, they can create one from the link and land back on the invitation. Pending invitations are listed under **Invitations**, where you can cancel them. ## Roles | Role | Can | | --- | --- | | **Owner** | Everything, including deleting the team | | **Admin** | Invite and remove people, and change their roles | | **Member** | Use the team's plan and see who's in the team | Owners and admins can change a member's role or remove them from the member list. Anyone other than the owner can leave a team. ## Delete a team The owner can delete a team under **Delete Team**: press and hold the button to confirm. This removes the team, its members and its invitations. Everyone keeps their own account. Source: https://kazocode.app/docs/account/teams --- # Agent SDK > Run the KazoCode coding agent from Node with @kazocode/sdk - in scripts, CI and your own apps - with file, search, shell and web tools, permission modes and custom tools. `@kazocode/sdk` runs KazoCode's coding agent from Node, with the same file, search, shell and web tools, permission modes and `KAZO.md` instructions as the editor. Use it in scripts, CI jobs, bots or your own apps. The same package has the APIs for [extensions](https://kazocode.app/docs/sdk/extensions.md), [plugins and mods](https://kazocode.app/docs/sdk/plugins.md), and the [`kazocode-sdk` command](https://kazocode.app/docs/sdk/cli.md). It needs Node 22 or later and has no runtime dependencies. ```sh npm install @kazocode/sdk ``` ## Run the agent ```ts import { query, anthropic } from "@kazocode/sdk"; for await (const event of query({ prompt: "Find why the date parser fails on leap years and fix it", provider: anthropic(), // reads ANTHROPIC_API_KEY model: "claude-opus-5-5", cwd: "./my-project", permissionMode: "acceptEdits", })) { if (event.type === "text") process.stdout.write(event.text); if (event.type === "tool_use") console.log(`\n→ ${event.name}`, event.input); if (event.type === "result") console.log(`\nDone in ${event.turns} turns`); } ``` `query` starts a fresh conversation. For several messages in one conversation, use `Agent`: ```ts import { Agent, openai } from "@kazocode/sdk"; const agent = new Agent({ provider: openai(), model: "gpt-5", cwd: process.cwd() }); const { text } = await agent.run("What does src/server.ts do?"); await agent.run("Add a /health route to it"); const resumed = new Agent({ provider: openai(), model: "gpt-5" }, agent.messages); ``` Save `agent.messages` and pass them back later to continue a conversation. Pass an `AbortSignal` as `signal` to stop a run. ## Events | Event | When | | --- | --- | | `text` | A piece of the answer as it streams | | `assistant` | A whole model turn: its text and tool calls | | `tool_use` | The agent calls a tool | | `tool_result` | The tool's output (`isError` when it failed or was refused) | | `usage` | Tokens used by one model turn | | `result` | The final answer, total tokens, number of turns and why it stopped (`end`, `max_turns`, `aborted`, …) | | `error` | The provider failed (bad key, network, rate limit) | ## Providers | Function | Model API | | --- | --- | | `anthropic({ apiKey?, baseUrl? })` | Claude through the Messages API. Reads `ANTHROPIC_API_KEY` by default | | `openai({ apiKey?, baseUrl?, headers? })` | Any OpenAI-compatible Chat Completions API. Reads `OPENAI_API_KEY` by default | | `openrouter()`, `groq()` | Those services, reading `OPENROUTER_API_KEY` and `GROQ_API_KEY` | | `ollama({ baseUrl? })` | A local Ollama server. Use a model with tool support | A provider is any object with a `complete(request)` method, so you can wrap another API yourself. ## Permissions | `permissionMode` | Reads | Edits | Commands and network | | --- | --- | --- | --- | | `default` | run | ask | ask | | `acceptEdits` | run | run | ask | | `plan` | run | refused | refused | | `bypassPermissions` | run | run | run | "Ask" calls your `canUseTool` callback. Without one, the call is refused and the agent is told why. ```ts new Agent({ provider: anthropic(), model: "claude-opus-5-5", canUseTool: async ({ name, input }) => { if (name === "bash" && String(input.command).startsWith("npm test")) return true; return { behavior: "deny", message: "Only npm test is allowed here." }; }, }); ``` Tools can't read or write outside `cwd` unless you set `allowOutsideCwd: true`. `onToolCall` runs before every call and can block it (`{ block: "reason" }`) or change its input (`{ input }`); `onToolResult` sees every result. ## Tools The agent gets `read_file`, `write_file`, `edit_file`, `list_files`, `grep`, `bash` and `web_fetch`. Add your own with `defineTool`: ```ts import { Agent, anthropic, defaultTools, defineTool } from "@kazocode/sdk"; const ticket = defineTool<{ id: string }>({ name: "get_ticket", description: "Reads a ticket from our tracker", risk: "network", parameters: { type: "object", properties: { id: { type: "string" } }, required: ["id"] }, async run({ id }) { const response = await fetch(`https://tracker.example.com/api/tickets/${id}`); return await response.text(); }, }); new Agent({ provider: anthropic(), model: "claude-opus-5-5", tools: [...defaultTools(), ticket] }); ``` A tool returns a string, or `{ output, isError: true }` to tell the agent it failed. Thrown errors become failed results too. ## Instructions Like the editor, the agent reads `~/.kazocode/KAZO.md`, then `KAZO.md`, `AGENTS.md` or `CLAUDE.md` in the project and its parent folders, and `KAZO.local.md`. Set `instructions: false` to skip them, `systemPrompt` to replace KazoCode's prompt, or `appendSystemPrompt` to add to it. Source: https://kazocode.app/docs/sdk/overview --- # Extensions > Write a KazoCode extension in TypeScript - register commands, read and write workspace files, show messages, add languages - then test it locally and publish it to the marketplace. An extension is a folder with a `package.json` and a script whose `activate(context)` function runs inside KazoCode. Types come from `@kazocode/sdk/extension`, the same ones KazoCode itself uses. ## Create one ```sh npx kazocode-sdk new extension word-count --publisher acme ``` ```ts title="src/extension.ts" import type { ExtensionContext } from "@kazocode/sdk/extension"; export function activate(kazo: ExtensionContext) { kazo.commands.register("acme.word-count.count", async () => { const text = await kazo.workspace.readFile(kazo.workspace.resolve("README.md")); kazo.window.showInformationMessage(`README has ${text.split(/\s+/).length} words`); }); } ``` ## The manifest ```json title="package.json" { "id": "acme.word-count", "name": "word-count", "publisher": "acme", "displayName": "Word Count", "version": "0.1.0", "main": "dist/extension.js", "contributes": { "commands": [{ "command": "acme.word-count.count", "title": "Count Words in README" }], "languages": [{ "id": "toml", "extensions": ["toml"], "module": "dist/toml.js" }] } } ``` `id` is `publisher.name` in lower case and `version` is a semantic version. ## What the context offers | Member | For | | --- | --- | | `commands` | Register commands for the command palette and shortcuts | | `workspace` | Resolve paths, and read, write and list files in the open project | | `window` | Show information, warning and error messages | | `languages` | Register a CodeMirror language for file extensions | | `log` | Write to the Output panel | | `subscriptions` | Things to clean up when the extension is turned off | See `ExtensionContext` in `@kazocode/sdk/extension` for every member. ## Try it locally Build the extension, copy the folder to `~/.kazocode/extensions/.`, and reload KazoCode. ## Publish Check the extension the way the marketplace will: ```sh npx kazocode-sdk validate ./word-count ``` The marketplace reads GitHub repositories. Put `.kazocode/marketplace.json` at the root of a repository, listing your extension folders: ```json title=".kazocode/marketplace.json" { "name": "Acme Tools", "owner": { "name": "Acme" }, "plugins": [{ "source": "./extensions/word-count" }] } ``` `npx kazocode-sdk new marketplace acme-tools --publisher acme` creates one for you. Commit your built `dist` files, push, and add the repository as a source in KazoCode's Extensions view. An extension can have at most 300 text files, 512 KB each and 4 MB in total. Source: https://kazocode.app/docs/sdk/extensions --- # Plugins and mods > Bundle skills, slash commands, sub-agents, hooks, MCP and language servers into a KazoCode plugin compatible with Claude Code, or change how KazoCode behaves with a mod. ## Plugins A plugin bundles the things that customize the agent: [skills](https://kazocode.app/docs/customize/skills.md), slash commands, [sub-agents](https://kazocode.app/docs/agent/agents.md), [hooks](https://kazocode.app/docs/customize/hooks.md), [MCP servers](https://kazocode.app/docs/customize/mcp.md) and language servers. Plugins use the Claude Code plugin layout, so one plugin works in both. ```sh npx kazocode-sdk new plugin review-kit ``` ```text review-kit/ .claude-plugin/plugin.json skills/review-kit/SKILL.md skills the agent can use commands/hello.md /hello in the chat agents/review-kit-reviewer.md a sub-agent hooks/hooks.json commands that run on agent events .mcp.json MCP servers .lsp.json language servers ``` `@kazocode/sdk/plugin` has types for every file: `PluginManifest`, `HooksFile` (with every `HookEvent`), `McpFile`, and the frontmatter of skills, agents and commands. Install a plugin by copying it to `~/.kazocode/plugins/`, or from the Extensions view. ## Mods A mod is a single file that changes how KazoCode itself behaves: block certain tool calls, add a chat command, or show something in the status bar. Put it in `.kazo/mods/` for one project or `~/.kazocode/mods/` for every project. ```ts title=".kazo/mods/guard.ts" import { defineMod } from "@kazocode/sdk/mod"; export default defineMod((kazo) => { kazo.onToolCall((call) => { if (call.tool === "bash" && /git push --force/.test(String(call.input.command))) return { block: "No force pushes." }; }); kazo.commands.register("standup", "Summarize today's commits", async (_args, say) => say("…")); kazo.statusBar.set("oncall", "On call"); }); ``` KazoCode asks before running a mod, and asks again whenever its file changes. `/mods` lists, reloads or creates mods. ## Plugin, mod or extension? | You want to | Use | | --- | --- | | Teach the agent a workflow, add commands, agents, hooks or MCP servers | A plugin | | Change KazoCode's own behavior with a few lines of code | A mod | | Add editor features: commands, languages, UI messages | An [extension](https://kazocode.app/docs/sdk/extensions.md) | Source: https://kazocode.app/docs/sdk/plugins --- # The kazocode-sdk command > Use the kazocode-sdk command to scaffold extensions, plugins, mods and marketplaces, validate an add-on against the marketplace rules, and run the KazoCode agent from a terminal. `kazocode-sdk` comes with [`@kazocode/sdk`](https://kazocode.app/docs/sdk/overview.md). Run it with `npx kazocode-sdk`, or install the package globally. ## Commands ```sh npx kazocode-sdk new [--publisher ] [--dir ] npx kazocode-sdk validate [folder] npx kazocode-sdk run "fix the failing test" [--provider anthropic|openai|openrouter|groq|ollama] [--model ] [--mode acceptEdits] ``` ### new Starts an add-on from a template. | Template | Creates | | --- | --- | | `extension` | A TypeScript [extension](https://kazocode.app/docs/sdk/extensions.md) with a command | | `plugin` | A [plugin](https://kazocode.app/docs/sdk/plugins.md) with a skill, a command, a sub-agent and hooks | | `mod` | A [mod](https://kazocode.app/docs/sdk/plugins.md#mods) file | | `marketplace` | A repository layout with `.kazocode/marketplace.json` | ### validate Checks an add-on with the marketplace's rules: `id` is `publisher.name` in lower case, `version` is semantic, the main script exists, and there are at most 300 text files, 512 KB each and 4 MB in total. ### run Runs the agent in the current folder and streams its answer to the terminal. In the `default` permission mode it asks before each edit or command. The provider reads its usual API key variable, such as `ANTHROPIC_API_KEY` or `OPENAI_API_KEY`. ```sh ANTHROPIC_API_KEY=sk-ant-… npx kazocode-sdk run "add input validation to the signup form" --mode acceptEdits ``` Source: https://kazocode.app/docs/sdk/cli --- # Terms of Service > The agreement between you and KazoCode for the desktop app, the CLI, the SDK, kazocode.app accounts, KazoCode models and the marketplace. **Effective November 20, 2026** These Terms of Service ("Terms") are a binding agreement between you and [company] ("KazoCode", "we", "us"), [address]. They cover the KazoCode desktop app, the KazoCode CLI, the `@kazocode/sdk` package, your account on kazocode.app, KazoCode-hosted models, the extension and plugin marketplace, and this website (together, the "Services"). By creating an account, installing or using the Services, you agree to these Terms, the [Privacy Policy](https://kazocode.app/docs/legal/privacy.md) and the [Acceptable Use Policy](https://kazocode.app/docs/legal/acceptable-use.md). If you use the Services for an organization, you agree on its behalf and confirm you have the authority to do so, and "you" includes that organization. If you don't agree, don't use the Services. ## 1. Who can use KazoCode You must be at least 18, or the age of majority where you live, to create an account. If you're between 13 and that age, you may use the Services only with the consent of a parent or guardian who agrees to these Terms for you. The Services are not for anyone under 13. You can't use the Services if you're barred from receiving them under the laws of your country, or if you're on a government list of restricted or sanctioned parties. ## 2. Your account - Give accurate information when you sign up and keep it current. - Keep your password and signed-in devices secure. You're responsible for what happens under your account. - Tell us at security@kazocode.app right away if you think someone else has access to it. You can sign out any device from the **Computers** page on kazocode.app. - One account is for one person. Teams share a plan through [team membership](https://kazocode.app/docs/account/teams.md), not shared logins. ## 3. The software we license to you The KazoCode desktop app and CLI are licensed, not sold. While you follow these Terms, we grant you a personal, worldwide, non-exclusive, non-transferable, revocable license to install and use them on devices you own or control, for personal or commercial work. You may not: - copy, modify, distribute, sell or sublicense the apps, except as open-source licenses allow; - reverse engineer, decompile or disassemble them, except where the law allows it despite this restriction; - remove or change any proprietary notices; - get around usage limits, license checks or security measures. Parts of KazoCode are open-source software under their own licenses. The `@kazocode/sdk` package is under the MIT License. Where an open-source license gives you more rights than these Terms, the open-source license governs that component. We may update the apps automatically to fix bugs, close security holes or add features. Some features may stop working on versions we no longer support. ## 4. Your content "Your Content" is everything you bring to or create with the Services: your code, files, prompts, chats, instructions, memory, settings and the output the agent produces for you. **You own Your Content.** We don't claim any ownership of it. As between you and us, you own the output the agent generates for you, to the extent the law allows it to be owned. You give us a limited license to host, copy, transmit and process Your Content only as needed to run the Services for you, for example to sync your settings between your devices or to send a prompt to a KazoCode model and return its answer. This license ends when the content is deleted from our systems. **We don't train AI models on Your Content.** Most of what you work on never reaches us. Your projects, files, chats and terminal stay on your computer, as the [Privacy Policy](https://kazocode.app/docs/legal/privacy.md) explains. You're responsible for Your Content and for having the rights to use it, including any code, data or credentials you give the agent access to. ## 5. AI output The agent can read files, write code, run commands, use a browser and call tools you connect. AI output can be wrong, incomplete, insecure or similar to other people's work. - Review what the agent proposes before you rely on it, run it, ship it or publish it. - You decide what the agent may do through its [permission settings](https://kazocode.app/docs/agent/permissions.md). Actions you approve, or allow with a saved rule or an automatic mode, are your actions. - Don't use output as a substitute for professional legal, medical, financial or safety advice. - Similar requests from different people can produce similar output. Output generated for someone else isn't Your Content. ## 6. Models and third-party services **Your own providers.** You can connect model providers with your own API key, custom endpoints, MCP servers, websites and other third-party services. Requests to them go from your device to that provider under its terms and privacy policy, not ours. We don't control them and aren't responsible for them, their availability, their charges or what they do with your data. **KazoCode models.** Models that KazoCode hosts are served through our gateway and the model providers we work with. They count against your plan's usage, as [Usage and limits](https://kazocode.app/docs/account/usage.md) describes. You must also follow the usage policies of the underlying model provider, which the Acceptable Use Policy incorporates. ## 7. Plans, usage and payment The Free plan is free of charge and has usage limits that we may change. KazoCode models are limited by a 5-hour window and a weekly budget. If we offer paid plans or usage-based pricing, the price, billing period, renewal and cancellation terms will be shown before you buy, and you agree to pay them, plus applicable taxes. Usage-based pricing is never on unless you turn it on, and stops at the monthly limit you set. Except where the law requires otherwise, payments are non-refundable. We may change prices with at least 30 days' notice. A change applies from your next billing period, and you can cancel before then. ## 8. The marketplace The marketplace lists extensions, plugins, skills and other add-ons published by third parties from their own repositories. They aren't made by us unless we say so. Installing one is a choice between you and its publisher, under its own license. Add-ons can run code on your computer, so install only those you trust. We may review, label, delist or block any add-on at any time, for example for security, legal or policy reasons. Publishers also agree to the [Marketplace Publisher Terms](https://kazocode.app/docs/legal/marketplace.md). ## 9. Acceptable use Follow the [Acceptable Use Policy](https://kazocode.app/docs/legal/acceptable-use.md). In short: don't use KazoCode to break the law, harm people, attack systems you're not authorized to test, abuse our infrastructure or other users, or get around usage limits. ## 10. Feedback If you send us ideas or suggestions, we may use them without any obligation to you. ## 11. Our intellectual property The Services, including the software, models we provide, design, logos and the KazoCode name, belong to us and our licensors and are protected by law. These Terms don't give you any right to our trademarks. Other product names and logos, such as Claude or ChatGPT, belong to their owners and are used only to identify those products. Their use doesn't mean they endorse KazoCode. ## 12. Copyright complaints We respond to notices of claimed copyright infringement as the [Copyright Policy](https://kazocode.app/docs/legal/copyright.md) describes, and we terminate the accounts of repeat infringers where appropriate. ## 13. Suspension and termination You can stop using the Services at any time and delete your account in **Settings** on kazocode.app. We may suspend or end your access if you seriously or repeatedly break these Terms, if we must for legal reasons, or to protect the Services, our users or others. Where reasonable, we'll tell you why in advance and give you a chance to fix the problem. If we stop offering a Service, we'll give reasonable notice and, for a paid plan, refund any prepaid amount for the time you can no longer use. Sections 4 (your license to us ends as described), 10, 11 and 14 to 19 survive termination. ## 14. Disclaimers The Services are provided "as is" and "as available". To the fullest extent the law allows, we disclaim all warranties, express or implied, including merchantability, fitness for a particular purpose, title and non-infringement. We don't promise that the Services or AI output will be accurate, secure, uninterrupted or error-free, or that the agent won't make changes you didn't expect. Keep backups and use version control. You're responsible for changes the agent makes with your permission. Some places don't allow these exclusions, so some of them may not apply to you. ## 15. Limitation of liability To the fullest extent the law allows: - We aren't liable for indirect, incidental, special, consequential or punitive damages, or for lost profits, revenue, data or goodwill, even if we were told they were possible. - Our total liability for all claims about the Services is limited to the greater of the amount you paid us for the Services in the 12 months before the claim, or USD 100. Nothing in these Terms limits liability for fraud, for death or personal injury caused by negligence, or any other liability that can't be limited by law. ## 16. Indemnity If you use the Services for a business, you'll defend and indemnify us against third-party claims arising from Your Content, your use of the Services in breach of these Terms or the law, or add-ons you publish, and pay the resulting costs and damages, including reasonable legal fees. ## 17. Changes to these Terms We may update these Terms. If a change materially affects you, we'll tell you at least 30 days before it takes effect, by email or in the app, unless it's needed sooner for legal or security reasons. If you keep using the Services after a change takes effect, you accept it. If you don't agree, stop using the Services and delete your account. ## 18. Governing law and disputes These Terms are governed by the laws of [governingLaw], without regard to conflict-of-law rules. Disputes will be heard by the courts of [courts], and you and we agree to their jurisdiction. If you're a consumer, you also keep the protection of the mandatory laws of the country where you live, and you can bring claims in your local courts. Before filing a claim, please contact us at legal@kazocode.app so we can try to resolve it informally within 30 days. ## 19. General - **Entire agreement.** These Terms, together with the policies they link to, are the whole agreement between you and us about the Services. - **Assignment.** You can't transfer these Terms without our consent. We may transfer them in a merger, acquisition or sale of assets, or to an affiliate. - **Severability.** If a court finds part of these Terms unenforceable, the rest stays in effect. - **No waiver.** If we don't enforce a right, we haven't given it up. - **Force majeure.** Neither of us is liable for delays caused by events beyond reasonable control. - **Export.** You'll follow the export control and sanctions laws that apply to your use of the Services. - **Notices.** We'll send notices to your account email. Send notices to us at legal@kazocode.app. ## Contact Questions about these Terms: legal@kazocode.app. Help with your account: support@kazocode.app. Source: https://kazocode.app/docs/legal/terms --- # Privacy Policy > What KazoCode collects, what stays on your computer, who we share data with, how long we keep it and the rights you have over it. **Effective November 20, 2026** This policy explains how [company] ("KazoCode", "we", "us"), [address], handles personal data when you use the KazoCode desktop app, the CLI, the SDK, kazocode.app, KazoCode models, the marketplace and this website (the "Services"). We are the controller of the personal data described here, except where section 9 says otherwise. ## The short version - **Your code stays on your computer.** Projects, files, chats, agent memory, terminal sessions and browser tabs are stored locally. We don't receive them. - **We collect what an account needs**: your name, email, sign-in details, signed-in devices, synced settings and usage counts. - **We don't sell your data, show ads or use tracking cookies, and we don't train AI models on your content.** - You can see your devices and usage on kazocode.app, and delete your account and its data at any time. ## 1. What stays on your device KazoCode is a desktop app. These stay on your computer and aren't sent to us: - your projects, files, code and the changes the agent makes; - chats, conversation history, plans and agent memory; - terminal sessions and command output; - API keys for your own model providers, which are kept in your operating system's key store; - pages you open in the built-in browser. When you connect your own model provider, MCP server or other service, the app sends your requests **directly from your device to that service**. We aren't part of that exchange, and the service's own privacy policy applies. ## 2. What we collect **Account.** Your name, email address, whether the address is verified and your password, which we store only as a salted hash. If you sign in with GitHub or Google, we receive your name, email address and profile picture from them, plus the sign-in tokens they issue. We use what we receive from Google only to sign you in, as the [Google API Services User Data Policy](https://developers.google.com/terms/api-services-user-data-policy) and its Limited Use requirements allow. **Sessions.** When you sign in on the web, we record the session's IP address, browser user agent and timestamps, to keep you signed in and to detect misuse. **Devices.** When you sign in from the desktop app, we store the device name, operating system, app version, when it was added and last seen, and hashed access tokens. You can see and remove devices on the **Computers** page. **Settings sync.** If you use sync, we store your editor settings and keybindings so they follow you between devices. API keys aren't part of sync. **Usage.** For each request to a KazoCode model, we record the time, the model, the app it came from, the device, your team if any, and token counts and cost. We use these to apply your plan's limits and show you your usage. We don't keep the content of these prompts or responses beyond what's needed to process the request (section 3). **Teams.** If you create or join a team, we store its name, logo, members and roles, and the email addresses you invite. **Marketplace.** When you install an add-on, we record which add-on was installed and on which device, to count installs. For publishers, we store the public details of their repository and add-ons. **Updates.** When the app checks for an update, it sends its version, operating system, processor type, release channel and a random install identifier that isn't linked to your account. We use the identifier only to roll updates out in stages. **Email.** We send you account emails, such as address verification, password resets and team invitations. We don't send marketing emails without your consent. **Support.** If you contact us, we keep your message and our reply. **Website.** Our hosting provider processes your IP address and request details in its logs to serve and protect the site. The website doesn't use analytics or advertising trackers. ## 3. KazoCode models When you use a model that KazoCode hosts, the prompt, the context the agent includes (which can contain code and file contents) and the model's response pass through our gateway to the model provider that runs it. They are processed only to return the response to you and are not stored by us after the request finishes, apart from the usage record in section 2. We use only model providers whose terms forbid them from training on this traffic. They may keep requests for a limited time to detect abuse, under their own policies. The providers are listed on the [Subprocessors](https://kazocode.app/docs/legal/subprocessors.md) page. ## 4. Features that use other services Some features send data to third parties when you use them: | Feature | What is sent, and to whom | | --- | --- | | Web search | Your search query, to DuckDuckGo | | Built-in browser and web fetch | Requests to the sites you or the agent open | | Voice input | With an OpenAI or Mistral key, your audio goes to that provider. Local Whisper keeps audio on your computer. Windows Speech uses Windows' speech service | | MCP servers, hooks and add-ons | Whatever you or the add-on configures them to send | | Sign in with GitHub or Google | The sign-in request, to that provider | ## 5. Why we use it | Purpose | Data | Legal basis (EEA and UK) | | --- | --- | --- | | Create and run your account, sign-in and devices | Account, sessions, devices | Performing our contract with you | | Sync settings, run KazoCode models, apply usage limits, run teams | Sync, usage, teams | Performing our contract with you | | Deliver updates and the marketplace | Updates, marketplace | Our legitimate interest in providing secure, working software | | Keep the Services secure and prevent abuse | Sessions, devices, usage | Our legitimate interest in security, and legal obligations | | Send account emails and answer support | Email, support | Performing our contract with you | | Comply with the law and enforce our terms | Any relevant data | Legal obligation and legitimate interest | We don't make decisions about you based solely on automated processing that have legal or similarly significant effects. ## 6. Who we share it with - **Service providers** that host and run the Services for us, under contracts that limit their use of the data to our instructions. They're listed on the [Subprocessors](https://kazocode.app/docs/legal/subprocessors.md) page. - **Your team.** Team owners and admins can see members' names, emails, roles and usage. - **Legal reasons.** When the law requires it, or when it's needed to protect someone's rights, safety or property. Where we're allowed to, we'll tell you first. - **Business transfers.** If KazoCode is merged, acquired or sells assets, data may transfer under this policy, and we'll tell you before it's covered by a different one. We don't sell or rent personal data, and we don't share it for cross-context behavioral advertising. ## 7. How long we keep it | Data | Kept | | --- | --- | | Account, teams, synced settings | Until you delete them or your account | | Signed-in devices | Until you remove the device or delete your account | | Web sessions | Until they expire or you sign out | | Usage records | While your account exists, to show history and apply limits | | Marketplace install records | Until the device or add-on is removed | | Support messages | Up to 2 years after the conversation ends | | Hosting logs | As set by the provider, usually up to 30 days | When you delete your account, we delete your account, sessions, devices, synced settings, usage records, team memberships and install records right away. Copies in encrypted backups are overwritten within 35 days. We may keep what the law requires us to. ## 8. Your rights Wherever you live, you can ask us to: - **access** the personal data we hold about you and get a copy in a portable format; - **correct** it; - **delete** it, which you can also do yourself in **Settings** on kazocode.app; - **restrict** or **object** to how we use it, including processing based on legitimate interest; - **withdraw consent** where we rely on it. Email privacy@kazocode.app from your account's address. We'll respond within 30 days, or sooner where the law requires, and we won't treat you differently for exercising your rights. We may need to confirm your identity first. An authorized agent may make a request for you with your signed permission. If you're in the EEA, UK or Switzerland, you can also complain to your local data protection authority. Residents of California and other US states have these rights under state privacy laws, and we don't sell or share personal information as those laws define it. Users in India have these rights under the Digital Personal Data Protection Act, 2023, and may also contact our grievance contact at privacy@kazocode.app. ## 9. Teams When a team owner invites you, the team's organization decides who's a member. We process the team's data to provide the Services to it. Questions about a team's membership should go to its owner. ## 10. International transfers We and our service providers may process data in countries other than yours, including the United States. Where the law requires it, we protect these transfers with safeguards such as the European Commission's Standard Contractual Clauses and the UK addendum to them. ## 11. Security Passwords and device tokens are stored only as hashes. Connections to our servers are encrypted with TLS. Access to production systems is limited to the people who need it. No system is perfectly secure. If a breach affects your personal data, we'll notify you and the authorities as the law requires. To report a vulnerability, see the [Security](https://kazocode.app/docs/legal/security.md) page. ## 12. Cookies We use only the cookies needed to keep you signed in, and your browser's local storage for preferences like a collapsed sidebar. The [Cookie Notice](https://kazocode.app/docs/legal/cookies.md) lists them. ## 13. Children The Services aren't for children under 13, and we don't knowingly collect their data. If you believe a child has given us personal data, email privacy@kazocode.app and we'll delete it. ## 14. Changes If we change this policy, we'll update the date at the top. If a change materially affects how we use your data, we'll tell you by email or in the app before it takes effect. ## Contact [company], [address]. Email privacy@kazocode.app. Source: https://kazocode.app/docs/legal/privacy --- # Acceptable Use Policy > What you can't use KazoCode, KazoCode models or the marketplace for, and what happens if someone does. **Effective November 20, 2026** This policy is part of the [Terms of Service](https://kazocode.app/docs/legal/terms.md). It applies to everything you do with the Services, including what you ask the agent to do and add-ons you publish. ## Don't use KazoCode to **Break the law or harm people** - violate any law or anyone's rights, including privacy, intellectual property and publicity rights; - create or distribute child sexual abuse material, or sexualize minors in any way; - harass, threaten, stalk, defame or discriminate against anyone; - plan or promote violence, terrorism or violent extremism; - develop weapons capable of mass casualties, including biological, chemical, nuclear or radiological weapons; - commit fraud, run scams or phishing, or impersonate people or organizations; - collect or process people's personal data without a lawful basis, including scraping it in breach of a site's terms; - make automated decisions with legal or similarly significant effects on people without the human review and notices the law requires. **Attack systems or networks** - access, scan, probe or test systems, accounts or networks you don't own or aren't authorized to test; - write, distribute or deploy malware, ransomware, spyware or code meant to damage, disable or secretly take control of systems; - run denial-of-service attacks, or build tools meant to evade detection for malicious purposes; - compromise software supply chains, including by publishing add-ons or packages that contain hidden or malicious behavior. Authorized security work is welcome: penetration testing you're engaged to do, capture-the-flag challenges, research on your own systems and defensive tooling. **Abuse the Services** - get around usage limits, plan restrictions, rate limits or security measures, including by creating multiple accounts or sharing accounts; - resell, sublicense or provide access to KazoCode models as a service to others without our written permission; - use KazoCode model output to build a competing model or service, where the model provider's terms forbid it; - interfere with or overload our infrastructure; - scrape the Services except through the interfaces we provide. **Mislead people about AI** - present AI-generated content as human-made where that would deceive people in a way that causes harm, or where the law requires disclosure; - generate spam or content designed to manipulate elections or public opinion through deception. ## Model provider policies When you use a KazoCode model, you also agree to follow the usage policy of the company that makes it. When you use your own provider, its policies apply to you directly. ## Enforcement If we believe someone has broken this policy, we may remove content, delist add-ons, limit features, or suspend or close accounts, as the Terms describe. Where the law requires it, or where someone is at risk, we may report activity to the authorities. ## Report abuse Email legal@kazocode.app with what you saw and where. For security vulnerabilities in KazoCode itself, see [Security](https://kazocode.app/docs/legal/security.md). Source: https://kazocode.app/docs/legal/acceptable-use --- # Cookie Notice > The only cookies kazocode.app sets keep you signed in. No analytics, advertising or tracking cookies. **Effective November 20, 2026** kazocode.app uses only what's strictly needed to work. Because we don't use analytics, advertising or tracking cookies, there's nothing to opt in to and no cookie banner. ## Cookies | Name | Purpose | Lasts | | --- | --- | --- | | `better-auth.session_token` | Keeps you signed in. On the live site it's named `__Secure-better-auth.session_token` and is sent only over HTTPS | 7 days, renewed while you use the site, or until you sign out | | `better-auth.dont_remember` | Set only if you sign in without staying signed in, so the session ends when you close the browser | Until you close the browser | These are first-party cookies set by kazocode.app and shared with its subdomains, such as the account server. They aren't used to track you on other sites. ## Local storage Your browser's local storage keeps preferences on your device, such as whether the sidebar is collapsed. They're never sent to us. ## Desktop app The desktop app doesn't use cookies to track you. Sites you open in its built-in browser can set their own cookies, which stay on your computer. ## Controlling cookies You can delete or block cookies in your browser settings. If you block the session cookie, you won't be able to sign in. Questions: privacy@kazocode.app. See the [Privacy Policy](https://kazocode.app/docs/legal/privacy.md) for more. Source: https://kazocode.app/docs/legal/cookies --- # Subprocessors > The service providers that process personal data for KazoCode, what each one does and what data it handles. **Updated November 20, 2026** These companies process personal data on our behalf to run the Services. Each is bound by a contract that limits its use of the data to providing its service to us, and requires appropriate security. The [Privacy Policy](https://kazocode.app/docs/legal/privacy.md) explains what we collect. ## Infrastructure | Provider | What it does | Data it handles | | --- | --- | --- | | Neon | Hosts our Postgres database | All account data in our database: account, sessions, devices, synced settings, usage, teams, marketplace records | | Render | Runs the account server (api.kazocode.app) | All data passing through the account server, and its request logs | | Cloudflare | Hosts and protects kazocode.app | IP addresses and request details for the website | | Resend | Sends account emails | Your email address and the content of account emails | ## Sign-in and marketplace | Provider | What it does | Data it handles | | --- | --- | --- | | GitHub | Sign in with GitHub, and hosting of marketplace add-on repositories | Sign-in requests and the tokens GitHub issues | | Google | Sign in with Google | Sign-in requests and the tokens Google issues | GitHub and Google act as independent controllers for the accounts you hold with them. ## Model providers KazoCode models are run by the model providers we route them to. Before we make a KazoCode model available, we add its provider to this page. Each one may process the prompts, context and responses of requests to its models, and must not train on them. ## Changes We'll update this page before a new subprocessor starts handling personal data. Team owners who want notice of changes, or who want to object to one, can email privacy@kazocode.app. Source: https://kazocode.app/docs/legal/subprocessors --- # Marketplace Publisher Terms > The terms for publishing extensions, plugins, skills and other add-ons to the KazoCode marketplace. **Effective November 20, 2026** These terms apply when you publish an add-on, such as an extension, plugin, skill, mod or MCP server listing, to the KazoCode marketplace. They're in addition to the [Terms of Service](https://kazocode.app/docs/legal/terms.md) and the [Acceptable Use Policy](https://kazocode.app/docs/legal/acceptable-use.md). "You" means the publisher. ## 1. Publishing The marketplace lists add-ons from public repositories. By submitting a repository, you confirm that you have the right to publish everything in it, and that you or your organization controls it. ## 2. License to us You keep ownership of your add-on. You give KazoCode a worldwide, non-exclusive, royalty-free license to copy, store, index, display, distribute and install your add-on, its name, icon, description and screenshots, so we can list it and deliver it to users. This license lasts while the add-on is listed, and afterward for copies already installed. ## 3. License to users Your add-on must include a license that tells users what they can do with it. Users get your add-on from you, under your license. We aren't a party to that license. ## 4. What your add-on must do - **Do what its listing says**, and nothing hidden. Describe what it accesses, including files, the network, commands it runs and data it sends anywhere. - **Ask before it collects personal data**, and publish a privacy policy if it collects any. - **Contain no malware**, obfuscated code meant to hide behavior, cryptocurrency miners or code that disables other software or security features. - **Not impersonate** KazoCode, another publisher or another product, or use names or logos you don't have the right to use. - **Follow the law**, including export controls, and the Acceptable Use Policy. - **Be maintained.** Fix security problems you're told about promptly. ## 5. Review and removal We may review add-ons at any time, automatically or by hand, and may label, delist, block or remotely disable an add-on that breaks these terms, poses a security risk or is the subject of a valid legal complaint. Where reasonable, we'll tell you why and give you a chance to fix it. We may also rank, feature or verify add-ons at our discretion. ## 6. Install counts and data We show how many times your add-on has been installed. We don't give publishers users' personal data. ## 7. Responsibility You're responsible for your add-on and for support requests about it. You'll defend and indemnify KazoCode against third-party claims arising from your add-on, including claims that it infringes someone's rights or harmed a user's system or data. ## 8. Ending You can remove your add-on at any time by removing your repository from the marketplace. We may stop listing it as section 5 describes. ## Contact legal@kazocode.app. To report an add-on, include its name and what you found. Source: https://kazocode.app/docs/legal/marketplace --- # Copyright Policy > How to report content on KazoCode that infringes your copyright, how to send a counter-notice, and how we handle repeat infringers. **Effective November 20, 2026** We respect intellectual property and expect our users and publishers to do the same. This policy covers material hosted or listed on the Services, such as marketplace add-ons, their listings and team content. Code on your own computer isn't hosted by us. We respond to notices that comply with the US Digital Millennium Copyright Act (DMCA) and similar laws elsewhere. ## Reporting infringement Send a notice to copyright@kazocode.app with: 1. your physical or electronic signature, as the owner or someone authorized to act for them; 2. a description of the copyrighted work you believe is infringed; 3. where the infringing material is on the Services, with links, so we can find it; 4. your name, address, phone number and email address; 5. a statement that you believe in good faith that the use isn't authorized by the copyright owner, its agent or the law; 6. a statement that the information in your notice is accurate and, under penalty of perjury, that you're the owner or authorized to act for them. We'll remove or disable access to the material, notify the person who posted it and send them a copy of your notice. ## Counter-notice If your material was removed and you believe it was a mistake or misidentification, send a counter-notice to copyright@kazocode.app with: 1. your physical or electronic signature; 2. what was removed and where it was before; 3. a statement under penalty of perjury that you believe in good faith it was removed by mistake or misidentification; 4. your name, address and phone number, and a statement that you consent to the jurisdiction of the courts for your address (or, outside the US, any judicial district where we may be found), and that you'll accept service from the person who sent the original notice. Unless the person who sent the notice tells us within 10 to 14 business days that they've filed a court action, we may restore the material. ## Repeat infringers We close the accounts of users and publishers who repeatedly infringe, where appropriate. ## Misuse Knowingly making false claims in a notice or counter-notice can make you liable for damages. Source: https://kazocode.app/docs/legal/copyright --- # Security > How KazoCode protects your account and data, and how to report a security vulnerability under our safe harbor. **Updated November 20, 2026** ## How we protect you - **Your code stays local.** Projects, chats, memory and terminal sessions live on your computer, so they aren't exposed by a breach of our servers. - **Keys stay in your OS key store.** API keys for your own providers are kept in Windows Credential Manager, macOS Keychain or the Linux secret service, and aren't synced. - **Hashed secrets.** Passwords are stored as salted hashes. Device access and refresh tokens are stored only as hashes and rotate on use. - **Encryption in transit.** Every connection to kazocode.app and api.kazocode.app uses TLS. Session cookies are HTTP-only and secure. - **Signed updates.** App updates are cryptographically signed, and the app refuses an update whose signature doesn't match. - **The agent asks first.** Writes, commands and network access go through the [permission system](https://kazocode.app/docs/agent/permissions.md) unless you allow them. - **Least access.** Only the people who need it can reach production systems. ## Report a vulnerability Email security@kazocode.app with: - what you found and where; - steps to reproduce it, and a proof of concept if you have one; - what an attacker could do with it. We'll confirm we received it within 3 business days, keep you updated, and tell you when it's fixed. With your permission, we'll credit you. ## Safe harbor If you research in good faith under this policy, we won't pursue legal action against you or report you to the authorities, and we'll consider your research authorized. In return: - test only against your own accounts and data, and stop as soon as you reach anyone else's; - don't degrade the Services for others, run denial-of-service tests, spam or social-engineer our staff or users; - don't access, change or keep more data than you need to show the problem, and delete what you've accessed when you're done; - give us reasonable time to fix the issue before telling anyone else, and don't demand payment in exchange for not disclosing it. ## Out of scope - vulnerabilities in third-party services, add-ons or model providers, which should go to their owners; - reports from automated scanners without a demonstrated impact; - missing security headers or best practices with no exploitable impact; - attacks that need physical access to a user's unlocked device; - the agent doing something a user explicitly approved. Source: https://kazocode.app/docs/legal/security ---