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

# Capy

> Probe inside Capy, a cloud coding agent, and capturing the threads you start there.

[Capy](https://capy.ai) runs its coding agent on its own servers and its tools on a Capy machine. Nothing installs on your computer, so Probe meets it in two places:

* **Inside Capy**, the agent reads and records Probe work itself: the Probe MCP server for search, the `probe` CLI and SDK on the Capy machine for writes and instrumented runs, and a small skills bundle that says how.
* **On your own computer**, `probe capy connect` copies the Capy threads you start into Probe as sessions, every 10 minutes.

<Note>
  Capy has no hooks and no status line, so there is no `/probe` switch, no Probe daemon and no Probe footer in Capy. `probe session` and `probe ask` do not work there: the agent checks prior work with the MCP `search` tool. Capy's API shares your prompts, the agent's replies and a one-line summary per tool call, never tool output, file diffs or the model's reasoning, so a Capy session in Probe is thinner than a Claude Code one.
</Note>

## Set Probe up inside Capy

The wizard shows these steps too: `npx probe-research`, then **Capy → Set up Probe inside Capy**.

<Steps>
  <Step title="Connect the Probe MCP server" icon="plug">
    In Capy: **Settings > MCP servers > New MCP server**.

    * Key: `probe`. Availability: your project, or org-wide.
    * Transport: **HTTP**, URL `https://mcp.research.prbe.ai/mcp`.
    * Save, open it, click **Connect** and approve in Probe.

    <Warning>
      Use a **personal** connection: each person connects their own. A shared connection makes every teammate's Probe calls from Capy run as the admin who connected it.
    </Warning>
  </Step>

  <Step title="Install the skills" icon="wand-magic-sparkles">
    The Capy bundle lives in the [`capy/skills`](https://github.com/prbe-ai/research-os-agent/tree/main/capy/skills) folder of `prbe-ai/research-os-agent`: `probe-capy` (read first), `track-work`, `instrument-code`, `plan-research-review`, `edit-notes` and `notes-audit`. Install it into your repository's `.agents/skills/`:

    ```bash theme={null}
    npx skills add https://github.com/prbe-ai/research-os-agent/tree/main/capy/skills --agent universal
    ```

    Name the folder, not just the repository: the repository root also carries the Claude Code plugin's own copies. Or ask Capy: *"Install the skills in the capy/skills folder of prbe-ai/research-os-agent into my personal drive."*
  </Step>

  <Step title="Put the CLI on the Capy machine" icon="terminal">
    In the project's **Environment variables > Personal** tab. Personal, so your token never reaches a teammate's thread or a PR review.

    | Name | Value |
    | - | - |
    | `PROBE_TOKEN` | A Probe token. On your own computer: `probe token create --name capy --scope read --scope write`. No `delete` scope: the agent never needs it |
    | `PROBE_CAPY` | `1`. Marks the CLI's calls and telemetry as coming from Capy |

    Then add the CLI to the machine recipe, in **Dev environment** or a committed `.capy/setup.json`:

    ```json .capy/setup.json theme={null}
    {
      "$schema": "https://api.capy.ai/schemas/setup.v1.json",
      "format_version": 1,
      "scripts": {
        "initialize": "uv tool install probe-research",
        "refresh": "uv tool upgrade probe-research"
      }
    }
    ```

    Code that calls the SDK (`import probe`) also needs `probe-research` in its own environment (`uv add probe-research`). The CLI tool install above is isolated.
  </Step>

  <Step title="Tell the agent" icon="file-lines">
    Add this to your repository's root `AGENTS.md`, or your Capy drive's:

    ```markdown AGENTS.md theme={null}
    ## Probe
    This team records ML work in Probe. Before ML work, read the `probe-capy` skill and
    run `probe notes team --brief`. Check the team's prior work with the Probe MCP
    `search` tool before proposing new experiments.
    ```
  </Step>
</Steps>

Inside Capy, `probe doctor` reports only what applies there: the CLI version, whether `PROBE_TOKEN` signs in, and where capture happens.

## Capture your Capy threads

This part runs on your own computer. You need:

* The `probe` CLI, version 0.237.0 or later, installed for good: `uv tool install probe-research`. The timer runs that `probe`, so a throwaway `npx` copy cannot host it.
* A Capy API key, from Capy **Settings > API**. Give it an expiry.
* To be signed in to Probe (`probe wizard --action login`) with the same email your Capy account uses.

Then:

```bash theme={null}
probe capy connect --project "<your Capy project name>"
```

Or from the wizard: **Capy → Capture my Capy threads**.

It asks for the key with a hidden prompt, or reads `$CAPY_API_KEY`, or takes `--api-key-stdin`. Never type the key as an argument, where shell history keeps it. It then finds your Capy user by your Probe account's email, asks you to approve capture once in the browser (or checks that the approval it already has belongs to your team), and installs a timer that syncs every 10 minutes: systemd on Linux, launchd on macOS, and anywhere else it prints a crontab line to add. The first sync starts in the background, and a long history can take a while.

* **Only threads you start are captured**, in the projects you named. A Capy key can read your teammates' threads too, and capturing those would need their consent. Messages teammates add to **your** threads are part of them, and are captured.
* **Captured:** your prompts, the agent's replies, attachment names and a one-line summary per tool call. **Not captured:** tool output, file contents, diffs, the model's reasoning. Likely credentials are replaced before upload, which is a filter, not a guarantee: keep live credentials out of prompts.
* **One thread is one Probe session.** Each subagent is its own session, linked to its thread. A thread quiet for a day, or archived, is finished. New messages reopen it.
* **Your computer being off loses nothing:** the next sync catches up. On Linux, user timers stop when you log out unless lingering is on (`loginctl enable-linger`), and `connect` tells you when it is off.

```bash theme={null}
probe capy status        # the last sync, and what failed
probe capy sync          # run one now
probe capy disconnect    # remove the timer, the key, the sync record and the capture credential
```

Sessions already uploaded stay in Probe after `disconnect`. Signing out of Probe or uninstalling it disconnects Capy too.

The key is stored owner-only (`0600`) beside the capture credential, and is sent to Capy's API only. `probe capy` only reads from Capy; it never writes there.

<CardGroup cols={2}>
  <Card title="Session capture" icon="message" href="/agents/capture#capy-threads">
    What leaves the machine, and how to stop it.
  </Card>

  <Card title="Command reference" icon="list" href="/cli/commands#capy">
    Every `probe capy` command and flag.
  </Card>
</CardGroup>


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