> For the complete documentation index, see [llms.txt](https://thecontentforge.gitbook.io/thecontentforge-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://thecontentforge.gitbook.io/thecontentforge-docs/investor-intel/hosted-mcp.md).

# Hosted MCP Server

Investor Intel runs an MCP server at one hosted address. Create an agent token on the **Agents** page (`/intel/agents`), give your agent the address and the token, and it can read the market and tokenized real-world-asset intelligence, read your own records within the token's scopes, and propose changes that you approve. Nothing is installed on your computer.

```
https://api.thecontentforge.io/functions/v1/intel-mcp
```

The first address, `https://andrimdaxlxcqgqdqrbz.supabase.co/functions/v1/intel-mcp`, still works and will keep working: a client set up with it needs no change.

The Agents page shows the same address under **Connect your agent**, with ready-made lines for each client and a **Test this token** button that checks a token without spending a daily call. How tokens, scopes and approvals work is on [Agents and Agent Access](https://thecontentforge.gitbook.io/thecontentforge-docs/investor-intel/agent-access.md). The hosted server has no tool for the Portfolio, Theses and Charts scopes; those are reached through the [Local Agent Bridge](https://thecontentforge.gitbook.io/thecontentforge-docs/investor-intel/local-agent-bridge.md).

## Connect a client

**Claude Code**

```bash
claude mcp add --transport http investor-intel \
  https://api.thecontentforge.io/functions/v1/intel-mcp \
  --header "Authorization: Bearer tcfagt_..."
```

**Cursor, and any client whose config takes a URL with headers.** `.cursor/mcp.json` for one project, `~/.cursor/mcp.json` for all of them:

```json
{
  "mcpServers": {
    "investor-intel": {
      "url": "https://api.thecontentforge.io/functions/v1/intel-mcp",
      "headers": { "Authorization": "Bearer tcfagt_..." }
    }
  }
}
```

**Claude Desktop.** A Claude Desktop **Custom Connector** cannot reach this server: a connector runs the server's own sign-in (normally OAuth) and has no field for a header you supply, so pointing one at this address ends in a registration or sign-in failure. Use `mcp-remote`, a small local bridge that Claude Desktop starts like any local server and that forwards the header. Node must be installed. In **Settings**, then **Developer**, then **Edit Config**:

```json
{
  "mcpServers": {
    "investor-intel": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://api.thecontentforge.io/functions/v1/intel-mcp",
        "--header", "Authorization:${INTEL_TOKEN}",
        "--transport", "http-only"
      ],
      "env": { "INTEL_TOKEN": "Bearer tcfagt_..." }
    }
  }
}
```

* Keep the token in `env` and reference it from the header, as above. An argument list is visible to other processes; an environment variable is not. If the variable is missing, `mcp-remote` warns and sends the literal text, which then fails as a bad token.
* Write `Authorization:${INTEL_TOKEN}` with no space after the colon. `mcp-remote` splits on the first colon, so a space would end up inside the value.
* `--transport http-only` saves a round trip, because this server has no SSE endpoint.

**Check a token**

```bash
curl -s https://api.thecontentforge.io/functions/v1/intel-mcp \
  -H "Authorization: Bearer tcfagt_..." \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

A list of tools means the token is live. A 401 with a `WWW-Authenticate` header means the token is missing, wrong, revoked or expired. With the MCP Inspector:

```bash
npx @modelcontextprotocol/inspector --cli \
  https://api.thecontentforge.io/functions/v1/intel-mcp \
  --transport http --header "Authorization: Bearer tcfagt_..." \
  --method tools/list
```

The Inspector CLI turns a numeric-looking `--tool-arg` value into a number, so `--tool-arg subject=4705` is refused by a schema that wants a string. That comes from the Inspector, not from this server.

## Public demo (no account)

```
https://api.thecontentforge.io/functions/v1/intel-mcp-demo
```

The first address, `https://andrimdaxlxcqgqdqrbz.supabase.co/functions/v1/intel-mcp-demo`, still works and will keep working.

Anyone can connect to the demo with no account and no token. It serves the read tools that answer from stored captures on free plan surfaces; `tools/list` on the demo names them.

* **Not in the demo:** every write; every tool that reads your own records, your token or its allowance (`whoami`, `data_budget`, watchlists, alerts, proposals, `save_research_note`, `daily_brief_read`, `explain_read`, `saved_research_read`); `rwa_issuer_terms`, which sits on a Starter plan surface; `export_series`; and the members-only CoinMarketCap readings, which are licensed for signed-in members only. Calling one is refused by name, with the reason, before anything runs.
* **Candles without CoinMarketCap.** `get_candles` is in the demo and reads the demo chart's own stored candles. CoinMarketCap price history is for signed-in members, so the demo serves venue and other stored candles only and counts the CoinMarketCap candles it left out in `points.withheld_for_licence`.
* **Read only, stored data only.** The demo never writes, never calls a provider and never runs AI. A stale `as_of` means the capture is stale, and asking again returns the same reading.
* **Tracked assets only.** A tool that names one asset answers only for assets one of our capture lanes observed in the last 7 days. Anything else comes back as an answer with `state: not_tracked_in_demo`, which is a fact about the demo, not about the asset.
* **Limits per network address:** 60 requests and 30 tool calls a minute, and 300 tool calls a UTC day.
* **One shared cap for everyone:** 10,000 tool calls a day across all demo users together. When it is spent, the 429 says the public demo has answered its 10,000 tool calls for today. That is everyone's allowance running out, not yours, and it resets at midnight UTC. Every 429 carries `Retry-After`.
* **Size:** a request body may be 16 KiB and an answer 256 KiB. In full text mode an oversize answer drops its duplicate `structuredContent` first; if it is still too large, or in summary mode, it is refused with `result_too_large`, which says to ask for fewer rows, a shorter window or one subject.
* Every demo result starts with a `demo` block (read only, stored data, and its `as_of`), and `initialize` answers with `serverInfo.name` `investor-intel-demo`. If the demo cannot check its limits it answers 503 and runs nothing.

## Authentication

The only credential is an agent token, sent as `Authorization: Bearer tcfagt_...`. No `apikey` header is needed, and there is no OAuth flow. Before any tool runs, every request is checked in this order:

1. **An agent token.** A missing bearer, or one that is not an agent token (for example a signed-in session key), is refused with 401 and a `WWW-Authenticate` header that says what is wanted.
2. **The token is live**, and the member who created it is still in the workspace with Investor Intel access. A revoked token, or a member who lost access, is stopped on the next request.
3. **The plan includes agent access** (Starter and above), asked again on every request. Otherwise 403, in words, and nothing is read.
4. **The token's limits** (see [Limits](#limits)).
5. **Per tool:** the token's scope, then the tool's plan surface.

Refusals are named: `token_invalid`, `token_revoked` and `token_expired` (401); `membership_revoked` and `entitlement_lost` (403); `rate_limited` and `daily_quota_reached` (429); `limiter_unavailable` and `quota_unavailable` (503). A token cannot create, list or revoke tokens, and cannot approve anything: those need you, signed in, on the Agents page.

## Protocol

MCP Streamable HTTP, stateless, one JSON response per POST. Protocol versions `2025-06-18` and `2025-03-26` are supported; a client that asks for another gets `2025-06-18` back and decides whether it can work with it.

| Method                                                 | Behaviour                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `initialize`                                           | Negotiates the version, advertises `tools`, `resources` and `prompts` with `listChanged: false`, and returns the server instructions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `notifications/initialized`, `notifications/cancelled` | Accepted: 202, empty body                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `ping`                                                 | Empty result                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `tools/list`                                           | Every tool with its JSON Schema, an `outputSchema` for the result envelope, and `annotations`: `readOnlyHint` is false only on the writes (`watchlist_add`, `alert_create`, `alert_create_rule`, `write_run`, `save_research_note`), `destructiveHint` is false, `openWorldHint` is false on every tool but `exit_quote` (the one tool that asks a provider), and `idempotentHint` is true on every read except `exit_quote` and on `alert_create`, `alert_create_rule` and `write_run`. Each description ends with the scope and plan surface the tool needs, `Contract version 1.` on a versioned tool, and its capture cadence, which is also in `_meta` under `investor-intel/freshness` (`cadence`, `cadence_seconds`, `stale_after_seconds`, `kind`, `lanes`) |
| `tools/call`                                           | Runs one tool                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `resources/list`, `resources/read`                     | Two static resources: `investor-intel://tools` (the tool catalogue as JSON, with each tool's scope, plan surface and whether it writes) and `investor-intel://grounding` (how to quote a figure, as Markdown)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `resources/templates/list`                             | An empty list                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `prompts/list`, `prompts/get`                          | Two prompts: `ground_a_claim` (takes `claim`) and `rwa_due_diligence` (takes `subject`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `GET`, `DELETE`, anything else                         | 405 with `Allow: POST, OPTIONS`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |

Neither resource carries your data; your data is only ever behind a tool, where the scope and plan checks are. A resource uri or prompt name that was never listed is refused with `INVALID_PARAMS` naming it. A prompt with a missing required argument still renders, with a named blank for you to fill in.

There is no session and no server stream. `Mcp-Session-Id` is never issued, and one sent by a client is ignored. JSON-RPC batches are refused: send one request per POST.

A request body may be at most 64 KiB, and every tool argument has a `maxLength` (the largest, `save_research_note.body`, is 20,000 characters). A larger body is refused with 413 before anything is parsed. Above roughly 256 KiB the connection can stall instead of returning that 413, and your client times out on its own clock; nothing is read or spent either way.

A **tool that refuses** returns a normal result with `isError: true` and a reason your agent can act on. A **protocol fault** (unknown method, unknown tool name, malformed request) returns a JSON-RPC error. A client retries one and not the other.

### Text mode: one copy of the answer

* **Summary text.** A client that sends `MCP-Protocol-Version: 2025-06-18` or newer gets the full answer in `structuredContent` and a short plain summary in the text block: the tool, `as_of` with its readable label, the provider, `calculated_by`, the note, whether the reading is stale, the window asked for against the window returned with any gaps (for example `Window: asked for 30 days, returned 21 days, 1 gap`), how many rows each main list holds, the attribution when one is required, the licence line, up to 24 key figures by their field path (for example `latest.fearGreed 45`, three rows per list), and the sentence "A client that reads only text can add ?text=full to the server address."
* **Full text.** A client that sends no protocol header, or `2025-03-26`, gets the whole payload as compact JSON in the text block as well.
* **The address decides first.** `?text=full` on the server address forces the full JSON text whatever version was negotiated; `?text=summary` forces the summary.
* A refusal (`isError: true`) always keeps its full JSON text, because it is small and a model must read the reason to act on it.

### Result size

Every result is bounded. A single series carries at most 60 points, chosen at an even stride that always keeps the first and last observation, so the window you asked for is unchanged; `series_points` says how many points there really were, and the note says a trim happened. An answer with several series shares one budget of 180 points, at least 12 per series (`series_points.per_type_cap` and `total_cap` report what was applied); past 15 series only the first 15 get points and the rest keep their row with an empty series and `points_omitted`. Ranked lists are cut at the head by a named argument, and the note says how many matched. As a last step, a payload still over 50,000 bytes has its lists cut (series by even stride, lists from the head) until it fits, never a single figure changed, and the note says so. The text block is compact JSON, not indented.

## What every result carries

| Field            | Meaning                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `as_of`          | The **observation time** of the newest data the answer rests on: the provider's own clock, or when we read the provider, whichever the store records. **May be null**, which means nothing has been captured yet. Never the current time standing in for a capture time                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `observed_at`    | The same observation time, or null when the store records none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `capture_bucket` | The capture window the rows are filed under, when the store files by window (for example `16:00` for a run that read prices at `16:47`), else null                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `as_of_meaning`  | `observation_time`, or `capture_window` when the store records no observation time and `as_of` is only the window (a DEX board with no price clock on its rows, our hourly unusual-move scoring)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `captured_at`    | When **we** captured the reading, beside the provider's observation time, on tools whose store records both. A provider can publish a figure once a day while we capture it hourly, so the two can be hours apart                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `freshness`      | `{ cadence, cadence_seconds, stale_after_seconds, age_seconds, stale }` from the published cadence table on [Methodology](https://thecontentforge.gitbook.io/thecontentforge-docs/investor-intel/methodology.md). `stale` is true once the reading is older than its lane allows (1.5 cadences plus 15 minutes) and null when that cannot be judged. A result with `captured_at` is judged by capture time, and freshness then also carries `judged_by` (`capture_time` or `observation_time`), `captured_at`, `capture_age_seconds`, `observed_at` and `observation_age_seconds`: a daily provider figure we captured an hour ago is not stale, and its own age is shown beside it                                                |
| `window`         | On every windowed tool: `requested { from, to, days }`, `returned { from, to, days, captures }`, `expected_step_seconds`, `starts_late_by_seconds`, `ends_early_by_seconds`, `gaps_checked`, `gaps [{ from, to, seconds, missing_captures }]` (the first 20 in time order), `gap_count` and `gap_seconds` (which count them all), `complete`, `truncated` and a `summary` sentence. A gap is two consecutive captures further apart than the lane's step times 1.5 plus 15 minutes; on a sampled series the threshold is at least 2.5 times the median spacing, so sampling is never reported as a gap. `gaps_checked: false` means the store could not be checked, never that it has no gaps. Never describe a trend across a gap |
| `time_labels`    | Each distinct timestamp or date in the result mapped to a readable label with its weekday, for example `Tue 22 Sep 2026, 16:58:36 UTC`. Quote these rather than working out a weekday. At most 40; `time_labels_truncated` says when the list stopped                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `source`         | `{ provider, endpoint_family, store }`: who the figure came from, which family of their endpoints, and `store`, which names our table holding the figure. An array when an answer joins two stores. `attribution` when a licence requires one                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `calculated_by`  | `provider` when the figure is theirs, `investor_intel` when it is ours                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `inputs`         | Only when `calculated_by` is `investor_intel`: what the figure was made from                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `tier`           | `{ tier, surface, open }`, so a served answer is attributable and a refusal is legible                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `coverage`       | `{ from, to, count, truncated }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `note`           | Why an answer is thin or empty, in words. An empty state always says why                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `data`           | The reading, under its own key, so a field called `source` inside a reading cannot overwrite the envelope                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `tool_version`   | Only on a versioned tool (the CoinMarketCap readings below): the contract version that answered                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `licence`        | Which figures you may republish. See [Licence](#licence)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |

Where an answer joins two stores with different clocks, `as_of` is the **older** of them: a reading is only as fresh as its staler half. On these tools `as_of` is: `market_regime`, the provider's own clock on the newest point; `rwa_wrapper_premiums`, `rwa_best_wrapper` and `rwa_premium_history`, when the wrapper prices were read; `rwa_yield_provenance`, the newest feed read; `rwa_universe` and `meme_graduations`, the newest write in the capture hour; `market_structure` for `liquidations`, `attention`, `index_constituents` and `categories`, the write or observation time; `rwa_exit_capacity`, the older of the depth capture and the volume capture; `dex_boards`, the newest provider price clock on the board's rows. `capture_bucket` keeps the capture window on each of them. Every other tool dates itself by a read or observation time.

### Licence

The rule is "our own figures only". You may republish figures Investor Intel calculates (`calculated_by: investor_intel`), including in a paid newsletter, with the attribution `Calculated by Investor Intel (thecontentforge.io/intel)`. Figures from CoinMarketCap, CoinGecko and other providers need permission first (<support@thecontentforge.io>), and the provider's own terms apply.

Every result carries `licence`:

| Field                 | Meaning                                                                                                                                |
| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| `republish`           | `allowed_with_attribution` when the result is our calculation, `ask_first` when it is a provider's figure                              |
| `attribution`         | The line to print with an allowed figure                                                                                               |
| `ours`                | `{ republish, attribution, applies_to }` for the figures this tool calculates, or null                                                 |
| `theirs`              | `{ republish: ask_first, providers, attribution[], applies_to, how }` for the provider figures the result carries or rests on, or null |
| `per_figure`          | How nested figures are marked (below)                                                                                                  |
| `per_figure_complete` | False only when a very large result was cut short of marking every nested figure                                                       |
| `terms_url`           | `https://thecontentforge.io/intel/methodology#data-licence`                                                                            |

It also carries `policy` (which version of this rule applies), `calculated_by` and a plain `note`. **Per figure:** a nested object whose rule differs from its result carries its own compact `licence`: `{ "republish": "allowed_with_attribution" }` on a figure marked `calculated_by: investor_intel` inside a provider result (the regime breadth, a cross-source verdict), and `{ "republish": "ask_first", "provider": "coinmarketcap" }` on a figure naming a provider inside our calculation (a search match's market cap, a catalogue row). The text summary carries one line: `Licence: figures Investor Intel calculated may be republished with "..."; coinmarketcap figures need permission first (...)`.

### Withheld data

A tool the workspace's plan does not reach returns the refusal **instead of** the reading, before the work that would produce it. There is no `data`, no row, no count and no sample in that body:

```json
{
  "tool": "rwa_issuer_terms",
  "withheld": true,
  "error": "intel_surface_locked",
  "surface": "investigation",
  "tier": { "tier": "free", "surface": "investigation", "open": false, "opens_at": "starter" },
  "message": "Connected Research is part of the starter plan. ..."
}
```

## Tools

`tools/list` and the Agents page (`/intel/agents`) name every tool, with the scope and plan surface each needs and how fresh its data is. Every schema is closed: no extra properties, a `maxLength` or an enum on every string, a `maxItems` on every array, a maximum or an enum on every number, and a default on every limit, so an agent cannot ask for an unbounded page.

**No read tool calls a provider.** Each reads a stored capture, a cached observation, the shared response cache (read only) or your own rows, so a stale `as_of` means the capture is stale and calling again returns the same reading.

### Market and tokenized assets

No scope is needed: these are shared intelligence, not your private records, and are gated by plan surface alone.

| Tool                                                                       | Surface         | Returns                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| -------------------------------------------------------------------------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `search_assets`                                                            | `market_boards` | Assets matching a ticker, name or `chain:address`, exact matches first. `query` 2 to 100 characters, `limit` up to 20                                                                                                                                                                                                                                                                                                                                                                                      |
| `get_asset`                                                                | `market_boards` | Identity, contract per chain, the newest retained quote with its observation time, and our cross-source agreement verdict. A CoinMarketCap id outside the top 1,000 is answered from the long-tail tier (ranks 1,001 to 5,000) or the newest new-listing capture; `asset.catalog_tier` says which, so every id `new_listings` returns can be opened                                                                                                                                                        |
| `get_candles`                                                              | `market_boards` | One asset's candles at any of the chart's 15 widths (`interval`: `1M` one minute, `3M`, `5M`, `15M`, `30M`, `1H`, `2H`, `4H`, `6H`, `8H`, `12H`, `1D`, `3D`, `1W`, `1MO` one calendar month, or `auto`) over any of its ranges (`range`: `1H`, `12H`, `24H`, `3D`, `7D`, `1M` one month, `3M`, `6M`, `1Y`, `2Y`, `5Y`, `ALL`). Name the asset with `query`, or `provider` and `provider_id`. At most 300 candles a page, newest first; `before` (a UTC time, from `next_before`) for older ones. Versioned |
| `export_series`                                                            | `capture_views` | A whole stored series in pages, oldest first, as `json` or `csv`: `price_history` (one asset's candles, named as `get_candles` names them; default `ALL` at `1D`), `regime` (every hourly capture, `days` up to 365) or `new_listings` (`days` 7, 30 or 90). `page` from 1; `total_pages` says how many. Versioned                                                                                                                                                                                         |
| `market_regime`                                                            | `market_regime` | The regime series (fear and greed, altcoin season, BTC and ETH dominance, total, stablecoin and DeFi market cap) plus our breadth figure (cap-weighted 24h return minus the median). `range` 7d, 30d, 90d or 1y. `series_points { returned, captured, read }`                                                                                                                                                                                                                                              |
| `new_listings`                                                             | `capture_views` | New listings with chain, contract, inspection state, `canonical_key` and the move since **our** first capture. `days` 7, 30 or 90; `status`; `limit` up to 50                                                                                                                                                                                                                                                                                                                                              |
| `meme_graduations`                                                         | `capture_views` | Launchpad funnel, graduation rate, time to graduate, retention and recent graduations, per chain and pad. `days` 1, 7 or 30; `chain`, `launchpad`, `source`; `limit` up to 50                                                                                                                                                                                                                                                                                                                              |
| `rwa_universe`                                                             | `capture_views` | Per asset type: assets, issuers, market value, 24h volume, top assets, and the series. `days` up to 90, `top_assets` up to 25                                                                                                                                                                                                                                                                                                                                                                              |
| `rwa_issuer_legitimacy`                                                    | `capture_views` | Legal entity and LEI or CIK, SEC Form D admission history and drift, risk signals, holder concentration, transfer restrictions. `subject`, `limit` up to 25                                                                                                                                                                                                                                                                                                                                                |
| `rwa_yield_provenance`                                                     | `capture_views` | Advertised against realized (ours) against benchmark rate, the spread, NAV deviation and feed health. When a feed is benchmarked against SOFR, `sofr_notice` carries the notice the New York Fed's Terms of Use require beside SOFR; show it wherever you show SOFR. `days` 7, 30 or 90; `feed`; `limit` up to 50                                                                                                                                                                                          |
| `rwa_issuer_terms`                                                         | `investigation` | The dated issuer review facts (who may redeem, minimums, exclusions, hours) with links, plus unit arithmetic for a `quantity`. `subject` and `crypto_id` required                                                                                                                                                                                                                                                                                                                                          |
| `rwa_best_wrapper`                                                         | `capture_views` | The cheapest, closest and most traded wrapper of one asset, and every wrapper left out with its reason. `rwa_id` or `crypto_id`, digits only                                                                                                                                                                                                                                                                                                                                                               |
| `rwa_coverage`                                                             | `capture_views` | The daily coverage headline, per state and per type, and the expected-ticker watch (BUIDL, BENJI, OUSG, USYC). No arguments                                                                                                                                                                                                                                                                                                                                                                                |
| `rwa_universe_changes`                                                     | `capture_views` | `listed`, `removed`, `became_tradeable` and `shelved` events between daily snapshots. `days` 1 to 30 (default 7), `kind`, `limit` up to 100                                                                                                                                                                                                                                                                                                                                                                |
| `rwa_issuer_concentration`                                                 | `capture_views` | HHI (0 to 10,000), effective issuers, top-five share and exclusions, overall and per type, plus deployments per chain. `top_issuers` up to 10                                                                                                                                                                                                                                                                                                                                                              |
| `rwa_premium_history`                                                      | `capture_views` | Anchor, dispersion and per-wrapper premium series, each point labelled `capture` or `ohlcv_reconstructed`. `rwa_id` required; `days` 30, 90, 180 or 365 (default 90); `crypto_id`                                                                                                                                                                                                                                                                                                                          |
| `rwa_exit_capacity`                                                        | `capture_views` | Days to sell a position at a share of daily volume, in two scenarios, plus the position as a percent of recognised pool size. `crypto_id` and `position_usd` required; `participation_pct` 0.1 to 100 (default 10); `haircut_pct` 0 to 90 (default 0)                                                                                                                                                                                                                                                      |
| `rwa_wrapper_premiums`, `rwa_liquidity_depth`, `rwa_underlying_registrant` | `capture_views` | See [RWA lane readings](#rwa-lane-readings)                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `market_structure`                                                         | `capture_views` | One of twelve precomputed Structure figures, named by `figure` (below)                                                                                                                                                                                                                                                                                                                                                                                                                                     |

**`get_candles`.** The same candles the asset page chart draws, read through the chart's own sources with every one held to what is stored: the stored hourly and daily candle archive, the shared candle caches and the retained prices. Nothing is fetched from a provider, so a window no stored source holds comes back empty with a sentence saying so, and asking again returns the same candles. Each answer carries:

* `interval`: the width you asked for (`requested`), the width the candles really have (`served`, with `served_seconds`) and `substituted`. A width the stored sources cannot sample for that window is served at the nearest one they can, and never relabelled as the finer one.
* `columns` and `candles`: one row per candle, `[open_time, open, high, low, close, volume, source]`, where `open_time` is the UTC start of the candle (a daily candle runs from 00:00 UTC) and `source` is the provider of that candle.
* `sources`: every provider behind the series with its role (`live` for a shared candle cache, `archive` for the stored archive, `stored` for candles built from retained prices), how many candles it supplied and when.
* `points`: `in_window`, `returned`, `older_on_next_page`, `cut_by_plan_allowance`, `cut_by_display_ceiling` and `withheld_for_licence`, so every candle that is not in the answer is counted. `next_before` is the `before` for the next older page.
* `history_allowance`: your plan's price history allowance in days, or `null` when the plan has no limit. Every paid plan and the trial hold no limit.
* `coverage`: the chart's own sentence about what it drew; `window` with every gap, as on every windowed tool; `freshness` judged against the width served (a series is stale once its newest completed candle is more than one and a half widths old, plus fifteen minutes).

CoinMarketCap candles carry `Data provided by CoinMarketCap.com` and are for you, the member. The public demo server serves `get_candles` without them: its answers say how many it left out.

**`export_series`.** Every row carries `figure_owner`: `investor_intel` for a figure we calculate (republish it with "Calculated by Investor Intel (thecontentforge.io/intel)"), or the provider for theirs (ask first). A `new_listings` listing has two rows, one with the provider's figures and one with ours (when we first captured it, the move since our first captured price, and our reading of its inspection); a cell that does not belong to a row's owner is empty. Nothing is sampled: `regime` returns every stored hourly capture, and the provider's daily history since 2013 stays with `history_atlas`.

`meme_graduations` carries `Powered by CoinGecko` on `source.attribution` and `data.attribution`. That is a **licence condition**: show it wherever you show those figures.

**`rwa_best_wrapper`.** `cheapest` is the lowest premium to the anchor among wrappers that cleared the volume floor; `closest` is the smallest absolute premium among the same, with `circular: true` when that wrapper set the liquid-wrapper median and `closestOther` naming the nearest independent wrapper; `mostLiquid` is the highest reported 24h volume among wrappers with a premium. Ties go to higher volume, then lower id. With no anchor, cheapest and closest are `{available: false, reason}`. `state: not_in_capture` means the asset is not among the captured multi-wrapper assets, which is missing coverage, not an absence of wrappers. It is not a recommendation.

**`rwa_coverage`.** `universe` counts the assets in the newest snapshot with a tradeable token (a price and reported 24h volume), with tokens that do not trade, with no token, and `not_returned` (asked and not answered, never read as no tokens); `is_a_floor` is true when the asset map was truncated or anything was not returned. In the expected-ticker watch, **present** means a name-matched row was found in our catalogue or the day's coverage tokens, which can be a CoinGecko row (`seen_in[].provider` says which); `in_rwa_universe` is true only when CoinMarketCap's own RWA capture carries it; `symbol_seen_name_differs` is never counted as present.

**`rwa_universe_changes`.** Newest first, cut to `limit`; `counts` always cover every event in the window. `removed` needs the asset map itself to have stopped seeing the asset after a complete run. `comparable: false` means fewer than two snapshots exist, which is not the same as no changes.

**`rwa_issuer_concentration`.** Weighted by market cap on the newest token snapshot. A token with no market cap or no issuer is excluded and counted (`excluded_no_market_cap`, `excluded_no_issuer`), never weighted as zero. Market cap per chain is given only for single-chain tokens; a multi-chain token's value has no per-chain split and is reported once as `multi_chain_market_cap_usd`.

**`rwa_premium_history`.** Points are `capture` (two-hourly live) or `ohlcv_reconstructed` (daily closes, only before `boundary.live_from`). `calendar` gives the closed spans of the underlying (NYSE weekends and holidays for stocks and ETFs, weekends only for commodities; COMEX holidays are not modelled). With no `crypto_id`, at most 12 wrappers share the 180-point budget and the anchor gets its own 60; with `crypto_id`, that wrapper gets 60 points. Each wrapper's `summary` (latest, min, max, mean premium) is computed over its full series.

**`rwa_exit_capacity`.** `days = position / (participation x volume x (1 - haircut))`, once over the recognised pools' 24h volume and once over CoinMarketCap's all-venue 24h volume. Each scenario returns the per-day amount, the day count and the formula with the numbers in it, or `unavailable` with a sentence. Missing data is never zero days. `pool_comparison` is the position as a percent of the recognised pool size and is never called slippage. It matches the exit simulator in the app.

**`rwa_issuer_terms`.** Sits behind `investigation` because that is where those facts are produced in the app; a reading is never cheaper through an agent than through the app. When no review fact is stored for the pair, it serves our dated issuer review, with `served_from`, `identity_check` (`coverage_capture` when our coverage capture names the same issuer, `review_record` when none exists) and `conflict: true`, with nothing served, when the capture names a different issuer. Issuer review facts **have no expiry**: a review date is never a deadline.

**`market_structure`** takes `figure` and only that figure's arguments. An argument the figure does not take is refused by name, and a value outside the figure's bounds is refused rather than clamped.

| `figure`                | Arguments                                                       | Trimmed to                                         |
| ----------------------- | --------------------------------------------------------------- | -------------------------------------------------- |
| `unusual_moves`         | `rows` (default 20, max 50), `day` YYYY-MM-DD                   | `rows`; per-window distributions dropped           |
| `liquidations`          | `provider_ids` (required, max 10), `hours` 1 to 24              | shared series budget; 7-day hourly total 60 points |
| `attention`             | `provider_id` (required), `hours` 1 to 168                      | 48 entries per list; capture stamps as a count     |
| `breadth`               | none                                                            | already small                                      |
| `categories`            | `days` 1, 7 or 30; `top` up to 30 (default 10)                  | shared series budget, first 15 series only         |
| `category_disagreement` | `min_members` 2 to 50, `rows` (default 25)                      | `rows`, lowest agreement first                     |
| `exchange_reserves`     | `days` 7, 30 or 90; `exchange_id`; `rows` up to 20 (default 10) | `rows` exchanges                                   |
| `venue_share`           | `days` 30, 90 or 365; `kind` spot or derivatives                | ten venues and other                               |
| `index_constituents`    | `days` up to 90, `rows` (default 20)                            | `rows` per index, shared series budget             |
| `rank_map`              | `top` up to 30 (default 25), `weeks` up to 26 (default 12)      | bounded by its arguments                           |
| `airdrops`              | `status`, `days` up to 365, `rows` (default 25)                 | `rows`                                             |
| `network_stats`         | `rows` (default 25)                                             | `rows`                                             |

The market regime is served by `market_regime`, not here, and FX is not exposed. `airdrops` never takes your holdings.

### The token verdict (members only, versioned)

`token_verdict` takes `network` (the way Investor Intel names chains: `solana`, `ethereum`, `base`, `bnb` and the rest of the DEX networks) and `address` (the 0x contract, or the mint on Solana). It returns the token page's verdict panel for that contract from the same stored readings and the same rule the page uses: `liquidity` (the deepest stored pool, or the launch curve's reserve), `top10`, `developer` (its share and whether its tagged holding fell), `bundlers` and `snipers`, `tags`, `lp` (burn or lock), `mint`, `freeze`, `controls` on EVM (blacklist, pause, owner powers), `tax`, `honeypot` and `curve`. Each fact carries its `source` and `observed_at`, with any second source under `others`.

* A contract nobody has opened in Investor Intel has no stored reading: `security_read` is `false`, and `not_reported` there is missing coverage, never a finding that the token is safe. The token page reads security when a member opens it, at most once a day per token; this server never fetches one.
* No wallet address is returned. Tags are CoinMarketCap's labels for addresses, and an address is not a person.
* The priced exit check (what it costs to sell at your size) is a live quote, so it is not part of this tool: `exit_quote.state` says `not_in_this_tool`. Ask the `exit_quote` tool below, or run it on the token page.
* CoinMarketCap holder tags and security carry `Data provided by CoinMarketCap.com`, and CoinGecko onchain carries `Powered by CoinGecko`. Show them wherever you show those figures. Not in the public demo.

### The exit quote (members only, versioned, live)

`exit_quote` is the token page's exit check for your agent: what selling `size_usd` of a token now would move and return. It runs the same code as the page, so the two never answer differently. It takes `network` (`solana`, `bnb` or `base`), `address` (the mint on Solana, the 0x contract on BNB Chain and Base) and `size_usd` (1 to 100,000, default 200).

* **Solana:** DFlow's live route quote for selling the token for USDC, sized from Birdeye's price and decimals, at 1% slippage. `calculated_by` is `provider`.
* **BNB Chain and Base:** the venues' own contracts read on-chain at the latest block (the Four.meme curve and PancakeSwap v2 and v3 on BNB Chain, Uniswap v2 and v3 on Base), one pool, the best of the deepest checked. `calculated_by` is `investor_intel`.
* **Every answer states** `sources` (who answered), `quoted_at` (also `as_of`), `size_usd` and `sold` (the amount in base units, the decimals and whole tokens), `quote.price_impact_pct`, `quote.returns_usd`, the page's `quote.quality` grade and, when the quote fails, `route_failure` with its `code`, a sentence, and DFlow's impact and tolerance where it gave them. A failed quote is a finding about the sale at that size, not an error.
* **It is the one live tool.** Each call uses one of the member's exit quotes for the UTC day, taken before the quote is asked, so a quote that fails still counts. The daily number is set by the plan: Starter 25, Pro and the trial 100, Elite 500. Past it the call is refused with `exit_quote_daily_cap` and the reset time. A platform-wide daily ceiling across every member also applies (`exit_quote_platform_cap`). `data_budget` shows `exit_quotes` used today against the cap. The token page's own exit check is not counted here.
* Nothing is traded, signed or stored. No wallet address is sent or returned, and no CoinMarketCap call is made. Not in the public demo. The agent API offers the same tool as the operation `exit_quote`.

### CoinMarketCap readings (members only, versioned)

| Tool                  | Surface              | Returns                                                                                                                                                                                                           | Arguments                                                                                                         |
| --------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| `spot_venues`         | `capture_views`      | Spot exchanges by reported 24h volume (CoinMarketCap's adjusted volume beside it, never in place of it), or one venue's twelve months of daily volume and its largest pairs. `share_pct` is ours                  | `exchange_id`; `rows` 10, 25 or 50 (default 25); `pairs` up to 20 (default 10)                                    |
| `asset_venues`        | `capture_views`      | Where one asset trades: per venue the counted pairs, volume, share and volume-weighted price with its distance in basis points from the median, and the dispersion summary. Flagged pairs are counted apart       | `provider_id` required; `provider` (default coinmarketcap); `venues` up to 25; `pairs_per_venue` up to 5          |
| `rwa_venue_pairs`     | `capture_views`      | The venues and pools CoinMarketCap lists for one tokenised asset, with our venue totals and shares, and `sample_keys` because the row shape is not yet fully confirmed                                            | `rwa_id` required; `limit` up to 50                                                                               |
| `asset_performance`   | `capture_views`      | Dated all-time high and low, first price and its date, return since it, and the 365 day to 24 hour period blocks, beside our recorded window high                                                                 | `provider_ids` 1 to 25                                                                                            |
| `history_atlas`       | `research_on_demand` | `atlas: rank`: the top 10, 25 or 50 on sampled dates since 2013, rank paths, entries and exits, survivorship. `atlas: regime`: the regime series since 2013 (hourly over the last year) and one UTC day's reading | rank: `span`, `top`, `paths` (up to 25); regime: `date`, `resolution`. Each refuses the other's arguments by name |
| `dex_boards`          | `capture_views`      | The newest trending, new or gainers board for one network, with each contract's persistence (hours on board, streak) and, on the new board, the due diligence check                                               | `board` and `network` required (app chain ids: `bnb`, never `bsc`); `hours` up to 72; `limit` up to 25            |
| `holder_intelligence` | `research_on_demand` | Holder tags with tagged accounts, balance and ratio, the concentration trend per tag, the provider-dated holder count, cohort aggregates, and whether the contract is tracked                                     | `network` and `address` required; `days` 7, 30 or 90                                                              |
| `sector_vote`         | `capture_views`      | CoinMarketCap's category vote against our sector labels: the daily summary and per label with two weeks of history, or one asset's labels from each source and the verdict                                        | `provider_id`                                                                                                     |
| `source_agreement`    | `capture_views`      | Per lane (cex, dex) the latest verdict counts and deltas, a short run history, the largest disagreements and provider darkness, or every verdict for one asset                                                    | `provider_id`, `lane`                                                                                             |

* **Members only.** CoinMarketCap data is licensed for display to signed-in members, so these need a member's token (`member_required` otherwise) and the public demo serves none of them. Keep the figures inside your answer to that member; do not republish them.
* **Cache only, never fetched.** Each reads a stored capture or the shared cache as it is. A cold entry is reported as `warming` or missing; the history atlases list `missing_dates` and `cold_pages` and carry on through what is warm, and the note says how many are missing. Our capture lanes keep the atlases warm (the daily regime atlas every 2 hours, the rank atlas dates every 6 hours), and an entry also fills when a member opens that reading in Investor Intel.
* **Attribution.** `Data provided by CoinMarketCap.com`, with its link, is on `source.attribution` and `data.attribution`. `sector_vote` and `source_agreement` also carry the CoinGecko attribution, because they compare the two.
* **No headlines or community content.** No tool returns CoinMarketCap news or community posts.
* **Addresses are not people.** `holder_intelligence` returns counts and aggregates only, never an address, and says that an address is never a person.
* **Versioned.** Each result carries `tool_version` (1). A field may be added under a version and never changes its meaning under it; a breaking change ships as a new tool name.
* **Sized** with the same budgets as every other tool, and each result says what it cut. `sector_vote` for one asset is shared for fifteen minutes, because it changes once a day.

### RWA lane readings

`rwa_wrapper_premiums`, `rwa_liquidity_depth` and `rwa_underlying_registrant` report one of three states, and the difference matters: "no pools found" for a token whose lane does not exist would be a false claim about the market.

* `not_available_yet`: we have not built that lane. A fact about us, not about the market
* `empty`: the lane exists and holds no row for this request, which is missing coverage, not an absence
* `served`: rows

| Tool                        | `as_of` from  | Filter                        | Fields per row                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| --------------------------- | ------------- | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rwa_wrapper_premiums`      | `captured_at` | `subject` (a crypto id)       | `rwa_id, crypto_id, symbol, name, issuer_name, price, normalised_price, market_cap, volume_24h, unit_state, wrapper_state, premium_bps, accrual_gap_bps, in_anchor, state_reason, captured_at, fetched_at, underlying_ref_price, underlying_ref_bps, underlying_ref_within_band, underlying_ref_session, underlying_ref_observed_at, underlying_ref_source`                                                                                                                                                                                                                                                                                                                                                                                                            |
| `rwa_liquidity_depth`       | `captured_at` | `subject` (`cmc:<crypto id>`) | `token_key, crypto_id, symbol, token_name, rwa_name, asset_type, issuer_name, token_market_cap, depth_state, chains_deployed, chains_read, chains_not_covered, pool_count, total_liquidity_usd, total_volume_24h_usd, deepest_pool_dex, deepest_pool_chain, deepest_pool_pair, deepest_liquidity_usd, deepest_volume_24h_usd, pool_classification, recognised_pool_count, recognised_liquidity_pools, recognised_liquidity_usd, recognised_volume_24h_usd, unrecognised_pool_count, unrecognised_liquidity_usd, deepest_recognised_dex, deepest_recognised_chain, deepest_recognised_pair, deepest_recognised_liquidity_usd, deepest_recognised_volume_24h_usd, exit_liquidity_usd, exit_liquidity_pools, holder_count, restriction_state, snapshot_date, captured_at` |
| `rwa_underlying_registrant` | `fetched_at`  | `subject` (a ten-digit CIK)   | `rwa_id, cik, state, reason, registrant_name, asset_name, name_match, sic, sic_description, state_of_incorporation, fiscal_year_end, exchanges, tickers, latest_annual_*, latest_quarterly_*, latest_current_*, filings_read, source_url, fetched_at`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |

`rwa_wrapper_premiums` measures each wrapper against its asset's anchor, the volume-weighted median of the liquid wrappers, and the tool description in `tools/list` explains its accrual and ratio fields. `rwa_underlying_registrant` describes the listed company under a tokenized stock or fund, never the token issuer; `state: not_found` means EDGAR has no such filer.

**`rwa_liquidity_depth` has two sets of liquidity fields; never mix them.** CoinMarketCap values **both** legs of a DEX pool, so a pool whose other side is a token nobody can value can still report a large USD figure that no seller could take out (one XAUt pool against GOLDGR reported $16.5M on $812 of daily volume).

| Fields                                                  | What they cover                                                                                                                                           | Quote them for                                            |
| ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
| `recognised_*`, `deepest_recognised_*`                  | Only pools whose **other leg** is a major quote asset on that chain, or another tokenized asset we captured, matched by contract address, never by symbol | Where a token can actually be sold                        |
| `total_liquidity_usd`, `deepest_pool_*`                 | Every pool found, as CoinMarketCap reported it                                                                                                            | Reconciling with CoinMarketCap's own figure, nothing else |
| `unrecognised_pool_count`, `unrecognised_liquidity_usd` | The difference between the two                                                                                                                            | Explaining why our number is smaller                      |
| `exit_liquidity_usd`, `exit_liquidity_pools`            | The quote legs' own reported sizes, summed over the pools that reported one                                                                               | A **floor**, never a capacity or a slippage estimate      |

`pool_classification` is `by_counter_leg_address` when the split is real and null on an older capture without pool leg addresses, where every `recognised_*` field is null. A token with `recognised_pool_count` 0 and a positive `unrecognised_pool_count` **has pools but none anyone could sell into**, which is not the same as having no pool. Known gap: WETH, WBTC, cbBTC and wSOL are recognised only on Ethereum, Base and Solana, so an Arbitrum WETH or WBTC pool counts as unrecognised today, which understates depth rather than overstating it.

### Your own records

| Tool                                                      | Scope                                  | Surface                  |
| --------------------------------------------------------- | -------------------------------------- | ------------------------ |
| `watchlist_read`                                          | `read:watchlists`                      | `watchlist`              |
| `watchlist_add`                                           | `write:watchlists`                     | `watchlist`              |
| `alerts_list`                                             | `read:alerts`                          | `alert_evaluation`       |
| `alert_create`, `alert_create_rule`                       | `write:alerts`                         | `alert_evaluation`       |
| `save_research_note`                                      | `write:research`                       | none beyond agent access |
| `daily_brief_read`, `explain_read`, `saved_research_read` | `read:evidence`                        | none beyond agent access |
| `write_status`, `write_run`                               | none (the token must own the proposal) | none beyond agent access |
| `whoami`, `data_budget`                                   | none                                   | none beyond agent access |

`write:research` pairs with `read:evidence`, which is the scope that reads saved research. **A token with no write scope can only read.** The scope is checked before the target is read, so a refusal says nothing about whether a record exists.

**Proposals.** `alert_create` **proposes** a price alert and creates nothing. The asset must name something in our catalogue (the market catalogue, the long tail, a new listing, a native coin or a contract), or the proposal is refused with `asset_not_found` before anything is stored, and the summary you approve names the asset in words (`Bitcoin (BTC, market:coinmarketcap:1)`). `alert_create_rule` proposes an alert on any other trigger the Alerts page offers (`price_move`, `volume_spike`, `liquidity_drop`, `supply_shock`, `unlock`, `metadata_migration`, `holder_shift`, `narrative_heat`, `venue_share`, `venue_dispersion`, `rwa_venue_depth`, `ath_distance`, `dex_board_persistence`), checked by the same rules the app's save applies, so a proposal that could never be saved is refused when it is made, and a live rule our captures cannot evaluate is refused with `alert_not_evaluable`. Wallet activity, the recorded market-fact triggers and the fund triggers are made in the app. You approve the exact request on the Agents page; the agent polls `write_status` and then calls `write_run`, which checks everything again, recomputes the request's hash, writes through the same path the app uses and reads the row back, comparing the asset and the rule's fields. A write that reports success and cannot be found afterwards is reported as **failed**, never as done, and the approval is spent either way. Approvals are explained on [Agents and Agent Access](https://thecontentforge.gitbook.io/thecontentforge-docs/investor-intel/agent-access.md).

**Direct writes.** `watchlist_add` and `save_research_note` write without approval: each touches one item you can undo in one click, each is bounded by your plan's limits exactly as the app is, and each reads the row back before reporting success. `watchlist_add` makes "My Watchlist" when the workspace has none, resolves `asset` (a catalogue key, or an exact ticker) to the same asset the app uses, and never adds the same asset twice to one list (it answers `already_on_list`). `save_research_note` tags the note as agent-written with the token that wrote it; it is never marked as a Connected Research receipt.

**Idempotency keys.** Both direct writes take an optional `idempotency_key` (8 to 80 letters, digits, `.`, `_`, `:` or `-`). The same key and arguments within seven days replay the first answer and write nothing; the same key with different arguments is refused with `idempotency_key_reused`, and a key whose first call is still running answers `idempotency_in_progress`. Keys are per token and per tool.

**Reading back what Investor Intel wrote for you.** None of these generates anything or spends an allowance. Each reads only your workspace, and only items shared in it or private to you. Quote an item as the product's earlier answer with its date, never as a fresh reading.

| Tool                  | Reads                                                                                                      | Returns per item                                                                                                                                                                                                                   |
| --------------------- | ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `daily_brief_read`    | Your own and the workspace's Daily Briefs, and private daily-brief answers not linked to one, newest first | Date, confidence label, summary or verdict, what happened, why it matters, what to watch, receipts (each point with its source), sources, source observation times, missing context and asset notes; `detail: full` adds the cases |
| `explain_read`        | Your Explain This answers                                                                                  | The same fields; `detail: full` adds the cases                                                                                                                                                                                     |
| `saved_research_read` | Your saved research, with the answer each item links to                                                    | Title, body for an agent's own notes, `made_by_agent` and the token name, and the linked answer with its confidence label and receipts                                                                                             |

**`whoami`** lists the token's scopes and expiry, every available tool and every refused tool with the reason, how many calls are left today, and a `plan` block: `tier` (`trial` on a trial, `unknown` when it cannot be read, never guessed), the plan `name`, `on_trial`, `trial_ends_at`, `trial_days_left`, `trial_ends_soon`, what the workspace becomes after the trial and whether agent access survives it, and the token's own `expires_at` and `days_left`.

**`data_budget`** returns your own figures: calls used and left today, the plan's daily ceiling, the per-minute ceilings, and the newest capture time of every store the read tools use, so an agent can plan rather than discover a stale board mid-answer. It also returns `data_plan`, the CoinMarketCap plan our shared captures run on and when a time-limited plan grant ends (`grant.active`, `expires_at`, `days_left`, the warning windows, `plan_after_grant`; an unreadable profile is reported as no grant, never guessed), and `credits_by_lane`, which is `{state: 'withheld'}` unless we have turned it on. When on, it shows this month's metered credits per CoinMarketCap feature allowance (`used_this_month`, `monthly_allowance`, `used_pct`), the lanes that draw on each, and each lane's state (`on`, `off`, `requires_plan:<tier>`, `no_policy_row`) and cadence. Those are the platform's shared capture lanes, the same for every member: your own reads are served from those captures and cost nothing. `exit_quotes` is the one exception: the live exit quotes this member's agents asked today (`used`), the plan's daily cap (`limit`, null when the plan sets none) and `resets_at`. It never returns the CoinMarketCap account's credit or rate limits, its key, the raw monthly ledger, cost projections, renewal prices or operator notes.

## Limits

| Limit, per token                                                                                     | Ceiling                                                         |
| ---------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| Requests a minute (every JSON-RPC request, handshakes and tool lists included)                       | 240                                                             |
| Tool calls a minute                                                                                  | 60                                                              |
| Tool calls a day, resetting at midnight UTC                                                          | Trial 10,000; Starter 2,000; Pro 10,000; Elite no daily ceiling |
| Live exit quotes (`exit_quote`) a day, **per member** across their tokens, resetting at midnight UTC | Starter 25; Pro and trial 100; Elite 500                        |

Free has no agent access, so a Free workspace is refused with 403 before anything is counted. Every limit is **per token**: two tokens in one workspace each get the full allowance. If the plan's daily ceiling cannot be read, 2,000 a day applies and `data_budget` says why.

**What counts against today's allowance:**

* `initialize`, `tools/list`, `ping` and other protocol requests do not; some clients re-handshake every turn.
* A `tools/call` that passes the minute limit takes its daily call **before** the tool runs, so a call the tool then refuses (a missing scope, a plan that does not reach the reading, invalid arguments, an unknown asset) or that fails still counts.
* A call refused by the minute limit does not count.
* A call refused because the day is spent is recorded (so `used` can read above the limit) but costs nothing more.
* A 401 or a 403 is refused before any count.

### What a 429 looks like

Both limits answer HTTP 429 with a JSON-RPC error and a `Retry-After` header that is the real wait: the minute limiter's own wait for `rate_limited`, or the seconds until midnight UTC for `daily_quota_reached`, whose message names the reset time. The error's `data` carries the same numbers for a client that does not read headers:

```json
{"jsonrpc":"2.0","id":7,"error":{"code":-32603,"message":"daily_quota_reached: This token has used all 2000 of its calls for today. The allowance resets at 2026-10-28T00:00:00.000Z. A higher plan carries a larger allowance.","data":{"reason":"daily_quota_reached","retry_after_seconds":20733,"window":"day","limit":2000,"used":2001,"resets_at":"2026-10-28T00:00:00.000Z"}}}
```

For the minute limit, `window` is `minute`, `limit` is 60 (tool calls) or 240 (requests), `used` is the count in the window and `resets_at` is null.

## Your calls, in the app

Each token on the Agents page shows its calls used today, the same count `data_budget` reports. **Recent calls** under each token lists one row per tool call: the time, the tool, whether it was served, refused or failed, a short reason code, whether a refusal was the plan rather than a scope, how long it took and how large the answer was. **Tool arguments are never recorded**, not even in part. Call records are kept for 90 days. See [Agents and Agent Access](https://thecontentforge.gitbook.io/thecontentforge-docs/investor-intel/agent-access.md) for **Recent calls** and **What your agents made**.

## Security

* The token is a bearer credential. Only a fingerprint of it is stored, the full token is shown once, and every snippet on the Agents page carries `YOUR_TOKEN` rather than your token.
* The workspace is fixed on the token when it is created, never worked out per request.
* Scopes live on the token's record, so narrowing or revoking takes effect on the next request.
* Plan gating happens on the server and produces the refusal instead of the reading.
* If the limits cannot be checked, the server answers 503 and runs nothing, rather than serving unmetered traffic.
* Responses are `Cache-Control: private, no-store`.

No tool returns: a way to mint, list, revoke or approve; the CoinMarketCap account's credit and rate limits, key, per-call cost log, cost projections, renewal prices or job schedule; CoinMarketCap headlines or community content; holder addresses; other members' data; token fingerprints or the token store; arbitrary SQL or tables. No tool makes a live provider call or spends a provider credit.

## Troubleshooting

| Symptom                                                                      | Meaning                                                                                                                                         |
| ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| 401 with `WWW-Authenticate`                                                  | No token, not an agent token, or the token is unknown, revoked or expired                                                                       |
| 403 `membership_revoked` or `entitlement_lost`                               | The member who created the token left the workspace, or the workspace lost Investor Intel access                                                |
| 403 naming the Starter plan                                                  | The workspace's plan does not include agent access                                                                                              |
| A result with `withheld: true`                                               | The plan does not reach that reading. Nothing was produced                                                                                      |
| A result with `scope_missing`                                                | The token lacks that scope. Create a token that carries it                                                                                      |
| 429 `rate_limited`                                                           | 60 tool calls or 240 requests in a minute. `Retry-After` and `error.data.retry_after_seconds` say how long                                      |
| 429 `daily_quota_reached`                                                    | The day's allowance is spent. `Retry-After` is the seconds to midnight UTC                                                                      |
| The text block is a short summary, not JSON                                  | The client negotiated `2025-06-18`, so the full answer is in `structuredContent`. Add `?text=full` to the address if the client reads only text |
| `as_of_meaning: capture_window`                                              | The store records no observation time, so `as_of` is the capture window                                                                         |
| `freshness.stale: true`                                                      | The newest stored reading is older than its lane allows. It is still the newest one; say how old it is                                          |
| `window.complete: false`                                                     | The window came back shorter than asked, or with gaps. `window.summary` says which; describe no trend across a gap                              |
| `asset_not_found` from `alert_create` or `alert_create_rule`                 | The asset names nothing in the catalogue. `search_assets` finds the id                                                                          |
| `idempotency_key_reused`                                                     | The key was used with different arguments. Use a new key for a new request                                                                      |
| 503 `limiter_unavailable` or `quota_unavailable`                             | The server could not check its limits, so it ran nothing. Retry later                                                                           |
| `state: not_available_yet`                                                   | That RWA lane is not built. It is not evidence about the market                                                                                 |
| `state: warming`, `missing_dates` or `cold_pages` on a CoinMarketCap reading | That entry is not in the shared cache yet. This server never fills it; our lanes or a member opening the reading in Investor Intel do           |
| `member_required`                                                            | A CoinMarketCap reading was asked without a member's token behind it                                                                            |
| `as_of` is null                                                              | Nothing has been captured into that store yet                                                                                                   |
| A request just hangs                                                         | The body is probably over about 256 KiB. See [Protocol](#protocol)                                                                              |
| Claude Desktop reports a registration or sign-in failure                     | The address was added as a Custom Connector. Use the `mcp-remote` entry above                                                                   |
| `subject must be a string` from the Inspector CLI                            | The Inspector turned a numeric `--tool-arg` into a number                                                                                       |

Call `whoami` first when anything refuses. It lists the token's scopes, your plan (with the trial end date on a trial), every available tool and every refused tool with the reason for each.
