# Kaitoi Code

> Penny in your terminal. Code works with local files in a folder you trust, Kaitoi projects and graphs, runtime recipes, and approved local commands, and can hand long coding tasks to the Crew.

Source: https://kaitoi.io/docs/cli/code/
Section: Kaitoi CLI
Written for: Anyone who wants to drive Kaitoi from the terminal rather than the canvas.
Prerequisites: Kaitoi CLI installed and logged in
Last reviewed: 2026-09-16

---

Kaitoi Code is Penny in your terminal. It can use Kaitoi Core API tools,
inspect and run node graphs, work with local workspace files once you trust a
folder, run local runtime recipes, and download or upload files with your
confirmation.

Start an interactive session:

```bash
kaitoi code
```

In an interactive session Code offers to use the
current folder as its trusted workspace, so `--workspace .` is normally
unnecessary. To target a different folder:

```bash
kaitoi code --workspace /path/to/project
```

Ask a one-shot question instead:

```bash
kaitoi code "Create a project with a text-to-image node and tell me what you did"
```

## Slash commands

```text
/login                 refresh your Kaitoi login token
/status                show auth, model, workspace, and mode
/providers             list available providers and models
/provider gemini       switch model provider
/model <model-id>      switch model
/workspace <path>      set or show the trusted workspace
/mode plan             switch to read-only planning
/commands on           enable per-command confirmed local shell commands
/permissions           show session approvals
/doctor                show local Code diagnostics
/config init           create a persistent Code config file
```

`/provider`, `/model` and `/commands` change the current session only. They do
not silently rewrite your config file.

## File access is explicit on purpose

Code only reads or writes files inside a trusted workspace, and every write,
download and upload asks first. This is a deliberate constraint rather than an
oversight: an agent that can quietly write anywhere on your machine is not one
you can leave running.

## Handing a task to the Crew

For a larger coding task, ask Code to use the **Crew**. Code inspects
the trusted Git workspace, gathers any missing choices, and shows the exact
proposed scope, models, verification commands and budgets before asking for
approval.

Once approved, the run is durable: it can plan, implement, test and review in
the background even after the Code session ends. Afterwards, ask Code in plain
language to check status or progress, read the result and its evidence, or
propose a control action such as steering, pausing, resuming, interrupting or
cancelling.

Starting a run and changing its controls require explicit approval. Status,
progress, evidence and results are read-only and do not.

The Crew is available to Code as a permission-aware tool, not as a
slash command. Advanced users can inspect the direct surface with
`kaitoi crew --help`.

## Modes

Code has three modes. `plan` is read-only. `build` edits files in the trusted
workspace. `crew` keeps workspace reading, the Crew's own tools
and the Kaitoi platform tools, but has no file-writing, command, install or
delete tools at all, so a request to build something becomes one exact start
proposal for your approval rather than files changed in the chat session.

```bash
kaitoi code --mode crew
```

Inside a session, `/mode crew` switches, and `/crew <task>`
switches and sends the task in one step. A tool outside the current mode is
refused rather than run, so the guarantee does not depend on the model choosing
well.

## Current limitations

- Local shell commands are off until you enable them with `/commands on`, and
  each one is confirmed individually.