# Whozit for Claude and AI agents

Whozit turns any meeting recording into Markdown with the right person on every line, and serves it to your AI tools over MCP. Name each person once. Unsure names are marked, so your agent never treats a guess as fact.

Works today with Claude Code, Claude Desktop, Cursor, VS Code and any MCP client that can send a header.

This is the Markdown copy of https://whozit.io/agents.

## Quick start

1. **Make a token.** Sign up or sign in at https://whozit.io/account, then create a token there. It is shown once, so copy it straight away. You can revoke it any time.
2. **Add the server.** In Claude Code, run this with your token in place of `YOUR_TOKEN`:

   ```bash
   claude mcp add --transport http whozit https://whozit.io/mcp --header "Authorization: Bearer YOUR_TOKEN"
   ```

3. **Ask about a meeting.** Try "List my meetings", or ask about a person or a topic. Your agent only sees names you have given. Until you name people in Whozit, every voice is just Speaker 1, Speaker 2 and so on.

To try it with the sample team: load it, name the four people in the first meeting (Fiona Lane, Mark Diaz, Ed Park and Dan Cole), then ask "What did Fiona Lane commit to?"

## Set up your client

Whozit is a hosted MCP server at `https://whozit.io/mcp` (streamable HTTP). Every request sends one header: `Authorization: Bearer YOUR_TOKEN`.

### Claude Code

The command from the quick start. It uses Claude Code's default local scope, which needs no approval. With `--scope project` the server shows "Pending approval" in `claude mcp list` until you run `claude` and approve it.

### Claude Desktop

Claude Desktop reaches Whozit through `mcp-remote`, which needs Node.js. Add this to `claude_desktop_config.json`, then restart Claude Desktop.

```json
{
  "mcpServers": {
    "whozit": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://whozit.io/mcp",
               "--header", "Authorization: Bearer ${WHOZIT_TOKEN}"],
      "env": { "WHOZIT_TOKEN": "YOUR_TOKEN" }
    }
  }
}
```

On Windows, Claude Desktop can split the header at the space. If that happens, set `WHOZIT_TOKEN` to `Bearer YOUR_TOKEN` and pass `Authorization:${WHOZIT_TOKEN}` instead.

### Cursor

Add this to `~/.cursor/mcp.json`.

```json
{
  "mcpServers": {
    "whozit": {
      "url": "https://whozit.io/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}
```

### VS Code

Add this to `.vscode/mcp.json`.

```json
{
  "servers": {
    "whozit": {
      "type": "http",
      "url": "https://whozit.io/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}
```

### Check a token

Put the token in `WHOZIT_TOKEN` and ask for the tool list. You should get the five tools back as JSON.

```bash
curl -s https://whozit.io/mcp -H "Authorization: Bearer $WHOZIT_TOKEN" -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

## The five tools

Four tools only read. One writes, and it is marked destructive: clients that follow the hint ask before running it. The hints are standard MCP tool annotations. Every tool returns JSON.

| Tool | Hint | Arguments | What it does |
| --- | --- | --- | --- |
| `list_meetings` | read-only | `person`, `since`, `limit`, `offset` | Your meetings, newest first: id, title, date, length, status and who is named. |
| `list_people` | read-only | none | The people Whozit knows: how many meetings each is named in, their latest meeting, and whether Whozit has learned their voice. |
| `get_meeting` | read-only | `meeting_id`, `timestamps`, `page` | One meeting as Markdown, in the `markdown` field, with `meeting_id`, `page` and `pages`. A long meeting comes in pages: ask for the next page until `page` equals `pages`. |
| `find_lines` | read-only | `person`, `words`, `meeting_id`, `since`, `limit` | Lines by who said them, by words in them, or both. Each line has `meeting_id`, `title`, `date`, `time`, `speaker`, `name_confirmed` and `text`. |
| `name_voice` | destructive | `meeting_id`, `speaker`, `name` | Puts a name on one voice in one meeting, for example "Speaker 4" as "Kai Tanaka". It replaces the name that voice has there now, even a confirmed one, and marks the new name confirmed. It touches only that meeting. |

## The Markdown

`get_meeting` returns a header, then every line under the name of the person who said it. The header lists the people named, how many voices are still unnamed, which names nobody has confirmed, and the file it came from. Each line carries the time it starts. This example has made-up names.

```markdown
---
title: "Team sync"
date: 2026-10-02
duration: "12:40"
participants:
  - "Dev Patel"
  - "Rosa Alvarez"
  - "Sam Ortiz"
unnamed_speakers: 1
unconfirmed_names:
  - "Sam Ortiz"
source: "team-sync.m4a"
generated_by: Whozit
---
# Team sync
**Dev Patel** (4:31): I'll send the pilot list by Thursday.
**Rosa Alvarez** (4:40): I'll check who meets in person by Wednesday.
**Speaker 4** (5:02, might be Kai Tanaka): Does the pilot list include the Denver team?
**Sam Ortiz** (5:20, name unconfirmed): It should, yes.
```

## How names are marked

Whozit never passes a guess off as a name. There are three cases:

- **Confirmed**, `**Dev Patel** (4:31)`: a person put this name on the voice, or checked it. In `find_lines`, `name_confirmed` is `true`. Safe to quote.
- **Unconfirmed**, `**Sam Ortiz** (5:20, name unconfirmed)`: Whozit filled the name in from a voice it knows, and nobody has checked it. The header lists it under `unconfirmed_names`, and `find_lines` says `name_confirmed: false`. Treat it as likely, not certain.
- **Speaker N, with a hint**, `**Speaker 4** (5:02, might be Kai Tanaka)`: nobody has named this voice. The hint is a suggestion, never a name.

A good rule for an agent: state confirmed names as fact, say "probably" for unconfirmed ones, leave hints out of answers, and ask the person before using `name_voice`.

## Tokens and limits

- Each user makes a personal token on the account page. It is shown once and can be revoked.
- A token only reads that user's own data.
- 120 calls a minute per account, all its tokens together.
- A result stays under 150,000 characters. Long meetings come in pages, and a search that matches too much tells you to narrow it.

## Coming next

OAuth sign-in. The Claude.ai and ChatGPT connector directories need it, and Whozit doesn't have it yet, so it isn't in them. Until then, use one of the clients above. To hear when it's ready, write to hello@whozit.io.