Skip to main content
Agent skill

Emem Field Tokens

Get a native-resolution raster field over an area from emem, or a field over time, as a signed, verifiable artifact rather than a set of per-cell scalars. Use when the user needs the actual grid of values over an area of interest (a world model input, an NDVI/band drape, change analysis over a scene window, exportable pixels a third party can re-derive) rather than one number at one point. Returns content-addressed grid artifacts plus a signed derivation record and an emem:raster: or emem:cube: token. Reads are public — no auth required.

Get started

Get the complete skill folder, including its scripts and reference files.

When to use this skill

Use Emem Field Tokens when an AI agent needs a reusable SKILL.md workflow for this job: Get a native-resolution raster field over an area from emem, or a field over time, as a signed, verifiable artifact rather than a set of per-cell scalars. Use when the user needs the actual grid of values over an area of interest (a world model input, an NDVI/band drape, change analysis over a scene window, exportable pixels a third party can re-derive) rather than one number at one point. Returns content-addressed grid artifacts plus a signed derivation record and an emem:raster: or emem:cube: token. Reads are public — no auth required.

When not to use it

Skip Emem Field Tokens when the task is outside the analysis category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/emem-field-tokens
# Save SKILL.md to ~/.claude/skills/emem-field-tokens/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/emem-field-tokens/SKILL.md. For a shared project, commit the folder at .claude/skills/emem-field-tokens/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Emem Field Tokens skill for this task: Use Emem Field Tokens when this documented workflow matches the task. Confirm any required inputs or files before making changes.

What supports this recommendation?

70/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
77/100
Practical detail
68/100
Source evidence
57/100
Source signals
72/100
Model compatibility evidence
  • claudeinferred

    The skill text mentions Claude or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# emem-field-tokens

A world model is a **field over an area across time**, not a set of points. This skill fetches that field from emem as a signed, re-derivable artifact:

- `POST /v1/band_raster` — one native-resolution field over a bbox at one time, as a content-addressed grid plus an `emem:raster:` token. Four recipes share this shape: a raw satellite band (`band_raster@1`), a cloud-free median composite (`s2_median_composite@1`), static terrain (`dem_raster@1`), and a foundation-model embedding, 128-D per cell (`embedding_raster@1`). - `POST /v1/band_cube` — the same field over several dates, a signed manifest over the raster slices, as an `emem:cube:` token (the field-over-time token). - `POST /v1/raster_bundle` — several rasters as one re-derivable set, as an `emem:rasterset:` token; `POST /v1/raster_bundle/resolve` walks it back to its members, which outlive the bundle and re-derive on their own. - `POST /v1/raster/resolve` with `{"spot_check": true}` — re-fetch the pixels and re-hash them for you, and cross-check sampled cells against the signed facts at those addresses. Use it to prove an artifact you were handed is the one its token names. - `POST /v1/cells_in_bbox` — enumerate the cell64s in a bbox, paged, when you want the per-cell address list instead of the packed grid.

The receipt does not attest a value, it attests a **derivation**: this responder computed the artifact whose blake3 is `artifact_cid`, from a pinned Sentinel-2 scene, over a content-addressed area (`aoi_cid`) and time. Anyone can re-fetch the bytes and re-hash them, or re-run the recipe from the pinned scene, and get the same artifact.

## When to invoke

The user wants an area's field of values, not a point reading:

- "Give me the 10 m NDVI grid over this farm, not per-cell scalars." - "Get the red band (B04) as a raster over this bbox." - "Build a time series of the near-infrared band over this AOI across the summer." - "I need the actual pixels over this area that a stranger can re-derive."

For a single value at one place use **emem-locate-and-recall**. For similar places use **emem-find-similar**. For per-cell facts inside a polygon use **emem-recall-polygon**.

## How to invoke

The endpoint is `https://emem.dev`. Reads are public. Bands: `s2.B02`, `s2.B03`, `s2.B04`, `s2.B08`, `s2.B11`, `s2.B12`. Window cap: 512 px per side.

### One field (a raster)

```sh curl -sf -X POST https://emem.dev/v1/band_raster \ -H 'content-type: application/json' \ -d '{"bbox":{"min_lat":32.5699,"min_lng":77.0328,"max_lat":32.5727,"max_lng":77.0362}, "band":"s2.B04"}' \ | jq '{raster: .tokens.raster, artifact: .artifact.url, grid: .grid, scene: .derivation.sources[0].id, docs: .docs}' ```

The response carries the `emem:raster:` token, the artifact URL (`GET /v1/artifacts/{cid}`, immutable), the grid georeferencing, and the pinned scene. Fetch the bytes and re-hash to verify:

```sh CID=$(curl -sf ... | jq -r '.artifact.artifact_cid') # from the response curl -sf "https://emem.dev/v1/artifacts/$CID" \ | python3 -c "import sys,base64;from blake3 import blake3; d=sys.stdin.buffer.read(); print('re-hash matches:', blake3(d).digest().hex())" # compare to artifact_cid (base32) ```

The grid bytes are a canonical little-endian f32 array with a 64-byte header (`application/x.emem-grid-f32.v1`): magic `EMEMGRD1`, then `width`, `height`, `epsg`, `nodata`, and the lat/lng origin + steps. A NaN is nodata.

### A field over time (a cube)

```sh curl -sf -X POST https://emem.dev/v1/band_cube \ -H 'content-type: application/json' \ -d '{"bbox":{"min_lat":32.5699,"min_lng":77.0328,"max_lat":32.5727,"max_lng":77.0362}, "band":"s2.B08", "observed_on":["2026-05-15","2026-06-15","2026-07-15"]}' \ | jq '{cube: .tokens.cube, count: .member_count, members: [.derivation.members[] | {tslot, scene: .scene_id, requested_dates, distance: .requested_date_distance_days, raster: .raster_token}]}' ```

A cube is **not** new pixels: it is a signed manifest over `member_count` independently resolvable `emem:raster:` slices, one per date (dates that hit the same scene collapse; each member echoes which `requested_dates` mapped to it). `cube_cid` is the blake3 of the ordered member derivation cids. Resolve a member independently, or the whole cube:

```sh curl -sf -X POST https://emem.dev/v1/cube/resolve \ -H 'content-type: application/json' -d '{"token":"emem:cube:..."}' | jq '.resolved, .member_tokens' ```

### Enumerate the cells in an area (paged)

When you want the address list rather than the packed grid — a dense recall, a sample frame, a world build:

```sh curl -sf -X POST https://emem.dev/v1/cells_in_bbox \ -H 'content-type: application/json' \ -d '{"bbox":{"min_lat":32.5699,"min_lng":77.0328,"max_lat":32.5727,"max_lng":77.0362}, "page_size":1024}' \ | jq '{total, count, next_cursor, first: .cells[0]}' ```

Page with `next_cursor` until it is null, and feed each page's `cells` to `POST /v1/recall_many` with a `budget_ms` to read them under the partial-results contract. Pure geometry: no facts read, no receipt.

## Verify a token you were handed

Resolve first, then re-hash the artifact and check its receipt with the **emem-verify-receipt** skill:

```sh curl -sf -X POST https://emem.dev/v1/raster/resolve \ -H 'content-type: application/json' -d '{"token":"emem:raster:..."}' \ | jq '{bound: .resolved, artifact: .artifact.url, receipt: .receipt.field}' ```

Every claim in the token binds to the signed record before anything dereferences: a mismatched area, band, or date is a typed `409`, never a silent wrong answer.

## Notes

- The artifact is **evictable by design**: the small derivation record persists and pins the scene, recipe, and geometry, so an evicted artifact is a rebuild recipe (re-POST with the same bbox/band/date), never a broken citation. - For NDVI specifically, `POST /v1/band_raster` gives you B08 and B04 as two rasters; NDVI = (B08 − B04) / (B08 + B04) per pixel. Or use **emem-locate-and-recall** for the pre-computed, cloud-gated `indices.ndvi` scalar at one cell. - Reads are public; no key. The reference for the whole token family is [`https://emem.dev/reference#tokens`](https://emem.dev/reference#tokens).

Intended uses

  • Use Emem Field Tokens when this documented workflow matches the task.

Implementation notes

  • Review the source instructions and adapt inputs before running the workflow.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.