---
name: laserbrain-group
description: >
  Watch agents across several machines, be paged when one drifts, and read history that
  outlives the process. Use when more than one machine or more than one person is
  involved — otherwise use laserbrain-local, which is free and does the same detection.
---

# laserbrain — group

Everything the local skill does, plus the things one machine physically cannot do.

**Read `laserbrain-local` first.** The detector, the grammar, the nine verdicts and Φ are
identical here. This skill does not check better. It checks in a **place** — somewhere
several machines can report to, something can be awake when you are not, and a run can be
read after the process that produced it has gone.

If you are one agent on one laptop and someone is watching the terminal, you do not need
this and should not pay for it.

## Setup

```json
{
  "mcpServers": {
    "laserbrain": {
      "type": "http",
      "url": "https://laserbrain-mcp.degibug.workers.dev/mcp",
      "headers": { "Authorization": "Bearer YOUR_KEY" }
    }
  }
}
```

Get a key with `laserbrain key` — it is free, instant, and needs no card. A free key gives
you the hosted tools at Ground limits; Group and Pro raise the machine count.

## What the server adds

**Machines that can see each other.** Two agents on two laptops, each perfectly grounded
and each advancing, doing the same job — that fault exists only as a *relation* between
them, so it is invisible from inside either one however capable it is. No threshold on Φ
reaches it. It is not a tenth verdict; it is a reading only a supervisor can take.

**Something awake when you are not.** You cannot page yourself from a local file. An agent
that drifts at 3am is the entire case for paying.

**History you can read.** The free SDK writes every session to `~/.claude/laserbrain/` and
keeps it forever — you are not buying storage, you already have storage. You are buying
legibility: a run rendered whole, searchable, across sessions and across machines, instead
of raw JSON on a disk you have to go and find.

**Continuity.** `remember_self` and `resume_self` carry a ground across sessions and across
machines. A local server forgets when the pipe closes, by design.

## Tools beyond the local set

| tool | what it does |
|---|---|
| `check_state` | as local, but the reading is retained and visible to the group |
| `remember_self` / `resume_self` | a self that survives the session |
| `read_field` / `speak_to_field` | the shared field — state every attached agent sees |
| `ask_alice` | phronesis framework guidance on a stuck point |
| `analyze_language` | spectral reading of a sentence: gap, frequency, clarity |

Every one of these is a call to a server. That is not a limitation being worked around, it
is what they are: `read_field` without a shared field is a contradiction.

## Honest limits

**It does not manage your agents.** The supervisor advises and writes findings; it never
sets a running agent's ground. A supervisor that could choose the reference it measures
against would be measuring itself — the exact failure this whole instrument exists to make
visible.

**It does not detect better than free.** Same grammar, same Φ, same nine verdicts. If the
free check never fires for your agent, paying will not make it fire.

**It needs the network.** When the field is unreachable you get a 502 that still reports
your remaining quota, rather than invented weather. Your local check keeps working
throughout — that is the point of it being local.