> ## 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.

# Quickstart

> Set Probe up with the wizard, then record a run you can open in the dashboard.

Start with the wizard. It is the shortest path in, and it is the only step that needs doing once per machine.

**Set up with the wizard**

**1. Run it**

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

No prior install needed — `npx` fetches the launcher, which resolves the real CLI. The wizard signs you in through the browser, then walks four screens: pick your coding agents, review what will be set up, install, and offer to import work you already have. Before the import offer it asks where this computer's work should go — the workspace its new projects are filed in.

> [!NOTE]
>
> Add `--agent codex` to set up Codex instead of (or as well as) Claude Code. `--agent both` does both. Everything the menu offers is also a flag — see [unattended use](/wizard/flags.md).

**2. Confirm it took**

```bash theme={null}
probe doctor
```

Read-only. It prints what is installed, which credentials resolve, whether auto-update is working, and when the last update attempt was.

In Claude Code, the install also added a one-line indicator under the input box, such as `● tracking`, `● tracking → folding` or `● tracking → folding · running`. See [Status line](/agents/statusline.md) for every state.

**3. Use it**

In your agent, the switch is `/probe`:

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

With the switch on, your work is recorded as it happens — by the [Probe daemon](/agents/daemon.md) beside your agent, or by the agent itself through the `/track-work` skill, depending on the wizard's **Who records** setting. The agent can also search your lab's history read-only at any time through the [MCP server](/agents/mcp.md).

**4. Bring your history with you**

From the wizard's main menu, choose **Import research work** — or run it directly:

```bash theme={null}
probe backfill /path/to/project --project existing-project
probe backfill --transcripts-only
```

Folder imports read the directory, upload what they find and describe it. Session imports pull saved coding-agent transcripts into the knowledgebase. Both run in the background and survive a terminal disconnect.

> **[The wizard in full](/wizard/overview.md)**
>
> Every screen, every menu row, and the flags behind them.

**Record a training run**

**1. Install the client**

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

This gives you both the Python SDK (`import probe`) and the `probe` command-line tool. They are the same implementation with two ergonomics.

**2. Sign in**

```bash theme={null}
probe wizard --action login
```

This opens a browser device flow and signs the device in — nothing else is installed. You approve the device in the dashboard; nothing is pasted. The credential is written to `~/.config/probe/config.json`.

Signing in this way does not ask which workspace this computer's work goes into. If your team has more than one workspace, pick one before the first run:

```bash theme={null}
probe workspace list
probe workspace use <slug>
```

> [!TIP]
>
> You can skip this step entirely. The first `probe.init()` or `probe run start` with no token triggers the same browser approval inline, as long as you are on a TTY. In CI, set `PROBE_TOKEN` instead — headless callers get a clean `AuthError` rather than a hung prompt.

**3. Instrument the script**

```python theme={null}
import probe

probe.init(
    project="folding",
    experiment="dockq-sweep",
    question="does temperature 0.7 win?",
)

for step, batch in enumerate(loader):
    loss = train_one(batch)
    probe.log({"train/loss": loss}, step=step)

probe.finish()
```

`project` and `experiment` are created if they do not exist. `question` is the one opt-in to creating an experiment, so the first run in a new experiment says what you expect to see; every run after that is bare.

A new project goes into this computer's workspace. On a team with several workspaces and none set, `probe.init` raises `WorkspaceRequired` before creating anything: run `probe workspace use <slug>`, set `PROBE_WORKSPACE`, or pass `workspace=` to `probe.init`.

If the script exits without `finish()`, the run is still closed at exit as `completed`, `failed` or `canceled` rather than left for the crash reaper.

**4. Watch it**

Open [research.prbe.ai](https://research.prbe.ai) — the run appears under its experiment with live curves. Or stay in the terminal:

```bash theme={null}
probe metrics plot $RUN_ID --key train/loss
```

## What you just created

```text theme={null}
workspace
└── project          folding
    └── experiment   dockq-sweep        ← carries the question
        └── run      run-1              ← carries metrics, files, spans
```

A run does not need an experiment — a project-direct run is the honest home for work that has no hypothesis. And an experiment does not need to be created up front; naming one in `probe.init()` with a `question` creates it.

> **[Core concepts](/concepts.md)**
>
> The full model, including workspaces, run groups, artifacts and notes.

## Next steps

> **[Log more than scalars](/tracking/metrics.md)**
>
> Coordinates, labels, non-numeric values, derived series and terminal plots.

> **[Capture files and code](/tracking/artifacts.md)**
>
> Artifacts, anchors, versions and reuse.

> **[The whole CLI](/cli/commands.md)**
>
> Every command group, with what each one is for.

> **[Import from W\&B](/integrations/wandb.md)**
>
> Local run directories or hosted projects.


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