# GEML — a plain-text document format built to be edited in place, one section at a time (remote · geml-mcp.supermarket.workers.dev)

One section in, one section out — on Markdown/GEML files, bad writes refused.

- Trust score: 69/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `geml-mcp.supermarket.workers.dev`: 69/100 (this document), [markdown](https://verifymcp.io/servers/geml-spec-geml/geml-mcp.md), [page](https://verifymcp.io/servers/geml-spec-geml/geml-mcp)
- npm · `@geml/geml`: 50/100, [markdown](https://verifymcp.io/servers/geml-spec-geml/geml-geml.md), [page](https://verifymcp.io/servers/geml-spec-geml/geml-geml)

## Channel facts

- Endpoint: `https://geml-mcp.supermarket.workers.dev/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.13.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Endpoint Security**: 46/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (geml_set).
  - HTTPS enforcement could not be verified: the plaintext port answered with HTTP 405, which proves neither a plaintext path nor enforcement.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 60/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3771 tokens (~419/item across 9 items; 9 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 87/100
  - Stability observed for 26 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 10 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the GEML — a plain-text document format built to be edited in… MCP server?

GEML — a plain-text document format built to be edited in… is a hosted endpoint at https://geml-mcp.supermarket.workers.dev/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http geml-spec-geml 'https://geml-mcp.supermarket.workers.dev/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "geml-spec-geml": {
      "url": "https://geml-mcp.supermarket.workers.dev/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "geml-spec-geml": {
      "type": "http",
      "url": "https://geml-mcp.supermarket.workers.dev/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.geml-spec-geml]
url = "https://geml-mcp.supermarket.workers.dev/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "geml-spec-geml": {
      "type": "remote",
      "url": "https://geml-mcp.supermarket.workers.dev/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add geml-spec-geml --url 'https://geml-mcp.supermarket.workers.dev/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  geml-spec-geml:
    url: "https://geml-mcp.supermarket.workers.dev/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "geml-spec-geml": {
      "Transport": "http",
      "Url": "https://geml-mcp.supermarket.workers.dev/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add geml-spec-geml -t streamable-http -u 'https://geml-mcp.supermarket.workers.dev/mcp'
```

### Other

```json
{
  "mcpServers": {
    "geml-spec-geml": {
      "type": "http",
      "url": "https://geml-mcp.supermarket.workers.dev/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 80 to 83. That category is still filling its 30-day observation window: 24 days of observed history at the previous scan, 25 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-02 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 73 to 77. That category is still filling its 30-day observation window: 22 days of observed history at the previous scan, 23 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-30 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 63 to 67. That category is still filling its 30-day observation window: 19 days of observed history at the previous scan, 20 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-28 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 57 to 60. That category is still filling its 30-day observation window: 17 days of observed history at the previous scan, 18 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-26 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 50 to 53. That category is still filling its 30-day observation window: 15 days of observed history at the previous scan, 16 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-24 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-22 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 37 to 40. That category is still filling its 30-day observation window: 11 days of observed history at the previous scan, 12 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-20 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (9)

### `geml_list` (~328 tokens)

List the blocks of a document

List every addressable block in a GEML document — its address, kind and heading text — in one call, with no paging. Call this FIRST: what it returns is what every other tool here addresses, and it is cheaper and more reliable than reading the file to see what is in it. Rows marked `anon` have no `#id`; geml_get and geml_set take their `address` as `id`, while the other write tools need a real id, so give such a block one first. A file that is not under the server root is an error. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.
- `within` (string): Optional: only look inside the blocks this selector names, e.g. `#install` for a section or `=== table` for every table. It takes the same selector forms as geml_get's `id`.

### `geml_find` (~365 tokens)

Find the blocks that hold some text

Search block CONTENT in the document; each hit is one `<name>\t<address>` row. geml_list says what a document contains, this says which block holds the words — as an address that pastes straight into geml_get or geml_set, not a line number the next edit invalidates. The address is the innermost block holding the match, and a block matching on many lines is reported once. Substring, case-insensitive unless `case` is true. No match is an empty result, not an error. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `case` (boolean): Match case exactly (default: case-insensitive)
- `head` (boolean): Add the matching line as a third column
- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `pattern` (string, required): Text to look for inside block bodies
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.
- `within` (string): Optional: only look inside the blocks this selector names, e.g. `#install` for a section or `=== table` for every table. It takes the same selector forms as geml_get's `id`.

### `geml_get` (~649 tokens)

Read one block

Read ONE block from a GEML document instead of the whole file: only that block comes back, typically a few percent of the document. Pass the `address` geml_list prints as `id` — it also reaches blocks with no `#id`; to locate a block by its words instead, use geml_find first. An `id` that matches nothing, or a file that is not under the server root, is an error naming it. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `id` (string, required): What to read: a block id (with or without `#`), a `## Heading` line (its whole section), `=== type` for every block of a type, `=== code {lang=py}` or `{.warn}` for every block carrying those attribu…
- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `part` (string): How much of the block to return (default: whole). For a SECTION these cut it three ways: `head` is the heading line, `intro` everything under it up to its first subheading, `body` everything under it…
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.
- `view` (boolean): Read THROUGH an `embed` block to the entity block it stands for, following a multi-layer chain to its end. An `embed` has no content of its own, so this is the only way to see what it points at; on a…
- `within` (string): Optional: only look inside the blocks this selector names, e.g. `#install` for a section or `=== table` for every table. It takes the same selector forms as geml_get's `id`.

### `geml_check` (~230 tokens)

Validate a document

Validate a GEML document without changing it: returns every diagnostic with a stable `code`, a severity and a line, and an empty list means the document is valid. Use it to confirm a document is sound before reporting work as finished. Every write through this server runs the same check before it lands, so a refused write already carries this information. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.

### `geml_to` (~432 tokens)

Convert a whole document

Convert a WHOLE document and get the result back as text — the read half of the CLI's `geml <file> --to <fmt>`. `to: "geml"` on a Markdown file is the importer, the one thing the block tools cannot do; `to: "md"` projects a GEML document out (lossy); `to: "json"` returns the full document model, for when geml_list plus geml_get is not enough. Nothing is written — pass the result to geml_add or geml_set to land it. `to: "html"` also works but returns a whole self-contained page, usually tens of kilobytes this server cannot save: prefer the CLI (`geml <file> --to html -o out.html`) unless you want the markup in the conversation. A document with errors returns its diagnostics instead of a conversion, and a file that is not under the server root is an error. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `from` (string): Override the input format, which is otherwise inferred from the extension (.md -> md, .json -> json, else geml).
- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.
- `to` (string): Target format. Default is the CLI's: a GEML input becomes json, a Markdown input becomes geml. `html` is a whole page — large, and not writable from here.

### `geml_set` (~600 tokens)

Replace one block

Replace ONE block and leave every other byte untouched — prefer this to rewriting a file. For content that does not exist yet use geml_add; to remove a block, geml_delete. The replacement is validated before it is written: if it would break the document, nothing is written and the diagnostics come back — fix the body rather than resending it. Removing content is not refused: if the replacement drops blocks, the write goes through and the result names each one, so check it after shortening a section; geml_revert puts one back. `part` replaces the whole block (default), its head line, a section's `intro`, or its body. In a Markdown file a heading's anchor is its text, as on GitHub: new heading text gives the heading a new address, and the document's links to the old one follow in the same write. GEML content written over a Markdown heading or prose is converted to Markdown, as in geml_add; a GEML block already in the file stays GEML. An `id` that matches no block, or several, is refused. Returns `{ok, file, diagnostics, revision}`, with `notes` when the write did something to say out loud (a block it dropped, an address it changed); a refusal is `ok: false` with a `hint`, and the file is unchanged. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `body` (string, required): The replacement text
- `id` (string, required): Which block to replace: an id (with or without `#`), a `@<hex>` content address from `geml_list` for a block with no id, or `L27`/`L27-58` for the smallest block holding those lines. Must match exact…
- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `part` (string): What to replace (default: whole). `intro` replaces a section's opening — everything under the heading up to its first subheading — and leaves every subsection byte-identical, which is what makes a re…
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.

### `geml_add` (~423 tokens)

Insert new content

Insert new content — one or more blocks, or prose — at the end of the document (`position: append`) or before/after the block named by `anchor`. Use this for content that does not exist yet; to change a block that does, use geml_set. Ids inside the content are kept. In a `.md` file Markdown lands as written, and GEML content is converted to Markdown as `to: "md"` converts it, the result's `notes` saying so; content Markdown cannot hold, such as a view without its source, is refused. Like every write here it is validated first: a missing anchor, an id that clashes with an existing one, or content that would break the document is refused. Returns `{ok, file, diagnostics, revision}`, with `notes` when the write did something to say out loud (a block it dropped, an address it changed); a refusal is `ok: false` with a `hint`, and the file is unchanged. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `anchor` (string): The block the insertion is relative to — an id, or any address geml_list prints; it must name one block. Required for before/after
- `content` (string, required): The GEML fragment to insert
- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `position` (string, required): Where to insert
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.

### `geml_delete` (~361 tokens)

Delete blocks

Remove one or more blocks, each named by an id or any address geml_list prints; a filter (`=== type`, `{key=value}`) removes every block it matches. Each block takes the blank line that separated it from its neighbours, so deleting what geml_add inserted leaves the file as it was. To undo a deletion, geml_revert the removed id; to change a block rather than remove it, use geml_set. References left pointing at a removed block come back as diagnostics but do NOT block the deletion — read them, then repair the references or revert. A selector that names nothing is skipped, so repeating a call changes nothing. Returns `{ok, file, diagnostics, revision}`, with `notes` when the write did something to say out loud (a block it dropped, an address it changed); a refusal is `ok: false` with a `hint`, and the file is unchanged. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `ids` (array, required): The blocks to remove: ids or addresses
- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.

### `geml_rename` (~332 tokens)

Rename a block id

Rename a block id AND every reference to it in the same document, in one id-boundary-safe write. Use this rather than geml_set or a text search-and-replace, which would also hit ids that merely share a prefix. A Markdown heading's anchor is its text, so it is renamed by changing the heading with geml_set (`part: head`), not here. An `old` id that does not exist, or a `new` one already taken, is refused. Returns `{ok, file, diagnostics, revision}`, with `notes` when the write did something to say out loud (a block it dropped, an address it changed); a refusal is `ok: false` with a `hint`, and the file is unchanged. This server is STATELESS: the document travels in `source` and a write comes back as `document` for you to save; it holds no other documents, so a cross-document reference such as `[[other.geml#id]]` cannot be resolved here and is reported as `unresolvable-document`.

Input parameters:

- `name` (string): The document's file name, e.g. notes/spec.geml or README.md — it decides whether the text is read as GEML or as Markdown (a `.md` name), and it is how the document is called in messages. Default: doc…
- `new` (string, required): New id
- `old` (string, required): Current id
- `source` (string, required): The document's full text. This server keeps no files: what you send is the document.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/geml-spec-geml/geml-mcp#diagnostics

## Score history

- 2026-11-05: 69
- 2026-11-04: 69
- 2026-11-03: 68
- 2026-11-02: 68
- 2026-11-01: 67
- 2026-10-31: 67
- 2026-10-30: 67
- 2026-10-29: 66
- 2026-10-28: 66
- 2026-10-27: 65
- 2026-10-26: 65
- 2026-10-25: 64
- 2026-10-24: 64
- 2026-10-23: 63
- 2026-10-22: 63
- 2026-10-21: 62
- 2026-10-20: 62
- 2026-10-19: 61
- 2026-10-18: 61
- 2026-10-17: 60
- 2026-10-16: 60
- 2026-10-15: 60
- 2026-10-14: 59
- 2026-10-13: 59
- 2026-10-12: 58
- 2026-10-11: 58
- 2026-10-10: 57

## Common questions

### What is the GEML — a plain-text document format built to be edited in… MCP server?

GEML — a plain-text document format built to be edited in… is an MCP server listed in the public MCP registry as io.github.geml-spec/geml. One section in, one section out, on Markdown/GEML files, bad writes refused. This page covers its hosted endpoint (https://geml-mcp.supermarket.workers.dev/mcp).

### Is the GEML — a plain-text document format built to be edited in… MCP server safe to use?

GEML — a plain-text document format built to be edited in… scores 69 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the GEML — a plain-text document format built to be edited in… MCP server expose?

GEML — a plain-text document format built to be edited in… exposes 9 tools: geml_list, geml_find, geml_get, geml_check, geml_to, and 4 more. Their descriptions and schemas cost roughly 3,720 tokens of context every time the server is loaded.

### Does the GEML — a plain-text document format built to be edited in… MCP server require authentication?

No. We connected to GEML — a plain-text document format built to be edited in… without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the GEML — a plain-text document format built to be edited in… MCP server still maintained?

GEML — a plain-text document format built to be edited in… is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://geml-mcp.supermarket.workers.dev/mcp
- Repository: https://github.com/geml-spec/geml
- Website: https://geml-spec.github.io/
- Changelog RSS feed: https://verifymcp.io/servers/geml-spec-geml/geml-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/geml-spec-geml/geml-mcp.json
- HTML version of this page: https://verifymcp.io/servers/geml-spec-geml/geml-mcp