docs › The analyst

The analyst

What Claude sees, the skills, the MCP tools, the short bold answer style, and what it can never do.

The analyst is your own Claude Code login, spawned as a local claude process by dexterm. No API key ships with the app; your subscription, billing and limits apply. It talks to the app through a read-only MCP server (dexterm mcp) that exposes the same data adapters the screens use, a sourced knowledge base and historical case files. Default model: claude-sonnet-5-5 (override with DEXTERM_ANALYST_MODEL).

Starting a run#

Nothing runs behind your back. Opening a token with ⏎ is free. A paid run starts only when you:

press a on a list screen: a rug-check of the highlighted coin, or a trench-scan of the screener when nothing is highlighted, on the analyst tab;
press a on the token screen: the full token-dossier for that coin (once a conversation exists, a just toggles the panel);
press V on a live token: the larp-check of its website and socials (see LARP detector);
type a question (i or ⏎ to focus, ⏎ to send). A question is a chat turn on the warm session, or a new session with that question as its first turn, never a structured skill run;
let AI scan mode lock a coin.

Each token keeps its own conversation for the run; the analyst tab has its own. esc interrupts a running answer from any screen. The caption under an answer shows cost, latency, tool calls and the model.

What it sees#

Every turn carries a firewalled CONTEXT block: the screen you are on, the filter and sort, the selected or hovered coin, the visible rows (price, change, liquidity, volume), your watchlist, and any open PAPER ticket or position. So "this coin", "it" and "the highlighted one" resolve without asking. Token names, descriptions, socials, RugCheck text and fetched page text are wrapped as <untrusted> data before the model sees them; instruction-like text inside such a block is itself reported as a red flag (injection_detected) and never followed.

Facts come only from tools. The system prompt forbids token facts from model memory: every number, address, flag and level must come from a tool result in the session, each carrying its source and age. The knowledge base explains mechanics and patterns; it never holds a fact about a live token.

Answer style#

Default answers are 3 to 6 short lines, written for a narrow panel beside the screener, no recap of what is already on screen, no boilerplate:

the call: LONG|SHORT|WAIT|AVOID <SYMBOL> · conf <0-100> · setup strong|mixed|weak
why: the one or two tool facts that decide it and that you cannot already see
levels: entry zone · invalidation (and why it sits there) · target
size: risk as a % of account, stop at the invalidation; dollar math only when you state an account size
at most one risk line that changes the trade

Long form (sections, a table, at most about 25 lines) only when you ask with words like "full", "detail", "deep dive" or "break it down". The analyst is instructed never to narrate tool calls, never to pad with disclaimers (the app shows its own footer), and never to refuse a normal trading question: WAIT and AVOID are calls. Confidence is 0–100 in prose and 0–1 in the structured skills.

model output is a model's reading of tool results. It can be wrong, incomplete or stale, and it is not financial advice. The app labels it as model output with data ages; treat it as a starting point for your own checking.

Skills#

Four versioned skills ship with the app (larp-check, rug-check, token-dossier, trench-scan). Each forces a JSON schema the app renders beside the summary (verdict, bias, setup quality, key levels, invalidation, size hint, missing_data, sources_used, injection_detected).

skill	started by	what it does
`token-dossier`	`a` on the token screen; a scan lock; `get_dossier` in one round trip	market, holders and concentration, authorities, RugCheck, candle summary, tape aggregate, creator. A partial verdict with `missing_data` when a section is unavailable; it refuses only when there is no price and no liquidity.
`rug-check`	`a` on a list screen with a coin highlighted	the risk read: authorities, LP lock, holder concentration, tape, wallet share, dev history where the tier allows.
`trench-scan`	`a` on a list screen with nothing highlighted	a read of the screener as a whole: what is running, what is organic, what to look at.
`larp-check`	`V` on a live token	vets the advertised website, domain and GitHub; see LARP detector.

MCP tools#

dexterm mcp is a plain stdio MCP server. The analyst is launched with --strict-mcp-config and only mcp__dexterm__* tools allowed; it has no shell, no file access and no other tools. You can add the same server to any Claude Code with:

$ claude mcp add dexterm -- node packages/mcp/bin/dexterm-mcp.mjs

what is on screen

tool	what
`screen_state`	the screen, filter, sort, selected and hovered coin, visible rows, watchlist, open PAPER ticket. Called first for "this coin".

market, holders, security, chart (read-only)

tool	what
`screener_query`	screener rows with provenance for a preset (new, trending, all).
`get_token`	token + pair + stats + audit for a mint or symbol, each field with its source and age.
`get_dossier`	everything about one mint in a single parallel pass (market, holders, security, candles summary, tape aggregate, creator) plus an availability block that says what is missing.
`get_holders`	top holders (≤20) with the top-10 share; the ranked list needs a free RPC key.
`get_trades`	recent trades of the most liquid pool with buy/sell aggregates and a wash signal.
`get_candles`	candles plus computed summaries (range, drawdown, VWAP, change).
`rugcheck`	RugCheck summary: risks (firewalled text), normalised score, LP locked %, token program.
`get_dev_history`	creator address and prior-launch forensics; Tier-1 fields are null keyless and say so.

knowledge base and case files

tool	what
`kb_lookup`	one knowledge-base entry (mechanics, patterns, glossary) with sources and confidence. Never facts about a live token.
`kb_search`	search the knowledge base.
`case_lookup`	historical case files with verified on-chain references, for pattern comparison only.

LARP detector (only when you ask for a vet)

tool	what
`get_links`	the website and socials a coin advertises, classified and de-duplicated. Claims, not verified.
`fetch_page`	SSRF-safe, read-only GET of one URL (no JS, no cookies, size and time capped, private hosts refused) returning mechanical signals and a firewalled excerpt.
`check_domain`	domain registration age, registrar and privacy via RDAP.
`check_github`	repository activity via the keyless GitHub API.

UI actions (navigation only, re-validated by the app, refused in scan mode)

tool	what
`open_token`	put a coin that is already on screen on the token screen.
`show_in_screener`	apply a filter, sort or highlight in the screener (the app re-parses the filter with the real grammar).
`add_to_watchlist`	add a coin that is on screen to the watchlist.
`switch_feed`	switch the screener preset.
`open_ticket`	open the PAPER ticket pre-filled in its editing phase. It never sizes, confirms, signs or sends.

The five UI-action tools are the only way the analyst can change what you see. They are navigation only: each action is re-validated by the app against the current screen's allow-list (a mint must already be on screen; a feed or sort key must exist), rate-limited, and shown as "analyst did X". An injected instruction that names a coin not on screen is rejected and changes nothing. In scan mode the allow-list is empty and the launch adds --disallowedTools for all five.

What the analyst can never do#

sign, send or confirm a transaction. No tool builds, signs or sends anything; there is no signer for it to talk to.
confirm a PAPER trade. open_ticket opens the ticket in its editing phase; your keys arm and confirm it.
act on a coin that is not on your screen, or act at all while the scan has the session.
use its memory about a token. Facts come from tools or they are not facts.
follow text found in a token's name, description, socials or website. That text is data, wrapped and flagged.
read your keys. It never sees the RPC key, your wallet, or your Claude credentials; dexterm only spawns the claude binary already on your machine.

Plain-language filters#

"show me coins under 5M mcap with over 100k liquidity, up on the day, not rugs" becomes a filter in the grammar applied through show_in_screener, and the analyst states the numbers it chose (low cap → mcap < 5M, safe → lplocked >= 100 !flag:mint !flag:freeze org > 50). Follow-ups ("tighter", "only ones with locked LP", "drop the age limit") modify the current filter. The app re-parses the string with the real grammar and rejects anything malformed; an invented field never reaches the screener.

If `claude` is missing#

The panel shows a one-line fix (npm i -g @anthropic-ai/claude-code && claude login) and the rest of dexterm keeps working. dexterm doctor reports the Claude CLI line as a warning, not a failure.