emem

{
  "additionalInterfaces": [
    {
      "protocol": "openapi-3.1",
      "transport": "HTTP+JSON",
      "url": "https://emem.dev/openapi.json"
    },
    {
      "protocol": "well-known-json",
      "transport": "HTTP+JSON",
      "url": "https://emem.dev/.well-known/emem.json"
    },
    {
      "protocol": "agent-card-v1",
      "transport": "HTTP+JSON",
      "url": "https://emem.dev/v1/agent_card"
    },
    {
      "protocol": "mcp-streamable-http",
      "transport": "JSONRPC",
      "url": "https://emem.dev/mcp"
    }
  ],
  "capabilities": {
    "pushNotifications": false,
    "stateTransitionHistory": true,
    "streaming": true
  },
  "defaultInputModes": [
    "text/plain",
    "application/json"
  ],
  "defaultOutputModes": [
    "application/json"
  ],
  "description": "Agent-native, content-addressed, ed25519-signed Earth memory protocol. Recall any place on Earth (cell \u00d7 band \u00d7 tslot) and get back a signed receipt with a content address you can cite.",
  "documentationUrl": "https://emem.dev/agents.md",
  "iconUrl": "https://emem.dev/favicon.svg",
  "name": "emem",
  "preferredTransport": "HTTP+JSON",
  "protocolVersion": "0.2",
  "provider": {
    "contact": "avijeet@vortx.ai",
    "country": "India",
    "data_protection": {
      "contact": "avijeet@vortx.ai",
      "ip_handling": "blake3-truncated-8B (one-way hash of client IP)",
      "log_retention_days": 30,
      "log_retention_enforced_by": "systemd-journald MaxRetentionSec=30day",
      "no_pii_in_canonical_channel": true,
      "regimes": [
        "GDPR",
        "UK-GDPR",
        "DPDP-2023",
        "CCPA-CPRA"
      ],
      "sells_personal_data": false,
      "shares_for_advertising": false,
      "third_party_analytics": [
        {
          "configured_via": "env var EMEM_GA_MEASUREMENT_ID; repo holds a placeholder so forks do not inherit",
          "consent_banner": {
            "buttons": [
              "Accept",
              "Reject"
            ],
            "buttons_equal_prominence": true,
            "decision_storage": "first-party cookie emem_consent (Path=/, Max-Age=180d, SameSite=Lax, Secure)",
            "decision_storage_rationale": "switched from localStorage in 2026-05; EU-strict browser configs (Firefox Strict, Brave Shields, 'delete site data on close') were clearing localStorage between sessions and causing the banner to re-prompt on every refresh. First-party cookies survive those configs.",
            "esc_key_action": "Reject",
            "is_cookie_wall": false,
            "rendered_for": "human visitors with a JS-capable browser",
            "rendered_for_ai_agents": false,
            "revocation": "footer 'Manage cookies' link deletes the cookie and reopens the banner"
          },
          "consent_default": "denied for ad_storage, ad_user_data, ad_personalization, analytics_storage, functionality_storage, personalization_storage; granted for security_storage",
          "consent_mode": "v2",
          "cookies_post_accept": [
            "emem_consent (180d, necessary)",
            "_ga (2yr)",
            "_ga_<container> (2yr)"
          ],
          "cookies_post_decision": [
            "emem_consent (180d, necessary, ePrivacy Art. 5(3) exempt)"
          ],
          "cookies_pre_consent": [],
          "ga_post_consent_cookies": [
            "_ga (2yr)",
            "_ga_RBLXX5LR9L (2yr)"
          ],
          "ip_transmitted_pre_consent": false,
          "lawful_basis_post_consent": "GDPR Art. 6(1)(a) consent",
          "lawful_basis_pre_consent": "GDPR Art. 6 not engaged (no personal data processed)",
          "measurement_id": "G-RBLXX5LR9L",
          "opt_out": "https://tools.google.com/dlpage/gaoptout",
          "pii_transmitted_pre_consent": false,
          "scope": "HTML landing page only (/), not /v1/*, /mcp, /openapi.json, /agents.md, /llms.txt, or .well-known/*",
          "transfer_basis": "Google TADPF self-certification + SCCs",
          "transport": "navigator.sendBeacon (non-blocking)",
          "vendor": "Google Analytics 4"
        }
      ]
    },
    "organization": "Vortx AI Private Limited",
    "privacy_policy_url": "https://emem.dev/privacy",
    "support_url": "https://emem.dev/support",
    "terms_of_service_url": "https://emem.dev/terms",
    "url": "https://vortx.ai"
  },
  "responder": {
    "hash_alg": "blake3",
    "pubkey_b32": "777er3yihgifqmv5hmc2wwmyszgddzderzhsx6rex4yoakwomvka",
    "signature_alg": "ed25519"
  },
  "security": [
    {
      "none": []
    }
  ],
  "securitySchemes": {
    "none": {
      "type": "noAuth"
    }
  },
  "skills": [
    {
      "description": "Resolves a place mention (free-text name, address, or lat/lng) to the protocol's cell64 identifier, and returns the topic-grouped inventory of bands and algorithms available at that location.",
      "examples": [
        "Use whenever the input refers to a real-world location and the next step needs the cell64 identifier or wants to know which bands are available before recalling. The response carries `data_at_this_cell` with three sub-fields: `live_bands_by_topic` (every band recallable here, grouped by topic such as flood_water_event_window, vegetation_condition, built_up_human_geography), `algorithms_for_topic` (composition recipes that fuse those bands into named scores), and `declared_but_no_materializer_at_this_responder` (cube slots reserved without a live connector). For the single-shot path that runs the full chain server-side and returns one packaged answer, use `emem_ask` instead."
      ],
      "id": "emem_locate",
      "name": "Resolve place to cell64 + band inventory",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Single-shot free-text answer about a real-world location, backed by signed satellite/elevation/water/built-up receipts. Forwards a place mention plus a question; runs the locate \u2192 recall \u2192 algorithm chain server-side; returns one packaged envelope.",
      "examples": [
        "Use when the question concerns a specific real-world place and a packaged, citation-bearing answer is preferable to manual primitive composition. Forward the user's question verbatim as `q` plus the location as `place` (free text), `cell` (cell64), or `lat`+`lng`. The server resolves the location, classifies the question to a topic, recalls every relevant band (auto-materializing Sentinel-2 / Sentinel-1 / Cop-DEM / JRC GSW / Overture / weather on miss), surfaces the algorithm recipes that compose those bands into named scores, and returns a single envelope with `topic_routing`, `facts`, `algorithms_for_question`, an optional Sentinel-2 RGB scene URL, and a `caveats` block (grid resolution, revisit cadence). All facts are signed by the responder; the receipt's `fact_cids` are content-addressed and citable. Set `include_image: true` to bundle the latest cloud-free Sentinel-2 thumbnail. Out-of-scope questions return `topic_routing.matched_topic: null` plus the full inventory so the caller can route elsewhere."
      ],
      "id": "emem_ask",
      "name": "Ask a free-text question about a place",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Event-discovery sweep: pick an event keyword (algal_bloom, deforestation, flood_extent, wildfire, urban_heat_island, methane_plume, landslide, drought, soil_salinity, crop_stress, water_turbidity, oil_slick) plus a region (free-text name or polygon_bbox). The responder geocodes the region, fans out across up to 32 sampled cells, recalls each event's primary scalar input band, and returns the top 8 hotspots ranked by that scalar \u2014 each carrying its cell64, lat/lng, the recalled value, a fact_cid for citation, and a scene.png URL. Bypass for free-text input is `emem_ask` (the classifier in /v1/ask routes \"find X in Y\" questions to the same hunter path).",
      "examples": [
        "Call when the user asks an open-world discovery question (\"find oil spills in the Persian Gulf\", \"where is deforestation happening in the Amazon\", \"show me algal blooms in Lake Erie\", \"hunt wildfires across California\"). Surface 3\u20138 hotspots with their scene.png as image attachments and quote at least one fact_cid. For `oil_slick` the responder honestly reports `not_yet_implemented` and points at SAR-darkening + turbidity proxies \u2014 don't fabricate detections. The ranking uses the algorithm's primary scalar input only; for the full per-cell algorithm score, fetch the formula at /v1/algorithms/<key> and apply it client-side over the same recalled bands."
      ],
      "id": "emem_hunt",
      "name": "Hunter mode \u2014 find event hotspots over a region",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Produce a Due Diligence Statement per Regulation (EU) 2023/1115 for one or more plots. Each plot carries operator-supplied geometry (GeoJSON Polygon for >4 ha, Point for \u22644 ha non-cattle per Article 2(28)), country of production (ISO3), Combined Nomenclature code (HS-6+), and quantity in kg. The endpoint applies the regulation's 10 % canopy / 0.5 ha / 5 m height forest definition (Article 2(4)) using the EU Commission's expected JRC GFC2020 V3 baseline plus Hansen GFC v1.12 loss-year confirmation; Sims et al. 2025 driver attribution and RADD SAR fallback layer on when those connectors are wired (Absence today). The response is an Annex II-shaped envelope with per-plot verdict (pass/fail/not_in_scope/indeterminate/fail_below_de_minimis), failing-cell fraction, and signed fact CIDs for every per-cell verdict \u2014 operators quote them in the company's Article 12 record. Article 9(1)(b) legality (land tenure, FPIC, country-of-origin laws) is structurally out of EO scope; the response carries an explicit `legality_disclaimer` for that reason.",
      "examples": [
        "Call when a commodity supplier or EU importer needs to evidence due diligence under Regulation (EU) 2023/1115. Use the plot-level signed receipts as evidence inside the operator's company record; pair with a partner legality module before submitting the final DDS to the EU Information System (TRACES NT). For a single plot, pass one entry in `plots`. For batch supply-chain audits, pass up to a few dozen plots in one call \u2014 the endpoint fans out per plot. Surface the failing-cell fraction, the chosen forest baseline, and the legality disclaimer in the user-facing response so the operator understands what the engine claims (and does not)."
      ],
      "id": "emem_eudr_dds",
      "name": "EUDR Due Diligence Statement \u2014 polygon-in, signed Annex II envelope out",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Dense state vector for a place. Two views: `encoder` (single foundation embedding at its native dim \u2014 128-D Tessera, 1024-D Clay, 1024-D Prithvi) and `cube` (the full 1792-D voxel concatenated across every wired band, with per-band coverage manifest and full-fidelity extras for any encoder whose native dim exceeds its cube slot).",
      "examples": [
        "Call when the agent needs a dense, ready-to-feed vector for downstream similarity / linear-probe / clustering, or wants a single rebindable handle (`memory_token` / `state_cid`) for a place. Default `view=encoder` (cheap, single recall) \u2014 pass `encoder` (default `geotessera`) to pick the band. Pass `view=cube` for the responder's full attested view at the cell; the response carries `coverage[]` so an agent can distinguish attested-zero (signed Absence) from not-yet-materialised, and `extras[]` preserves full Clay/Prithvi 1024-D vectors when the cube truncates to a 384-D slot. Pair with `emem_find_similar` for k-NN, `emem_compare` for two-cell cosine, or `emem_verify_receipt` to verify the signed payload offline."
      ],
      "id": "emem_state",
      "name": "Read the place's state vector (single encoder OR full 1792-D cube)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Fans out across every wired foundation-embedding encoder (`geotessera`, `clay_v1`, `prithvi_eo2`) for one cell and returns a structured per-encoder state map. Each encoder is attempted independently; encoders that fail at this cell surface under `missing` with a typed reason instead of killing the request.",
      "examples": [
        "Call when the agent wants cross-encoder consensus (do Tessera, Clay, and Prithvi agree on the archetype here?), redundancy-aware reasoning (which encoder is freshest at this cell?), or a concatenated multi-encoder state for downstream linear probes. Pass `encoders: [...]` to override the default foundation set."
      ],
      "id": "emem_state_multi",
      "name": "Multi-encoder state at one cell (foundation fan-out)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Vector delta between the same cell at two tslots: returns the per-element residual, its L2 norm (scalar change-magnitude), the cosine between the two source vectors (orientation drift), and both source fact CIDs so the agent can quote both attestations as evidence.",
      "examples": [
        "Call when the user asks 'how much did X change between A and B' for a foundation embedding at one place. Pass `tslot_a` and `tslot_b` (must differ); default `encoder=geotessera`. For per-band scalar change (NDVI delta, elevation delta) use `emem_diff` instead."
      ],
      "id": "emem_state_diff",
      "name": "Between-tslot state vector delta (residual + cosine)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Compose a `memt:<cell64>:<fact_cid>` (or `memt:<cell64>:<state_cid>`) citation handle. Validates both components are non-empty and do not contain the outer separator `:`.",
      "examples": [
        "Call when the agent wants a single rebindable string to cite a place + attested fact across messages, threads, or tools. The token is the recommended way for agents to pass earth-memory citations to other agents without re-fetching. Pair with `emem_verify_receipt` on the receiving end to verify the signed payload."
      ],
      "id": "emem_memory_token",
      "name": "Compose a memory_token citation handle",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Parse a `memt:<cell64>:<fact_cid>` citation handle and return the signed fact body the cid binds. Saves the agent from string-splitting the token and chaining `GET /v1/facts/<cid>` manually.",
      "examples": [
        "Call when an agent receives a memory_token from another agent (or out of a previous turn) and wants the underlying signed bytes. The response carries the parsed cell + fact_cid, the full fact body, and the stable `fact_url` an agent can hand to any other peer. 404 with a typed code if the responder doesn't hold the cid; try /v1/fetch with the cid then, or paste the token at a mirror."
      ],
      "id": "emem_memory_token_resolve",
      "name": "Dereference a memory_token in one round-trip",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Signed snapshot of corpus liveness: distinct_cells, distinct_bands, facts_scanned, top per-band counts, manifest CIDs. Same payload that backs /v1/stream's corpus.state tick (signed). Use this for a one-shot poll instead of holding an SSE connection.",
      "examples": [
        "Call when an agent needs a single liveness reading to surface in a dashboard, attach to a report, or decide whether to refresh local caches. Includes ed25519 signature over a deterministic preimage so the snapshot is verifiable. For a continuous feed, GET /v1/stream over Server-Sent Events instead."
      ],
      "id": "emem_corpus_state_stats",
      "name": "Signed snapshot of corpus liveness",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Hand-verified evaluation items for grading an agent against the responder. Returns {items[], grader_url}. Submit answers (cell64 or fact_cid per item) to POST /v1/benchmark/grade for per-item scores. Items today: elevation recall, NDVI, find_similar neighbours.",
      "examples": [
        "Call once at agent-onboarding time (or in CI) to fetch the canonical task list, then have the agent answer each item using its normal tool routing, and POST the answers map to /v1/benchmark/grade for a deterministic score. Lets an operator regression-check that an agent build still hits ground truth."
      ],
      "id": "emem_benchmark",
      "name": "Hand-verified eval items for agent grading",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall facts about a cell \u2014 auto-materializes on miss for any band with a registered materializer.",
      "examples": [
        "Call after `emem_locate` (or with a known cell64). Returns every Primary fact stored at that (cell, band, tslot). IMPORTANT: if the cell has no fact yet for a requested band AND that band has `has_materializer=true` (per `emem_coverage_matrix` / `emem_materializers`), the responder fetches the upstream value, signs it under its identity, persists it, and returns it in the same response (~180 ms first call, ~10 ms cached thereafter). So for any wired band you can recall ANY cell on Earth without seeding \u2014 just pass `bands: [<band>]`. The response carries `materialize_notes` listing what was just fetched. Empty result with no notes means the band has no materializer at this responder."
      ],
      "id": "emem_recall",
      "name": "Recall facts at a cell (auto-materializes on miss)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall facts across every cell inside a place's polygon (single signed envelope). Closes the place-name-drift gap for wide features (parks, lakes, regions).",
      "examples": [
        "Call when the user names a wide feature (national park, river basin, country, large urban area) where one cell is too small. Pass `place` and the geocoder will fan out across the polygon \u2014 or pass `polygon_bbox` directly if you have coordinates. Returns `merged_facts`, `by_cell`, and a `polygon_bbox.source` indicator (`nominatim_boundingbox` = real polygon, `centre_cell_bbox` = fallback to one cell because the geocoder had no polygon). For *farm* queries the OSM polygon is the whole estate envelope; pass `include: [\"ftw_fields\"]` to additionally attach per-field agricultural-boundary polygons from Fields of The World (CC-BY-4.0) \u2014 or call the dedicated `emem_field_boundaries` for the pure-fetch shape."
      ],
      "id": "emem_recall_polygon",
      "name": "Recall facts across a place's polygon",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Per-field agricultural-boundary polygons from the Fields of The World global product (~3.17B fields, 241 countries, 10 m resolution, CC-BY-4.0). Returns a GeoJSON FeatureCollection with the polygon geometries, FIBOA-compatible properties, and a planar `area_m2` per field \u2014 plus provenance (source CID, provider URL, license, attribution).",
      "examples": [
        "Call when the user asks about farms, fields, parcels, croplands, plots, or agricultural boundaries inside a region \u2014 anywhere the OSM/Nominatim boundary alone is too coarse (the OSM polygon for a farm is its estate envelope; this returns the individual field polygons inside). Pass `place` (free-text) or `polygon_bbox`. For farms wider than ~10 km\u00b2, split the bbox: the fetcher caps each call at 16 covering tiles. The receipt quotes `license: CC-BY-4.0` and `attribution: Fields of The World / Taylor Geospatial Institute` \u2014 surface both with any rendered map. For a one-shot \"facts at every cell inside the farm PLUS the field polygons\", call `emem_recall_polygon` with `include: [\"ftw_fields\"]` instead."
      ],
      "id": "emem_field_boundaries",
      "name": "Per-field agricultural boundaries (Fields of The World)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Query facts over a region (single cell or list of cells), optionally aggregated per band.",
      "examples": [
        "Call when the user asks 'how does region X look', 'what's the average NDVI here', or wants a region-level summary. Use `agg=mean|median|p90|vector_centroid` to fold per-band values."
      ],
      "id": "emem_query_region",
      "name": "Aggregate facts over a region",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Compare two cells: cosine similarity over shared vector bands + per-band scalar deltas.",
      "examples": [
        "Call when the user asks 'how similar is X to Y', 'compare these two places', or wants a difference vector. Returns a single cosine score and per-band deltas."
      ],
      "id": "emem_compare",
      "name": "Compare two cells (cosine + scalar deltas)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Compare two bands at the same cell. Scalar pair \u2192 metric=delta, value=b-a. Vector pair (equal dim) \u2192 metric=cosine + per-dim delta. Returns a signed receipt naming both source fact CIDs.",
      "examples": [
        "Call when the user wants cross-source consistency at one place ('does Cop-DEM agree with GMRT here?'), cross-vintage drift ('how did the embedding change between 2017 and 2024 at this cell?'), or any band-vs-band comparison within a single cell. `cell` + `a` + `b` are required. `tslot_a`/`tslot_b` are OPTIONAL: omit them to let the responder auto-pick each band's latest attested tslot \u2014 required for medium/fast-tempo bands (NDVI 30-day, MODIS 8-day, weather, CAMS) where there is no fact at tslot=0. The response carries `tslot_resolution` (echoes what was chosen and why) and `bands_with_no_history` (lists any band the cell has no attested fact for)."
      ],
      "id": "emem_compare_bands",
      "name": "Compare two bands at one cell",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "k-NN over the corpus by cell embedding or inline vector.",
      "examples": [
        "Call when the user asks 'find places like X', 'where else looks like this', or hands an embedding to find neighbours. `key` is either a cell64 or `inline:[x,y,...]`. Default band is `geotessera` (128-D Tessera foundation embedding); pass `band: \"geotessera.multi_year\"` for the 1024-D 8-vintage fusion."
      ],
      "id": "emem_find_similar",
      "name": "k-NN over the corpus by embedding",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Time series for one (cell, band) over an inclusive [start, end] tslot window. Returns only what's already attested \u2014 does NOT trigger materialization. For historical backfill use `emem_backfill`.",
      "examples": [
        "Call when the user asks 'how did X change over time' for a band that already has multiple historical tslots seeded. IMPORTANT differences from `emem_recall`: (1) trajectory does NOT auto-materialize past tslots \u2014 it returns only facts that have already been attested at this responder, so for fast-tempo bands like `indices.ndwi` you'll typically see ONE point at the latest tslot until an attester seeds history. (2) tslots are non-negative `u64`; there's no negative-offset 'last 2 years' shorthand. For LONG-TERM history questions ('flooded in last 2 years', 'forest loss since 2020') prefer either (a) a static-tempo summary band that one fact answers \u2014 `surface_water.recurrence` covers 1984-2021 in a single signed value, no trajectory needed \u2014 or (b) `emem_backfill` to materialize and sign the missing tslots in one call."
      ],
      "id": "emem_trajectory",
      "name": "Time series for one (cell, band)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Compute a DerivativeFact (delta) between a band's values at two tslots.",
      "examples": [
        "Call when the user asks 'what changed between t1 and t2', 'give me the delta'. Returns a signed DerivativeFact + receipt \u2014 the delta itself is content-addressed and citable."
      ],
      "id": "emem_diff",
      "name": "Signed delta between two tslots",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Fetch a fact by its content-address (CID). Returns the full signed Primary or Absence fact \u2014 the same body served by REST `/v1/facts/{cid}`. Closes the citation loop: any fact_cid surfaced by recall, materialize, attest, or verify can be re-resolved by another agent without REST.",
      "examples": [
        "Call whenever you have a `fact_cid` (e.g. from `emem_recall`'s response, an `emem_attest` receipt, an `emem_materializers` outcome, or a citation in another agent's reply) and need the full fact body \u2014 its value, unit, sources, signer, signed_at, and derivation. Particularly useful for verifying that a citation a downstream agent gave you actually resolves on this responder. The response is byte-identical across responders for the same CID \u2014 the CID itself is the validator."
      ],
      "id": "emem_fetch",
      "name": "Resolve a fact by content-address (CID)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Materialize and sign every per-tslot fact for one (cell, band) inside a [start_unix, end_unix] window. Returns a signed list of (tslot, fact_cid, status) for each step. Slow but possible \u2014 one upstream fetch per tslot, capped by `max_facts`.",
      "examples": [
        "Call when the user wants HISTORY for a fast/medium-tempo band and `emem_trajectory` returned only the latest point. The responder iterates the tslot range derived from the band's tempo, calls the per-tslot historical materializer, signs each result, and persists. After completion `emem_trajectory` over the same window returns the full series. Bands without a historical materializer (e.g. `weather.*` from met.no's nowcast) return `status: \"present_only\"` for past tslots \u2014 check `emem_coverage_matrix.history_available_from`/`history_available_to` to see how far back each band can be backfilled. Prefer this over staking an attestation when the upstream is publicly fetchable."
      ],
      "id": "emem_backfill",
      "name": "Materialize historical facts in a window",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Forward-step 2-D explicit finite-difference solver for the heat equation \u2202u/\u2202t = \u03b1\u2207\u00b2u over a 3\u00d73 cell stencil centred on `cell`. Reads `modis.lst_day_8day` (Land Surface Temperature) at the centre and 8 cell64 neighbours, integrates N hours ahead under a CFL-stable timestep, returns a signed forecast. Real PDE rollout \u2014 not a decay-scoring heuristic.",
      "examples": [
        "Use when the user wants a short-horizon LST forecast (urban heat island, surface-temperature evolution, heatwave onset modelling) at a specific cell. Default \u03b1=1e-6 m\u00b2/s matches urban surface diffusivity (Oke 2017); pass a smaller \u03b1 for water bodies or higher for vegetated surfaces. The solver caps at one-week horizons because the 8-day MODIS composite stops being a representative initial condition past that. Each call materialises 9 MODIS facts (one per neighbour) on miss \u2014 first call ~5 s cold, ~30 ms warm. Receipt cites all 9 input fact CIDs."
      ],
      "id": "emem_heat_solve",
      "name": "2-D heat-equation forecast (urban LST evolution)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Forward-step 1-D explicit finite-difference solver for the shallow-water wave equation \u2202\u00b2u/\u2202t\u00b2 = c\u00b2\u2202\u00b2u/\u2202x\u00b2 with c\u00b2 = g\u00b7h, where depth h comes from `gmrt.topobathy_mean` along the seaward gradient. Models how an offshore swell of height H_s and period T propagates toward `coastal_cell`. Returns arrival height + time + depth + phase-speed profiles, all under a CFL-stable timestep.",
      "examples": [
        "Use when the user wants to predict swell arrival at a coast (storm-surge planning, shoreline-impact assessment, surf forecasting). The solver walks `n_offshore_cells` cells seaward from `coastal_cell` along the bathymetric gradient (default 8 cells = 80 m of profile at the active 10 m grid), samples GMRT depth at each, and integrates the wave equation forward until the wavefront reaches the coast plus one period. Receipt cites every depth fact CID along the profile. Returns 422 with a clear message if `coastal_cell` is land-locked."
      ],
      "id": "emem_wave_solve",
      "name": "1-D shallow-water swell propagation to coast",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Predict next-month NDVI at a cell using a constrained JEPA-pattern AR(2) seasonal predictor. Reads up to 24 past months of `indices.ndvi`, fits a closed-form predictor `y_{t+1} = \u03b1\u00b7(lag-12 NDVI or recent mean) + \u03b2\u00b7(last + slope) + \u03b3\u00b7recent_mean`, returns the prediction clamped to NDVI's physical range. Coefficients (\u03b1=0.6, \u03b2=0.3, \u03b3=0.1) are NOT learned \u2014 they're fixed from the agricultural-NDVI literature. v2 (future) will train an actual encoder + predictor on the geotessera embedding pool.",
      "examples": [
        "Use when the user wants a one-month-ahead NDVI forecast at a specific cell (crop-stress monitoring, growing-season tracking, vegetation-anomaly anticipation). Lookback defaults to 6 months; if fewer monthly tslots are attested at this cell, the predictor uses what's there and surfaces the count in `lookback_months_used`. Returns 422 if no NDVI history exists at the cell \u2014 chain to `emem_backfill` first to seed history. Receipt cites every input NDVI fact CID."
      ],
      "id": "emem_jepa_predict",
      "name": "Constrained JEPA-pattern next-month NDVI predictor",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Predict the next-vintage 128-D Tessera embedding at a cell using a small learned dynamics MLP. Reads the K=3 most-recent attested `geotessera.YYYY` vintages, runs them through an ONNX dynamics head (~200k params, CPU-fast), returns the predicted next-year embedding. The receipt's `model` block carries `model_id`, `version`, `blake2b_hex` (model_cid), training/validation provenance, and `honesty_warnings` flagging `untrained_baseline` when the artifact is the zero-init sentinel. Distinct from v1 (`emem_jepa_predict`) \u2014 v1 returns an NDVI scalar via closed-form coefficients; v2 returns a 128-D embedding from a learned model.",
      "examples": [
        "Use when you want a forecast in EMBEDDING space rather than NDVI scalar \u2014 e.g. to find next-year analogs via `emem_find_similar` against the prediction, or to feed any algorithm in `algorithms_for_topic.foundation_embedding`. Returns 422 with a `/v1/backfill` hint when the cell has fewer than 3 consecutive Tessera vintages cached. Always read the receipt's `model.honesty_warnings` array \u2014 when it contains `untrained_baseline`, the prediction is the trivial 'predict last vintage' baseline (treat as no-op)."
      ],
      "id": "emem_jepa_predict_v2",
      "name": "Learned dynamics head over Tessera embeddings (jepa_temporal_predictor@2)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Verify a structured claim against a cell's facts. Returns verdict + evidence CIDs + signed receipt.",
      "examples": [
        "Call when the user asks a yes/no question about a cell ('is the NDVI > 0.7 here', 'has this been deforested'), or when downstream code wants citable evidence for a logical predicate."
      ],
      "id": "emem_verify",
      "name": "Verify a structured claim against a cell",
      "tags": [
        "verify",
        "L1"
      ]
    },
    {
      "description": "Active band ontology (offsets, dims, tempo, privacy).",
      "examples": [
        "Call once at session start to learn the band registry \u2014 every other primitive's `band` argument MUST come from this list."
      ],
      "id": "emem_bands",
      "name": "Active band ontology",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Active function registry (derivation recipes).",
      "examples": [
        "Call when you need to know which derivative ops are available for `emem_diff` or how a band is computed from upstream sources."
      ],
      "id": "emem_functions",
      "name": "Active function registry",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Active source-connector registry (URL templates, providers, licenses).",
      "examples": [
        "Call when you need to inspect which upstream EO providers are wired (Copernicus DEM, JRC GSW, ESA WorldCover, etc.) \u2014 useful for license attribution in agent answers."
      ],
      "id": "emem_sources",
      "name": "Active source-connector registry",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Active CDDL/JSON schema bundle by CID.",
      "examples": [
        "Rarely needed at chat time. Useful for offline verification of receipts / attestations against the exact schema version a responder used."
      ],
      "id": "emem_schema",
      "name": "Active CDDL/JSON schema bundle",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Stable error code catalog.",
      "examples": [
        "Call to enumerate the wire-stable error codes \u2014 useful when the LLM wants to programmatically branch on responses."
      ],
      "id": "emem_errors",
      "name": "Stable error code catalog",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Active manifest CIDs (bands / functions / sources / schema).",
      "examples": [
        "Call to learn which exact registry versions a responder is serving. Cite these CIDs alongside any answer where reproducibility matters."
      ],
      "id": "emem_manifests",
      "name": "Active manifest CIDs",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Live capability snapshot of the responder's GPU sidecar \u2014 extensions[] (e.g. gpu, clay-v1.5, prithvi-eo2), cuda_available, models_loaded[], healthy, last_polled_unix_s. Refreshed every 30 s by a background poller; reads are constant-time.",
      "examples": [
        "Call before scheduling a GPU-heavy plan (Clay / Prithvi / Galileo embeddings, foundation-anchored algorithms) so the agent knows whether the GPU tier is up *right now* without per-request /health round-trips. Pair with `emem_topics` (its `algorithm_availability` map says which algorithm keys can run given the current capabilities) and `emem_explain_algorithm` (full inference-tier metadata per algorithm). When `extensions[]` is empty the sidecar is unreachable \u2014 only CPU/scalar/cached tiers will produce facts; foundation-anchored materializers will sign Absence with `gpu_unavailable` reason."
      ],
      "id": "emem_capabilities",
      "name": "Cached upstream capability snapshot",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Active grid encoding: cell64 ground resolution, lat/lng axis sizes, DGGS lineage.",
      "examples": [
        "Call once at session start (or when the user asks about cell resolution / 'how big is a cell'). Returns the actual ground resolution today (~9.54 m \u00d7 9.55 m square at the equator (lat 21 bits \u00d7 lng 22 bits, matching Sentinel-1/Sentinel-2 native pixel pitch). The cell64 bit layout reserves a resolution-tag field for future hierarchical refinement targeting H3-equivalent res-13 (~3.4 m) cells in v0.1.) and the spec target. Useful before you reason about whether one cell is enough or whether you need `emem_recall_polygon`."
      ],
      "id": "emem_grid_info",
      "name": "Active grid encoding",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Per-band live status \u2014 what data is alive AND auto-materializable, with history bounds, tempo cadence, and the responder pubkey that signs the band.",
      "examples": [
        "Call BEFORE `emem_recall` when you don't know which bands answer at this responder. For each band returns `has_materializer` (true \u2192 an empty recall will auto-fetch+sign, no seeding needed), `facts_count` (how many cells already cached), `last_attested_unix_s` (freshness), `tempo_seconds` (slot duration), `history_available_from` / `history_available_to` (oldest/newest Unix epoch the materializer can fetch \u2014 use these to bound an `emem_backfill` request), and `responder_pubkey_b32` (the ed25519 key whose signature attests this band \u2014 use to detect federation / multi-responder setups). Bands with `has_materializer=false AND facts_count=0` are cube placeholders without a wired connector \u2014 don't bother recalling them."
      ],
      "id": "emem_coverage_matrix",
      "name": "Per-band live status & history bounds",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Auto-fetch registry: which bands the responder will materialize on a recall miss, the upstream provider, license, value shape, and history bounds.",
      "examples": [
        "Call once at session start (alongside `emem_bands` and `emem_coverage_matrix`) to learn which bands answer for ANY cell on Earth without seeding. Each entry declares `upstream_scheme`, `upstream_endpoint`, `derivation_fn_key`, `value_kind` (primary | absence | primary_or_absence), `coverage` (where the upstream has data), `unit`, `tempo`, `confidence`, and `history_available_from` / `history_available_to` (when the upstream supports historical fetch via `emem_backfill`). Use this when the user asks 'do you have flood data here', 'what providers feed this', or you need license attribution. The response also carries an `agent_hint` block explaining the trust model (responder signs, not upstream) and the absence-fact contract."
      ],
      "id": "emem_materializers",
      "name": "Auto-fetch registry (per-band materializers)",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Temporal catalog: for every materializable band the upstream-of-record window the data genuinely covers, the temporal `kind` (static | annual_snapshot | annual_stack | time_series | now_only | per_release), tempo seconds, upstream wire path, and whether `emem_backfill` is meaningful.",
      "examples": [
        "Call before `emem_backfill` or any historical recall to check whether a band has a meaningful past at the requested time. Each entry includes `history_available_from_unix` / `history_available_to_unix` (and ISO strings) plus `backfill_supported`. Use this to avoid trial-and-error 422s on now-only bands (`weather.*`) and to enumerate the per-year `geotessera.YYYY` vintages the responder ships. The catalog is driven by the same registry the recall path consults \u2014 so what it lists is exactly what materializes."
      ],
      "id": "emem_data_availability",
      "name": "Per-band temporal coverage catalog",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Content-addressed dictionary of composition recipes \u2014 formulas that fuse attested band facts (and embeddings) into derived scores, classifications, and similarity metrics.",
      "examples": [
        "Call when the user's question is COMPOSITE (flood risk, urban density, water consensus, change-since-2020) rather than a single band readout. Each entry has `kind` (solo | combined | embedding), the input `bands` (assemble one `emem_recall` body from them), the `formula` in plain math, the `output` shape, and a `citation`. The agent applies the formula in-process and quotes the algorithm key + `algorithms_cid` (from `emem_manifests`) alongside the input fact_cids \u2014 that gives the receipt enough context for any other operator to replay the same composition deterministically. Embedding entries (cosine, novelty, change, neighborhood-consistency) operate on `geotessera`; for the most common k-NN pattern the protocol-native `emem_find_similar` is faster than fetching vectors and computing locally."
      ],
      "id": "emem_algorithms",
      "name": "Composition recipes (algorithms)",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Per-key drill-down on a single composition recipe \u2014 full body (kind, inputs, formula, output, citation, references) for ONE algorithm key. Companion to `emem_algorithms` (which is the catalog).",
      "examples": [
        "Call when you already know the algorithm key (from `emem_algorithms`'s catalog or the topic registry) and need its full math. Cheaper than fetching the 190 KB catalog when you only need one entry. Returns the same structure that `/v1/algorithms/{key}` does. 404s with `cid_not_found` if the key isn't registered \u2014 call `emem_algorithms` for the live key list."
      ],
      "id": "emem_explain_algorithm",
      "name": "One-algorithm drill-down (formula + inputs + citation)",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Topic-grouped registry of every band and algorithm at this responder, plus visual surfaces and the `declared_but_no_materializer_at_this_responder` block (cube slots reserved without a live connector). Single source of truth shared with `/v1/locate`'s `data_at_this_cell` block.",
      "examples": [
        "Call when the user's question lives in a topic but they haven't named a specific band \u2014 e.g. 'is this place flood-prone' (\u2192 flood_history_long_term + flood_water_event_window) or 'how walkable is this' (\u2192 urban_livability). Returns three blocks: `live_bands_by_topic` (every band you can recall right now), `algorithms_for_topic` (named recipes that compose those bands into derived answers \u2014 pair with `emem_algorithms` for the formulas), and `declared_but_no_materializer_at_this_responder` (honest gaps). Browse here BEFORE inventing your own synthesis formula."
      ],
      "id": "emem_topics",
      "name": "Topic-grouped band + algorithm registry",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Live SVG render of the responder's corpus density, returned as a proper MCP EmbeddedResource content block (image/svg+xml) \u2014 multimodal MCP agents can render it natively.",
      "examples": [
        "Call when the user asks 'where do you have data?', 'show me the coverage', or wants a visual brief of the responder's corpus footprint. Returns a 1440\u00d7720 Plate-Carr\u00e9e SVG (1\u00b0 \u00d7 1\u00b0 bins, log-scale colour, continent envelopes for orientation) plus a structuredContent summary (cell_count, total_facts, responder pubkey, REST URL). Multi-content-block reply: an EmbeddedResource (mimeType `image/svg+xml`, with text + uri) followed by a one-line text summary so text-only clients still see the cell / fact counts. For the bare image bytes, fetch `/v1/coverage_map.svg` over plain REST."
      ],
      "id": "emem_coverage_map",
      "name": "Coverage map (SVG image)",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "True-colour Sentinel-2 L2A RGB thumbnail centred on a cell. PNG returned as a native MCP ImageContent block (mimeType image/png). Pure-Rust pipeline: STAC search + HTTP-Range COG reads + 2-98 percentile stretch + PNG encode.",
      "examples": [
        "Call when the user wants a VISUAL of a place \u2014 'show me what this looks like', 'before/after the flood', 'is there a forest here', 'is this developed'. Returns a 256\u00d7256 px RGB image (~2.56 km \u00d7 ~2.56 km at S2's 10 m native resolution), centred on the cell. Pass `cell` as a cell64 string OR a place name (auto-resolved). `max_cloud` filters scenes by `eo:cloud_cover` (default 20 %); raise it (60\u201380 %) for cloud-prone tropics if you keep getting 'no scene' errors. `datetime` is an RFC 3339 interval like `\"2024-01-01T00:00:00Z/2024-12-31T00:00:00Z\"` for a temporal slice (defaults to last 90 days). `structuredContent` carries the STAC item id, capture time, cloud_cover, EPSG, and per-channel reflectance percentile stretch values used \u2014 quote those alongside the image so the receipt is reproducible."
      ],
      "id": "emem_cell_scene_rgb",
      "name": "Sentinel-2 true-colour thumbnail (PNG)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Cell polygon as a native MCP EmbeddedResource (mimeType application/geo+json). Properties carry centre lat/lng, bbox, approx size in metres, and the 8-cell neighbourhood \u2014 drop straight into Mapbox / Leaflet / Deck.gl / QGIS without a GIS pipeline.",
      "examples": [
        "Call when the agent (or a downstream renderer) needs the cell as geographic geometry \u2014 for map overlays, polygon-clipping ops, or feeding a styling pipeline. Pass `cell` as cell64 or place name. The result is a GeoJSON Feature with Polygon geometry; for a FeatureCollection that includes every recalled fact's value as a property, fetch /v1/cells/{cell64}/recall_geojson?bands=... over plain REST instead."
      ],
      "id": "emem_cell_geojson",
      "name": "Cell polygon as GeoJSON",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall facts across a list of up to 256 cell64 strings in one signed envelope. Server fans out per-cell recalls in parallel, then aggregates the response. Auto-materializes any cell with a missing fact whose band has a registered materializer \u2014 same contract as emem_recall.",
      "examples": [
        "Use after emem_find_similar (give it the neighbour cells), after emem_recall_polygon (when you want a deterministic cell list rather than a polygon), or whenever you have a precomputed set of cells (e.g. an admin-2 sample frame) and want one round-trip. Pass `cells: [c1, c2, ...]` plus the same `bands` shape as emem_recall. For more than 256 cells, batch the call."
      ],
      "id": "emem_recall_many",
      "name": "Bulk recall across up to 256 cells",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "One-shot elevation answer that fuses Cop-DEM 30 m (land), GMRT (ocean topobathy), and ESA WorldCover (water mask) into a single signed scalar at a place or coordinate. Returns `elevation_m`, the source actually used, and a `coherence_note` when the two surfaces disagree at the coast.",
      "examples": [
        "Use when the user asks 'how high is X' or 'what's the elevation at this lat/lng' and you want the correct answer regardless of whether the cell is land, water, or coastline \u2014 the handler picks Cop-DEM for land and GMRT for water and surfaces the choice. Pass `place` (free text), `lat`+`lng`, OR `cell`. Otherwise, prefer emem_recall with `copdem30m.elevation_mean` / `gmrt.topobathy_mean` individually."
      ],
      "id": "emem_elevation",
      "name": "Coherent elevation across Cop-DEM + GMRT + WorldCover",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Per-band satellite-and-sensor fleet inventory \u2014 names the upstream platform (e.g. Sentinel-2A/B, MODIS Aqua/Terra, Landsat-8/9), revisit cadence, native resolution, and license for every materialized band. Lets an agent attribute imagery products correctly and pick the right band when revisit cadence matters.",
      "examples": [
        "Call when the user asks 'which satellite is this from', 'what's the revisit time', or needs source attribution for a derived answer. Pair with emem_materializers for the wire path and emem_sources for the connector-level metadata."
      ],
      "id": "emem_fleet",
      "name": "Satellite / sensor lineage per band",
      "tags": [
        "introspect",
        "L0"
      ]
    },
    {
      "description": "Walk the algorithm registry's `temporal_recipe` blocks against a cell + (optional) intent, and emit a concrete plan: which bands to recall at which lookback windows, with `purpose` tags. Useful before a multi-band emem_recall when the question is time-shaped (flood window, growing season, change year).",
      "examples": [
        "Use when the user's question references a TIME relationship ('flooded last year', 'NDVI baseline', 'change between vintages') and you want the responder to assemble the lookback recipe rather than reasoning about tslot offsets yourself. Pass `cell` plus optional `intent` (free-text hint). The plan is deterministic and verifiable; the receipt cites the algorithm key that supplied each recipe."
      ],
      "id": "emem_temporal_route",
      "name": "Plan a temporal recall recipe for a cell",
      "tags": [
        "plan",
        "L0"
      ]
    },
    {
      "description": "Verify a signed receipt envelope server-side: recomputes the canonical preimage (`request_id | served_at | primitive | cells, | fact_cids,`), runs ed25519 over the embedded pubkey + signature, and returns `{valid, reason, pubkey_b32}`. Use when the in-browser /verify path is blocked (CDN offline, agent runtime has no crypto) or when you want a server-side audit of a third-party receipt.",
      "examples": [
        "Pass a receipt object exactly as returned by any read primitive (signature can be byte[] or sig_b32; pubkey can be byte[] or responder_pubkey_b32 \u2014 the verifier tolerates both shapes). Optionally override `pubkey_b32` to assert verification against a specific signer. Returns 200 with `valid: false` when the signature fails \u2014 never 4xx for a structurally-well-formed bad signature."
      ],
      "id": "emem_verify_receipt",
      "name": "Server-side ed25519 receipt verifier",
      "tags": [
        "verify",
        "L1"
      ]
    },
    {
      "description": "One-shot multi-band recall at a place (or lat/lng). Defaults to emem's standard at-a-glance band set; pass `band` / `bands` to override. Polygon-resolved places stay at the centroid by default (`n_cells: 1`) to keep multi-band calls cheap \u2014 pass `n_cells: 2..=64` to fan out.",
      "examples": [
        "Use when the user names a place and wants the standard situational readout (vegetation + elevation + landcover + recent weather) without picking bands. Polygon-aware: `place` that resolves to a polygon (park, lake, district) lands at the centroid unless `n_cells` widens it. For a single band, use the domain-specific shortcuts (emem_ndvi, emem_air, \u2026) or emem_recall directly."
      ],
      "id": "emem_at",
      "name": "Multi-band snapshot at a place",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall Sentinel-2 NDVI (indices.ndvi, 10 m native) at a point or place. Composes locate \u2192 cell64 \u2192 recall in one call; auto-materializes on miss.",
      "examples": [
        "Use when the user names a place (or lat/lng) and just wants the NDVI number. Polygon-resolved places default to a 16-cell fan-out aggregated as mean/median. Set `n_cells: 1` for point behaviour. For multi-band batches use emem_recall."
      ],
      "id": "emem_ndvi",
      "name": "NDVI at a place (one-shot, polygon-aware)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall Copernicus CAMS air-quality bands at a place: PM2.5 + NO2 + O3. Composes locate \u2192 recall \u2192 aggregate.",
      "examples": [
        "Use when the user names a place and asks about air quality, pollution, or emissions exposure. CAMS is the European reanalysis \u2014 global coverage, ~0.4\u00b0 native (resampled). For finer-grained urban PM2.5, pair with /v1/at-style stations data when available."
      ],
      "id": "emem_air",
      "name": "Air-quality snapshot (CAMS PM2.5 / NO2 / O3)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall MODIS land surface temperature day-8day + night-8day composites at a place. 1 km native, 8-day composite.",
      "examples": [
        "Use when the user asks about surface heat, urban heat island, thermal anomalies, or wants day/night LST. Returns both fluxes so the agent can derive day\u2013night spread."
      ],
      "id": "emem_lst",
      "name": "Land surface temperature (MODIS day + night)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall SoilGrids 250 m profile at a place: SOC, pH, clay/sand/silt fractions, bulk density, nitrogen \u2014 all at 0\u201330 cm depth.",
      "examples": [
        "Use when the user asks about soil quality, agricultural suitability, or carbon stocks at a location. Six bands returned in one envelope."
      ],
      "id": "emem_soil",
      "name": "Soil profile (SoilGrids 0\u201330 cm: SOC, pH, texture)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall surface-water signals at a place: JRC Global Surface Water recurrence (1984\u20132021) + Sentinel-1 SAR backscatter (current). Pair detects standing water through clouds.",
      "examples": [
        "Use when the user asks about flooding, wetlands, surface-water dynamics, or wants a robust water-presence check. JRC alone gives historical baseline; Sentinel-1 gives current flood detection."
      ],
      "id": "emem_water",
      "name": "Surface water (JRC GSW recurrence + S1 backscatter)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall forest signals at a place: Hansen Global Forest Change (tree cover 2000 baseline + year-of-loss) + ESA WorldCover 2021 land class.",
      "examples": [
        "Use when the user asks about deforestation, canopy cover, forest loss, or wants a forest-vs-not classification. Hansen gives year-of-loss for any cell with disturbance since 2001; WorldCover gives the current land class."
      ],
      "id": "emem_forest",
      "name": "Forest signals (Hansen GFC + ESA WorldCover)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Recall the standard met.no/CAMS weather bundle at a place: 2 m temperature + total cloud cover + precipitation + 10 m wind speed.",
      "examples": [
        "Use when the user names a place and asks 'what's the weather' or wants a now-cast snapshot. weather.* bands are now-only (no backfill); for climatology use terraclimate.*."
      ],
      "id": "emem_weather",
      "name": "Current weather snapshot (temperature, cloud, precip, wind)",
      "tags": [
        "read",
        "L0"
      ]
    },
    {
      "description": "Submit a typed Intent; receive a plan or executed result.",
      "examples": [
        "Call when the user asks something like 'where is X' or 'is A like B' and you don't want to pick a primitive yourself \u2014 the planner maps Intent variants to the right tool call."
      ],
      "id": "emem_intent",
      "name": "Intent-routed planner",
      "tags": [
        "plan",
        "L0"
      ]
    }
  ],
  "url": "https://emem.dev/mcp",
  "version": "0.0.6"
}