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

# Scoreboard

> Every question on every engine in three colours: green when you are named and linked, amber when you are named, red when you are not, and grey where nothing was read.

The scoreboard answers one question for each engine: how many of your questions does it answer with you? It is read from the same cells as the [prompt state](https://docs.attensira.com/measure/prompt-state.md) grid, so the two never disagree about a question.

## What do the colours mean?

Each question gets one colour per engine. The colour is that engine's [cell state](https://docs.attensira.com/measure/prompt-state.md) on the question, from the latest successful answers in the window.

| Colour | Cell state (`state`) | What it means |
| - | - | - |
| Green | Named and linked (`named_linked`) | You are named in at least half of the answers, and your site is cited in at least half of them. |
| Amber | Named (`named`) | You are named in at least half of the answers, but your site is not cited in half of them. |
| Red | Lost or absent (`lost`, `absent`) | You are not named. When a tracked competitor is named instead, the scoreboard says which one. |
| Grey | Not measured (`unmeasured`) | No successful answer came back on this engine in the window. |

Grey is never counted as red. An engine we could not read has not measured you at zero, so a grey cell neither helps nor hurts you.

Each question also gets one colour across its engines, using the prompt rule on the [prompt state](https://docs.attensira.com/measure/prompt-state.md) page. It is green when you are named on at least half of its engines and named and linked on at least one, amber when you are named on at least one engine but not enough for green, red when you are not named on any, and grey when no engine measured it.

## How is the list ordered?

Red questions come first, and among them the questions lost on the most engines. Then come amber, green and grey. A red question that a competitor took names that competitor: the one it was lost to on the most engines, with ties broken alphabetically.

## What does each engine's line show?

* **Counts.** How many questions are green, amber, red and grey on that engine. They add up to every question the engine is tracked on, including the grey ones.
* **Share.** Green questions divided by measured questions (green, amber and red). Grey questions are left out of the share. For example, "12 of 20 green" means 20 questions were measured and 12 were green.
* **Change.** The share against the same share over the window before, of the same length.

An engine with no measured question is grey and shows **not read**. Its share is empty, never 0%.

## When is a change shown?

A change is shown only when it is larger than the sampling noise, using the same rule as [before and after](https://docs.attensira.com/measure/before-and-after.md):

* When both windows have at least 30 measured questions on the engine, the change must pass a two-proportion z-test at 95%.
* Otherwise, it must pass Fisher's exact test, two-sided, at p ≤ 0.05.

A change that does not pass shows no number. In the API it is `"value": null, "real": false`, and `delta_reason` says why: `inside the noise`, `no change`, `not read in the window before, so there is nothing to compare`, or `not read in this window`.

At small sample sizes, most changes do not pass. For example, 3 of 5 green against 2 of 5 the week before is inside the noise, while 12 of 12 against 0 of 12 is a real change.

## What if an engine is slow?

Each engine reads the window before on its own, with its own deadline. If one engine does not answer in time, it keeps its counts and share, and only its change is empty, with the reason `the window before did not answer in time`. The other engines are not affected.

## Can I see one market?

When your workspace reads more than one [market](https://docs.attensira.com/tracking/markets.md), add `market` with a country code, for example `?market=DE`, to count only that market's answers, the window before included. Leave it out, or pass `all`, for every market.

A market with nothing read in the window is grey and says **not read**, and so is every engine and question in it. A market we have not read has not measured you at zero. The response then also carries:

```json theme={null}
"market": { "market": "FR", "read": false, "colour": "grey", "label": "not read" }
```

A market that was read carries `"market": { "market": "DE", "read": true }`. A value that is not a two-letter country code is refused with a 400.

Under `?market=`, readings stored without a country (taken before your workspace had markets) are not counted, not even for your primary market. Without `market`, every reading counts as before.

## In the app

The Scoreboard is the first tab of the right panel in the [thread view](https://docs.attensira.com/app/harness.md#the-right-panel), on every screen there, and it has a page of its own at `/scoreboard`. `/scoreboard?question=<prompt id>` opens with that question's drawer open, once the board lists it; a question the board does not list opens nothing. A [rival alert](https://docs.attensira.com/agent/rival-alerts.md)'s **See the rival** adds `&alert=<id>`: the alert and its **Counter it** lead that drawer, or sit above the board when the drawer is not open.

* **The headline** is *N / M questions green*: questions, not engine cells. M is the questions some engine read in the window; questions no engine read are counted apart as *not read*, never as not mentioned. When no question has been read yet, the headline is a dash and says why, never *0 / 0*. Beside it, *▲k* (or *▼k*) is how many more (or fewer) questions are green than in the window before. It is shown only when that change passes the same test as an engine's change, every engine read now was also read in the window before, and the count moved the same way as the share; otherwise nothing is shown. Under the headline, a line gives the green, amber, red and not-read counts and the window, and *As of* gives the time the numbers were read.

* **By engine**, a bar per engine shows its green, amber and red questions, largest first, with each count written beside a symbol (● with a link, ◐ mentioned, ○ not mentioned), so the bar is never the only way to read it. The share is printed beside the engine's name with the number of questions it was counted over (*33% of 6*). Under five read questions, the share is not shown: one question would move it by a fifth or more, so the line says *Not enough answers yet to tell (n=3 of 5 needed).* A change appears only when it passed the test [above](#when-is-a-change-shown). An engine that was not read is drawn as an empty outline that says **not read**, with no share.

* **Competitors**, beside the page's title, opens the Scoreboard's [Competitors view](https://docs.attensira.com/tracking/competitors.md#where-are-competitors-in-the-app): every tracked competitor's share of answers beside yours, the suggestions, and each competitor's lost questions and sources.

* **Not mentioned** lists the red questions, each with who was named instead and on how many engines. In the panel the list shows the first eight and counts the rest; the page lists every question, grouped by colour, and switches the window between 7, 30 and 90 days.

* **A question opens a drawer**, full screen on a phone, that leads with its **deciding sources**: for each engine that does not name you (every engine, for a question that is not red), the domains its answers cite most, each with the share of answers and the number of answers counted. Then come the changes made for the question: each opens beside the thread with its diff, Undo and receipt (on a phone, as its own page). Below them is the question's full [detail](https://docs.attensira.com/tracking/prompts.md#a-prompts-detail): its answers and sources.

* **Boards**, beside the page's title, opens the workspace's [boards](https://docs.attensira.com/measure/boards.md) at `/scoreboard/boards`: ours, yours, and the charts you pinned from chats.

### Prompts: changing what the Scoreboard reads

**Prompts**, in the page's header, opens `/scoreboard/prompts`: every prompt the Scoreboard reads, grouped by [topic](https://docs.attensira.com/tracking/topics.md), with your [prompt slots](https://docs.attensira.com/tracking/prompts.md#how-do-prompt-slots-work) used against your plan's limit. You can also reach it by typing "prompts" or "topics" into search. Everything about the tracked set is changed there; see [Prompts](https://docs.attensira.com/tracking/prompts.md#how-do-i-add-prompts) and [Topics](https://docs.attensira.com/tracking/topics.md#how-do-i-create-and-change-topics) for what each action does.

On a phone the panel becomes one line at the top of the thread, *1/4 green ›*, which opens it full screen. If the Scoreboard has not loaded, the line says *Scoreboard didn't load ›* and opens the panel, which has **Retry**.

### In the first 30 days

Until the window has been read on every one of its days and no change has a 30-day result yet, the Scoreboard says when the first 30-day result arrives (*First 30-day results on Nov 16*, the earliest 30-day check of a change that has shipped), how many changes have shipped and how many are live on your site, and how many questions already name you, with a link to what we did, change by change. It never shows an empty "no data" block.

### When the Scoreboard cannot be read

The Scoreboard is read again every five minutes while it is on screen, and when you come back to the tab. The same holds when the app cannot tell which workspace you are looking at: that read is tried again on the same clock.

* If a read fails after one has succeeded, the last numbers stay on screen with the time they were read, a line saying the latest read didn't come back and when it will be tried again, and **Retry**.
* If the first read fails, the panel says so, says when it will be tried again, and offers **Retry**. It is never a blank panel.

In the app, the panel reads the same handler as the API below, for the workspace you are looking at (`GET /v1/projects/{id}/scoreboard?days=`, signed in), so the panel and an agent get the same numbers for the same window.

### Site health

**Site health** is a view of the Scoreboard at `/scoreboard?view=site-health`: what stops answer engines and AI agents reading your site, each check with its status and the fix. Open it from **Site health** beside the Scoreboard's title, or type *site health* (or *llms.txt*, *crawl*, *schema*) in Search. It switches between 7, 30 and 90 days like the board, and **Scoreboard** takes you back. It is on every plan. The old `/analytics/site-health` page no longer exists.

It has two sections, each read on its own, so one that fails never hides the other:

* **Agent readiness** lists three checks, each *Passing*, *Failing*, *Needs you* or *Not checked yet*:
  * **Product feed**: your public [product feed](https://docs.attensira.com/agent-readiness/feed.md), and how many of your facts are in it. When it is off, **Turn on** turns it on. Turning it on is your decision, so an agent cannot do it for you. When it is on with nothing to publish, **Open Brand Book** takes you to the facts to confirm and mark public.
  * **llms.txt**: the same feed as an llms.txt, with its address once it is live.
  * **Signup walk**: the weekly [signup check](https://docs.attensira.com/agent-readiness/signup-check.md). A blocker shows what the agent found, and **Open the fix** opens the Change it filed. Until you have given [consent](https://docs.attensira.com/agent/consent.md) for agents to browse your domain, the row says **Needs you** and **Give consent** takes you to **Settings › Autonomy**, where you give it.
* **Page checks** lists what the crawl of your own pages found: unreadable pages, `noindex`, missing titles and meta descriptions, shared titles, thin or empty pages, missing structured data, canonical problems, missing H1 and Open Graph tags. Issues are ordered by **how many pages one change fixes**, then by severity (*Critical*, *Serious*, *Minor*), so a shared template behind 30 pages comes before a single broken page. Each row says how many pages it affects, gives up to two example URLs, and says who ships the fix:
  * **Fix with the agent** opens the agent with the issue, its page count and an example already in the question. What it drafts waits for your approval in the [Inbox](https://docs.attensira.com/app/queue.md) as a Change. Nothing ships until you approve it.
  * **Write up with the agent** is shown instead when the fix belongs to your engineers (headers, redirects, a page that fails to load). The agent writes up the exact change for them.
  * **Dismiss** (×) hides the issue on this board. The issue is not deleted: it is still on the site, and the next crawl still checks for it.

Before any page has been read, the section says *0 pages read* and when issues will appear. It never says *nothing to fix* before then. A crawl that found nothing says *0 open issues*. When some reads failed, some pages are still to be read, or some checks could not run, a line above the list says so, because the list may then be missing issues. When this deployment does not report one of the sections, it says *isn't reported here* and never shows it as passing.

The view reads the same `/v1` endpoints as the API, signed in: `GET /v1/projects/{id}/analytics/site-health?days=` (and `POST …/site-health/{issueId}/dismiss`) and `GET /v1/projects/{id}/agent-readiness` (and `PATCH` with `{"enabled": true}` for **Turn on**).

## Can I read it from my own tools?

Yes. Over REST the scoreboard is the `scoreboard` view of [`GET /v1/views/{view}`](https://docs.attensira.com/api/endpoints#get-/v1/views/view), with `days` and `market`, and is also read directly from `GET https://webapp.attensira.com/v1/scoreboard?days=30` (optionally `&market=DE`). Both take the same API key as the [REST API](https://docs.attensira.com/api/overview.md). Over MCP it is [`analyze`](https://docs.attensira.com/mcp/tools#analyze) with `view: "scoreboard"` and `days`; the `market` parameter reaches MCP once the MCP server's view list carries it; until then MCP takes `days` only and reads every market. The read returns this document (inside `data` on the view):

```json theme={null}
{
  "project_id": "…",
  "window": { "start": "2026-09-18T00:00:00Z", "end": "2026-10-18T00:00:00Z", "coverage": { "days_sampled": 30, "days_in_window": 30 } },
  "totals": { "green": 14, "amber": 9, "red": 13, "grey": 4 },
  "engines": [
    {
      "engine": "chatgpt",
      "read": true,
      "label": "8 of 18 green",
      "counts": { "green": 8, "amber": 4, "red": 6, "grey": 2 },
      "share": { "value": 0.444, "n": 18 },
      "delta": { "value": null, "real": false },
      "delta_method": "fisher_exact",
      "delta_reason": "inside the noise"
    },
    {
      "engine": "gemini",
      "read": false,
      "colour": "grey",
      "label": "not read",
      "counts": { "green": 0, "amber": 0, "red": 0, "grey": 20 },
      "share": { "value": null, "n": 0 },
      "delta": { "value": null, "real": false },
      "delta_method": "none",
      "delta_reason": "not read in this window"
    }
  ],
  "questions": [
    {
      "prompt_id": "…",
      "text": "What is the best expense tool for a small agency?",
      "colour": "red",
      "lost_on": 2,
      "lost_to": "rival.com",
      "engines": [
        { "engine": "chatgpt", "colour": "red", "state": "lost", "n": 3, "lost_to": "rival.com" },
        { "engine": "gemini", "colour": "grey", "state": "unmeasured", "n": 0, "reason": "not read in this window" }
      ]
    }
  ],
  "questions_delta": {
    "green": null,
    "share": { "value": null, "real": false },
    "method": "none",
    "reason": "not every engine was read in the window before, so the questions cannot be compared"
  }
}
```

`delta_method` is `z_test`, `fisher_exact` or `none`. `questions_delta` is the headline's movement, `{green, share, method, reason}`: `green` is the change in green questions, set only when `share` (green questions ÷ read questions, against the window before) is `"real": true` and the count moved the same way as the share; `reason` says why it is null otherwise.


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