# Wake

> Wake is agent analytics for websites: it tracks the AI agents visiting a site (ChatGPT, Claude, Perplexity, Cursor, scripted clients), what they try, where they stop, and tells the owner exactly what to change so agents can find, navigate and buy, because the person behind the agent is the customer. One file to install (Cloudflare Worker, Express or Next.js middleware). Free up to 10,000 agent visits per site, then $100 per site per month. No raw IP, user-agent, path, query, body, prompt, cookie or referrer is ever stored.

## Start here
- [What Wake is](https://agent-observatory-desk-production.up.railway.app/wake/docs/index.md): AXO (agent experience optimization) and AEO (agent engine optimization), in one page.
- [Why analytics cannot see AI agents](https://agent-observatory-desk-production.up.railway.app/wake/docs/analytics.md): ChatGPT, Claude and Perplexity fetch the page and do not run a browser pixel, so Google Analytics and PostHog stay at zero.
- [What AXO measures](https://agent-observatory-desk-production.up.railway.app/wake/docs/axo.md): family, page class, status, and the funnel from discovery to a checkout that succeeded. Crawlers are shown and never billed.
- [AEO and GEO](https://agent-observatory-desk-production.up.railway.app/wake/docs/aeo.md): AEO is whether an agent can fetch the site and finish. GEO is whether an answer engine can quote the page. The files overlap. The score does not.
- [llms.txt, robots.txt, sitemap, agent card](https://agent-observatory-desk-production.up.railway.app/wake/docs/discovery.md): what each file is for, including the rule that a named bot does not inherit the wildcard group.
- [Install](https://agent-observatory-desk-production.up.railway.app/wake/docs/install.md): prove ownership, deploy the collector (Cloudflare Worker, Express, Next.js), see the first event. Or let the desk write wake-playbook.md from a deep scan and hand it to your coding agent.
- [API reference](https://agent-observatory-desk-production.up.railway.app/wake/docs/api.md): REST endpoints, auth, windows, errors.
- [OpenAPI](https://agent-observatory-desk-production.up.railway.app/api/wake/v1/openapi.json): machine-readable description of the API.
- [MCP](https://agent-observatory-desk-production.up.railway.app/wake/docs/mcp.md): connect Claude Code, Cursor, Codex or Claude Desktop to a desk.
- [CLI](https://agent-observatory-desk-production.up.railway.app/wake/docs/cli.md): the wake command.
- [Privacy](https://agent-observatory-desk-production.up.railway.app/wake/docs/privacy.md): what is kept, what is never kept.
- [Pilot](https://agent-observatory-desk-production.up.railway.app/wake/docs/pilot.md): how a 30-day pilot runs, from the invite link to the written review.
- [Pricing](https://agent-observatory-desk-production.up.railway.app/wake/docs/pricing.md): free up to 10,000 agent visits per site, then $100 per site per month.
- [Terms](https://agent-observatory-desk-production.up.railway.app/wake/docs/terms.md): the terms of service every account accepts.
- [DPA](https://agent-observatory-desk-production.up.railway.app/wake/docs/dpa.md): the data processing addendum for GDPR customers.

## Product
- [Start with your website](https://agent-observatory-desk-production.up.railway.app/wake/start): enter a hostname, get the deep scan, the tasks and wake-playbook.md at once, no account; sign up only to see the data.
- [Start tracking](https://agent-observatory-desk-production.up.railway.app/wake/signup): open a desk for your site.
- [Inspect a site](https://agent-observatory-desk-production.up.railway.app/wake/?host=example.com): public readiness view of any host.

## Machine endpoints
- Check any site's agent readiness, no key: https://agent-observatory-desk-production.up.railway.app/api/wake/v1/public/readiness?host=example.com (JSON) or the public MCP server POST https://agent-observatory-desk-production.up.railway.app/api/wake/v1/public/mcp (tool wake_check_site)
- API index: https://agent-observatory-desk-production.up.railway.app/api/wake/v1 (GET, no auth)
- Authenticated reads: https://agent-observatory-desk-production.up.railway.app/api/wake/v1/overview?window=7d with Authorization: Bearer wk_live_…
- MCP (streamable HTTP, JSON): POST https://agent-observatory-desk-production.up.railway.app/api/wake/v1/mcp with the same bearer key
- Agent card: https://agent-observatory-desk-production.up.railway.app/.well-known/agent-card.json
- [Full text](https://agent-observatory-desk-production.up.railway.app/llms-full.txt): every public doc in one file, for an answer engine that quotes instead of crawling.

## Research
- [Agent Observatory sensor](https://agent-observatory-sensor.nolimit-observatory.workers.dev/control): the public research desk behind Wake.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/index.md

# Wake

> Wake shows a website which AI agents reach it, what they tried, where they got stuck, and what to change so agents can navigate the site, and the fixes that let the next agent get through. Raw IP, user-agent, query strings, bodies, cookies and referrers are never stored.

Wake has two halves that share one desk:

- **AXO** (agent experience optimization): a small collector on your edge or server mirrors agent requests, coarsened on your side, to Wake. The desk turns them into sessions, a funnel (discovered → read docs → authenticated → attempted action → converted), friction (auth walls, rejected calls, retry loops, docs dead ends) and ranked fixes with evidence. A session is *authenticated* only when a credential was accepted (a 2xx/3xx write on a sign-in path, or an account page after it), and *converted* only by a successful write on checkout; a 2xx API call is an attempted action. Crawlers are sessionised but never produce a docs dead end or a conversion gap. Detail: [What AXO measures](/wake/docs/axo).
- **AEO** (agent engine optimization): a readiness check of your public site as an agent sees it (homepage, robots.txt, llms.txt, sitemap, agent card), publish-ready discovery files (llms.txt, robots.txt, sitemap, agent card), and arrival counts judged by identified agents only. Crawlers are counted separately and never sold as agents. Generative engine optimization (GEO) is the related job of being quoted by an answer engine; the files overlap and the score does not. Detail: [AEO and GEO](/wake/docs/aeo).

## Where to go

| Need | Go to |
|---|---|
| Why Google Analytics misses agents | [Analytics](/wake/docs/analytics) |
| What AXO measures | [AXO](/wake/docs/axo) |
| AEO, and how it differs from GEO | [AEO and GEO](/wake/docs/aeo) |
| llms.txt, robots.txt, sitemap, agent card | [Discovery files](/wake/docs/discovery) |
| Start with your website, no account | [/wake/start](/wake/start): deep scan, tasks and `wake-playbook.md` in one go; then "Verify my setup" once installed |
| Check any public site | `/wake/?host=yourdomain.com` |
| Open a desk for your site | [Start tracking](/wake/signup) |
| Install the collector | [Install](/wake/docs/install) |
| Read the data from code | [API](/wake/docs/api) · [OpenAPI](/api/wake/v1/openapi.json) |
| Ask your AI about your agents | [MCP](/wake/docs/mcp) (Claude Code, Cursor, Codex, Claude Desktop) |
| Terminal | [CLI](/wake/docs/cli) |
| What is kept | [Privacy](/wake/docs/privacy) · [Data processing addendum](/wake/docs/dpa) |
| What it costs | [Pricing](/wake/docs/pricing): free up to 10,000 agent visits per site, then $100 per site per month |
| The rules | [Terms](/wake/docs/terms) |

## The loop

1. **Verify** you own the host (DNS TXT or a well-known file).
2. **Deploy** the collector (Cloudflare Worker, Express middleware or Next.js middleware). Agents are headless, so a browser pixel never sees them; the collector does.
3. **Watch** the first agent session land. The desk, the API, the CLI and your AI assistant all read the same rows.
4. **Fix** what the friction says: a 401 with no instructions, a docs page with no runnable first request, a 5xx on the action call.
5. **List** the site: publish `llms.txt` (title, one blockquote summary, live links), allow the task agents in `robots.txt` (training crawlers are a separate choice), and judge arrivals by identified agents. The scan also checks what the fixes prescribe: a JSON error body on unknown paths, auth instructions on the API, a pricing page readable without JavaScript, Markdown twins of the docs.

## Vocabulary

- **Nickname**: a daily HMAC of the agent's network identity, computed on your side with your own secret. The same machine is a new nickname tomorrow; nothing in Wake can be joined back to an address.
- **Page class**: `home`, `docs`, `auth`, `pricing`, `checkout`, `account`, `search`, `api`, `discovery`, `other`. The collector sends the class, never the URL.
- **Friction kind**: `auth_wall`, `action_unauthorized` (401/403), `action_rejected` (400/422), `action_not_found` (404), `action_wrong_method` (405), `action_rate_limited` (429), `action_server_error` (5xx), `repeated_error` (the same method on the same page class failing three times with the same status; 404s on docs and discovery never count, they are probes), `abandoned_on_error`, `docs_dead_end`. Each kind maps to one remedy in the fixes.
- **Fix**: a friction kind with evidence. It needs three sessions, or a quarter of all sessions on a small site; severity reads both the count and the share (five sessions, or a quarter with at least three, is a block). Every fix carries `sessions`.
- **Identified agent**: a client that names itself (Claude, ChatGPT, Cursor, Perplexity…) or a user-triggered fetcher. Smithery scanners, Amazonbot, Meta, Yandex and bare Chrome on a crawler network are crawlers, reported but never billed.

This site is built with the same rules it recommends: a readable `llms.txt`, the full text in `llms-full.txt`, Markdown docs at `/wake/docs/*.md`, an agent card at `/.well-known/agent-card.json`, and an OpenAPI description.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/analytics.md

# Why Google Analytics cannot see AI agents

> AI agents fetch pages without running JavaScript, so a browser pixel such as Google Analytics or PostHog never records the visit.

ChatGPT, Claude, Perplexity and a coding agent request a URL the way curl does. The person behind the agent asked for a comparison, a price, a docs page or a signup. The agent reads the HTML or the JSON and either continues or stops. There is no browser, no cookie banner and no `gtag`.

## What a pixel needs

A pixel runs after a browser has parsed the document and executed its scripts. It needs the response to be HTML, JavaScript to be allowed to run, and the tag not to be blocked. An agent that wants the docs, the pricing page or the OpenAPI file does none of that.

The request is still real. The person who sent the agent is still a possible customer. The analytics dashboard stays at zero.

A server log sees the request. A pixel does not. Wake sits with the server. A collector on a Cloudflare Worker, in Express middleware or in Next.js middleware reads the request where the site is served, then keeps a coarse record.

## What is kept

Timestamp, method, page class, status, provider family, country, network operator, and a daily nickname computed on your side. The raw IP address, the user-agent string, the path, the query string, the body, the prompt, cookies and the referrer are not stored. The same rule is written in [Privacy](/wake/docs/privacy).

## What the record is for

The desk turns those rows into a session and a funnel: discovered, read docs, authenticated, attempted an action, converted. A conversion is a successful write on checkout, not a page view. Friction is the status plus the page class: an auth wall, a 401 with no next step, a docs page that ends, a repeated error. Each kind has a fix, and the fix carries the sessions behind it. That measurement is [AXO](/wake/docs/axo).

Search crawlers are sessionised and shown. They are not billed, and they are not counted as the agents that can buy.

## What to do

Install the collector where the site is served. [Install](/wake/docs/install) is the three steps. A browser tag cannot be patched into seeing a client that never runs it.

The free scan at [/wake/start](/wake/start) shows how the public site answers an agent before any collector is installed: homepage, robots.txt, llms.txt, sitemap, agent card. How those files should be written is [Discovery files](/wake/docs/discovery).

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/axo.md

# What AXO, agent experience optimization, measures

> AXO is agent experience optimization: which agent fetched the site, what it tried, where it stopped, and which fix matches that stop.

AXO is the measurement half of Wake. A small collector on your edge or server mirrors agent requests, coarsened on your side, to the desk. The desk turns them into sessions, a funnel and ranked fixes. Prompts are never stored.

## The funnel

A session moves through five beats:

1. **Discovered** the site.
2. **Read docs.**
3. **Authenticated.** A credential was accepted: a 2xx or 3xx write on a sign-in path, or an account page after it.
4. **Attempted an action.** A 2xx API call counts here. It is not a conversion.
5. **Converted.** A successful write on checkout.

Search crawlers are sessionised. They do not produce a docs dead end or a conversion gap, and they are never billed.

## The break

Friction is a label on the path class, the status and the order of requests:

- `auth_wall`
- `action_unauthorized` (401 or 403)
- `action_rejected` (400 or 422)
- `action_not_found` (404)
- `action_wrong_method` (405)
- `action_rate_limited` (429)
- `action_server_error` (5xx)
- `repeated_error` — the same method on the same page class failing three times with the same status. A 404 on docs or discovery is a probe, not this.
- `abandoned_on_error`
- `docs_dead_end`

A fix needs three sessions, or a quarter of all sessions on a small site. Severity reads both the count and the share. Every fix carries `sessions`.

## Who counts

An identified agent names itself (Claude, ChatGPT, Cursor, Perplexity) or is a user-triggered fetcher. Smithery scanners, Amazonbot, Meta, Yandex and bare Chrome on a crawler network are crawlers. They are reported. They are not sold as agents.

The page class is one of `home`, `docs`, `auth`, `pricing`, `checkout`, `account`, `search`, `api`, `discovery`, `other`. The collector sends the class, never the URL. The nickname is a daily HMAC of the network identity, computed with your secret. The same machine is a new nickname tomorrow.

Why a browser pixel cannot see any of this is [Why analytics cannot see AI agents](/wake/docs/analytics). Putting the public site where the next agent can read it is [AEO and GEO](/wake/docs/aeo).

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/aeo.md

# Agent engine optimization and generative engine optimization

> AEO is whether an agent can fetch the site and finish the task. GEO is whether an answer engine can quote the page. The files overlap. The score does not.

## AEO

Agent engine optimization is the public half of Wake:

- a readiness check of the homepage, robots.txt, llms.txt, the sitemap and the agent card, as an agent fetches them
- publish-ready copies of those files
- arrivals judged by identified agents: Claude, ChatGPT, Cursor, Perplexity, or a user-triggered fetcher

A search crawler that follows a pinged redirect is not an identified agent. Count it separately. A hop is not a sale and it is not a unique visitor. The same rule is in [What Wake is](/wake/docs/index).

## GEO

Generative engine optimization is how a page gets cited when a person asks an assistant instead of opening a list of links. The name comes from Aggarwal, Murahari, Rajpurohit, Kalyan, Narasimhan and Deshpande, [GEO: Generative Engine Optimization](https://arxiv.org/abs/2311.09735) (KDD 2024). Answer engines — ChatGPT search, Perplexity, Google AI Overviews, Copilot — fetch the page, often without running JavaScript, and quote a passage that already answers the question.

A page that can be quoted tends to have:

- the answer in the first paragraph, in one or two sentences
- the question as a heading
- the same answer in the HTML, not only after a script runs
- a Markdown twin, for a client that sends `Accept: text/markdown`
- `llms.txt` at the root, with a link and a reason for each page
- `robots.txt` that allows the crawlers behind those answers, including OAI-SearchBot, ChatGPT-User, ClaudeBot, PerplexityBot, Googlebot, Google-Extended, Bingbot and Applebot

Those are the same conditions an agent needs in order to read the page and act. GEO is the citation. AEO is the visit, and what happened after it. How to publish the files is [Discovery files](/wake/docs/discovery).

## What this does not claim

Publishing the files does not by itself create customers. Wake shows whether an identified agent arrived, where it stopped, and which file-level change matches that stop. The scan at [/wake/start](/wake/start) is the readiness half. The collector is the visit half, described in [AXO](/wake/docs/axo). [Pricing](/wake/docs/pricing) is free up to 10,000 agent visits per site, then $100 per site per month.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/discovery.md

# llms.txt, robots.txt, the sitemap and the agent card

> llms.txt, robots.txt, a sitemap and an agent card tell an agent what a site is, which paths it may fetch, and which URL is the page.

Wake publishes all four on its own origin. The scan checks them on yours.

## llms.txt

`/llms.txt` is a Markdown index. One heading, one blockquote that says what the site is in a sentence, then a list of links. Each link gets a short reason.

`/llms-full.txt` is that index with the page text inlined, for an answer engine that will quote one file instead of crawling ten.

Serve both as `text/markdown`. Link them from the HTML with `rel="alternate"`.

## robots.txt

Allow the public pages. Disallow desks, sign-in and the API.

A named `User-agent` group does not inherit the `User-agent: *` group. The most specific group is the whole policy for that bot. If GPTBot or OAI-SearchBot has its own group that only says `Allow: /`, that bot is not bound by the Disallow lines written under `*`. Put every bot in one group that shares one set of rules, or repeat the allows and the disallows in each group.

Allowing a bot to read the docs is a separate choice from allowing it to train. OAI-SearchBot and ChatGPT-User fetch a page because a person asked a question. GPTBot is the training crawler. Name both if you want to be cited and you accept training. Name only the search bots if you do not.

## Sitemap

`/sitemap.xml` lists canonical URLs that return 200 and are meant to be indexed. One URL per page. Leave out the duplicate that redirects, or that serves the same document under another path. `lastmod` is the day the page text changed, not the day the sitemap was generated.

Do not list hop redirects. A pinged redirect is how a search crawler arrives. It is not how an agent that can act arrives.

## Agent card

`/.well-known/agent-card.json` names the service, what it does, and the URL of the docs. A client reads it before it calls a tool.

## The page itself

The first HTML response has to contain the words. A document that is an empty `<div id="root">` is invisible to a client that does not run JavaScript. Put the answer in the HTML. Hide that block with CSS only after the app has rendered the same answer.

A doc that agents will quote should answer `Accept: text/markdown` with the source, and `Accept: text/html` with one `h1`, a title, a description and a canonical link.

## Check

[/wake/start](/wake/start) fetches a public hostname the way GPTBot, ClaudeBot, PerplexityBot, a script and a browser would, and reports which of these are missing or blocking. No account. Why those fetches never show up in Google Analytics is [Why analytics cannot see AI agents](/wake/docs/analytics).

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/install.md

# Install Wake

> Three steps: prove you own the host, deploy the collector on your edge or server, watch the first event land. Nothing runs in the browser except, on Express, one optional script tag that tells people apart from headless browsers.

## 0 · Or hand the whole thing to your AI

Open your desk → **Install**. Step 1 has **Hand it to your AI**: one block of instructions with the ownership tag, where it goes on your stack, and the check. Step 2, option B, writes **`wake-playbook.md`** from a deep scan of the public site (how it answers GPTBot, ClaudeBot, PerplexityBot and a scripted client; the stack; llms.txt, agent card, MCP server card, OpenAPI; the site's shape by page class; docs without JavaScript; Markdown negotiation): every change the scan calls for, with the exact files generated from your own pages, where they go on your stack, the collector for your stack with its key once ownership is confirmed, and a curl to verify each step. Save it in the repository and tell Claude Code, Cursor or Codex to complete every task in it. Also: `wake playbook --out wake-playbook.md`, `GET /api/wake/v1/playbook.md`, or the MCP tool `wake_playbook`.

## 1 · Ownership

Open your desk → **Install → step 1**. Add one of:

- **Meta tag (preferred)**: `<meta name="wake-verify" content="…">` in the `<head>` of the homepage, or
- **Well-known file**: `https://<host>/.well-known/wake-verify.txt` with the body shown, or
- **DNS record**: a TXT record at `_wake-verify.<host>` with the value shown.

Wake checks every 30 seconds while the page is open (for up to four hours, then **Check now** starts another four) and the step turns green on its own; **Check now** checks at once. Any one method proves control of the host; nothing else is read. Ownership gates the collector keys, the readiness report and the listing plan.

The check follows one redirect when it stays on the same site (apex ↔ www) and names itself with the user-agent `WakeVerify/0.1`. When it fails, the screen says why per method: the homepage redirects to another host (add that host as the site), the site answered 403 (allow `WakeVerify` in the WAF or bot rules, or use the DNS record), a tag with another token is on the page (copy the tag again), a TXT record exists with another value.

## 2 · Collector

Press **Generate the file**. You get, once, an ingest key and deploy-ready files that already carry it:

| File | Where it runs |
|---|---|
| `cloudflare-worker.js` + `wrangler.toml` | A Cloudflare Worker route in front of your origin (recommended in front of any stack, hosted builders included; zero latency, `waitUntil`). Fill in the route in `wrangler.toml`. |
| `express.js` | Express / Connect middleware on Node ≥ 18. |
| `nextjs-middleware.js` | Next.js `middleware.ts` on the Edge runtime (`proxy.ts` on Next.js 16), plus `withAxo()` on the route handlers agents call. |

The desk opens the files again any time (**Open the files**) as long as the kit was minted after kits were kept; older collectors need **Rotate keys**. The ingest endpoint chosen when the kit was minted is reused when it is reopened, so a reopened file points where the deployed one does. The read key shown with the kit is read access for the API and MCP server; the collector does not need it.

What the collector sends, per agent request: timestamp, method, **page class**, status code, the user-agent (sent for classification and never stored), a country code if your platform provides one, the **network operator** of the address block (the ASN name, such as Amazon or Google, which the Cloudflare collector reads from the edge), and an **opaque per-agent hint** computed from the client address with **your** site secret. The raw IP never leaves your infrastructure. No query string, body, cookie or referrer is ever sent. Prefetch and prerender requests (`Sec-Purpose: prefetch`) are skipped. Wake's own checks carry a keyed `x-wake-probe` header (an HMAC of the UTC day under your ingest key hash) and are never counted; a bare header value does nothing.

Status codes are what make the friction screens work. The Cloudflare Worker and the Express middleware see every response status. Next.js middleware runs before the route and cannot, so its events carry status 0 ("reached"). **The Next.js middleware does not report api, auth, account or checkout requests at all**: wrap those route handlers with the `withAxo()` export from the same file (`import { withAxo } from "@/middleware"`; `@/proxy` on Next.js 16) and their real 401s, 404s and 5xx reach the desk. Without it, those requests are invisible. `withAxo()` reports through `after()` on Next.js 15+, through `waitUntil` where the runtime passes one, and otherwise awaits the send with a 1.5 s cap.

Secrets: each file reads `AXO_SITE_SECRET` (and `AXO_INGEST_KEY`) from the environment first and falls back to the literal inside it, so it can live in a shared repository. On Cloudflare: `wrangler secret put AXO_SITE_SECRET`.

### Express behind a proxy

Behind Railway, Render, Fly, Heroku or any load balancer, the socket address is the proxy's. Tell Express to trust it, before the collector:

```js
app.set("trust proxy", 1);
app.use(axoCollector);
```

The generated file reads the country from `cf-ipcountry`, `x-vercel-ip-country` or `x-country-code`, and the client address from `req.ip`. Both are options of `axoExpressMiddleware`, for a proxy that uses other headers:

```js
axoExpressMiddleware({
  endpoint, ingestKey, siteSecret,
  country: (req) => req.headers["x-my-country"] || "",
  clientIp: (req) => req.headers["x-real-ip"] || req.ip || "",
});
```

A Cloudflare Worker from the same kit in front of an Express collector marks the requests it already reported (`x-wake-collected: 1`); the middleware skips them, so nothing is counted twice.

You can also fetch the kit from a terminal once a key exists ([CLI](/wake/docs/cli)):

```bash
wake install --kit --out ./wake-collector
```

**Rotate keys** mints a new ingest key and site secret; the deployed collector stops until you redeploy, and nicknames restart. The desk says so while no event has arrived since the rotation.

## 3 · First event

The Install screen checks every 10 seconds. Wake never sends test traffic on your behalf: a real agent, or one request you make as an agent after the deploy, produces the first event:

```bash
curl -s -o /dev/null -A "WakeFirstEvent/1.0" https://<host>/
```

It appears as an undeclared likely agent (a non-browser user-agent with no operator family). From then on **Overview** leads with the agents that came, what they did, and what to add to the site so they can navigate it. A desk that has reported once stays live through a quiet week: step 3 shows the first event and says that nothing arrived in the last 7 days.

## The human tell · agent or human, as a percentage

Agents never run page scripts; people scroll, move a pointer, type. Add one line to your HTML layout (Express collector today):

```html
<script src="/__wake/i.js" defer></script>
```

The collector serves that script itself. A page that reports a person (pointer, scroll, keys or touch, with a small proof-of-work the page had to compute) is dropped on your server: nothing about the person is sent. A browser-looking page view that stays silent for ten seconds goes out as a headless suspect. The script also measures how the pointer and the wheel move during the first second after the first interaction, on the page, and sends only a few bucketed numbers (straightness, speed variation, timing regularity, teleport jumps, micro-corrections, wheel burst pattern), never a coordinate: interpolated movement, the way Playwright, Puppeteer and Selenium drive a mouse, is flagged as scripted and the page view goes out as an agent; a hand's movement strengthens the person verdict. Every session on the desk then carries a certainty, **Agent 96%** or **Human 93%** or **Unsure**, with the evidence beside it: identity (a verified Web Bot Auth signature, a declared operator, a non-browser user agent), fingerprint (what every browser sends, the protocol, a cloud address block), behaviour (bursts, strafing, machine-only trails, metronome timing) and the human tell. Nothing identifying is stored at any point.

## Connect your AI

Under **Connect your AI** mint an API key and paste one snippet into Claude Code, Cursor, Codex or Claude Desktop. Your assistant can then ask the desk what agents did and what to fix, directly. See [MCP](/wake/docs/mcp) and [API](/wake/docs/api).

## Troubleshooting

- **401 from the ingest endpoint**: the ingest key was rotated; redeploy with the new file.
- **No events but agents visit**: check the route covers the paths agents hit (docs, API); the Worker template matches the agent user-agent list and `Sec-Fetch` signals, not browsers. On Next.js, api/auth/account/checkout need `withAxo()`.
- **Ownership check answers 403**: a WAF or bot rule blocks `WakeVerify/0.1`; allow that user-agent or use the DNS record.
- **"Could not read the collector state just now"**: the desk could not read the site record or the edge; try again in a minute. The Generate button is withheld rather than minting a key twice.
- **Readiness says agents cannot fetch the homepage**: the first HTTPS request returned a challenge or a non-200. Serve a plain 200 with HTML or Markdown for named AI clients.


## Send agent events to PostHog

If your product analytics live in PostHog, connect your project under **Connect your AI → Destinations**. Every fifteen minutes the desk forwards each agent request as an `agent_request` event and each closed visit as an `agent_session` event (stage, task, friction, conversion, threat level), in PostHog's batch capture format, with `$geoip_disable` and no person profiles. Filter on `wake_site` in PostHog; a funnel of `agent_request` by `page_class` shows the same path the desk shows.


## Which of your accounts the agent acted for

PostHog identifies people with `identify()`; Wake does the agent edition on your server, where you already know who authenticated. In your auth code, name the account on the response: Express `res.locals.axoAccount = user.id` (or the header `x-axo-account: <user id>`); Next.js and Cloudflare: set the response header `x-axo-account`. The collector hashes it with your site secret and strips the header, so the desk groups sessions by account (Agents → "Acting for your accounts", the session detail, the `account` dimension in Explore) and never sees the id. Match the hash on your side when you need to know who.

## Let your AI do the whole install

Give your coding agent an API key from Connect your AI and this prompt:

> Set up Wake for this repository. Call `wake_me` to learn the host. Call `wake_verify`; if it is not verified, place the meta tag it returns in the homepage head, deploy, and call `wake_verify` again until it passes. Then call `wake_provision`, write the file for this stack where its README says (Cloudflare Worker route with its wrangler.toml, Express middleware with `app.set("trust proxy", 1)` and the `/__wake/i.js` script tag in the layout, or Next.js `middleware.ts` / `proxy.ts` plus `withAxo` on the api, auth, account and checkout handlers), set `x-axo-account` in the auth code, deploy, then make one request with the user-agent `WakeFirstEvent/1.0` and call `wake_health` until it reports the event. Report what you changed.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/api.md

# Wake API

> Read what agents did on your site, where they got stuck, what to fix and how the listing is going. Base URL `/api/wake/v1`. Auth: `Authorization: Bearer wk_live_…`. Machine description at [`/api/wake/v1/openapi.json`](/api/wake/v1/openapi.json).

## Authentication

Mint a key on your desk under **Connect your AI** (up to 10 active keys per desk; shown once; stored hashed; revoke any time). Send it as a bearer token:

```bash
curl -H "Authorization: Bearer wk_live_…" "https://wakeagents.ai/api/wake/v1/overview?window=7d"
```

A key reads exactly one desk (one host). Limits: 120 requests per minute per key.

## Windows

`window` is `24h`, `7d` (default) or `30d`. `24h` buckets by hour, the others by day.

## Endpoints

| Method and path | Returns |
|---|---|
| `GET /` | API index (no auth). |
| `GET /openapi.json` | OpenAPI 3.1 (no auth). |
| `GET /me` | Host, verification, collector status, key label, MCP and docs URLs. |
| `GET /overview?window=` | Events, sessions, unique agents, conversions, friction, by provider / class / intent / country / network operator, the funnel, top friction. |
| `GET /agents?window=` | One row per nickname: sessions, events, stage reached, converted, friction types, intents. |
| `GET /sessions?window=&limit=&nickname=` | Session rows, newest first (limit ≤ 500). |
| `GET /sessions.csv?window=` | The same as CSV. |
| `GET /funnel?window=` | Sessions that reached each stage (not cumulative), share, drop, biggest drop. |
| `GET /friction?window=` | Friction tally by kind and page class, with the fixes it implies. |
| `GET /fixes?window=` | Ranked fixes with evidence, plus readiness recommendations (verified desks). |
| `GET /alerts?window=` | Changes versus the previous window. |
| `GET /series?window=` | Time buckets of events, sessions, agents, friction sessions, conversions. |
| `GET /pages?window=` | Page classes touched and the most common sequences. |
| `GET /insight?window=&metric=&breakdown=&filters=&compare=` | A trend: metric (sessions, agents, events, errors, friction_sessions, conversions) per hour or day, broken down by one dimension (provider, agent_class, country, network, path_class, status_class, status, method, stage, intent, friction), filtered by a JSON array of `{dimension, value}`, with the previous window when `compare=true`. |
| `GET /errors?window=` | Every 4xx and 5xx agents received, grouped by page class and status: requests, sessions, agents, families, countries, first and last seen, sessions that ended or looped on it, daily trend, what it means for an agent. |
| `GET /events?window=&limit=&filters=` | The newest coarse requests (max 500), newest first, each with its session's family, tier, country and network. |
| `GET /security?window=` | Threat scoring of agent sessions: hostile, suspicious, watch or clean, from behaviour, claimed identity versus network, anonymisers and your watchlists; flagged sessions with evidence, actors, signal totals, guidance. |
| `GET /destinations` | The PostHog destination: host, masked key, last sync, events sent. Configure it on the desk under Connect your AI. |
| `GET /alert_rules` | The alert rules on this desk (threshold, silence, signal), their channel, last check and delivery, and the delivery log. Rules are created on the desk under Alerts. |
| `GET /health` | Collector health: first and last event, requests and agents in 24 h and 7 d, 14 daily counts, what the requests carry, warnings that name the fix. |
| `GET /readiness` | The public site as an agent sees it: scores, recommendations, probe, publish-ready files. Verified desks. |
| `GET /listing` | AEO plan, step status, arrivals (identified vs crawler), trial. |
| `POST /verify` | Run the ownership check now; records it when it passes. Returns the tag, file and record to place when not yet verified. |
| `POST /provision` · `{rotate}` | Mint the collector keys and return the deploy-ready files (verified desks). The install agent calls verify, then provision, writes the file, deploys. |
| `POST /listing/plan` | Prepare the listing plan (never publishes). Verified desks. |
| `GET /benchmarks` | k-anonymous cohort medians, withheld below k=5. |
| `GET /install` · `?kit=1` | Collector status; with `kit=1` the deploy-ready files (verified desks). |
| `POST /mcp` | MCP endpoint, see [MCP](/wake/docs/mcp). |

## Public, no key

| Method and path | Returns |
|---|---|
| `GET /public/readiness?host=` | Readiness of any public host: scores, recommendations, publish-ready files. 20 requests per minute per address. |
| `GET /public/about` | What Wake is, with links. |
| `POST /public/mcp` | Public MCP server with `wake_check_site` and `wake_about`. Listed on Smithery as `wake-site-readiness`. |

## Shapes

A session row:

```json
{
  "nickname": "ax_1a1IT2kn",
  "provider": "anthropic",
  "agent_class": "declared_ai",
  "started_at": "2026-10-29T04:37:00.000Z",
  "ended_at": "2026-10-29T04:41:12.000Z",
  "duration_ms": 252000,
  "event_count": 6,
  "stage": "attempted_action",
  "intent": "Call the API / integrate",
  "inferred": true,
  "converted": false,
  "friction": [{ "type": "action_unauthorized", "path_class": "api", "detail": "2 failed api requests (status 401) with no success." }],
  "path_classes": ["docs", "docs", "api", "api", "auth", "api"]
}
```

Friction kinds: `auth_wall`, `action_unauthorized`, `action_rejected`, `action_not_found`, `action_wrong_method`, `action_rate_limited`, `action_server_error`, `repeated_error`, `abandoned_on_error`, `docs_dead_end`. Intent is a labelled inference with a confidence, never a claim about what the remote agent meant.

## Errors

JSON `{ "error": "…", "code": "…" }`:

| Status | code | Meaning |
|---|---|---|
| 401 | `unauthorized` | Missing, unknown or revoked key. |
| 403 | `unverified` | The desk has not verified ownership of the host. |
| 404 | `not_provisioned` / `not_found` | No collector yet, or unknown route. |
| 429 | `rate_limited` | More than 120 requests in a minute for this key. |

## Privacy

Every answer is coarse by construction: daily HMAC nicknames, page classes, status codes, operator families, country codes, network operator names. There is no raw IP, user-agent, query, body, cookie or referrer anywhere in the store, so none can be returned. See [Privacy](/wake/docs/privacy).

## Account and desk hygiene (signed-in session)

- `POST /api/v1/wake/fixes/done` `{ id, done }`: marks a fix done on the desk record (every browser agrees). Returns `{ ok, fixes_done }`.
- `POST /api/v1/wake/sites/remove` `{ id }`: removes a site from the account: its desk row, its link sessions and the account's pointer. Events on the edge age out with retention.
- `GET /api/v1/wake/export`: one JSON file with the desk record (no secrets), the last 90 days of requests and visits, the rules and the alert log.
- `POST /api/v1/wake/account/delete` `{ "confirm": "DELETE" }`: deletes every desk on the account, every session, then the account.

Errors on these routes are `{ error, code }`.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/mcp.md

# Wake MCP

> Connect your coding assistant to your desk. Wake is an MCP server (Model Context Protocol, streamable HTTP, JSON responses) at `POST /api/wake/v1/mcp`, authenticated with the same bearer key as the API.

Your assistant gets one tool per question the desk can answer:

| Tool | Answers |
|---|---|
| `wake_me` | Which site this key reads, verification and collector status. |
| `wake_overview` | Headline numbers, funnel and top friction for a window. |
| `wake_agents` | Who came: one row per nickname. |
| `wake_sessions` | Session rows; filter by nickname, limit up to 500. |
| `wake_funnel` | Stages, shares, biggest drop. |
| `wake_friction` | Where agents got stuck and the fixes implied. |
| `wake_fixes` | Ranked fixes with evidence plus readiness recommendations. |
| `wake_pages` | Page classes and common sequences. |
| `wake_alerts` | What changed versus the previous window. |
| `wake_series` | Time buckets. |
| `wake_readiness` | The public site as an agent sees it, with publish-ready files. |
| `wake_listing` | The AEO plan, step status, arrivals, trial. |
| `wake_benchmarks` | Cohort medians (k-anonymous). |
| `wake_install` | Collector status; `kit: true` returns the deploy-ready files. |
| `wake_insight` | A trend: `metric` (sessions, agents, events, errors, friction_sessions, conversions) by `breakdown` (provider, agent_class, country, network, path_class, status_class, status, method, stage, intent, friction), `filters` as a JSON array of `{dimension, value}`, `compare: true` for the previous window. |
| `wake_errors` | Every 4xx and 5xx agents received, grouped by page class and status, with families, countries, trend and what it means. |
| `wake_events` | The newest requests (max 500), one row each with family, country, network, page class and status. |
| `wake_security` | Threat scoring of the window's sessions with evidence, actors and guidance. |
| `wake_destinations` | The PostHog destination and its sync status. |
| `wake_alert_rules` | The alert rules on this desk and their delivery log. |
| `wake_health` | Is the collector reporting, what the requests carry, warnings with the fix. |
| `wake_listing_plan` | Prepares the listing plan (never publishes). |

All tools take `window` (`24h`, `7d`, `30d`) where it applies. Replace `<key>` with a key minted under **Connect your AI** and `<origin>` with your desk origin (for the hosted desk: `https://wakeagents.ai`).

## Claude Code

```bash
claude mcp add --transport http wake <origin>/api/wake/v1/mcp --header "Authorization: Bearer <key>"
```

Then ask: *"Use wake_fixes to tell me what to change on my site this week."*

## Cursor

Save as `.cursor/mcp.json` in your project (or in `~/.cursor/mcp.json` for every project):

```json
{ "mcpServers": { "wake": { "url": "<origin>/api/wake/v1/mcp", "headers": { "Authorization": "Bearer <key>" } } } }
```

## Codex

In `~/.codex/config.toml`:

```toml
[mcp_servers.wake]
url = "<origin>/api/wake/v1/mcp"
bearer_token_env_var = "WAKE_API_KEY"
```

and `export WAKE_API_KEY=<key>` in the shell that starts Codex.

## Claude Desktop and other stdio-only clients

Use the CLI as a bridge:

```json
{ "mcpServers": { "wake": { "command": "npx", "args": ["-y", "wake-agents", "mcp"], "env": { "WAKE_API_KEY": "<key>", "WAKE_API_URL": "<origin>" } } } }
```

## ChatGPT

ChatGPT connectors need an OAuth-fronted MCP server; Wake uses API keys today. Use the [API](/wake/docs/api) from a custom GPT action with the bearer header, or the CLI.

## Protocol notes

- JSON-RPC 2.0 over POST; the server answers `application/json`. `initialize`, `ping`, `tools/list`, `tools/call`, `resources/list` and `prompts/list` are implemented; notifications get HTTP 202. There is no server-initiated event stream (GET returns 405), and no session id is required.
- Protocol versions `2025-06-18`, `2025-03-26` and `2024-11-05` are accepted.
- Tool results carry the JSON both as `content[0].text` and as `structuredContent`.
- Every `wake_*` query tool is read-only. Four tools write to your own desk and nothing else: `wake_verify` (records ownership once it passes), `wake_provision` (returns the collector kit; with `rotate: true` it revokes the live collector key, so it is marked destructive), `wake_listing_plan` (writes a plan to your desk and publishes nothing), and the scan/playbook tools, which only read your public site. Batches are answered in order, at most 20 messages per request, each counted against your key's limit.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/cli.md

# Wake CLI

> `wake` reads your desk from a terminal and bridges it to stdio-only MCP clients. Node ≥ 18, no dependencies.

```bash
npm i -g wake-agents
wake login --key wk_live_… --url https://wakeagents.ai
wake status
```

Config lives in `~/.config/wake/config.json` (mode 0600). `WAKE_API_KEY` and `WAKE_API_URL` override it; `--key` and `--url` override both.

| Command | Does |
|---|---|
| `wake status` | Host, verification, collector, last event, this window's headline. |
| `wake overview` · `agents` · `sessions` · `funnel` · `friction` · `fixes` · `pages` · `alerts` · `series` · `readiness` · `listing` · `benchmarks` · `install` | The matching API read, rendered as a table. `--window 24h|7d|30d`, `--json` for raw JSON. |
| `wake sessions --limit 100 --nickname ax_…` | Filter sessions. |
| `wake export sessions.csv --out file.csv` | CSV export. |
| `wake install --kit --out ./dir` | Write the collector files. |
| `wake listing plan` | Prepare the listing plan (never publishes). |
| `wake connect claude-code|cursor|codex|claude-desktop|chatgpt|curl [--write]` | Print (or write) the client config. |
| `wake mcp` | stdio MCP bridge to your desk, for Claude Desktop and similar. |
| `wake logout` | Forget the key. |

Exit code 1 on any API error, with a one-line reason (`401` → run `wake login`).

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/privacy.md

# Privacy

> Wake is built so that the data it holds cannot identify a person or a machine. This page says who we are, what is kept, what is never kept, and what you can ask. Version `2026-11-10`.

## Who we are

Wake is operated by Agent Observatory, the research project behind the public sensor at agent-observatory-sensor.nolimit-observatory.workers.dev. Contact: the email address in the footer of [the site](/wake/). For sites that process visitor data under the GDPR, the [Data processing addendum](/wake/docs/dpa) describes our role as processor.

## Kept, per site

- Coarse events from your collector: timestamp, method, page class, status code, operator family (a label such as `anthropic`, `openai`, `curl`), identity tier, country code, the network operator name where the edge knows it (an ASN organisation such as `Amazon.com, Inc.`, never an address), and a **daily nickname**.
- The nickname is an HMAC computed from an opaque hint that your collector derives from the client address with **your** secret, folded again with the UTC day and your site id on our side. The same machine tomorrow is a new nickname. Nothing in Wake can be joined back to an address.
- Your email with the hostname, the SHA-256 hashes of your keys, an AES-GCM-sealed copy of the ingest key so the install kit can be reopened, the verification method and time, and your listing plan.

## Never kept

Raw IP addresses, user-agent strings (read in transit to label the operator family, then discarded), query strings, request bodies, prompts, outputs, page content, cookies, referrers, tool arguments, fingerprints, precise location.

## About you, the account holder

Your email, a password hash (scrypt) or your Google account id with its verified email, the hostnames on the account, when you accepted the terms, and, once you subscribe, Stripe's customer and subscription ids. Stripe holds the card; we never see it. We email you about the desk: alerts you set, the end of the trial, invoices, a password reset you asked for, and changes to these pages. No marketing list, no third-party pixels on the desk.

## Retention

Agent visits are kept **90 days** on the edge and on the desk, then deleted. Per-site event files keep the newest records (compaction). Revoking an API key takes effect immediately. Rotating the collector keys restarts nicknames. Removing a site or deleting the account deletes its visits, labels and keys at once, including the rows on the edge. Daily backups of the desk ledgers follow the same 90 days.

## Sub-processors

Cloudflare (edge database and Worker), Railway (the desk), Stripe (payments), Resend (email when configured), and PostHog only if you connect your own project. The [DPA](/wake/docs/dpa) lists what each one sees.

## Your rights

Export the desk as JSON from Settings at any time. Delete the account from Settings; it is immediate and complete. Ask us by email to correct your account data or to send you what we hold about you, and we answer within 30 days. If you are in the EU or UK you can also complain to your data protection authority. A visitor to your site cannot be identified from what Wake holds, so a visitor's request cannot be matched to a row; we confirm that in writing when asked.

## What the API and MCP expose

Exactly what the desk shows: the rows above, aggregated. There is no endpoint that returns anything finer than a page class and a status code, so no key can leak more than that.

## Learning across sites

Wake learns the weight of each piece of evidence from sessions across every site, nightly. The training rows are evidence bits (a declared operator, a missing browser bundle, a burst, a scripted pointer), the address block operator's name, and a label: a verified signature, a page that reported a person, or a site owner's confirmation. No row carries an address, a user agent, a nickname that outlives the day, or the site it came from. The learned weights never flip the direction of a piece of evidence and replace the hand-set ones only when they predict held-out sessions at least as well.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/pilot.md

# Running a pilot with Wake

> A pilot is a named company we invite, onboarded with every step pre-done that can be pre-done. Thirty days, free, one site. The company does three things: claim the desk from the invite link, confirm the host, deploy one file. Wake does the rest.

## What a pilot gets

- A **pre-filled desk**: the invite link `/wake/pilot/<code>` already knows the site, the hosting stack and the readiness score. Claiming it is one sign-in; the site field is locked to the pilot host.
- **Three ways to confirm ownership**, pick the easiest: a `<meta name="wake-verify">` tag on the homepage, a DNS TXT record, or a well-known file. After the intro call Wake can also **vouch** for the host, so the Verify button passes on the first press.
- **The collector file for your stack first.** Wake reads the homepage response headers once (Next.js on Vercel, Cloudflare, Express…) and puts the matching file on top: `nextjs-middleware.js`, `cloudflare-worker.js` or `express.js`. Each already carries the ingest key and the endpoint; the site secret stays in your environment.
- **An engineer handoff page** at `/wake/pilot/<code>/brief.md`: what Wake is, where the site stands today, the three steps, the CLI commands. No secrets in it, safe to forward.
- **A playbook for their AI tool** at `/wake/pilot/<code>/playbook.md`: a deep scan of the site turned into ordered tasks with the exact files to add (llms.txt from their own pages, robots groups, agent card, JSON-LD, the collector for their stack) and a curl per task. Save as `wake-playbook.md`, point Claude Code or Cursor at it. The signed-in version on the desk also carries the ownership tag and the ingest key.
- **A checklist** on the Install screen: claimed → ownership → collector → first agent → AI connected. The same list is what we watch on our side.
- Everything a paying desk gets: agents, sessions, pages, where they stop, ranked fixes with evidence, alerts, benchmarks, the API, the MCP server and the CLI.
- A written review at day 14 and at the end.

## What we ask

- Deploy the collector within the first week. One file, one redeploy.
- Fix at least one friction item the desk ranks, so both sides see a before/after.
- Two 20-minute calls. Honest feedback, including where the desk was wrong.

## Timeline

| Day | What happens |
|---|---|
| 0 | Invite email with the pilot link and the brief. Readiness already run. |
| 0–2 | Claim the desk, confirm the host (or ask us to vouch), deploy the collector. |
| 2–14 | First agents land. Alerts and fixes start ranking. |
| 14 | Review call: what agents did, what to fix first. |
| 15–30 | Fix, recheck readiness, watch the before/after. |
| 30 | Closing review in writing. Decide together whether to continue. |

## Privacy, in one paragraph

The collector sends a timestamp, method, page class (never the URL), status code, operator family (from the user-agent, then discarded) and an opaque per-agent hint computed on your side with your own secret. Raw IP, user-agent, query strings, bodies, cookies, referrers and prompts never leave your infrastructure. Wake keeps the hostname, the account email, hashes of keys, and the pilot code. Full detail: [Privacy](/wake/docs/privacy).

## For the Wake operator

Pilots are minted from a terminal, never from the public site:

```bash
node scripts/with-local-credentials.mjs scripts/wake-pilot.mjs create https://example.com --company "Example" --contact "Ada"
node scripts/with-local-credentials.mjs scripts/wake-pilot.mjs list
node scripts/with-local-credentials.mjs scripts/wake-pilot.mjs vouch <code>
```

`create` runs the readiness check and the stack detection, prints the invite link, the brief link and the signup link. `vouch` is only for a host whose contact we have confirmed; it is recorded as the verification method `pilot` on the desk, visibly.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/pricing.md

# Pricing

> Free up to 10,000 agent visits per site. After that, $100 per site per month, cancel any time. The scan is free forever and needs no account.

## What is free

- **Scan any public site** at [/wake/start](/wake/start): the deep scan, the task list and `wake-playbook.md`. No account.
- **The first 10,000 agent visits on each site**: the full product, with the collector, the API, MCP and alerts. No card to start. An agent visit is one session by an identified or likely AI agent; search crawlers and people are never counted.
- **Pilots**: invited pilot accounts are not charged while the pilot runs.

## The plan

| | Free | Wake |
|---|---|---|
| Price | $0 | $100 per site per month, billed monthly |
| Agent visits | The first 10,000 per site | Not metered |
| Sites | One desk per site; an account holds up to three | Same |
| Collector | Cloudflare Worker, Express or Next.js middleware | Same |
| Data | 90 days of agent visits on the desk, the API, MCP and the export | Same |
| Alerts, integrations | Email and signed webhooks; API keys, MCP, PostHog forwarding | Same |

## When the free visits are used up

Nothing is deleted and the tracker keeps collecting. The Overview keeps showing the totals; Agents, Pages, Problems and Security, the API and MCP close behind a Subscribe button until a subscription exists. Everything that arrived meanwhile is there when you subscribe.

## Cancelling

Cancel from the billing portal under Settings. The desk stays open until the end of the paid month, then the free plan applies again. Deleting the account removes the desk and its data at once; see [Terms](/wake/docs/terms) and [Privacy](/wake/docs/privacy).

## Invoices and payment

Payment is by card through Stripe. Invoices are emailed on each charge and available in the billing portal. Prices are in US dollars and exclude any tax that applies where you are.

Questions: write to the address in the footer of [the site](/wake/).

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/terms.md

# Terms of service

> Plain terms for using Wake. Last changed 2026-11-10 (version `2026-11-10`). If you create an account you accept this page and the [Privacy policy](/wake/docs/privacy).

## Who we are

Wake is operated by Agent Observatory ("we"), reachable at the email address shown in the footer of [the site](/wake/). Agent Observatory is the research project behind the sensor at agent-observatory-sensor.nolimit-observatory.workers.dev.

## What Wake does

Wake shows a website which AI agents reach it, what they tried, where they got stuck, and what to change. You install a small collector where your site is served; it sends coarse events (a daily nickname, page class, status code, operator family, country, network operator) to Wake. The desk, the API, the MCP server and the alerts read those events. The scan at `/wake/start` reads your public site the way an agent does.

## Your account

- You need a working email address and a public site that you control. You claim the site by placing a tag, a DNS record or a file on it; do not claim a site that is not yours.
- You are responsible for the collector you deploy and for what it sends. Our collectors are open source files you can read before you deploy; they never send raw IP addresses, user-agent strings, bodies, cookies, referrers or query strings, and we ask you not to change them so that they do.
- Keep your password and API keys to yourself. Revoke a key from Settings if it leaks; rotate the collector keys from Install.
- One account holds up to three sites. Each site is one desk.

## Price and payment

The scan is free. Each site is free for its first 10,000 agent visits, then $100 per site per month, billed monthly by card through Stripe; see [Pricing](/wake/docs/pricing). When the free visits are used up, nothing is deleted and the collector keeps working; the desk's data screens close until a subscription exists. You can cancel at any time from the billing portal; the desk stays open until the end of the paid month, then the free plan applies again. Charges are not refunded for a part of a month.

## Acceptable use

Use Wake on sites you own or operate. Do not use it to identify people, to follow a machine over time, to collect prompts or page content, or to attack, probe or overload anyone else's site. Do not resell the desk. Do not GET the research sensor's machine endpoints to mint traffic.

## Our side

- We run Wake with care, but it is offered as is, without a guarantee of availability, accuracy or fitness for a purpose. The agent-or-human verdicts are estimates with a stated confidence; the fixes are recommendations.
- We back up the desk ledgers daily and keep agent visits for 90 days. We may change or stop a feature; if we stop Wake we give 30 days notice by email and the export stays available until then.
- To the extent the law allows, our total liability to you for anything arising from Wake is limited to what you paid us in the three months before the claim.

## Your data

What we keep, for how long, and your rights are in the [Privacy policy](/wake/docs/privacy). If you process your visitors' data under the GDPR or a similar law, the [Data processing addendum](/wake/docs/dpa) applies to the collector and forms part of these terms.

## Ending

You can delete the account from Settings at any time; the desk, its keys and its visits go with it, and the edge rows are deleted too. We can close an account that breaks these terms, after telling you unless the breach is an attack.

## Changes and law

We may change these terms; the version at the top changes and we email account holders about anything that matters. These terms are governed by the law of the operator's place of establishment, stated in the footer of the site.

---

Source: https://agent-observatory-desk-production.up.railway.app/wake/docs/dpa.md

# Data processing addendum

> For customers who process their visitors' data under the GDPR, the UK GDPR or a similar law. This page forms part of the [Terms](/wake/docs/terms). Version `2026-11-10`.

## Roles

For the events your collector sends, **you are the controller** and **Wake (Agent Observatory) is the processor**. For your own account data (email, password hash, hostname, billing) Wake is the controller; see [Privacy](/wake/docs/privacy).

## What is processed

Per request that reaches your site from a client the collector forwards: a daily nickname (an HMAC of the client address computed on your side with your secret, folded again with the UTC day and your site id on our side), timestamp, method, page class, status code, operator family, identity tier, country code, the network operator's name, and evidence bits (for example "proof-of-work answered", "pointer looked scripted"). The user-agent string is read in transit to name the operator family and is not stored. No IP address, user-agent, URL, query string, body, cookie, referrer, prompt or page content is ever processed by Wake.

Because the nickname cannot be joined back to an address and changes every day, the events are at the edge of personal data. We still treat them as personal data under this addendum.

## Instructions

Wake processes the events only to produce the desk, the API, MCP, the alerts and the fixes for your site, and, in anonymised form (no site id, no nickname that outlives the day), to learn the weight of each piece of evidence across sites. Your documented instructions are these terms, the settings on your desk, and anything you ask by email.

## Sub-processors

| Who | What | Where |
|---|---|---|
| Cloudflare | Edge database (D1) and Worker that receive and store the events | EU and US data centres, Cloudflare's choice |
| Railway | Hosts the desk and its ledgers | US |
| Stripe | Payments; sees your billing email and card, never events | US, EU |
| Resend | Sends alert and account emails when configured | US |
| PostHog | Only if you connect your own PostHog project; events are forwarded to your project | Your choice |

We tell account holders by email 30 days before adding a sub-processor.

## Security

Events are coarsened before they leave your infrastructure. Keys are stored as SHA-256 hashes; the ingest key copy that lets you reopen the install kit is sealed with AES-GCM. Access to the production stores is limited to the operator. Account passwords are scrypt hashes. Ledgers are backed up daily; backups follow the same retention.

## Retention and deletion

Agent visits are kept 90 days, then deleted on the edge and on the desk. Removing a site or deleting the account deletes its events, labels and keys at once, including the edge rows. The export under Settings gives you the data in JSON at any time.

## Your rights and your visitors' rights

Wake cannot identify a visitor from what it holds, so a request from a visitor cannot be matched to a row; tell us anyway and we will confirm that in writing. We help you answer authority requests and carry out an impact assessment with the facts on this page.

## Transfers

Data may be processed in the United States by the sub-processors above under their standard contractual clauses. Tell us if you need EU-only storage; the edge database region can be pinned.

## Breach

We tell you by email without undue delay, and within 72 hours of learning of it, about any breach affecting your events, with what we know and what we are doing.

## Audit

Once a year, on request and at reasonable notice, we answer a written questionnaire and share this page's evidence (collector source, retention jobs, access list).

## Contact

The email address in the footer of [the site](/wake/).
