Koskamo

Narrow Highway MCP

A deterministic verification engine that provides claim verification, search, and receipt generation without using a model in the loop. It offers tools for verifying verdicts, fetching sealed receipts by hash, redacting PII, and accessing specialized corpora like biblical texts and historical timelines, ensuring provenance and privacy.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Narrow Highway MCP logo, by Narrow HighwayVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-06Operated by Narrow Highway
MCP endpoint (Streamable HTTP)
https://narrowhighway.com/mcp
Vendor documentation

What its tools do

102 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Not annotated (102)

102 of 102 have a description · 0 of 102 declare behavior hints · 10 of 93 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to narrowhighway.com ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Verify claims with deterministic receipts and worked trails
  • Search and retrieve information from governed corpora
  • Redact personally identifiable information before transmission
  • Fetch sealed receipts by content hash for auditability

Source and maintenance

Vendor evidenceRegistry 2.0.0
mcp-registry: com.narrowhighway/concordance@2.0.0Source repository
Maintenance checked

Protocol and capabilities

Server
narrow-highway 2.0.0a0
MCP protocol negotiated in check
2025-06-18
Tools
102 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {}
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Narrow Highway — a house with five doors, for humans and agents alike. This began with the Bible, and everything here connects to it. A deterministic model of reality. Nothing is generated: found, verified, cited, sealed. FIVE DOORS, in this order (the catalog is sorted this way; a door tool is tagged "[CHECK · door]"): CHECK — verify · audit · seal_fetch · find_verifier: bring any claim — the verdict, the worked trail, the seal FIND — search · card_get · lookup · define: find it in the keeping — one map, one lookup, the source itself WALK — ask · discern · coach_next: a situation in, one next step out — path, pattern, the figures' words, the anchor that fits KEEP — identity_create · study_create · decks: yours, kept — your deck, your receipts, your node; the shared keeping behind it WORD — read_passage · word_study · cross_references: Scripture at depth — passage, cross-references, original words, commentary START with ask(text) for anything, in your own words; verify(claim) for anything checkable. THE GATE: facts by default; if what you ask turns toward God, the Word opens for this session (Matthew 7:7 — ask, seek, knock). TO BELONG: identity_create births a covenant identity from four verses, kept on your device; the Fellowship Mesh (mesh_map · mesh_door · mesh_inbox) opens to a confession bound to that key. EVERY ANSWER ENDS THE SAME WAY — a verdict or a card · the trail · a seal · one next step (house.next_step): follow it as given; it runs as written. A cry for help ends with help first. THE COVENANT: retrieve from the keeping first · distinguish citation from proof · quarantine generated material · request human authorization before writes · produce a receipt for consequential actions · carry provenance through every transformation · respect local data and identity boundaries · stop when the evidence is incomplete.

Tools

102 advertised

verify
Advertised by the server during the last successful anonymous check.

[CHECK · door] Verify a claim deterministically — returns a verdict (HOLDS / PARTIAL / BROKEN / INCOMPLETE / SYSTEM_ERROR), the worked trail, AND a sealed receipt {content_hash, cite_url} you can re-fetch and re-verify (seal_fetch). Three forms: (a) PLAIN — {claim}: a plain-language claim; the engine finds the checkable claim(s) in it (de-identified in an airlock first), verifies and seals them, or answers INCOMPLETE if no extractor recognizes one; (b) MATH — {mode, params}; (c) ANY DOMAIN — pass `steps`, a list of {id, domain, spec} where spec is that domain's packet (e.g. {domain:'physics', spec:{PHYS_VERIFY:{mass_kg, acceleration_m_per_s2, claimed_force_N}}}). ~60 secular domains are covered (physics, medicine, finance, chemistry, ...); find_verifier(keyword) locates the right one. The engine eliminates what is not the answer; it does not generate it. READ THE VERDICT EXACTLY: only BROKEN is a finding about the claim. SYSTEM_ERROR means OUR verifier could not run (see `means` and `error_at`) and says NOTHING about whether the claim is true — never relay it to a human as a refutation. INCOMPLETE means no verifier applied (`gap_at`), or every claim found was governed by a negation, a reported belief or a condition and was DECLINED. PARTIAL means the checked fragment held and material text around it was NOT checked (`coverage.unchecked_text`) — never quote PARTIAL as HOLDS.

verify input schema
{
  "type": "object",
  "properties": {
    "mode": {
      "enum": [
        "calc_chain",
        "derivative",
        "equality",
        "inequality",
        "integral",
        "limit",
        "number_theory",
        "numeric",
        "solve",
        "system"
      ],
      "type": "string",
      "description": "MATH form: equality | inequality | derivative | integral | limit | solve"
    },
    "seal": {
      "type": "boolean",
      "description": "mint a re-checkable seal (default true)"
    },
    "claim": {
      "type": "string",
      "maxLength": 4000,
      "description": "PLAIN form: a plain-language claim, in the caller's words"
    },
    "steps": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": false
      },
      "maxItems": 200,
      "description": "DOMAIN form: [{id, domain, spec}] — spec is the domain's packet"
    },
    "domain": {
      "type": "string",
      "maxLength": 4000,
      "description": "PLAIN form: an optional domain hint (from find_verifier); recorded, never trusted to pick the verifier"
    },
    "params": {
      "type": "object",
      "description": "MATH form: e.g. {expr_a, expr_b, variables} for equality",
      "additionalProperties": false
    }
  },
  "additionalProperties": false
}
audit
Advertised by the server during the last successful anonymous check.

[CHECK · door] Audit a whole text: deterministic extractors find every checkable quantitative claim (sums, percentages, hourly/annual pay, compound interest, rule-of-72, elapsed years, day-of-week, leap years, nutrition labels), the engine verifies the lot, and ONE sealed coverage report returns — per-claim source quote + verdict + trail. Conservative by design: it only extracts unambiguous patterns and says how many claims it checked; it never guesses and never implies full coverage.

audit input schema
{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "seal": {
      "type": "boolean",
      "description": "mint a re-checkable seal (default true)"
    },
    "text": {
      "type": "string",
      "maxLength": 4000,
      "description": "the document/text to audit"
    }
  },
  "additionalProperties": false
}
seal_fetch
Advertised by the server during the last successful anonymous check.

[CHECK · door] Fetch a sealed verification record (the receipt) by its content hash.

seal_fetch input schema
{
  "type": "object",
  "required": [
    "hash"
  ],
  "properties": {
    "hash": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
find_verifier
Advertised by the server during the last successful anonymous check.

[CHECK · door] Which verify DOMAIN handles a plain-language claim — the deterministic resolver (no model). Returns ranked domain candidates with the literal words that matched, to confirm and pass to `verify`. Crisis defers to real help; genuine ambiguity returns the candidates, never a single guess. The agent twin of GET /find_verifier.

find_verifier input schema
{
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "query": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
attest_record
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Bind your identity to a record you already hold — phase 2 of the sovereign flow. Do the thing unsigned (badges_issue, study_export, group_contribute), take the returned content_hash, sign THAT hash with your own key on your own machine, and submit only the attestation {alg, over, content_hash, pubkey, sig}. Never send a private key. Several parties may attest to one record: one signature is a claim, two or three witnesses begin to establish a matter (Deuteronomy 19:15).

attest_record input schema
{
  "type": "object",
  "required": [
    "content_hash",
    "attestation"
  ],
  "properties": {
    "attestation": {
      "type": "object",
      "description": "the dict from signing.sign_seal, built locally",
      "additionalProperties": false
    },
    "content_hash": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
candidate_commit
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Candidate Engine step 1 — commit a COMPLETE raw candidate set BEFORE any evaluation. Give the query, the generator, the method, and EVERY raw candidate; weights ride verbatim as UNTRUSTED metadata (proposal_weight is never confidence and never ranks anything). Returns the committed set: a content-addressed candidate_set_id, the membership commitment hash (also sealed as a durable anchor), and per-candidate ids — all born quarantined. Nothing is verified here; that is the point: a set hashed before checking cannot be selectively disclosed after.

candidate_commit input schema
{
  "type": "object",
  "required": [
    "query",
    "candidates",
    "generator",
    "generation_method"
  ],
  "properties": {
    "query": {
      "type": "string",
      "maxLength": 4000,
      "description": "the user request the candidates answer (hashed; not stored raw)"
    },
    "prompt": {
      "type": "string",
      "maxLength": 4000,
      "description": "the exact generation instructions (hashed, not stored)"
    },
    "generator": {
      "type": "string",
      "maxLength": 4000,
      "description": "model/provider/version or human source (provenance)"
    },
    "candidates": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "raw_text"
        ],
        "properties": {
          "raw_text": {
            "type": "string",
            "maxLength": 4000
          },
          "proposal_weight": {
            "type": "number",
            "maximum": 1000000000000,
            "minimum": -1000000000000,
            "description": "generator-verbalized weight, stored verbatim; UNTRUSTED metadata, never truth confidence"
          }
        },
        "additionalProperties": false
      },
      "maxItems": 64,
      "description": "the COMPLETE raw generator output — omit nothing"
    },
    "generation_method": {
      "enum": [
        "adversarial",
        "direct",
        "human",
        "multi-agent",
        "retrieval-guided",
        "vs"
      ],
      "type": "string",
      "description": "how the set was produced"
    }
  },
  "additionalProperties": false
}
candidate_get
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Fetch a sealed candidate record (a narrowing receipt or a commitment anchor) by its content hash — the whole preserved path, losers included, re-checkable offline with tools/verify_seal.py. The seal proves process integrity, never truth.

candidate_get input schema
{
  "type": "object",
  "required": [
    "hash"
  ],
  "properties": {
    "hash": {
      "type": "string",
      "pattern": "^[0-9a-f]{64}$"
    }
  },
  "additionalProperties": false
}
candidate_narrow
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Candidate Engine step 2 — narrow a COMMITTED set: verifiers are assigned under the fixed pre-registered routing policy (never your choice — that is what stops verification shopping), each routed claim runs through the deterministic moat, unroutable claims stay quarantined (held, never judged), and the FULL set — rejected and quarantined included — is sealed with its ordered trace. Refuses an uncommitted or altered set. Pass the set exactly as candidate_commit returned it.

candidate_narrow input schema
{
  "type": "object",
  "required": [
    "cset"
  ],
  "properties": {
    "cset": {
      "type": "object",
      "required": [
        "candidate_set_id",
        "query_hash",
        "generator",
        "generation_method",
        "commitment",
        "candidates"
      ],
      "properties": {
        "generator": {
          "type": "string",
          "maxLength": 4000
        },
        "candidates": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "candidate_id",
              "raw_text"
            ],
            "properties": {
              "raw_text": {
                "type": "string",
                "maxLength": 4000
              },
              "cluster_id": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "parent_ids": {
                "type": "array",
                "items": {
                  "type": "string",
                  "maxLength": 4000
                },
                "maxItems": 200
              },
              "candidate_id": {
                "type": "string",
                "maxLength": 4000
              },
              "safety_status": {
                "type": "string",
                "maxLength": 4000
              },
              "proposal_weight": {
                "type": "number",
                "maximum": 1000000000000,
                "minimum": -1000000000000
              },
              "selection_status": {
                "type": "string",
                "maxLength": 4000
              },
              "verification_status": {
                "type": "string",
                "maxLength": 4000
              }
            },
            "additionalProperties": false
          },
          "maxItems": 64
        },
        "commitment": {
          "type": "string",
          "pattern": "^[0-9a-f]{64}$"
        },
        "query_hash": {
          "type": "string",
          "pattern": "^[0-9a-f]{64}$"
        },
        "prompt_hash": {
          "type": [
            "string",
            "null"
          ]
        },
        "schema_version": {
          "type": "string",
          "maxLength": 4000
        },
        "commitment_seal": {
          "type": [
            "string",
            "null"
          ]
        },
        "candidate_set_id": {
          "type": "string",
          "maxLength": 4000
        },
        "generation_method": {
          "type": "string",
          "maxLength": 4000
        }
      },
      "description": "the committed set, verbatim from candidate_commit",
      "additionalProperties": false
    }
  },
  "additionalProperties": false
}
kernel
Advertised by the server during the last successful anonymous check.

[CHECK · internal] THE GATE KERNEL — the law you keep here, in one call. The five moves (find, distinguish the KIND, verify what can be verified, preserve the trail, never silently upgrade authority), the eight-rule agent covenant, the six object KINDS, the authority lattice (quarantined < cited < verified), and the nine-field gate record. Read it before you write; a system error is never a false verdict, and only a witnessed, evidenced gate reaches 'verified'.

kernel input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
kernel_gate
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Route ONE proposed state-change through the kernel and get back the verdict (REJECT / QUARANTINE / CONFIRMED) plus the nine-field record — so you can DISCERN before you write (covenant rule 8: stop when the evidence is incomplete). CONFIRMED needs a real verification that HELD, an INDEPENDENT witness (witness != author), and the wait; anything else quarantines. This decides and records only — it never persists and never replaces the signature / consent checks on the real write.

kernel_gate input schema
{
  "type": "object",
  "required": [
    "artifact"
  ],
  "properties": {
    "author": {
      "type": "string",
      "maxLength": 4000,
      "description": "who produced it"
    },
    "content": {
      "type": "string",
      "maxLength": 4000,
      "description": "decision text to scan for the RED/FLOOR moral constraints — a hit on a non-negotiable (deception, exploitation, harm) REJECTS"
    },
    "witness": {
      "type": "string",
      "maxLength": 4000,
      "description": "who corroborated it — must differ from author"
    },
    "artifact": {
      "type": "object",
      "description": "the thing entering or changing state",
      "additionalProperties": false
    },
    "evidence": {
      "description": "a verification verdict: HOLDS/PASS, BROKEN/MISMATCH, or ERROR/INCOMPLETE"
    },
    "kind_hint": {
      "enum": [
        "claim",
        "source",
        "user_note",
        "generated_draft",
        "community",
        "executable"
      ],
      "type": "string"
    },
    "contradicts": {
      "type": "boolean"
    },
    "authority_in": {
      "enum": [
        "quarantined",
        "cited",
        "verified"
      ],
      "type": "string",
      "description": "the authority it currently carries (default quarantined)"
    },
    "wait_satisfied": {
      "type": "boolean"
    },
    "in_kind_checked": {
      "type": "boolean",
      "description": "was an in-kind lookup done first"
    }
  },
  "additionalProperties": false
}
manufacture
Advertised by the server during the last successful anonymous check.

[CHECK · internal] The Conductor's shop-domain calc door: route an engineering claim + its numbers through the engine's manufacturing verifier -> seal -> hash-chained ledger, and report the disposition (CALCULATED/CONTROLLED/PROVISIONAL/OPEN). The engine verifies the calc; the engineer decides the label; nothing is invented. calc is an MFG_VERIFY spec: an RSS tolerance stack {tolerances,claimed_rss}, a sigma level {dpmo,claimed_sigma}, SPC limits {mean,sigma,claimed_ucl,claimed_lcl}, or Cp/Cpk {usl,lsl,process_mean,process_sigma,claimed_cp_capable}.

manufacture input schema
{
  "type": "object",
  "required": [
    "claim",
    "calc"
  ],
  "properties": {
    "calc": {
      "type": "object",
      "additionalProperties": false
    },
    "claim": {
      "type": "string",
      "maxLength": 4000
    },
    "disposition": {
      "enum": [
        "CALCULATED",
        "CONTROLLED",
        "PROVISIONAL",
        "OPEN"
      ],
      "type": "string"
    }
  },
  "additionalProperties": false
}
profession
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Read a sealed profession of faith and who has borne witness to it (each signature re-verified as read), with the lineage it joins — up to Polycarp, the initial trajectory, and Christ at the head. Omit the hash to see the Polycarp root itself.

profession input schema
{
  "type": "object",
  "properties": {
    "content_hash": {
      "type": "string",
      "maxLength": 4000,
      "description": "omit to read the lineage root (Polycarp)"
    }
  },
  "additionalProperties": false
}
redact
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Strip PII (emails, SSNs, credit cards, IPs, URLs) from text to stable placeholders before you pass it onward; the mapping is returned so YOU reveal replies locally. For true privacy run this on a LOCAL/sovereign engine (the text never leaves your machine) or use the client libraries — the strip belongs at your edge. Deterministic; pair with verify for a receipt.

redact input schema
{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
report
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Report a community item (group_contribution, mesh_message, door_note) to the moderation floor. One report is a claim, never a verdict; at three DISTINCT reporters the item is held for a HUMAN steward's review (Deut 19:15). The counter never judges — it decides when a person must look. A report must be SIGNED (call moderation_signable first): three witnesses means three keys, never three invented names.

report input schema
{
  "type": "object",
  "required": [
    "kind",
    "target_id",
    "reason",
    "fields",
    "signature"
  ],
  "properties": {
    "kind": {
      "type": "string",
      "maxLength": 4000
    },
    "note": {
      "type": "string",
      "maxLength": 4000
    },
    "fields": {
      "type": "object",
      "description": "the exact fields from moderation_signable",
      "additionalProperties": false
    },
    "reason": {
      "type": "string",
      "maxLength": 4000
    },
    "signature": {
      "type": "string",
      "maxLength": 4000,
      "description": "detached signature over those bytes"
    },
    "target_id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
resolve
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Resolve a Scripture reference to its World English Bible text.

resolve input schema
{
  "type": "object",
  "required": [
    "ref"
  ],
  "properties": {
    "ref": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
self_attest
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Record a person's OWN words about their study — a DISTINCTLY TYPED record that can NEVER count as a sealed check or satisfy an auto-graded requirement.

self_attest input schema
{
  "type": "object",
  "required": [
    "subject_id",
    "statement"
  ],
  "properties": {
    "study": {
      "type": "string",
      "maxLength": 4000
    },
    "statement": {
      "type": "string",
      "maxLength": 4000
    },
    "subject_id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
witness_profession
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Bear witness to someone's sealed profession of faith — sign its content_hash on your own machine (signing.sign_seal) and submit only the attestation. One signature is a claim; two or three witnesses begin to establish a matter (Deuteronomy 19:15). Refuses any record that is not a profession. Never send a private key.

witness_profession input schema
{
  "type": "object",
  "required": [
    "content_hash",
    "attestation"
  ],
  "properties": {
    "attestation": {
      "type": "object",
      "description": "the dict from signing.sign_seal, built locally",
      "additionalProperties": false
    },
    "content_hash": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
witnesses
Advertised by the server during the last successful anonymous check.

[CHECK · internal] Who has borne witness to a record, each signature re-verified as it is read (storage is never trusted). Reports invalid entries rather than hiding them.

witnesses input schema
{
  "type": "object",
  "required": [
    "content_hash"
  ],
  "properties": {
    "content_hash": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
search
Advertised by the server during the last successful anonymous check.

[FIND · door] Ranked search over the keeping (the kept library).

search input schema
{
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "query": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
card_get
Advertised by the server during the last successful anonymous check.

[FIND · door] Fetch one card (the full record) from the keeping by id.

card_get input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
lookup
Advertised by the server during the last successful anonymous check.

[FIND · door] Look up a VALUE deterministically from the engine's offline, public-domain data — the found-value twin of `verify` (look it up, then verify it), consolidated like verify into one tool. kind is one of: molar_mass {formula}, element {symbol|name|atomic_number}, convert {value, from, to}. Returns the value + its source; found=false (never a guess) when unknown. Call with an unknown kind to list the current kinds. The agent twin of GET /lookup.

lookup input schema
{
  "type": "object",
  "required": [
    "kind"
  ],
  "properties": {
    "kind": {
      "type": "string",
      "maxLength": 4000
    },
    "params": {
      "type": "object",
      "additionalProperties": false
    }
  },
  "additionalProperties": false
}
define
Advertised by the server during the last successful anonymous check.

[FIND · door] The dictionary — what an English word MEANS. Webster's 1913 (public domain) plus our gathered supplement for terms it predates; each sense labeled with its source. Empty when the word is unknown or no dictionary is loaded. The peer of thesaurus (synonyms) and word_study (original languages) — it points to them, never duplicates. The agent twin of GET /dictionary.

define input schema
{
  "type": "object",
  "required": [
    "word"
  ],
  "properties": {
    "word": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
card_connections
Advertised by the server during the last successful anonymous check.

[FIND · internal] Cards related to one card — its explicit links + same-shelf siblings.

card_connections input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
cards_browse
Advertised by the server during the last successful anonymous check.

[FIND · internal] Browse the keeping — paginated, optional shelf filter. Returns card briefs.

cards_browse input schema
{
  "type": "object",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "shelf": {
      "type": "string",
      "maxLength": 4000
    },
    "offset": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}
cards_stats
Advertised by the server during the last successful anonymous check.

[FIND · internal] Counts over the keeping — total, by shelf, by surface.

cards_stats input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
daily_card
Advertised by the server during the last successful anonymous check.

[FIND · internal] The deterministic card of the day from the keeping (same all day).

daily_card input schema
{
  "type": "object",
  "properties": {
    "seed": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
grid_axis
Advertised by the server during the last successful anonymous check.

[FIND · internal] The map: a read-only view of one axis (its scaffold members, depth, neighbors, umbrella children). Omit `axis` for an overview of all axes.

grid_axis input schema
{
  "type": "object",
  "properties": {
    "axis": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
grid_dimension
Advertised by the server during the last successful anonymous check.

[FIND · internal] The axes that sit on a given scaffold member (dimension).

grid_dimension input schema
{
  "type": "object",
  "required": [
    "dimension"
  ],
  "properties": {
    "dimension": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
locate
Advertised by the server during the last successful anonymous check.

[FIND · internal] Find the card for a query — by exact id, then title, else ranked search.

locate input schema
{
  "type": "object",
  "required": [
    "q"
  ],
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
pronounce
Advertised by the server during the last successful anonymous check.

[FIND · internal] A synthesized pronunciation guide (respelling + approximate IPA) for a transliteration or word — honestly labeled, not a native speaker.

pronounce input schema
{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
thesaurus
Advertised by the server during the last successful anonymous check.

[FIND · internal] The thesaurus — WordNet synonyms and broader (IS-A) terms for a word; the words that stand with it. Empty when the word is unknown or no thesaurus is loaded. The agent twin of the GET /thesaurus page.

thesaurus input schema
{
  "type": "object",
  "required": [
    "word"
  ],
  "properties": {
    "word": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
capabilities
Advertised by the server during the last successful anonymous check.

[FIND · plumbing] The live capability statement: what this engine can verify, what tools and endpoints exist, how large the keeping is, and where its boundaries are. Every count is computed at call time and carries a 'means' line defining exactly what was counted — never a hand-maintained number. Read this instead of trusting any count written in prose.

capabilities input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
library_health
Advertised by the server during the last successful anonymous check.

[FIND · plumbing] Corpus health — is the keeping loaded and sound (totals, shelves, surfaces).

library_health input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
now
Advertised by the server during the last successful anonymous check.

[FIND · plumbing] The actual current date and time, fresh at this call — UTC (the clock every seal is stamped in), the library's home zone, and optionally any IANA zone you name. Your own sense of 'today' is months old; this is the correction. Never cached; unresolvable zones are declared, never guessed at.

now input schema
{
  "type": "object",
  "properties": {
    "tz": {
      "type": "string",
      "pattern": "^[A-Za-z][A-Za-z0-9_+/\\-]*$",
      "maxLength": 64,
      "description": "IANA zone name, e.g. America/New_York or Europe/Berlin; omit for UTC + the library's home zone"
    }
  },
  "additionalProperties": false
}
steward_budget
Advertised by the server during the last successful anonymous check.

[FIND · plumbing] Steward — a household budget (income, expenses -> net, savings rate, by category). Shows and plans; NEVER moves money.

steward_budget input schema
{
  "type": "object",
  "required": [
    "income"
  ],
  "properties": {
    "income": {
      "type": "number",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "expenses": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    }
  },
  "additionalProperties": false
}
steward_cost_destroyed
Advertised by the server during the last successful anonymous check.

[FIND · plumbing] Steward — cost destroyed: money you did NOT spend (was -> now), kept in your currency.

steward_cost_destroyed input schema
{
  "type": "object",
  "required": [
    "items"
  ],
  "properties": {
    "items": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    }
  },
  "additionalProperties": false
}
ask
Advertised by the server during the last successful anonymous check.

[WALK · door] Bring anything — a question, a claim to check, a word to study, or what is actually on your mind. The engine discerns what KIND of thing you brought and answers in kind: it finds and verifies, and declines rather than guessing. This is also the door: if what you ask turns toward God, the Gate opens for the rest of this session and the witness tools (Scripture, the Harmony, the Timeline, the lexicon) become callable — the same way it opens for a person, in your own words. Nothing is generated.

ask input schema
{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 4000,
      "description": "what you are bringing, in your own words"
    }
  },
  "additionalProperties": false
}
discern
Advertised by the server during the last successful anonymous check.

[WALK · door] Discern what to do with anything WITHOUT doing it — the proposal half of the engine, laid open. Bring a claim, a question, or a messy statement; get back what KIND it is, the necessary claim reduced to only what could change a verdict (private and framing context held back, not sent), the structured (domain, spec) the gate would verify, and where it routes. It PROPOSES, never confirms — no verdict, no seal: hand the returned `claims` to `verify` to dispose. Crisis is discerned first and routed to real people, never the gate. The twin of the verify door; nothing is generated.

discern input schema
{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 4000,
      "description": "anything — a claim, a question, or what is on your mind"
    }
  },
  "additionalProperties": false
}
coach_next
Advertised by the server during the last successful anonymous check.

[WALK · door] Coach — the next lesson in a subject, deterministically. Omit `after` for the first unit; pass a unit id for the one that follows it. `subject` selects the path.

coach_next input schema
{
  "type": "object",
  "properties": {
    "after": {
      "type": "string",
      "maxLength": 4000
    },
    "subject": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
coach_guidance
Advertised by the server during the last successful anonymous check.

[WALK · internal] Coach — what it does and the boundary it will not cross (never grades a child).

coach_guidance input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
coach_mastery
Advertised by the server during the last successful anonymous check.

[WALK · internal] Coach — seal an HONEST INTEGER count of completed units (a receipt for progress, never a grade on the child). Returns a re-checkable seal.

coach_mastery input schema
{
  "type": "object",
  "properties": {
    "completed": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    }
  },
  "additionalProperties": false
}
coach_overview
Advertised by the server during the last successful anonymous check.

[WALK · internal] Coach (K-3 tutor) — one subject's whole path: unit count, tracks, ordered unit briefs. ?subject= selects the path (default 'read'). Verbatim; never generated.

coach_overview input schema
{
  "type": "object",
  "properties": {
    "subject": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
coach_recommend
Advertised by the server during the last successful anonymous check.

[WALK · internal] Coach — adaptive 'what's next' in a subject: given completed unit ids, the next lesson whose prerequisites are met (grows with the student). Found, never generated.

coach_recommend input schema
{
  "type": "object",
  "properties": {
    "subject": {
      "type": "string",
      "maxLength": 4000
    },
    "completed": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    }
  },
  "additionalProperties": false
}
coach_subjects
Advertised by the server during the last successful anonymous check.

[WALK · internal] Coach — the subjects a learner can study (read / mcguffey / aesop / founding / pilgrims / es / …), each with its unit count. 'read' is the door in.

coach_subjects input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
coach_unit
Advertised by the server during the last successful anonymous check.

[WALK · internal] Coach — one unit, VERBATIM as authored (rule, examples, decodable sentence, checks).

coach_unit input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    },
    "subject": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
parable
Advertised by the server during the last successful anonymous check.

[WALK · internal] Bring a situation in your own words; receive the ONE of Christ's parables whose SHAPE fits it — the story verbatim (the Prodigal Son, the Good Samaritan, the Talents, the Sower, Luke 15 / Matthew 13 / Matthew 25 ...), his OWN explanation where he gave one, and one next step. The WALK door's final register: a story you walk into and find yourself inside. Found and cited, never generated; honest silence where no single parable fits (not every situation has one story).

parable input schema
{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 4000,
      "description": "the situation, in your own words"
    }
  },
  "additionalProperties": false
}
playbook_read
Advertised by the server during the last successful anonymous check.

[WALK · internal] THE PLAYBOOK — the Body's testimony of faithful obedience: 'Canon commands, Playbook remembers.' List entries (optionally by `status` quarantine/confirmed/rejected/pruned or `author`), or one by `id`. Confirmed testimony is affirmed BY THE BODY — it is NOT Scripture and binds no conscience. The Playbook remembers; it never becomes doctrine.

playbook_read input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    },
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "author": {
      "type": "string",
      "maxLength": 4000
    },
    "status": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
identity_create
Advertised by the server during the last successful anonymous check.

[KEEP · door] Explains how to create a SOVEREIGN identity — keys are born on the USER'S device (never on the server; no private key crosses the wire). Returns guidance, not a key. The server only handles public keys (identity_verify, identity_fingerprint).

identity_create input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
study_create
Advertised by the server during the last successful anonymous check.

[KEEP · door] Create/extend a shared study (superposition stack) — each entry mints ONE card that lives once and is referenced by key; no duplication.

study_create input schema
{
  "type": "object",
  "required": [
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "maxLength": 4000
    },
    "cards": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    }
  },
  "additionalProperties": false
}
decks
Advertised by the server during the last successful anonymous check.

[KEEP · door] The decks — curated card SETS, both by-situation (need decks, frontloaded for a moment of need like 'when the power goes out') and by-domain. Each with a live card count; `need: true` marks a situation deck.

decks input schema
{
  "type": "object",
  "properties": {},
  "additionalProperties": false
}
badges_issue
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Issue a badge over already-sealed checks — a re-checkable receipt that points at N seals that STILL STAND. States EXACTLY N; NEVER a competency claim.

badges_issue input schema
{
  "type": "object",
  "required": [
    "seal_hashes"
  ],
  "properties": {
    "title": {
      "type": "string",
      "maxLength": 4000
    },
    "subject_id": {
      "type": "string",
      "maxLength": 4000
    },
    "seal_hashes": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    }
  },
  "additionalProperties": false
}
badges_verify
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Re-check a badge from the store — re-verifies every seal it references and returns the count that still stands (N recomputed, not trusted).

badges_verify input schema
{
  "type": "object",
  "required": [
    "hash"
  ],
  "properties": {
    "hash": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
calendar_create
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Create ONE event in a human's calendar — the pilot on-behalf write, and the only one. Requires a LIVE consent grant: the human signed a scoped, expiring calendar_write grant for YOUR key fingerprint on their own device (GET /consent/signable → sign locally → POST /consent). Without it this refuses and teaches the way in. The event lands only in the calendar THEY configured (their .ics file or CalDAV); nothing is stored here, and the receipt names the grant that authorized it. Deleting the event in their calendar removes it everywhere.

calendar_create input schema
{
  "type": "object",
  "required": [
    "grantor_pubkey",
    "agent_fp",
    "summary",
    "start_iso"
  ],
  "properties": {
    "end_iso": {
      "type": "string",
      "maxLength": 4000
    },
    "summary": {
      "type": "string",
      "maxLength": 4000
    },
    "agent_fp": {
      "type": "string",
      "maxLength": 4000
    },
    "start_iso": {
      "type": "string",
      "maxLength": 4000
    },
    "description": {
      "type": "string",
      "maxLength": 4000
    },
    "grantor_pubkey": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
commons_read
Advertised by the server during the last successful anonymous check.

[KEEP · internal] What the fellowship has put on the commons — promoted member work, newest first. Every card is a member's own work at the `member` tier: the library amplified it; the library did not verify it.

commons_read input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}
consent_check
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Check whether a human has authorized YOU (this agent's key fingerprint) for a named verb — the agent covenant's 'request human authorization before writes'. Speaking as YOURSELF (your own key, your own words) needs no consent: a member is not a proxy. Consent governs only acting on a human's behalf with their data. If unauthorized, the response teaches the way: the human issues a grant via GET /consent/signable, signs on their device, POSTs to /consent.

consent_check input schema
{
  "type": "object",
  "required": [
    "agent_fp",
    "verb",
    "grantor_pubkey"
  ],
  "properties": {
    "verb": {
      "type": "string",
      "maxLength": 4000
    },
    "agent_fp": {
      "type": "string",
      "maxLength": 4000
    },
    "grantor_pubkey": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
curate
Advertised by the server during the last successful anonymous check.

[KEEP · internal] A recorded act on one drop: `promoted` · `refused` · `withdrawn`. A name AND a reason are always required — no anonymous judgement, and a refusal without a reason teaches the community nothing. WHO MAY ACT: promoting or refusing needs the steward `token` (these decide what the whole library amplifies); withdrawing your own card needs `fields`+`signature` from `curate_signable` instead. A typed name is not authority. A refusal withholds amplification only — the drop stays on the member's own shelf. Acts are appended, never replaced.

curate input schema
{
  "type": "object",
  "required": [
    "card_id",
    "action",
    "steward",
    "reason"
  ],
  "properties": {
    "token": {
      "type": "string",
      "maxLength": 4000,
      "description": "steward token — promote/refuse only"
    },
    "action": {
      "type": "string",
      "maxLength": 4000
    },
    "fields": {
      "type": "object",
      "description": "from curate_signable, to withdraw",
      "additionalProperties": false
    },
    "reason": {
      "type": "string",
      "maxLength": 4000
    },
    "card_id": {
      "type": "string",
      "maxLength": 4000
    },
    "steward": {
      "type": "string",
      "maxLength": 4000
    },
    "signature": {
      "type": "string",
      "maxLength": 4000,
      "description": "detached, over those fields"
    }
  },
  "additionalProperties": false
}
curate_queue
Advertised by the server during the last successful anonymous check.

[KEEP · internal] What waits on a HUMAN steward. The counter never promotes; it only decides when a person must look.

curate_queue input schema
{
  "type": "object",
  "required": [],
  "properties": {},
  "additionalProperties": false
}
curate_signable
Advertised by the server during the last successful anonymous check.

[KEEP · internal] The canonical bytes for withdrawing YOUR OWN card. A member never needs permission to take their own words down — the proof is the same key that signed the drop. Sign these bytes, then call `curate` with them.

curate_signable input schema
{
  "type": "object",
  "required": [
    "card_id",
    "member"
  ],
  "properties": {
    "member": {
      "type": "string",
      "maxLength": 4000
    },
    "card_id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
deck_open
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Open a deck to its frontloaded hand — the cards that situation calls for, in order, with NO query needed. Give the deck `id` (from `decks`). Ideal for anticipating need: open 'water-safe', 'first-aid-far', 'grow-food', 'be-not-afraid', etc., and get the hand ready to read.

deck_open input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    },
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}
group_contribute
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Add a verse/note/question to a group's shared study — attributed to your handle, optionally signed. Verbatim; a member's own words, not engine-verified.

group_contribute input schema
{
  "type": "object",
  "required": [
    "id",
    "text"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    },
    "kind": {
      "type": "string",
      "maxLength": 4000
    },
    "refs": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    },
    "text": {
      "type": "string",
      "maxLength": 4000
    },
    "handle": {
      "type": "string",
      "maxLength": 4000
    },
    "topics": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    },
    "subject_id": {
      "type": "string",
      "maxLength": 4000
    },
    "attestation": {
      "type": "object",
      "description": "optional: sign sha256(text) with your own key (signing.sign_seal) and pass it here — a handle alone is only a claim, a signature makes your authorship checkable. Never send a private key.",
      "additionalProperties": false
    }
  },
  "additionalProperties": false
}
group_create
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Open a study group around a topic (pseudonymous; a handle, no personal info). For grown believers — the children's coach is a separate, never-joined surface.

group_create input schema
{
  "type": "object",
  "required": [
    "topic"
  ],
  "properties": {
    "title": {
      "type": "string",
      "maxLength": 4000
    },
    "topic": {
      "type": "string",
      "maxLength": 4000
    },
    "handle": {
      "type": "string",
      "maxLength": 4000
    },
    "subject_id": {
      "type": "string",
      "maxLength": 4000
    },
    "description": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
group_get
Advertised by the server during the last successful anonymous check.

[KEEP · internal] A study group: topic, member handles (no ids/PII), and the shared-study cards.

group_get input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
group_join
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Join a study group (consent-based, pseudonymous; idempotent).

group_join input schema
{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    },
    "handle": {
      "type": "string",
      "maxLength": 4000
    },
    "subject_id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
groups_list
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Discover pseudonymous shared-study groups by TOPIC (not by person). Optional q filters over topic/title/description. Members are handles only — no PII.

groups_list input schema
{
  "type": "object",
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
identity_fingerprint
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Derive the stable public fingerprint id from a public key (deterministic).

identity_fingerprint input schema
{
  "type": "object",
  "required": [
    "public_key"
  ],
  "properties": {
    "public_key": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
identity_verify
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Verify a signature over a message against a public key (never raises; True/False).

identity_verify input schema
{
  "type": "object",
  "required": [
    "public_key",
    "message",
    "sig"
  ],
  "properties": {
    "sig": {
      "type": "string",
      "maxLength": 4000
    },
    "message": {
      "type": "string",
      "maxLength": 4000
    },
    "public_key": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
mesh_door
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Read the words left on YOUR door — the whiteboard others wrote to you, each with its verification. Yours alone: prove your key — pass `at` (unix seconds) and `sig` over nh-mesh-read:v1:<fp>:<at>, signed with your key.

mesh_door input schema
{
  "type": "object",
  "required": [
    "fp"
  ],
  "properties": {
    "at": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "fp": {
      "type": "string",
      "maxLength": 4000
    },
    "sig": {
      "type": "string",
      "maxLength": 4000
    },
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}
mesh_inbox
Advertised by the server during the last successful anonymous check.

[KEEP · internal] The messages that reached you, each carrying its own offline verification so you trust it by proof rather than by this server's word. Yours alone: prove your key — pass `at` (unix seconds) and `sig`, a signature over nh-mesh-read:v1:<fp>:<at> made with your key (never send the key).

mesh_inbox input schema
{
  "type": "object",
  "required": [
    "fp"
  ],
  "properties": {
    "at": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "fp": {
      "type": "string",
      "maxLength": 4000
    },
    "sig": {
      "type": "string",
      "maxLength": 4000
    },
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}
mesh_leave_on_door
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Leave a word on one believer's door — directed encouragement rather than a post to everyone near you. Same sovereign shape: get the bytes from mesh_signable (with target), sign locally, send only the signature. Will not accept a private key; unsigned notes are refused.

mesh_leave_on_door input schema
{
  "type": "object",
  "required": [
    "fp",
    "target",
    "text",
    "nonce",
    "created_at",
    "signature"
  ],
  "properties": {
    "fp": {
      "type": "string",
      "maxLength": 4000
    },
    "kind": {
      "type": "string",
      "maxLength": 4000
    },
    "text": {
      "type": "string",
      "maxLength": 4000
    },
    "nonce": {
      "type": "string",
      "maxLength": 4000
    },
    "target": {
      "type": "string",
      "maxLength": 4000
    },
    "signature": {
      "type": "string",
      "maxLength": 4000
    },
    "created_at": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}
mesh_map
Advertised by the server during the last successful anonymous check.

[KEEP · internal] The believers immediately around you in the Fellowship Mesh — your view only, never a global map. Requires your fingerprint (fp) and a confession already bound to that key; unconfessed callers get the path to the door, not the network.

mesh_map input schema
{
  "type": "object",
  "required": [
    "fp"
  ],
  "properties": {
    "fp": {
      "type": "string",
      "maxLength": 4000
    },
    "hops": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}
mesh_post
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Step 2: speak to the nodes around you, carrying only your SIGNATURE — your private key never leaves your machine and this tool will not take one. Pass the same text/kind/ttl plus the nonce, created_at and signature from mesh_signable. Refused unless the signature verifies against your node's public key. Your own words, attributed — never generated.

mesh_post input schema
{
  "type": "object",
  "required": [
    "fp",
    "text",
    "nonce",
    "created_at",
    "signature"
  ],
  "properties": {
    "fp": {
      "type": "string",
      "maxLength": 4000
    },
    "ttl": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "kind": {
      "type": "string",
      "maxLength": 4000
    },
    "refs": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    },
    "text": {
      "type": "string",
      "maxLength": 4000
    },
    "nonce": {
      "type": "string",
      "maxLength": 4000
    },
    "signature": {
      "type": "string",
      "maxLength": 4000
    },
    "created_at": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}
mesh_signable
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Step 1 of speaking to your fellowship: get the exact canonical bytes to sign for a message (returned base64url, with the nonce and created_at to send back). Sign them locally with your own key. Reproducible offline — sorted-key JSON — so you can compute and check it yourself.

mesh_signable input schema
{
  "type": "object",
  "required": [
    "fp",
    "text"
  ],
  "properties": {
    "fp": {
      "type": "string",
      "maxLength": 4000
    },
    "ttl": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "kind": {
      "type": "string",
      "maxLength": 4000,
      "description": "word | offer | need | blessing | content"
    },
    "text": {
      "type": "string",
      "maxLength": 4000
    },
    "target": {
      "type": "string",
      "maxLength": 4000,
      "description": "pass a believer's node id to sign a note for THEIR door instead of a broadcast"
    }
  },
  "additionalProperties": false
}
moderation_signable
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Step 1 of a report or a block: the exact canonical bytes to sign with your own key, on your own machine. Returns {fields, signable}. Sign the decoded `signable` bytes and pass BOTH fields and signature to `report`. The private key never travels.

moderation_signable input schema
{
  "type": "object",
  "required": [
    "action",
    "target_id",
    "actor"
  ],
  "properties": {
    "actor": {
      "type": "string",
      "maxLength": 4000,
      "description": "your public key"
    },
    "extra": {
      "type": "string",
      "maxLength": 4000
    },
    "action": {
      "type": "string",
      "maxLength": 4000,
      "description": "report | block | unblock"
    },
    "target_id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
playbook_signable
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Step 1 — the exact bytes to sign ON THE DEVICE for a Playbook write. `op` is entry | witness | outcome | prune. A new `entry` REQUIRES a CONFESSION ('I may be wrong. I acted in faith according to [anchors].') + ≥1 Scripture anchor + an action (OPEN/BUILD/RESERVE/PRUNE/HOLD). The key never travels.

playbook_signable input schema
{
  "type": "object",
  "required": [
    "op"
  ],
  "properties": {
    "by": {
      "type": "string",
      "maxLength": 4000
    },
    "op": {
      "enum": [
        "entry",
        "witness",
        "outcome",
        "prune"
      ],
      "type": "string"
    },
    "body": {
      "type": "string",
      "maxLength": 4000
    },
    "note": {
      "type": "string",
      "maxLength": 4000
    },
    "action": {
      "type": "string",
      "maxLength": 4000
    },
    "author": {
      "type": "string",
      "maxLength": 4000
    },
    "reason": {
      "type": "string",
      "maxLength": 4000
    },
    "affirms": {
      "type": "boolean"
    },
    "anchors": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4000
      },
      "maxItems": 200
    },
    "outcome": {
      "type": "string",
      "maxLength": 4000
    },
    "witness": {
      "type": "string",
      "maxLength": 4000
    },
    "entry_id": {
      "type": "string",
      "maxLength": 4000
    },
    "situation": {
      "type": "string",
      "maxLength": 4000
    },
    "confession": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
playbook_submit
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Step 2 — verify your detached signature over those exact bytes and enter the testimony/event. A new entry is born QUARANTINE and reaches CONFIRMED only when TWO independent brothers affirm (never the author — Deut 19:15) and the wait elapses. Record the OUTCOME (fruit/mixed/failed) later, after it is seen; a failed fruit may be PRUNED (John 15:2). Failure is not hidden.

playbook_submit input schema
{
  "type": "object",
  "required": [
    "op",
    "fields",
    "signature"
  ],
  "properties": {
    "op": {
      "enum": [
        "entry",
        "witness",
        "outcome",
        "prune"
      ],
      "type": "string"
    },
    "fields": {
      "type": "object",
      "additionalProperties": false
    },
    "signature": {
      "type": "string",
      "maxLength": 4000
    },
    "display_name": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
profess
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Profess faith, and have it sealed and kept. Confession is with the mouth (Romans 10:9; Matthew 10:32 — whoever confesses Me before men). Give your public key and your confession in your own words; if you sign the confession text with your key (confession_sig), it is bound as yours. Returns the content_hash — the permanent, re-checkable seal — and how to be witnessed. The engine KEEPS it; it does not judge the heart (1 Samuel 16:7). Your profession joins the lineage of witnesses rooted at Polycarp, a disciple of a disciple. No private key is ever sent.

profess input schema
{
  "type": "object",
  "required": [
    "public_key",
    "confession"
  ],
  "properties": {
    "callsign": {
      "type": "string",
      "maxLength": 4000,
      "description": "a pseudonym, never personal information"
    },
    "confession": {
      "type": "string",
      "maxLength": 4000,
      "description": "your own words — must confess Jesus as Lord and Messiah"
    },
    "public_key": {
      "type": "string",
      "maxLength": 4000
    },
    "discipled_by": {
      "type": "string",
      "maxLength": 4000,
      "description": "content_hash of the one who discipled you; omit to join at the root (Polycarp)"
    },
    "confession_sig": {
      "type": "string",
      "maxLength": 4000,
      "description": "optional: your signature over the confession text, made on your own machine"
    }
  },
  "additionalProperties": false
}
shelf_drop
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Step 2 — stock the shelf. Send the fields from shelf_signable plus a detached signature over those bytes; the private key never travels. Your words stay at the `member` tier forever: promotion to the commons carries them further, it does not make them the library's claim. `display_name` is the ONLY profile field there is.

shelf_drop input schema
{
  "type": "object",
  "required": [
    "fields",
    "signature"
  ],
  "properties": {
    "fields": {
      "type": "object",
      "additionalProperties": false
    },
    "signature": {
      "type": "string",
      "maxLength": 4000
    },
    "display_name": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
shelf_read
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Read one member's shelf. Access is by PROOF, not by naming a key: an unproven caller sees only the promoted commons. To see your own rings (private + shelf) or a friend's shelf ring, pass `viewer` (a key), `at` (unix seconds) and `sig` — a signature over nh-shelf-read:v1:<member>:<viewer>:<at> made with the viewer key on your own machine (never send the key). Nothing anywhere records who read what.

shelf_read input schema
{
  "type": "object",
  "required": [
    "member"
  ],
  "properties": {
    "at": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "sig": {
      "type": "string",
      "maxLength": 4000
    },
    "member": {
      "type": "string",
      "maxLength": 4000
    },
    "viewer": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
shelf_signable
Advertised by the server during the last successful anonymous check.

[KEEP · internal] THE COMMONS — step 1 of stocking your own shelf. Returns {fields, signable}: the exact canonical bytes to sign with YOUR key on YOUR machine. A shelf is a covenant key with cards on it, not an account. Rings: `private` (only you) · `shelf` (you and the friends who chose you — UNGATED, live the moment you sign) · `commons` (site-wide, waits for a human steward). The gate is on what the library AMPLIFIES, never on what you may say.

shelf_signable input schema
{
  "type": "object",
  "required": [
    "member",
    "kind",
    "body"
  ],
  "properties": {
    "url": {
      "type": "string",
      "maxLength": 4000,
      "description": "kind=link only — the address. We open it once in an airlock, keep the WAYBILL (its own title, size, sha256, when we looked) and discard the bytes. No page of anyone else's is stored, and nothing is embedded: an iframe would hand the reader's IP to the provider. The body is still required — a bare link is not curation."
    },
    "body": {
      "type": "string",
      "maxLength": 4000
    },
    "kind": {
      "enum": [
        "build",
        "field_note",
        "link",
        "note",
        "question",
        "recipe",
        "suggestion",
        "writing"
      ],
      "type": "string",
      "description": "note|writing|recipe|build|field_note|question|link|suggestion"
    },
    "ring": {
      "enum": [
        "commons",
        "private",
        "shelf"
      ],
      "type": "string",
      "description": "private|shelf|commons"
    },
    "quote": {
      "type": "string",
      "maxLength": 4000,
      "description": "optional short passage YOU typed, capped; requires `attribution`"
    },
    "member": {
      "type": "string",
      "maxLength": 4000,
      "description": "your public key — the shelf is the key"
    },
    "subject": {
      "type": "string",
      "maxLength": 4000
    },
    "attribution": {
      "type": "string",
      "maxLength": 4000,
      "description": "whose words the quote is"
    }
  },
  "additionalProperties": false
}
study_export
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Export a study as a self-contained, portable bundle. Returns the bundle and its content_hash; to bind your identity to it, sign that hash with your own key on your own machine — this tool does not take a private key.

study_export input schema
{
  "type": "object",
  "required": [
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
study_import
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Import an exported study bundle — re-materializes its cards (each lives once).

study_import input schema
{
  "type": "object",
  "required": [
    "bundle"
  ],
  "properties": {
    "key": {
      "type": "string",
      "maxLength": 4000
    },
    "bundle": {
      "type": "object",
      "additionalProperties": false
    },
    "verify_signature": {
      "type": "boolean"
    }
  },
  "additionalProperties": false
}
want_offer
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Return to the comb with a FOUND source for an open want: label + url + snippet, attributed. You are a forager, not an author — offer only public-domain / openly-licensed sources you actually located, never generated text. The offer lands as a QUARANTINED option cell tagged with your agent label; a NAMED HUMAN chooses, and only then is a card created. There is no path around the comb.

want_offer input schema
{
  "type": "object",
  "required": [
    "want_id",
    "label"
  ],
  "properties": {
    "url": {
      "type": "string",
      "maxLength": 4000
    },
    "agent": {
      "type": "string",
      "maxLength": 4000,
      "description": "your self-declared name, e.g. 'claude' — the shaft-tag a steward can cut a branch by"
    },
    "label": {
      "type": "string",
      "maxLength": 4000
    },
    "domain": {
      "type": "string",
      "maxLength": 4000
    },
    "snippet": {
      "type": "string",
      "maxLength": 4000
    },
    "want_id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
want_open
Advertised by the server during the last successful anonymous check.

[KEEP · internal] Ask the library to ACQUIRE something it does not hold (kind=missing, give query) or to EXPAND a thin card (kind=expand, give card_id). Opens a want on the AGENT PLANE — held separate on the desk until the next human who looks seconds it by asking for the same thing. Call this only when your principal genuinely needs what the keeping lacks; the same miss asked twice is one want asked twice. No requester identity is stored; queries are scrubbed before storage.

want_open input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "kind": {
      "type": "string",
      "maxLength": 4000
    },
    "note": {
      "type": "string",
      "maxLength": 4000
    },
    "query": {
      "type": "string",
      "maxLength": 4000
    },
    "card_id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
wants_list
Advertised by the server during the last successful anonymous check.

[KEEP · internal] The library's desiderata desk — open wants, sorted by demand, agent plane marked and separate. Read it to find gaps you could dig for.

wants_list input schema
{
  "type": "object",
  "required": [],
  "properties": {
    "plane": {
      "type": "string",
      "maxLength": 4000
    },
    "state": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
read_passage
Advertised by the server during the last successful anonymous check.

[WORD · door] Read a passage — a single verse, a range (John 3:16-18), or a whole chapter (John 3). The WEB by default; lang picks a held public-domain translation (es, fr, de, zh, he, la, ru, ar, ja, ko, …; an unknown lang lists what is held).

read_passage input schema
{
  "type": "object",
  "required": [
    "ref"
  ],
  "properties": {
    "ref": {
      "type": "string",
      "maxLength": 4000
    },
    "lang": {
      "type": "string",
      "maxLength": 4000,
      "description": "ISO 639-1, default en"
    }
  },
  "additionalProperties": false
}
word_study
Advertised by the server during the last successful anonymous check.

[WORD · door] Strong's word study — original-language definition + pronunciation + every occurrence.

word_study input schema
{
  "type": "object",
  "required": [
    "strongs"
  ],
  "properties": {
    "strongs": {
      "type": "string",
      "maxLength": 4000,
      "description": "e.g. G26, H2617"
    }
  },
  "additionalProperties": false
}
cross_references
Advertised by the server during the last successful anonymous check.

[WORD · door] Verses connected to a reference by SHARED original words (Strong's) — the dots, connected; deterministic and found, ranked by shared-word count.

cross_references input schema
{
  "type": "object",
  "required": [
    "ref"
  ],
  "properties": {
    "ref": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
backmatter
Advertised by the server during the last successful anonymous check.

[WORD · internal] Back-matter reference tables: weights_measures, names_of_god, parables, miracles, book_intros, topical_index. Disputes carried (a cubit's two lengths, a book's two datings), refs verified against the corpus, names of God carry Strong's numbers that open in word_study. Pass table for one table; else the index of all six.

backmatter input schema
{
  "type": "object",
  "properties": {
    "table": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
bible_places
Advertised by the server during the last successful anonymous check.

[WORD · internal] The Atlas — biblical places with REAL coordinates, honestly held: located places carry lat/lon (cross-checked against an independent gazetteer); disputed sites (Mount Sinai, Cana, Golgotha) NAME their candidates instead of planting one flag; unlocatable places (Eden, Emmaus, Tarshish, Ophir) are honest blanks with no coordinates. Pass name for one place; else all places with by_status counts.

bible_places input schema
{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
canon
Advertised by the server during the last successful anonymous check.

[WORD · internal] The canon as concentric layers — the undisputed 66 that all major traditions share, plus the books held BEYOND it by particular traditions, each framed on its own layer and never merged. REPORTS who holds what with the history; does not judge which canon is correct. Pass book for one book's status; else the overview.

canon input schema
{
  "type": "object",
  "properties": {
    "book": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
character_get
Advertised by the server during the last successful anonymous check.

[WORD · internal] A Bible figure from Easton's Bible Dictionary (1897, PD) — summary + every verse that speaks of them (found + attributed; category tag is imperfect).

character_get input schema
{
  "type": "object",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
characters_browse
Advertised by the server during the last successful anonymous check.

[WORD · internal] Browse/search Easton's Bible Dictionary (people, places, terms).

characters_browse input schema
{
  "type": "object",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    },
    "letter": {
      "type": "string",
      "maxLength": 4000
    },
    "search": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
commentary
Advertised by the server during the last successful anonymous check.

[WORD · internal] Public-domain, attributed commentary (Matthew Henry) on a reference — the commentator's own words, found and cited, never generated.

commentary input schema
{
  "type": "object",
  "required": [
    "ref"
  ],
  "properties": {
    "ref": {
      "type": "string",
      "maxLength": 4000
    },
    "source": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
harmony
Advertised by the server during the last successful anonymous check.

[WORD · internal] Harmony of the Gospels — one event of Christ's life, every gospel that records it, side by side (found, verbatim WEB text, never generated). Pass id for one event; else lists every event grouped by phase of the ministry.

harmony input schema
{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
narratives
Advertised by the server during the last successful anonymous check.

[WORD · internal] The storyboards — the common narratives charted in the Bible FIRST (exile-and-return, the barren woman bears, down-to-the-pit-raised, the great reversal...), each instance real people with verified refs. The 17 movements are one shared vocabulary, so components isolate and recombine: pass movement='testing' to walk it across every storyboard. Pass id for one storyboard; else the index. FRAMING, always: a person may display characteristics of many of these at times of their life — a reference point, NEVER an identity assignment.

narratives input schema
{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    },
    "movement": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
original_words
Advertised by the server during the last successful anonymous check.

[WORD · internal] The original-language words behind a verse (Hebrew/Greek, with Strong's where known) — FOUND in the lexicon, never generated. Returns the tagged words AND coverage {tagged, total, untagged_positions, untagged_words, complete}: the tagged words are not the whole verse (Greek ~44% tagged, Hebrew ~98%), and the untagged words are shown, never dropped. Pass ref, e.g. 'John 3:16'.

original_words input schema
{
  "type": "object",
  "required": [
    "ref"
  ],
  "properties": {
    "ref": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
prophecy_traces
Advertised by the server during the last successful anonymous check.

[WORD · internal] Christ-signpost traces (prophecy/cross-cultural pointers to Jesus) — attributed, verdict CONCORDANT/MIXED, NEVER HOLDS (a signpost, not a proof). Pass id for one trace, q to search, else lists all.

prophecy_traces input schema
{
  "type": "object",
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 4000
    },
    "id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
seeds
Advertised by the server during the last successful anonymous check.

[WORD · internal] Seeds of the Word (the Areopagus / logos spermatikos pass) — true fragments mined from the nations, ATTRIBUTED, CONCORDANT/signpost NEVER HOLDS; each names the idol it refuses and points to Christ (Acts 17; 1 John 4:1-3). Pass id for one seed, q to search, tradition to filter, else lists all with Paul's 7-step method.

seeds input schema
{
  "type": "object",
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 4000
    },
    "id": {
      "type": "string",
      "maxLength": 4000
    },
    "tradition": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
study_find
Advertised by the server during the last successful anonymous check.

[WORD · internal] The quick-find index — ONE lookup across the whole reference section: archetypes, storyboards, movements, the six study tables, the atlas, harmony, timeline, and the encyclopedia. Each hit is a pointer to the real entry, which carries its own refs and its own honesty. The index finds; it never ranks truth.

study_find input schema
{
  "type": "object",
  "required": [
    "q"
  ],
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
teachings
Advertised by the server during the last successful anonymous check.

[WORD · internal] The teachings of Christ (Words in Red) — the frozen Greek anchor plus the history that ALIGNS to each teaching, gathered and attributed, never authored. Pass id for one teaching; else the queue.

teachings input schema
{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
timeline
Advertised by the server during the last successful anonymous check.

[WORD · internal] Timeline — Old Testament, New Testament (Acts onward), and Church History, one spine from creation to today. Genuinely disputed dates (early/late Exodus, the date of Revelation, etc.) carry both positions, never one verdict. Pass id for one event; else lists every event grouped by era and period.

timeline input schema
{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 4000
    }
  },
  "additionalProperties": false
}
tsk_cross_references
Advertised by the server during the last successful anonymous check.

[WORD · internal] Editorial cross-references for a verse (openbible.info, CC BY — expansion of the public-domain TSK), ranked by relevance votes. Found + attributed.

tsk_cross_references input schema
{
  "type": "object",
  "required": [
    "ref"
  ],
  "properties": {
    "ref": {
      "type": "string",
      "maxLength": 4000
    },
    "limit": {
      "type": "integer",
      "maximum": 1000000000000,
      "minimum": -1000000000000
    }
  },
  "additionalProperties": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
604 ms
95th percentile latency
604 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 604 ms · metadata changed · 102 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http narrow-highway-mcp https://narrowhighway.com/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add narrow-highway-mcp --url https://narrowhighway.com/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable narrow-highway-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "narrow-highway-mcp": {
      "url": "https://narrowhighway.com/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "narrow-highway-mcp": {
      "type": "streamableHttp",
      "url": "https://narrowhighway.com/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start narrow-highway-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "narrow-highway-mcp": {
      "type": "http",
      "url": "https://narrowhighway.com/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http narrow-highway-mcp https://narrowhighway.com/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://narrowhighway.com/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "narrow-highway-mcp": {
      "serverUrl": "https://narrowhighway.com/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Narrow Highway MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 5,159

Do you run Narrow Highway MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing