mcpbeat Sign in

Warmth Engine Observatory MCP Server

by warmthengine Your server? Claim it
answering

Warmth Engine Observatory is answering right now. Last checked 13 min ago. It exposes 17 tools. Last commit 17 Sep 2026.

Coordination Intelligence: AI infrastructure coordination dynamics across geopolitical blocs

Uptime history 47 days of history
47 days agonow
100.0%
Uptime 24h
91 of 91 checks
17
Tools
read from the server
218 ms
Response time
average over 24h
1
Stars
last commit 17 Sep 2026

What changed 44

Every tool that appeared, vanished or quietly changed what it asks for. Recorded since 19 August 2026. No other catalogue keeps this.

16 Sep a tool changed version
5 Sep a tool changed version
31 Aug 17 tools changed the parameters they ask for get_actors, get_blocs, get_capability_links and 14 more
31 Aug a tool changed version
30 Aug 5 tool descriptions were rewritten get_actors, get_capability_links, get_capability_signatures and 2 more
30 Aug 2 tools changed the parameters they ask for3 times that day get_capability_links, get_capability_signatures
30 Aug a tool changed version2 times that day
28 Aug a tool changed version
27 Aug 3 tools changed the parameters they ask for5 times that day get_actors, get_capability_links, search_events
27 Aug 4 tool descriptions were rewritten get_capability_links, get_coverage_stats, query_scp and 1 more
and 8 more, back to 19 August 2026

What the code does

We read the source, 19 h ago · tools taken from the live server · rules 3dff92dd89df

Capabilities

What this server is able to do. For an MCP server this is often the job itself — a terminal server runs commands because that is what it is for. Listed so you know what you are plugging in, not as an accusation.

                    $('enrichment').innerHTML = n.same_industry_enrichment.toFixed(1) +

Is this your server and something here is wrong? Tell us — corrections are free and do not require a plan.

This code can reach further than it looks

We found places where it runs commands, builds paths or queries from values it is given. None of that is a flaw by itself — it becomes one when the code changes, and code changes quietly between releases. We re-read it on every one.

Three servers free · no card

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 13 min ago.

run in your terminal
claude mcp add observatory --transport http https://warmthengine.com/mcp
~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "observatory": {
      "url": "https://warmthengine.com/mcp"
    }
  }
}
~/.codex/config.toml
[mcp_servers.observatory]
url = "https://warmthengine.com/mcp"
.cursor/mcp.json
{
  "mcpServers": {
    "observatory": {
      "url": "https://warmthengine.com/mcp"
    }
  }
}
.vscode/mcp.json
{
  "mcpServers": {
    "observatory": {
      "url": "https://warmthengine.com/mcp"
    }
  }
}

Available tools 17

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

capability
get_capability_links
Retrieve the event↔dimension membership links — which events qualify or contribute to each actor's Sovereign Capability Profile (SCP) capability dimensions. Filter by `actor` (e.g. "US", "CN", "GB" — note GB, not UK), `dimension` (D1–D7), or `event_id`. Each link carries its `link_type` (`qualifying_contributor` = establishes the dimension vs `capability_area` = contributes to it), `attribution` (specific | general), and `entity` (the named asset, on qualifying links only); its identity and lifecycle — `link_id` (the stable handle, CL-{ACTOR}-{Dn}-{eventID}.{sequence}), `created`, `scp_register_version` (the register cycle it was assessed in), `assessed_under` (the methodology version in force at that assessment, which may be older than the dataset's current one), `status`, and on retired links `status_changed`; and at full tier `qualification_basis`, `rationale` and `note` (the deep qualification analysis), `status_reason` (the assessed reasoning for a retirement), and `provenance` (construction-cohort marker). Sole-vs-multiple basis is derivable by counting `qualifying_contributor` links per actor×dimension (1 = sole; >1 = one of several) — links are never flattened to `qualifies:yes/no`. Active links are returned by default; retired links are never restored, and a relationship assessed afresh enters as a new link at the next sequence. Pass `include_retired` to receive the archive alongside the active links. The response carries a metadata block — totals by type, per-actor and per-dimension distributions, active/retired `status_counts`, met-dimension coverage figures, and the dataset's generation date and revision history — identical on both tiers; `last_updated` dates the most recent revision. For the higher-order signatures built from these links, use `get_capability_signatures`.
get_capability_signatures
Retrieve the precomputed Capability Signatures — directional Coordination Connection (CC) chains or hubs (connection types 1/3/4/5) whose member events span two or more Sovereign Capability Profile (SCP) dimensions, surfaced as corroborating structural texture rather than a headline finding. Omit `signature_id` for the whole set — each signature with its nodes, directional legs (from/to + connection type), dimension span, attribution profile, and narrative; its `member_links`, the explicit list of Capability Link `link_id`s its nodes correspond to; and its own lifecycle fields — `created`, `scp_register_version`, `assessed_under`, `status` — plus metadata (the directional-edge inventory, the active/retired `status_counts`, and the pre-operational caveat) and the non-signature same-capability clusters. Pass `signature_id` (e.g. "CS-001") for one. A signature is never edited in place: a change to its member set retires it whole, and a still-qualifying structure re-enters as a new signature. Active signatures are returned by default; pass `include_retired` to receive retired signatures alongside. `member_links` is the authoritative reference into the membership layer: the node fields are denormalised for rendering and are subordinate to it, so resolve a `link_id` through `get_capability_links` for that node's current status and full detail. For the underlying event↔dimension membership links, use `get_capability_links`. A derived overlay over the directional CC graph; served in full and free, lifecycle fields included.
event
get_event
Retrieve one event by ID — classification, assessment, sources, industry tags, Environmental Nexus Tags (ENTs), bloc analysis, and tier rationale. Use when you already hold an event ID; to find IDs, use `search_events`. Pass `event_id` as the zero-padded string (e.g. "06", "141"). Free tier returns the complete record for sample events and the classification facts for all others (deeper assessment and evidence withheld); full tier returns every field.
get_event_stack
Assemble the stack journey for one event — its kind-labelled value-chain neighbourhood at depth 1, the same composition the Atlas renders, in one call. Returns three separate arrays, never merged: `coordination` — the event's own Coordination Connections (CCs), all seven connection types, directed (types 1/3/4/5) and bidirectional/sibling (types 2/6/7) alike; each carries type/confidence/direction, plus evidence at full tier; `material` — the event's own Infrastructure-Thread edges, one per source→target pair, each with its sourced asset facts (`linkType` + asset + naming field); `capability` — the active Sovereign Capability Profile (SCP) dimension-membership waypoints for the event itself (actor, dimension, link_type, attribution, entity, and the link's `link_id` and lifecycle fields; plus qualification_basis/rationale/note at full tier). The three are different kinds of claim: a thread is a factual asset match, not a CC, and is never rendered as one. The capability array carries active links only and takes no parameter to widen it — a stack is the event's neighbourhood as the corpus now stands; for retired memberships, use `get_capability_links` with `include_retired`. A derived view over the existing connections, threads, and capability links — each substrate keeps its own gating, and the free tier leaks no paid fields. For the material layer alone, use `get_threads`; for the directed multi-hop coordination lineage between events, use `traverse_coordination`. Pass `event_id`.
actors
get_actors
Retrieve whole Sovereign Capability Profile (SCP) actors — each with its designation (PAA / AIK / ACS / Participant), capability score, severance result, `assessed` (the register month, YYYY-MM, the profile was assessed in), a met/not-met assessment across the seven capability dimensions (D1–D7), and `energy_context`. Use to fetch complete actor records; to pivot one dimension across all actors, compare actors side by side, or read the dimension-watch register, use `query_scp`. Filter by designation or actor name. Free tier returns each dimension's met status and recorded headline (and the US sample in full); full tier adds the per-dimension constraint, qualification, and sources. `energy_context` carries installed generation capacity from the U.S. Energy Information Administration and annual electricity generation from the energy think tank Ember, served in full on both tiers: external reference data outside the WEO analytical stack, national totals, dated observations reported as published, accompanying the profiles but forming no part of them. Descriptive — recorded status, never inference.
blocs
get_blocs
Retrieve the WEO Bloc Membership Register — every nation in the register with its bloc assignment and universal membership category (Core / Integrated / Engaged / Peripheral / Non-Aligned), its key evidence and source URLs, plus document metadata and sectioned provenance (snapshot history, changelog, pre-register decisions). Served whole and free — the machine mirror of the public blocs register. A descriptive roster, never inference; the category definitions themselves are served by `get_methodology`.
connection
get_connection_by_id
Retrieve a single Coordination Connection (CC) by its `connection_id` (e.g. "CC-06-11-3"). Use when you have the exact identifier; to list or filter CCs, use `get_connections`. Returns the CC with full evidence on the full tier — or when an endpoint is a sample event — and the base fields only otherwise.
connections
get_connections
Retrieve Coordination Connections (CCs) — the typed, directional relationships WEO records between events — optionally filtered by event (as source or target), type (1–7), or confidence (CC-V / CC-E / CC-A). For a single CC by its identifier, use `get_connection_by_id`. Each CC carries its id, source/target event IDs, type name + number, confidence, and direction; full tier — and either tier when an endpoint is a sample event — adds the evidence summary, evidence detail, and verification history.
contribution
get_contribution
Look up WEO Contribution Architecture vocabulary — the contributor programme's terms, credit classes, and governance provisions (e.g. "Delta Credit", "Founding Observer", "Observer Network", "rate card", "malinformation"). Returns the term's context, its section anchor, and a deep link into the self-hosted CA edition. Omit `term` for programme status: phase, activation criterion, current corpus size, and enquiry address. Use to resolve participation vocabulary — the Contribution Architecture governs participation, whilst the Methodology Manual (`get_methodology`) governs what qualifies. Matching is exact-first, then substring; an unknown term returns a sample of available terms. Served in full on both tiers.
coverage
get_coverage_stats
Retrieve the current corpus statistics — live counts and distributions of events, Coordination Connections (CCs), and Sovereign Capability Profile actors across bloc, tier, domain, event type, primary industry, CC type, confidence, and designation, plus Environmental Nexus Tag (ENT) statistics with the Warmth Engine Ratio, counts of the derived layers — Infrastructure Threads, Capability Links with their type split, and Capability Signatures — the event-ID range, and the methodology version. Capability Link and Capability Signature counts are of active records only: retired records are excluded so the figures describe present coverage rather than everything ever assessed, with the active/retired splits published in the two capability tools' metadata. No parameters; figures are computed live, so the response always reflects the present database. The secondary-industry breakdown is full-tier only.
events
search_events
Search and filter the WEO event corpus by `query` text or classification (bloc, tier, domain, event type, primary industry tag); returns the matching events with their metadata, capped by `limit` (default 20, max 50). Use to discover or shortlist events; for a single event's complete record, use `get_event`. Free tier returns the classification facts with the deeper assessment and evidence withheld on non-sample events; full tier — and sample events on either tier — return every field.
methodology
get_methodology
Look up the WEO methodology definition for any platform-specific term, field, or concept (e.g. "CC-V", "T2", "PAA", "ENT-1", "PIET"). Returns the term's definition, its section anchor, a deep link to that section of the published methodology, and the methodology version. Use to resolve any vocabulary the other tools return. Pass `term`; matching is exact-first, then substring, and an unknown term returns a sample of available terms.
metrics
get_metrics
Retrieve the WEO quantitative coordination metrics — dated observations of the documented connection network computed under Towards Coordination Science (TCS). Returns Cross-Sector Transmission Frequency (CSTF) with its permutation null model, the cross-sector transmission matrix (sparse non-zero cells plus the fixed 11-category row order), Framework Family Density, Cross-Bloc Connection Frequency, and Connection Growth Rate. For live corpus counts and distributions, use `get_coverage_stats` — metrics here are derived, dated observations, never live recomputations. Omit `metric` for all of them; set `include_history` for the full append-only series rather than the latest observation. Pre-operational: the corpus has not reached operational threshold, so every value is a dated observation of the documented record as constructed, not a measurement of the real-world coordination landscape. Each metric carries its own `status` — `published` metrics are surfaced on the platform; `pre_operational` ones are recorded but not publication-grade; `insufficient_corpus` ones are blocked. Values are comparable only within a `taxonomy` epoch. Served in full on both tiers.
scp
query_scp
Query the Sovereign Capability Profile (SCP) register by pivoting and comparing — distinct from `get_actors`, which fetches whole actors and is where `energy_context` is served; it is not returned here. Pass exactly one of: `dimension` (e.g. "D3") pivots that one dimension across every actor (each actor's met status and recorded headline, on what basis); `actors` (e.g. ["US","CN"]) lays those actors side by side across all seven dimensions (D1–D7); `watch:true` returns the `dimension_watch` register (forward-looking entries: actor, dimension, current vs expected_change, trigger, timeline). Readouts are descriptive — recorded status and fields, never causal inference. Free tier carries `met` + the headline for all actors and the US sample in full; the full tier adds the per-dimension evidence (constraint, qualification, sources, and `escalation_trigger` where recorded). Omit all three params for a usage hint.
threads
get_threads
Retrieve Infrastructure Threads — the factual material-link layer recording where the same named AI hardware asset (chip / GPU / NPU / custom ASIC) appears as a documented fact in two events. A thread is not a Coordination Connection: no connection type, no confidence grade — either the asset match is verified or it isn't. Pass `event_id` for that event's linked events in both directions: outbound = assets this event deploys or trains on, each linking to its producer event; inbound = events that use this event's asset. Each link carries the sourced claim (`linkType` ∈ deploys | trains_on | powered_by | fabricated_at, plus the asset) and the host-event field that names it. Omit `event_id` for the whole layer. For one event's value-chain stack, use `get_event_stack`. Free on both tiers.
topology
get_topology
Retrieve the precomputed Coordination Topology — the structural lineage layer over the parent→child Coordination Connection graph (a DAG). Omit `node_id` for whole-graph network statistics (taxonomy-class counts, roots, multi-parent nodes, dominant roots by coordination reach, weakly-connected components). Pass `node_id` (e.g. "E34") for one node's structural metrics: generational depth (min/max/all-paths), coordination reach, directed betweenness, path diversity, fan-in/out, taxonomy class, component id. For the actual paths between nodes or up/down a lineage use `traverse_coordination`; for one event's value-chain stack use `get_event_stack`. Optional `class` / `cc_type` / `min_reach` filters return matching nodes. The full tier adds the held analyst layer (chain participation, curated orphan/sibling and named-feature sets).
traverse
traverse_coordination
Walk the Coordination Topology lineage graph (precomputed lookups over the parent→child Coordination Connection DAG). `mode="path"` returns every path between `source` and `target`, each with its CC-type (connection-type) sequence and whether it is pure lineage (homogeneous) or crosses a sibling/bidirectional edge; `mode="ancestors"`/`"descendants"` return the nodes reachable up/down the hierarchy; `mode="neighbours"` returns direct parents and children. For a node's structural metrics or the whole-graph summary rather than walks, use `get_topology`. `cc_types` (connection-type filter) and `max_depth` apply to `path` AND to the `ancestors`/`descendants`/`neighbours` adjacency walks — supplying either runs a bounded typed walk over the backbone edges. `homogeneous_only` is `path`-only (drops any path crossing a sibling edge); sent to an adjacency mode it is returned in `ignored_params`. A bare numeric `node_id` missing the `E` prefix is resolved (the canonical form is echoed as `resolved_node_id`); a node that exists but carries no backbone edges is reported as such rather than as unknown.

Endpoints

URLTransportStateLatencyChecked
https://warmthengine.com/mcp streamable-http answering 281 ms 13 min ago

Alternatives to Warmth Engine Observatory

same job, measured the same way
Bezal — Local Business Intelligence for AI Agents
by bezal

Search 7,000+ local service businesses across America by category, location, or keyword.

13 tools answering
Futuristic Risk Intelligence
by cct15

Geopolitical conflict risk, political events, and maritime traffic data for AI agents

31 installs/wk local only
QSIG Intelligence
by qsig-x402

Geopolitical risk score with a published kill criterion. Measured state, not forecasts.

3 tools answering
eYKON Intelligence
by eykon

Live geopolitical intelligence feeds, plus eYKON's own scored and published forecast record.

24 tools answering
Terminal
by themonexus

Live geopolitical and markets intelligence wire: 35k+ wire items, event threads, 55k+ articles.

27 tools answering
Site Intelligence
by bayrakdaralper

Score any coordinate for ecological and agricultural land suitability from satellite data

local only
Location & Demand Intelligence
by timzinin-api

Pay-per-call where-and-when-to-operate signals from official local statistics.

7 tools answering
I
SEO GEO Intelligence
by atul0016

SEO and AI-answer visibility intelligence for search, content gaps, and GEO actions.

44 installs/wk local only

Warmth Engine Observatory — questions

Answers built from our own checks of this server.

What can Warmth Engine Observatory do?
It exposes 17 tools, read directly from the server on our last check. Among them: get_actors, get_blocs, get_capability_links, get_capability_signatures, get_connection_by_id, get_connections and 11 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →
What is Warmth Engine Observatory mostly used for?
Its tools cluster around capability and event. That is what this server is built to work with — the grouping comes from the actual tool names, not from a category we assigned.
Is Warmth Engine Observatory working right now?
We send a real MCP handshake every 15 minutes. Over the last 24 hours 91 of 91 checks got a reply (100.0%), average response time 218 ms. The bar chart above shows every period we have measured.
How do I connect Warmth Engine Observatory?
Copy the ready config from this page — we generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each with the file path that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.
Does Warmth Engine Observatory need an API key?
No. Warmth Engine Observatory completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 17 of them are readable on this page. This is what we observed, not what the docs claim.
How fast is Warmth Engine Observatory?
It answers our handshake in 218 ms on average, which is faster than 63% of all working MCP servers we measure. The comparison comes from our own checks across the whole registry, every 15 minutes.
Is Warmth Engine Observatory open source?
We cannot say either way: written in HTML and 1 stars on GitHub, but we could not determine the licence, and without one the code is not open source by default.