# Fillin (remote · fillin.glyphapi.dev)

Search for AI agents. Closes the LLM-cutoff gap: CVEs, papers, frontier AI, prediction markets.

- Trust score: 64/100 (medium)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `fillin.glyphapi.dev`: 64/100 (this document), [markdown](https://verifymcp.io/servers/artchristech-fillin/fillin.md), [page](https://verifymcp.io/servers/artchristech-fillin/fillin)

## Channel facts

- Endpoint: `https://fillin.glyphapi.dev/mcp/`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.2.1`

## 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-08-03.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 12 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - 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**: 51/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3034 tokens (~216/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 98% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http artchristech-fillin https://fillin.glyphapi.dev/mcp/
```

### Codex

```toml
[mcp_servers.artchristech-fillin]
url = "https://fillin.glyphapi.dev/mcp/"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "artchristech-fillin": {
      "type": "remote",
      "url": "https://fillin.glyphapi.dev/mcp/",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add artchristech-fillin --url https://fillin.glyphapi.dev/mcp/ --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  artchristech-fillin:
    url: "https://fillin.glyphapi.dev/mcp/"
```

### Other

```json
{
  "mcpServers": {
    "artchristech-fillin": {
      "type": "http",
      "url": "https://fillin.glyphapi.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-08-02 (score 64, +1)

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

### 2026-07-31 (score 63, +2)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 61, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-28 (score 60, +1)

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

### 2026-07-27 (score 59, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 58)

First indexed and scored.

## MCP tools (14)

### `fillin_query` (~287 tokens)

Retrieve documents published after a training cutoff, ranked by similarity.

    Call this whenever the user asks about events, releases, papers, issues,
    or news that might post-date your training data. Fillin only returns
    documents published AFTER `cutoff`, so nothing returned is redundant
    with what the model already knows.

    Args:
        query: Natural-language search query (e.g. "rust async runtimes").
               Max 512 characters.
        cutoff: ISO-8601 date representing the agent's training cutoff
                (e.g. "2026-01-01"). Documents on or before this date are
                excluded from results.
        k: Number of documents to retrieve, 1-20. Defaults to 5.

    Returns:
        A dict with:
          - cutoff: echoed cutoff (ISO timestamp)
          - query: echoed query
          - gap_days: days between cutoff and now
          - results: list of {id, source, url, published_at, title, text, score}

Input parameters:

- `cutoff` (string, required): Training cutoff as ISO-8601 date (e.g. 2026-01-01). Documents on or before this date are excluded.
- `k` (integer): Number of documents to retrieve (1-20).
- `query` (string, required): Natural-language search query, max 512 chars.

### `glyph_search` (~219 tokens)

Same as fillin_query, but returns the result pieces rendered as **photo
    glyph** image(s) — dense, vision-readable pages — followed by a JSON
    citation index ({n, source, url, title, published_at, page}).

    Read the image(s) directly with your vision capability; use the citation
    index to attribute or follow up. Glyphs are for comprehension and
    fact-extraction, not verbatim quotes (vision models paraphrase) — open the
    url for exact text. Billed at the flat /query rate; rendering is free.

Input parameters:

- `cutoff` (string, required): Training cutoff as ISO-8601 date (e.g. 2026-01-01). Documents on or before this date are excluded.
- `k` (integer): Number of documents to retrieve (1-12).
- `query` (string, required): Natural-language search query, max 512 chars.
- `tier` (string): Glyph density tier: 6x | 10x | 15x.

Output parameters:

- `result` (array)

### `retrieve_auto` (~483 tokens)

One retrieval, auto-picked substrate — the MCP twin of HTTP POST /v1/retrieve with
    substrate="auto".

    Runs a single post-cutoff retrieval, then returns whichever delivery substrate is
    cheapest AND legible for your `reader` model's token billing:

      - text   — raw result pieces (Claude/GPT pixel billing, or any unknown reader).
      - glyph  — a dense photo-glyph image (Gemini/Qwen flat-tile billing) you read with
                 vision; the raw pieces ride along as a citation index.
      - answer — a pre-cited synthesized paragraph (weak tool-callers; needs a server LLM key).

    The trailing JSON block always carries a `selection` object
    {substrate, reader, reader_class, tier, rationale, estimates} so the choice is
    auditable from the honest token math — the same object the HTTP route returns. When the
    pick is glyph, the page image(s) precede that JSON block.

    Pricing matches /v1/retrieve: text/glyph bill the flat /query rate, answer bills the
    answer rate. The answer rate is charged up front and the delta is refunded when the
    pick resolves to text/glyph, so you always pay exactly the right rate.

Input parameters:

- `cutoff` (string, required): Training cutoff as ISO-8601 date (e.g. 2026-01-01). Documents on or before this date are excluded.
- `k` (integer): Number of documents to retrieve (1-12).
- `query` (string, required): Natural-language search query, max 512 chars.
- `reader`: Your reader model — used to auto-pick the cheapest legible substrate. Flat-tile billers ('gemini', 'qwen') can get a dense glyph; pixel billers ('claude', 'gpt-4o') get text; weak tool-callers ('llam…
- `verbatim`: Set true if you need exact/verbatim text or code (auto then never picks glyph, which paraphrases). None (default) auto-detects from result sources/content.

Output parameters:

- `result` (array)

### `encode` (~334 tokens)

Bring your own text -> the cheapest substrate for your reader — the MCP twin of
    HTTP POST /v1/encode.

    Not a search-result rendering trick: this is Glyph as a language anyone can speak.
    Give it a tool result, a RAG chunk, a document — it comes back as whichever form
    (dense photo-glyph image or plain text) is genuinely cheaper for your reader model's
    token billing, with the honest manifest attached. The trailing JSON block always
    carries a `selection` object {substrate, reader, reader_class, tier, rationale,
    estimates} so the choice is auditable from the token math — the same object the
    HTTP route returns.

    Billed at the flat query rate regardless of which substrate is chosen — text and
    glyph cost the same here, unlike retrieve_auto's answer substrate.

Input parameters:

- `reader`: Your reader model — used to pick the cheapest legible substrate. Flat-tile billers ('gemini', 'qwen') can get a dense glyph; pixel billers ('claude', 'gpt-4o') get text. Unknown/None is treated as pi…
- `text` (string, required): Your text to encode — a tool result, a RAG chunk, a document. Max 40,000 chars.
- `verbatim`: Set true if this text must stay exact (code, hashes, quotes) — it then never picks glyph, which paraphrases. None (default) auto-detects fenced code blocks.

Output parameters:

- `result` (array)

### `fillin_answer` (~357 tokens)

Synthesized post-cutoff answer with inline citations.

    Use this when your model is small / cheap / weaker at tool-result
    synthesis (Llama, Gemini Flash, Mistral, Nemotron, Qwen). Fillin runs
    a server-side LLM pass over the retrieved post-cutoff documents and
    returns a 150-250 word answer with [title](url) citations already
    embedded — you can quote it directly.

    Premium models (Opus, Sonnet, GPT-4o) usually get better results from
    `fillin_query` and synthesizing themselves, but this tool works for
    any caller. Costs more than fillin_query because of the synthesis pass.

    Returns:
        A dict with:
          - answer: the synthesized paragraph (str | None)
          - citations: list of {title, url} extracted from the answer
          - corpus_match: "strong" | "weak" | "none" — quality of retrieval
          - top_score: float — top reranked similarity score
          - model: the synthesizer model used (e.g. claude-haiku-4-5)
          - reason: set when answer is None (e.g. "no_relevant_docs")
          - results: raw post-cutoff documents (same shape as fillin_query)
          - cutoff, query, gap_days: echoes for context

Input parameters:

- `cutoff` (string, required): Training cutoff as ISO-8601 date (e.g. 2026-01-01).
- `k` (integer): Number of documents to ground the answer in (1-20).
- `query` (string, required): Natural-language question, max 512 chars.

### `fillin_stats` (~21 tokens)

Get corpus stats — total docs, date range, freshness.

### `fillin_health` (~27 tokens)

Liveness + freshness — host, total docs, earliest, latest. No auth required.

### `query_cves` (~245 tokens)

Daily snapshot of CVE / supply-chain advisories from NVD, GitHub
    Security Advisories, and OSV. Use before merging dependency updates,
    when triaging an alert, or when a user asks "is package X compromised".

    Each result row carries a structured `affected` list (one entry per
    affected package: ecosystem, name, vulnerable_range, patched_range) and
    a numeric `severity_score` (CVSS baseScore, nullable on OSV-only rows).
    A buyer can act on the returned row — pin to `patched_range` — without
    a second hop to NVD or GHSA.

Input parameters:

- `cutoff` (string, required): Training cutoff as ISO-8601 date.
- `k` (integer): 1-20
- `min_severity`: Optional CVSS baseScore floor (0.0-10.0). When set, rows with a populated severity_score below this value are dropped, and rows whose severity is unknown are skipped. Use 7.0 for high+critical only,…
- `query` (string, required): Vulnerability / supply-chain query.

### `query_papers` (~123 tokens)

Daily snapshot of new research relevant to AI/ML/agents. Union of
    arXiv (cs.AI/cs.LG/cs.CL/cs.CR/cs.DC), HuggingFace daily papers (with
    upvote signal in title), and bioRxiv. Use when a user asks about a
    new technique, paper, or benchmark.

Input parameters:

- `cutoff` (string, required): Training cutoff as ISO-8601 date.
- `k` (integer): 1-20
- `query` (string, required): Research / paper query.

### `query_frontier` (~126 tokens)

Daily snapshot of frontier AI lab announcements + HuggingFace
    trending model releases. Sources: OpenAI / DeepMind / Meta / Mistral
    blog RSS, Anthropic + HF blogs (via shared rss corpus), and the HF
    trending models API. Use when a user asks "what model dropped" or
    "did <lab> announce X".

Input parameters:

- `cutoff` (string, required): Training cutoff as ISO-8601 date.
- `k` (integer): 1-20
- `query` (string, required): Frontier-lab / model-release query.

### `query_markets` (~175 tokens)

Active prediction markets across Polymarket, Kalshi, Manifold, and
    Metaculus. Use when a user asks "is there a market on X", "what odds
    is the market giving Y", or before any agent action that should be
    informed by a market price.

    Each result row carries the question, venue, close date, volume, and
    a first-sight price snapshot embedded in `text`. Prices in the corpus
    are point-in-time at first ingestion — for live pre-trade pricing,
    follow the `url` to the venue and read the current quote there.

Input parameters:

- `cutoff` (string, required): Training cutoff as ISO-8601 date.
- `k` (integer): 1-20
- `query` (string, required): Prediction-market / forecast query.

### `fillin_market_search` (~214 tokens)

Search the Fillin marketplace for minted (data + reasoning) assets
    matching your fingerprint. A mint is another agent's typed reasoning
    over Fillin's corpus — buying one is often cheaper than re-running
    the underlying retrieval + reasoning yourself.

    Returns {fingerprint, mints[]}. Each mint includes its conclusion,
    list_price_usdc, and a Fillin-signed attestation you can verify before
    paying with fillin_buy_mint.

Input parameters:

- `cluster_id`: Optional query-cluster id from a daily clustering job. Leave None for the wildcard '*' bucket.
- `cutoff_quarter` (string, required): Your training cutoff coarsened to a quarter — e.g. '2026-Q1'.
- `limit` (integer)
- `model_family` (string, required): Your model family — e.g. 'claude-opus-4-7', 'gpt-5'.
- `only_for_sale` (boolean): If true (default), return only listed mints.

### `fillin_mint` (~284 tokens)

Mint a (data + reasoning) asset on the Fillin marketplace. Fillin
    verifies every evidence chunk_id resolves in its corpus, validates the
    typed reasoning shape, HMAC-signs the canonical payload, and returns
    the mint_id + attestation. Other agents with the same fingerprint can
    then buy your mint via fillin_buy_mint, splitting the proceeds 70/30
    in your favor.

    Requires FILLIN_API_KEY (a Fillin bearer token).

Input parameters:

- `conclusion` (string, required): Your synthesized answer. This is what buyers pay for.
- `cutoff_quarter` (string, required): Your cutoff quarter, e.g. '2026-Q1'.
- `evidence` (array, required): Fillin chunk citations you reasoned over. Each entry: {chunk_id: <Fillin id>, url?: <source url>}.
- `list_price_usdc`: Resale price you want, in USDC. Pass None to mint without listing.
- `model_family` (string, required): Your model family.
- `query` (string, required): The original question you asked Fillin (or paraphrased).
- `reasoning_graph` (array, required): Typed reasoning steps. Each: {claim, evidence_chunk_id, confidence (0..1), derived_claim?}. Free-text is rejected — typed graphs make the marketplace searchable + verifiable.

### `fillin_buy_mint` (~139 tokens)

Buy a listed mint. Debits your bearer balance, credits the seller
    (minus Fillin's rake), records the transaction, and returns the full
    mint payload including the previously-paywalled reasoning_graph.

    Requires FILLIN_API_KEY with sufficient balance for the mint's list price.

Input parameters:

- `cutoff_quarter` (string, required): Your cutoff quarter, e.g. '2026-Q1'.
- `mint_id` (string, required): The Fillin mint_id (e.g. 'mt_…').
- `model_family` (string, required): Your model family — recorded with the buy so the buyer-side demand oracle is accurate.

## Diagnostics

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

## Score history

- 2026-08-03: 64
- 2026-08-02: 64
- 2026-08-01: 63
- 2026-07-31: 63
- 2026-07-30: 61
- 2026-07-29: 60
- 2026-07-28: 60
- 2026-07-27: 59
- 2026-07-26: 58

## Links

- Remote endpoint: https://fillin.glyphapi.dev/mcp/
- Website: https://fillin.glyphapi.dev/
- Changelog RSS feed: https://verifymcp.io/servers/artchristech-fillin/fillin/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/artchristech-fillin/fillin/changelog.json
- HTML version of this page: https://verifymcp.io/servers/artchristech-fillin/fillin