> ## Documentation Index
> Fetch the complete documentation index at: https://docs.prbe.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Coding agents

> Two plugins, one switch — what your coding agent gains when Probe is installed.

Most ML work now happens in a conversation with an agent. The agent plugin makes that conversation part of the record rather than something that evaporates when the terminal closes.

```bash theme={null}
npx probe-research install
```

Supported hosts: **Claude Code**, **Codex**, **pi**, **Kimi Code**. All four run on your machine, and the install sets them up there. Kimi Code needs version 2.1.1 or later, and loads Probe at its next session start (or on `/reload` in an open session).

**Capy** installs like the others (`npx probe-research install --agent capy`), but its agent loop runs on Capy's servers, so nothing of Probe's goes into it automatically: the installer captures the threads you start, and Probe's plugin (its MCP server and skills) goes into Capy in one step, which the installer can open for you on a Mac. See [Capy](/agents/capy.md).

## Two plugins, two decisions

They are separate because they are separate consent decisions.

> **probe-research**
>
> **Tracking.** Skills that teach the agent the experiment workflow, and a read-only MCP server it searches your lab's history with.
>
> Writes go through the `probe` CLI, never through MCP.

> **probe-research-tap**
>
> **Session capture.** Streams this device's sessions to the team knowledgebase: your prompts, the agent's replies, and the shell commands you run.
>
> Per-device, disclosed twice before it starts, off at any time.

## What the agent can do with them

> **Search what the team already did**
>
> Before proposing a direction, the agent can check whether somebody already tried it — across runs, notes, sessions, papers and connected sources. That is the read half, and it is available even with writes turned off.

> **Record work as it happens**
>
> Create the project and experiment explicitly, open runs, route files to artifacts and numbers to metrics, write decisions into notes, and close with the real lifecycle outcome. At the moment it happens — not summarised at the end of the session.

> **Instrument a script before it costs GPU hours**
>
> `/instrument-code` wires `probe.init` and `probe.log` into a trainer, an eval or a sweep, including trainers that already have their own tracker.

> **Keep the project and experiment pages**
>
> `/write-summary` has the agent keep each project's and experiment's summary, the page people read to catch up, with `probe summary checkout` and `push`. See [Summaries](/tracking/summaries.md).

> **Show you where the work stands**
>
> `/visualize-progress` renders the tracked state, the gaps, and the arc as one timeline with the next action named — every line read back from Probe, never from the session's own memory.

## Or let the Probe daemon record

Instead of your agent recording its own work, the [Probe daemon](/agents/daemon.md) can: a second agent that runs beside it, records the session, keeps the summaries, and answers your agent's `probe ask` questions about the team's prior work. **Who records** in the wizard chooses, per coding agent:

```bash theme={null}
probe wizard --who-records daemon --yes     # or: agent
```

## The switch

One control governs the whole conversation.

```text theme={null}
/probe on      reads and writes
/probe read    search yes, record no
/probe off     no calls at all

/probe         advance one step (on ↔ read)
/probe status  print it, change nothing
```

> [!NOTE]
>
> **Only the researcher moves the switch.** Typed bare by you it toggles between `on` and `read`; `off` is not on that cycle and is reached only by typing it. An agent invoking the skill itself loads guidance and never changes the state.

Where the Probe daemon records, the same words read `on (daemon)`, `read only (daemon)` and `off`, and `/probe inline` stops the daemon for the session so your agent reads and writes Probe itself. See [The Probe daemon](/agents/daemon.md#the-switch-with-the-daemon).

The switch has three scopes, and each has a natural home.

**This conversation**

Type it in the agent:

```text theme={null}
/probe on
/probe read
/probe off
```

Or from a shell, against the current session:

```bash theme={null}
probe session state read
probe session status         # what this conversation is doing, and how that was decided
```

**Wizard**

```bash theme={null}
npx probe-research                       # → Defaults → Probe in new sessions
probe wizard --action defaults           # straight to it
```

Three states, each spelling out what it means. This is the device-wide default every new session starts at. See [Settings](/wizard/settings.md#probe-in-new-sessions).

**Command**

```bash theme={null}
probe session default on     # the device-wide default for new sessions
probe session default        # read it back
```

`probe session status` returns the full decision, including which default applied and whether session capture is actually running — so "tracking is on" and "anything is being recorded" can be told apart.

## What each surface is allowed to do

| Surface | Reads | Writes |
| - | - | - |
| MCP server | yes | **never** — there are no mutation tools |
| `probe` CLI | yes | yes |
| Skills | — | they instruct the agent to use the CLI |
| The Probe daemon | yes | yes, through the same CLI, each command checked first |

The read/write split is structural, not a policy setting. An agent with only the MCP server cannot change anything.

## The managed rules block

The install writes a managed Probe block into each selected agent's global instruction file, prompting it to search Probe and track research there. Everything outside the block is left alone.

**Wizard**

**Install Probe** writes it, and **Uninstall Probe** removes it. It has no row of its own on the Settings screen: Probe is installed whole.

**Command**

```bash theme={null}
probe wizard --agent-rules --yes       # on
probe wizard --no-agent-rules --yes    # off
probe agent-rules refresh              # rewrite the block when it is older than this CLI
```

> **[Skills](/agents/skills.md)**
>
> Every skill, when it fires, and what it does.

> **[MCP reference](/agents/mcp.md)**
>
> Six tools, token budgets, pagination, entity views.

> **[Session capture](/agents/capture.md)**
>
> What leaves the machine, and how to stop it.

> **[Status line](/agents/statusline.md)**
>
> The tracked/untracked indicator in Claude Code.

> **[The Probe daemon](/agents/daemon.md)**
>
> A second agent that records the session for your agent.

> **[Capy](/agents/capy.md)**
>
> Installing for Capy, and capturing the threads you start.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.