MACHINE SURFACE

Same state, three renderings: Retail / Trader / Machine. Live REST + MCP Streamable HTTP (Claude / ChatGPT), now with EIP-191 proof-of-ownership (challenge 5m, session 6h, 1/wallet). Intelligence and risk analysis only — no promise of an outcome, no keys, no autonomous execution.

what this surface isread this before wiring an agent to it

t0xhoodX Terminal is the intelligence and risk-analysis layer of System One Terminal — not a profit guarantee and not an autonomous trading system.

The endpoints below return scores, verdicts and reason codes — analysis, not orders. Nothing on this surface holds keys, signs, or broadcasts, and no payload implies an expected return. Execution in this build is paper; the live spot venue for $T0XHOOD is the Uniswap v4 pool reached by the user directly.

{
  "positioning": {
    "product": "t0xhoodX Terminal",
    "system": "System One Terminal",
    "role": "intelligence and risk-analysis layer",
    "statement": "t0xhoodX Terminal is the intelligence and risk-analysis layer of System One Terminal — not a profit guarantee and not an autonomous trading system.",
    "isNot": [
      "a profit guarantee",
      "an autonomous trading system"
    ],
    "custody": "none — this service holds no keys and broadcasts nothing",
    "execution": "paper / user-signed only; autonomy is not offered here",
    "advice": "information, not investment advice"
  }
}

Served verbatim in GET /api/mcp discovery and in the MCP initialize instructions, so a client that never renders this page still reads the scope.

REST + auth endpoints/api/chain · /api/token · /api/holdings · /api/mcp/verify · /api/mcp are live
GET/api/chainlive

Robinhood Chain + Arc JSON-RPC health, head blocks, $T0XHOOD snapshot, Uniswap v4 pool, MCP gate constants.

curl -s "/api/chain" | jq .rh,.arc,.token.address
GET/api/tokenlive

Canonical $T0XHOOD CA, decimals, declared 1B supply, pool URLs.

curl -s "/api/token" | jq .token,.pool
GET/api/holdings?wallet=0x…live

On-chain balanceOf vs 0.5% MCP gate (5,000,000 T0XHOOD). No proof needed — read-only.

curl -s "/api/holdings?wallet=0x…" | jq .eligible,.balanceTokens
GET/api/mcp/verify?wallet=0x…free

Issue EIP-191 challenge for proof-of-ownership. Returns challengeId + challenge string (nonce + 5-min expiry) to personal_sign via WalletConnect / injected provider.

curl -s "/api/mcp/verify?wallet=0x…" | jq .challengeId,.challenge,.expiresAtISO
POST/api/mcp/verifyfree

Verify EIP-191 signature (Keccak + secp256k1 recovery). Body { wallet, challengeId, signature }. Returns 256-bit session token (TTL 6h, 1/wallet, revocable). Admin allowlist 0xa************* bypasses hold but not proof.

curl -s -X POST /api/mcp/verify -H 'content-type: application/json' \
  -d '{"wallet":"0x…","challengeId":"…","signature":"0x…"}' | jq .session,.expiresAtISO
POST/api/mcpgated

MCP Streamable HTTP for Claude / ChatGPT. Gated tools require header x-t0x-session (or ?session= / tool arg session) — wallet-only headers no longer accepted. Session from POST /api/mcp/verify.

curl -s -X POST /api/mcp -H 'content-type: application/json' -H 'x-t0x-session: 0x…' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"t0x_chain_status","arguments":{"session":"0x…"}}}' | jq .
GET/api/screener?lens=trenches-runners&chain=sol0.001 USDC / req

Token screener & discovery engine: filter by 6 discovery lenses (trenches-runners, smart-money-inflow, shield-clean, fresh-launches, breakout-candidates, whale-accumulated), the six desk chains, workspace, safety, liquidity, and volume. Each row states its Shield provenance (checksRun 0 = curated pad catalog, not an audit) and its verdict path; the payload carries board coverage. An unknown ?chain= is a 400 that names the accepted chains — never a silently unfiltered board.

curl -s "/api/screener?chain=sol&sortBy=shieldScore" | jq '.coverage.chains[], .rows[0].shield'
GET/api/coveragefree

Read-plane surface: per desk chain — endpoints in failover order, probe method, address grammar, rows tracked, live-sourced rows, oracle-resolved caps, honeypot probes and full Shield runs — scored 0-100 against published weights and capped at the mirror ceiling whenever the head probe is not answering. Coverage measures what this terminal can read; it is not a quality score for any chain or token.

curl -s "/api/coverage" | jq '.all.displayCoverage, .chains[].sentence'
GET/api/launchpads?limit=120.001 USDC / req

Top Launchpad Coins by Market Cap from CoinGecko's launchpad category with market cap, price, 7-day change and sparkline. Keyless public API by default (COINGECKO_API_KEY upgrades it on Pro/Demo); if the server can't reach the provider the page fetches the same public request from the browser (LIVE · DIRECT), labelled mirror only as last resort.

curl -s "/api/launchpads?limit=12" | jq '.source,.coins[0]'
GET/api/feed?workspace=markets0.001 USDC / req

Ranked alpha feed. $T0XHOOD row overlays live price when the chain is reachable.

curl -s "/api/feed?workspace=markets" | jq '.rows[0]'
GET/api/shield?sym=T0XHOOD&orderUsd=25000.002 USDC / req

Shield verdict: score, per-check reason codes + sources, honeypot probes, per-tier gate.

curl -s "/api/shield?sym=T0XHOOD" | jq .verdict,.score
GET/api/signals0.001 USDC / req

Signal objects with evidence, pre-registered predictions and resolution status.

curl -s "/api/signals" | jq '.[0].id'
GET/api/entities?tick=00.001 USDC / req

Entity graph v1 (cluster→entity→persona) + entity-class flow radar.

curl -s "/api/entities" | jq '.radar[0]'
GET/api/fomo?view=board0.001 USDC / req

fomo.family intelligence: memecoin board ranked by Thesis Conviction Score, hidden-gem divergence, top-trader leaderboard, per-coin deep research. Views: board · gems · traders · thesis?sym=ARGUS. Mirror by default; live leaderboard overlay when FOMO_API_URL/FOMO_API_KEY are set.

curl -s "/api/fomo?view=thesis&sym=ARGUS" | jq '.research.tcs,.research.topThesis.text'
GET/api/xtrackers?view=feed0.001 USDC / req

X trackers — the 26-account watchlist database for memecoin settlement tracking: CA detection (EVM hex + Solana base58), confidence-scored settlement ladder (registry → context → format → author-affinity → unresolved), first-buy windows (≤90s), per-account copy-trade defaults (buyUsd · only-CA) and Shield CRITICAL auto-blocking. Views: feed · watchlist · settlement · ?handle=ether_monk. Mirror by default (replayable by tick); live post rows when a live plane answers — the ave-ingest agent, the ave-reach Agent-Reach tracker (doctor-gated, 503 + reason when unready), or the direct twitterapi.io relay (TWITTERAPI_IO_KEY, serverless). Paper only.

curl -s "/api/xtrackers?view=feed&tick=12" | jq '.triggers[0] | {handle, phase, ca, settlement, action}'
GET/api/agent0.001 USDC / req

Autonomous on-chain monitoring agent telemetry: status (LIVE/DEGRADED/SIM), cycle count, per-chain heads + creation/factory-pool counts, fresh-launch findings with WATCH/CAUTION/ALERT risk — each carrying real FLOW (DexScreener 1h buys/sells/volume/liquidity) and ATTENTION (X mention counts over 1h/24h), both source-stamped (dexscreener/x-live live · sim mirror · unavailable + reason, never zero-filled) — plus an `enrichment` block and the operator log. RH · Arc · Base · BNB · HyperEVM (launch sensing + DEX factory logs) + Solana (head probe only, stated honestly); ?force=1 runs a cycle now.

curl -s "/api/agent" | jq '.status,.cycles,.chains,.findings[0]'
GET/api/scan0.001 USDC / req

Six-chain scan served by the autonomous agent: fresh token launches (Blockscout discovery on RH, RPC CREATE-derivation on Arc/Base/BNB/HyperEVM), rule-based triage (serial deployer / copycat / supply sanity), findings stamped live/sim per R13. ?force=1 scans now.

curl -s "/api/scan" | jq '.source,.cycles,(.findings[0]|{sym,risk,reasons})'
GET/api/brain0.004 USDC / analysis

LLM intelligence plane — senior-analyst verdicts (stance · confidence · Thai reasoning · risks · trade plan) for agent discoveries. ?finding=F-… analyzes one (cached or now). Advisory plane only: never touches Shield/policy/execution. Without a TypeSafe AI key (TYPESAFE_API_KEY) the deterministic SIM analyst answers (mode: sim).

curl -s "/api/brain" | jq '.status,(.analyses[0]|{stance,confidence,oneLiner})'
GET/api/eval?summary=1free (diagnostic)

Eval harness report (§11 B14): scenario pass/fail, swept invariants, pinned golden vectors. ?summary=1 for the CI gate (ok + digest), ?failures=1 for diffs only, ?group=policy to narrow.

curl -s "/api/eval?summary=1" | jq .ok,.digest,.totals.passRate
GET/api/workflows0.003 USDC / run

AI agent workflow registry: 5 declarative workflows (ave-discovery-triage · ave-pre-trade-review · ave-portfolio-risk · ave-market-regime · ave-mcp-briefing), their typed Jev questions, per-step authority guards, the resolved model plane, and the run ledger. POST { id, input, simulate } runs one; simulate:true runs the deterministic SIM control. Pre-rename ids still resolve and are answered with the ave- id.

curl -s "/api/workflows" | jq '.status.models,.workflows[0].steps[0].questions.stance.criteria'
POST/api/intent0.004 USDC / req

Natural language → IntentGraph (typed or blocking clarification) + deterministic policy verdict.

curl -s -X POST /api/intent -H 'content-type: application/json' \
  -d '{"text":"Buy $500 of T0XHOOD","tier":"strict","bookUsd":13000,"tick":0}' | jq .policy.decision
MCP tool server (session-gated)Claude · ChatGPT · any Streamable HTTP client
  • t0x_check_access — ungated balanceOf vs 5,000,000 T0XHOOD
  • t0x_chain_status — RH + Arc rpc health / head (needs session)
  • t0x_token — CA, 1B supply, Uniswap v4 pool (needs session)
  • t0x_screener — 6 discovery lenses + multi-factor filter (needs session)
  • t0x_get_feed — workspace rows + live $T0XHOOD overlay (needs session)
  • t0x_shield_verdict — full check list + probes + tier gates (needs session)
  • t0x_compile_intent — NL → IntentGraph + policy (needs session)
  • t0x_signals — signal objects + resolution history (needs session)
  • t0x_entities — entity graph + flow radar (needs session)
  • t0x_fomo — fomo.family radar: TCS board · gems · traders · thesis (needs session)
  • t0x_scan — Arc + RH scan by the monitoring agent: fresh launches, risk-ranked (needs session)
  • t0x_agent — agent telemetry: status, cycles, findings, operator log (needs session)
  • t0x_brain — LLM analyst verdicts on discoveries (advisory plane, needs session)
Auth at /mcp: GET /api/mcp/verify?wallet=0x… → personal_sign challenge (EIP-191, Keccak + secp256k1) → POST /api/mcp/verify { wallet, challengeId, signature } → x-t0x-session (256-bit, 6h, 1/wallet, revocable via DELETE /api/mcp/verify). Holder must have ≥0.5% (5M) on Robinhood Chain; admin allowlist 0xa************* bypasses the hold but not proof. Discovery JSON at GET /api/mcp exposes gate + auth with TTLs.
machines subsidise humans§5.2 #6

Agents and bots consume the MCP / REST surface. Holder-gated access keeps the intelligence layer aligned with $T0XHOOD — 5,000,000 tokens (0.5% of 1B) is the floor. Admin-allowlisted wallets get full MCP without holding 0.5% but must still prove ownership. Optional x402 metering can sit in front later; the holdings check is the production gate today. Address-spoofing via x-t0x-wallet / ?wallet= alone is closed — gated tools accept only x-t0x-session.

Gated tool without session:

{"error":"MCP_SESSION_REQUIRED","hint":"GET /api/mcp/verify?wallet=0x… → personal_sign → POST /api/mcp/verify"}

Below-threshold with valid session:

{"error":"MCP_TOKEN_GATE","holdings":{"eligible":false}}
full hybrid intelligence layerIndexer / SQL ➔ Jev Fast Decision Layer (Gates & Routing) ➔ Decoupled Storyteller
Selected target: $T0XHOOD
AVE AGENT WORKFLOWS · Jev by default · typed decisions · advice onlySIM DECIDER (no LLM key)
workflows
—
steps
—
typed questions
—
recorded runs
—

TypeSafe AI — Jev (System One API · api.typesafe.ai) — typed choices and bounded scores with calibrated probabilities; no free-form generation.

the terminal maps the typed answer to language deterministically (assimilate step). advisory plane only — never Shield gates, policy, sizing or execution (§10 determinism bias). Fallback: deterministic SIM decider, stamped mode:"sim" — never a silent downgrade.

Runs are advisory-plane only: no workflow writes a Shield gate, a policy decision, a size band or an execution. A model can only answer from the criteria declared above — "run (Jev)" returns its typed answer verbatim, and the rendered language beside it is produced deterministically by $T0XHOOD Terminal, not by the model. INV-14/15/16 in the eval harness hold this shape in CI.
Honesty note (R13): on-chain "AI agent volume" is unfalsifiable — a cron script and an agent produce identical records. This terminal reports policy-bounded executions and on-chain reads, never "AI agent volume".