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

> ## Agent Instructions
> Reticle is a dev-only, localhost-only verification layer for AI coding agents. It reads program truth (network, state, console, routing, animations, framework state) from inside a running web app and returns a deterministic verdict with evidence. It is not a screenshot tool and not a browser automation library.
> Only `reticle_act_and_wait` and `reticle_assert` produce a verdict. Every other tool moves or reads the app and proves nothing. A drive that ends without one of those two has no result, however many tools it used.
> A verdict of `verified: "unknown"` is not a pass. It means Reticle drove the app and could not tell what happened. Report it as unknown; never weaken a check to make it pass.
> Package names are scoped `@reticlehq/*` and the CLI is `reticle`. Install with `npx reticle init`. The complete tool surface is on the `/usage` page; `/agent-cheatsheet` is the one-screen version.

# Tools overview

> The 18 tools your agent sees every turn, the 30 more it can reach on demand, and why the surface is deliberately small.

Reticle ships 48 tools. Your agent is shown **18** of them.

That is not a limitation, it's the design. MCP re-sends every advertised tool definition to the model on **every single turn**, so the tool list is not a menu you pay for once. It's rent.

A wider surface costs tokens on every message. Less obviously, it makes the model wander: give it forty ways to look at a page and it will try several before doing anything useful.

The other 30 tools are one call away, never unreachable. `reticle_tools` lists them and `reticle_run` invokes them.

<Note>
  Measured off the real wire on 2026-08-14, by reading `tools/list` from a fresh daemon: the default
  surface is **18 tools at 21,468 bytes**, against **48 tools at 134,368 bytes**. That is 6.3x more,
  charged on every message. In real tokenizer terms that is roughly **4,930** and **30,200** tokens
  per turn ([measured by `bench/harness/schema-tax.mjs`](/token-efficiency), which puts every server
  through one tokenizer in a single pass). Re-measure before quoting these; the surface grows.
</Note>

## The default 18

Grouped by the job they do in the verify loop.

<CardGroup cols={2}>
  <Card title="Look" icon="magnifying-glass">
    `reticle_snapshot` · `reticle_query` · `reticle_inspect` · `reticle_sessions`
  </Card>

  <Card title="Act" icon="hand-pointer">
    `reticle_act` · `reticle_act_and_wait` · `reticle_act_sequence` · `reticle_navigate`
  </Card>

  <Card title="Observe" icon="satellite-dish">
    `reticle_observe` · `reticle_network` · `reticle_console` · `reticle_state` · `reticle_wait_for`
  </Card>

  <Card title="Prove & discover" icon="circle-check">
    `reticle_assert` · `reticle_tools` · `reticle_run`
  </Card>

  <Card title="Session & feedback" icon="comment">
    `reticle_session` · `reticle_feedback`
  </Card>
</CardGroup>

<Warning>
  Only **`reticle_act_and_wait`** and **`reticle_assert`** produce a verdict. Everything else moves
  or reads the app and proves nothing. A drive that ends without one of those two has no result,
  however many tools it used and however confident the summary sounds.
</Warning>

## Why these 18 and not others

Each one earned its slot, and a couple are there because of measured mistakes.

`reticle_inspect` maps a DOM node to `src/components/Sidebar.tsx:41`. Finding a bug is half the job. Knowing which file to open is the half that makes an agent useful.

It used to sit in the cold tail, which meant an agent had to already know it existed to use it. So essentially nobody did.

`reticle_act_sequence` batches a multi-step interaction into one round trip. It was also in the cold tail, and the consequence showed up in the data: agents drove login forms one call at a time, over and over.

Those repeats were not retries. The calls succeeded and got repeated, because the batching tool was invisible. A tool an agent must already know about is a tool that never gets called.

Direct `reticle_network` and `reticle_console` stay advertised even though `reticle_observe` can filter for both, because two obvious tools beat one clever tool with a filter grammar.

<Tip>
  Trimming further has a floor. An 8-tool cut measurably dropped real-agent accuracy, because the
  model loses scaffolding and wanders on harder flows. That reading is old enough to be dated
  evidence rather than proof, and a fresh A/B against a leaner surface is still unrun. Small is
  good; empty is not.
</Tip>

## Reaching the other 30

```json theme={"dark"}
{ "name": "reticle_flow_verify", "args": {} }
```

`reticle_run` takes a tool name and its arguments. `reticle_tools` lists what's available and returns the full argument grammar for any of them, so your agent can discover a tool mid-task without you having pre-loaded its schema.

Notable residents of the cold tail: flow recording and replay, visual diffing and screenshots, network mocking, viewport pinning, coverage, autonomous crawling, and the human-in-the-loop session controls.

## Every response carries its cost

Reticle tells you what each answer cost, because a verification tool that quietly eats your context window is not saving you anything:

```json theme={"dark"}
"cost": { "bytes": 938, "tokens": 235 }
```

That is a real `reticle_query` response: seven buttons found, with source pointers, for 235 tokens.

## Every response tells you when not to trust it

This is the part we're proudest of and the part that makes demos slightly less shiny.

When the browser tab is backgrounded, every response says so:

```json theme={"dark"}
"warning": "tab throttled; timer/rAF/pointer gestures may silently no-op — refocus before driving"
```

When the event buffer has evicted old events, a negative result might be a false negative, and it says that too:

```json theme={"dark"}
"buffer": {
  "held": 15,
  "dropped": 529,
  "note": "event buffer evicted older events (age/size cap) — a negative result here may be a false negative; the evidence may have expired. Grade sooner or widen the buffer."
}
```

A tool that says "no requests found" when it actually means "I lost the ones you asked about" is worse than useless. It is confidently wrong. Reticle would rather tell you its memory is imperfect.

## Reference

### Look

| Tool                                  | Answers                                                                     |
| ------------------------------------- | --------------------------------------------------------------------------- |
| [`reticle_snapshot`](/tools-snapshot) | What is on this page? Three modes, from full tree to a 25-token route check |
| [`reticle_query`](/tools-query)       | Where is the thing I mean?                                                  |
| [`reticle_inspect`](/tools-inspect)   | Everything about one element, down to source and design tokens              |
| [`reticle_sessions`](/tools-sessions) | Which tabs are connected, and can they actually be driven?                  |

### Act

| Tool                                          | Answers                                                    |
| --------------------------------------------- | ---------------------------------------------------------- |
| [`reticle_act`](/tools-act)                   | Do this. Proves nothing, and says so                       |
| [`reticle_act_and_wait`](/tools-act-and-wait) | Do this, and prove the consequence. **Produces a verdict** |
| [`reticle_act_sequence`](/tools-act-sequence) | Do these three things in one round trip                    |
| [`reticle_navigate`](/tools-navigate)         | Go here. Dispatched, not confirmed                         |

### Observe

| Tool                                  | Answers                                         |
| ------------------------------------- | ----------------------------------------------- |
| [`reticle_observe`](/tools-observe)   | Everything that happened in a window            |
| [`reticle_network`](/tools-network)   | Which requests fired, with bodies and timings   |
| [`reticle_console`](/tools-console)   | What was logged, and whether the read was real  |
| [`reticle_state`](/tools-state)       | What the app believes, not what it drew         |
| [`reticle_wait_for`](/tools-wait-for) | Block until something you did not cause happens |

### Prove and discover

| Tool                                              | Answers                                                |
| ------------------------------------------------- | ------------------------------------------------------ |
| [`reticle_assert`](/tools-assert)                 | Did the named consequence hold? **Produces a verdict** |
| [`reticle_tools`](/tools-tools-and-run)           | What else is available, and what are its arguments?    |
| [`reticle_run`](/tools-tools-and-run)             | Invoke any of the other 30                             |
| [`reticle_session`](/tools-session-and-feedback)  | Hand control back to the human                         |
| [`reticle_feedback`](/tools-session-and-feedback) | Tell the maintainers Reticle got something wrong       |

<Card title="The complete reference" icon="book" href="/usage">
  Every tool, every argument, including the 30 in the cold tail.
</Card>