# Fillin

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

- name: io.github.artchristech/fillin
- version: 0.2.1
- connection class: unknown (unknown)
- trust: 43/100 flags: no-repository, unreachable
- quality: 85/100 (good)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/io.github.artchristech%2Ffillin
- tools: https://api.protogrid.dev/v1/servers/io.github.artchristech%2Ffillin/tools

**Not classified yet.** The remote endpoints have not been probed successfully, or the listing has nothing to connect to.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "fillin": {
      "type": "http",
      "url": "https://fillin.glyphapi.dev/mcp/"
    }
  }
}
```


## Trust

- hygiene: 80
- liveness: 0
- freshness: 65
- provenance: 45
- drivers: +website -unreachable(11 failures) ~updated-150d-ago -no-repository
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 85/100 (good)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 86 (weight 30)

- pass `tools.descriptions`: every tool has a description
- warn `tools.description_length`: 4 tools have descriptions over 1,024 characters, which crowds the context
- pass `tools.schemas`: every tool has an object input schema
- pass `tools.annotations`: 17 of 17 tools declare readOnlyHint or destructiveHint
- warn `tools.directory_hints`: 4 of 17 tools declare all four hints; missing: fillin_query (destructiveHint); glyph_search (destructiveHint); retrieve_auto (destructiveHint); …
- pass `tools.token_cost`: about 6,039 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 17, about 6,039 tokens to load them all
- tool set hash: 6584dc442b1051f6b7304d4cd0e219cd
- badge: [![protogrid quality](https://protogrid.dev/badge/io.github.artchristech/fillin.svg)](https://protogrid.dev/servers/io.github.artchristech/fillin)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Remotes

- https://fillin.glyphapi.dev/mcp/ (streamable-http, auth none, reachable false, uptime30d 0.5555556)

## Packages

_none_

## Tools (17)

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

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.

    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.
    
- `fillin_answer`: Synthesized post-cutoff answer with inline citations.

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.

    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
    
- `fillin_buy_mint`: 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.
    
- `fillin_health`: Liveness + freshness — host, total docs, earliest, latest. No auth required.
- `fillin_market_search`: 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.
    
- `fillin_mint`: 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).
    
- `fillin_payment_challenge`: Mint an EIP-191 signing challenge — MCP twin of POST /v1/payment/challenge.

    No bearer required. Returns {nonce, message, expires_at,
    signing_scheme: eip-191-personal-sign}. Sign `message`, then retry
    fillin_query with headers X-Payer-Address, X-Payer-Nonce, X-Payer-Signature.
    Probe and trial signup are fillin_probe / fillin_signup (PR #12).
    
- `fillin_probe`: Free taste of the Fillin corpus — MCP twin of POST /v1/probe.

    No bearer and no x402. k is forced to 1. Quota is 1 request per IP per
    UTC day (same table as HTTP /v1/probe). On success: QueryOut JSON
    (results, corpus_match, substrate_estimate). On exhausted quota: isError
    with a probe_exhausted JSON object (same fields as HTTP 429).
    
- `fillin_query`: Retrieve documents published after a training cutoff, ranked by similarity.

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.

    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}
    
- `fillin_signup`: Mint a one-time free 20-query trial bearer — MCP twin of POST /v1/signup.

    No bearer and no x402. One key per IP per UTC day (same `trial:` quota
    as HTTP /v1/signup). Success is a JSON object with `key` (shown once),
    `trial`, `balance_usdc`, `queries_at_base_price`. Retry paid tools with
    Authorization: Bearer <key> on the MCP HTTP request. On exhausted
    quota: isError with a trial_exhausted JSON object (same fields as HTTP 429).
    
- `fillin_stats`: Get corpus stats — total docs, date range, freshness.
- `glyph_search`: 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}).

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.

    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.
    
- `query_cves`: 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".

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.

    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.
    
- `query_frontier`: 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".

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.
    
- `query_markets`: 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.

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.

    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.
    
- `query_papers`: 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.

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.
    
- `retrieve_auto`: One retrieval, auto-picked substrate — the MCP twin of HTTP POST /v1/retrieve with
    substrate="auto".

    Requires $0.01–$0.05 USDC (x402) or an Authorization Bearer trial/paid key.
    On payment_required, call fillin_probe then fillin_signup (POST /v1/signup)
    for a free 20-query trial, or fillin_payment_challenge then retry with
    X-Payer-Address, X-Payer-Nonce, X-Payer-Signature (or Bearer).
    POST /v1/probe for 1 free taste/IP/day.

    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.