RunEcho is a deterministic, model-free oracle server that lets AI agents query the real structure of enrolled code repositories to verify facts, detect drift, and avoid hallucinated symbol references.
Get repository structure: Retrieve deterministic file and symbol snapshots (tree, symbols, hashes, or full detail), with optional glob filtering.
Identify structural drift: Compare two snapshots by ID, or compare a labeled or latest snapshot against live code.
Obtain repository hash: Get a deterministic root hash and file count – identical code yields identical hashes across any machine.
Check repository status: View per‑repo health: last indexed time, staleness, parse errors, coverage, snapshot count, latest hash, and file cap.
Monitor overall health: Check store‑wide health including schema version, integrity, enrolled repos count, and database path.
Locate symbols: Deterministically find where a symbol is defined (name → file:line + body hash), with exact/prefix/last‑segment matching, kind filtering, and pagination.
RunEcho stops an agent from writing a call to a function your repo doesn't have —
before the write lands, not after the build fails. It runs as a PreToolUse
hook inside the agent loop: every Edit/Write is checked against the symbols
your code actually declares, and a reference to one that doesn't exist stops the
write and asks you first. ~12 ms, no build, no language server.
The same code produces the same answer. Every check is a parse and a lookup, so the verdict is identical on every run, every machine, and every agent — there is no model to sample from and nothing to re-roll. That is what makes it a gate rather than an opinion: it is model-free and vendor-neutral — no LLM, no API keys, no network, no build, no language server.
The guard costs zero context tokens — measured, not asserted: a clean check
writes nothing at all, and only an edit it actually stops costs anything (~100
tokens). It is a PreToolUse hook, so the agent never spends context deciding
whether to call it. The oracle MCP server is a separate surface and is not
free — its tool schemas cost ~968 tokens at session start, and structure
unscoped is expensive enough to be worth scoping. Every number, including the
unflattering ones, is in bench/TOKEN-COST.md.
How often it's wrong, measured against git history, not approvals. A
user's approve-anyway rate turned out to have no variance to measure — 308 of
308 ask-gated edits approved, zero denied, across 30 days of dogfood traffic.
So fpaudit judges each flagged symbol against dated git history instead:
was it defined at ask time, and is it defined now. Live reading across this
project's own dogfood corpus: 15.3% false-positive, 33.7% premature (the
guard was correct, just fired before the symbol it flagged existed — an
agent writing a caller before its callee), 51.0% stands (a real unbacked
reference). The full method, and what NOT to conclude from the 51%, is in
bench/FPAUDIT.md.
The scope, stated up front. RunEcho reads unqualified references — bare
calls, constant references, and type annotations. Measured against its own
corpus of real model hallucinations, that catches 4 of 9 (N=15 hand-verified
cases mined from live session transcripts, each backed by a compiler or runtime
error as independent ground truth). The other 5 are qualified positions —
df.groupby(…), tree.Root() — which need receiver-type resolution and are out
of scope by design. The numbers, including the misses, are in
bench/FINDINGS.md.
That is the honest shape of the thing: one cheap layer against AI coding mistakes — not the whole answer. A narrow, fast, certain check that runs before the write, not a system that makes your agent correct. Run it the way you run a type checker — one layer that removes one class of mistake completely, alongside the tests and review that catch the rest.
Coding agents are useful, but they routinely make three kinds of mistakes:
they refer to functions or types that do not exist
they describe structural changes inaccurately
they keep reasoning from stale repo state after the code has moved on
RunEcho exists to give those agents a local source of truth they can query before they speak, edit, or commit.
Use it when you want:
a deterministic answer to "does this symbol actually exist?"
a structural diff instead of a vague summary of what changed
a guard that catches invented helper calls before they land in your repo
If your main problem is broad semantic search or general codebase exploration, RunEcho is not trying to be that. Its job is narrower: verify repo facts and reduce hallucinated code changes.
Related MCP server: N3MO
RunEcho parses your source into a compact Intermediate Representation (IR): per file: its content hash plus the functions, classes, exports, and imports it declares. The IR has a deterministic root hash, so "did the structure change?" becomes a cheap hash comparison, and "what changed?" becomes a structural diff.
Snapshots of that IR are stored in a single central history database. Each enrolled repo has a stable identity, so the oracle can answer questions about any of your repos and compute drift between any two snapshots.
Three binaries make up the surface area:
runecho-ir — a CLI to enrol repos, index them, take snapshots, and inspect
diffs and churn from the terminal.
runecho-mcp — a stdio MCP server that exposes read-only oracle tools
(structure, diff, hash, status, health, locate) to an AI agent.
locate answers "where is symbol X" deterministically (name → file:line), so
an agent finds definitions without grepping or guessing.
runecho-guard — a guard that checks new code against the indexed IR and
flags references to symbols that don't exist (likely hallucinations). Runs as a
git pre-commit hook, or as a Claude Code PreToolUse hook that vets every
Edit/Write/MultiEdit before it lands.
source ──▶ parser ──▶ IR (hashed) ──▶ snapshot ──▶ ~/.runecho/history.db
│
AI agent ──(MCP)──▶ runecho-mcp ──▶ structure / diff / hash / ...
│
git commit / agent edit ──▶ runecho-guard ──▶ "symbol X doesn't exist — block/ask"Nothing to run a tagged release — the prebuilt binaries are self-contained (no runtime, no API keys).
Go 1.25+ only if you build from source (bash install.sh).
A POSIX or Windows shell. Storage lives under ~/.runecho/ by default.
No external services, no API keys.
Languages parsed today: Go, JavaScript, TypeScript, JSX, TSX, Google Apps
Script (.gs), Python, shell (.sh/.bash), Rust (.rs), and Ruby (.rb).
Extraction is intentionally shallow and deterministic: top-level structure, not
full semantic analysis.
Get the binaries. Either download a prebuilt release (no Go needed) — pick your OS/arch from the latest release:
# example: macOS arm64 — adjust the asset name for your platform.
# NOTE: the tag in the URL path is v-prefixed; the asset filename is not.
TAG=v0.17.1; NUM=0.17.1
curl -sSL "https://github.com/inth3shadows/runecho/releases/download/${TAG}/runecho_${NUM}_darwin_arm64.tar.gz" | tar -xz
install -m755 runecho-ir runecho-mcp runecho-guard ~/.local/bin/…or build from source (needs Go 1.25+), which also installs the guard hooks:
bash install.shEnrol a repo and capture its current structure:
runecho-ir repo add /path/to/your/repo
runecho-ir repo reindex <name> # name is shown by `repo add`If the directory you want to enrol is not the directory you want parsed, set a separate source root:
runecho-ir repo add /path/to/worktree --source-root=/path/to/sourceSee what's enrolled and ask for drift since the last snapshot:
runecho-ir repo list
runecho-ir diff --since=reindex /path/to/your/repoRegister the oracle with your AI agent so it can query directly:
claude mcp add runecho -- ~/.local/bin/runecho-mcpFor Codex, add this to ~/.codex/config.toml:
[mcp_servers.runecho]
command = "/home/YOUR_USER/.local/bin/runecho-mcp" # absolute path; TOML does not expand ~Install the edit-time guard in Claude Code — the primary integration if you want RunEcho to vet assistant edits before they are written:
/plugin marketplace add inth3shadows/runecho
/plugin install runecho-guard@runechoThe plugin wires both hooks — PreToolUse (the guard) and PostToolUse
(records the outcome and refreshes the index). It does not ship the
binary, so step 1 still has to have happened. If the binary is missing the
hook defers silently rather than erroring on every edit. Uninstall with
/plugin uninstall runecho-guard@runecho.
Without plugin support, print the equivalent ~/.claude/settings.json
snippet and merge it by hand:
bash install.sh --print-hook-config(Optional) Install the commit-time guard in a repo you've enrolled:
bash install.sh --hook # run from the target repo's rootIt blocks commits that call functions which exist nowhere in the indexed code
(with a "did you mean …?" suggestion when there's a close match). Bypass any
single commit with RUNECHO_GUARD_SKIP=1 git commit ….
(Maintainers/forks only) If you cut release tags from this repo, install the tag-monotonicity safety net:
bash install.sh --hook-pre-pushRejects a vX.Y.Z tag push that isn't semver-greater than the highest
existing tag — see issue #51.
RunEcho is strongest when you want deterministic structure and guardrails, not general-purpose code intelligence.
It tracks top-level symbols and imports/exports, not full type information.
Parsers are AST-based but intentionally shallow — they extract definitions
(functions, classes, methods), not semantics: no type inference, call graph,
or cross-file binding. Go uses the stdlib go/ast; Python, JS/TS, Rust, and
Ruby use a pure-Go tree-sitter runtime; shell uses a masking scan. Imports and
exports for the tree-sitter languages are still regex. Each language has known
gaps — see the Parser Capability Matrix
for the per-language honest accounting.
Indexing covers more languages than the guard checks. Shell, Rust, and
Ruby feed the index (structure, locate, diff) but are not validated at
edit time — the guard's reference checks exist for Go, JS/TS, and Python only.
The guard validates unqualified references: bare calls (foo(...)),
bare type annotations (x: SomeType), and SCREAMING_SNAKE constant
references. It does not flag qualified references (obj.method(...),
pkg.Thing, x.attr) — those would need receiver-type resolution, semantic
analysis RunEcho deliberately avoids. This boundary is measured, not asserted:
see bench/FINDINGS.md, where a corpus of real
transcript-observed hallucinations places the guard's catch-rate by reference
position (the qualified positions are the deliberate gap).
Snapshots, diffs, and hash queries are local and deterministic. There is no semantic search, embedding index, or hosted control plane here.
The guard runs unattended on every commit/edit with no sandboxing — see SECURITY.md for the threat model, what's stored, and how to report a vulnerability.
Path | Purpose |
| The CLI: snapshot, diff, map, log, churn, verify, truth-trail, validate-claims, contract, guard-stats, fpreport, fpaudit, repo, backup, install — plus indexing, which is the no-subcommand default ( |
| The stdio MCP oracle server |
| The guard: pre-commit mode + Claude Code hook mode, plus the opt-in checks |
| Per-language structure extraction (Go/JS/TS/JSX/TSX/.gs/Python/shell/Rust/Ruby) |
| IR build, deterministic hashing, JSON storage |
| Central store: migrations, registry, diff, churn, contracts, backup |
| Minimal MCP plumbing + the oracle tools |
| Diff parsing, symbol extraction, validation, did-you-mean |
| Edit-scope contract format and parsing |
| Memoized export sets for Go dependencies (qualified-call checks) |
|
|
| Symbol-reference extraction from prose ( |
| Canonical git-common-dir resolution (worktree identity) |
| Builds all three binaries; |
Technical Reference — architecture, storage schema, the IR, the MCP tools, maintenance
Usage Guide — day-to-day operations: enrolling repos, integrations, reading drift, troubleshooting
Token cost — measured context cost of every surface, including where RunEcho is expensive
False-positive audit — the guard's fp/premature/stands rate against git history, and why approval rate isn't a false-positive proxy
Changelog — notable changes per release; versioning policy
MIT — see LICENSE.
Structural drift for an enrolled repo. With a+b (snapshot ids) diffs those snapshots; with since=label diffs that snapshot vs live code; default diffs the latest snapshot vs live code.
| Name | Required | Description | Default |
|---|---|---|---|
| a | No | snapshot id A (with b) | |
| b | No | snapshot id B (with a) | |
| repo | Yes | name of an enrolled repo | |
| since | No | diff latest snapshot with this label vs live code | |
| session | No | with `since`: pin the reference snapshot to this session id |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the operational behaviors for every mode without hiding assumptions or side effects. There is no mention of side effects or permissions, but for a read-only diff operation, the behavior is transparent enough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core purpose, followed by a precise enumeration of modes. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers all parameter combinations and default behavior, and with no output schema, return details are not required. It is slightly thin on the definition of 'structural drift' and possible error conditions, but overall it gives a complete mental model for using the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds meaningful semantic grouping: it explains that a and b are used together, `since` uses a label against live code, and `session` pins the reference snapshot. This goes beyond the schema's literal parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Structural drift for an enrolled repo' and enumerates three distinct comparison modes (snapshot-snapshot, snapshot-live, latest snapshot-live). This signals a specific verb+resource and differentiates it from sibling tools like 'structure' or 'status'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context by defining when each mode applies: with a+b for snapshot diffs, with `since` for snapshot-vs-live, and default for latest-vs-live. It doesn't name alternative tools, but the decision logic is clear and tied to argument combinations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Deterministic root hash + file count of an enrolled repo's current code. Same code → identical hash across machines.
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | name of an enrolled repo |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral traits. It adds meaningful context beyond a simple 'computes hash' by emphasizing determinism and cross-machine reproducibility. It does not mention side effects, but hashing is inherently non-destructive, and the 'current code' phrasing implies a read-only operation on the repo's existing state.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the core purpose in the first sentence and a valuable behavioral trait in the second. No wasted words or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description adequately explains the return value ('root hash + file count') and a key behavioral guarantee (determinism). It could mention the hash format or error handling for unenrolled repos, but the description is largely complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% because the single parameter 'repo' is fully described as 'name of an enrolled repo'. The description adds minor extra context by saying 'current code', which clarifies that the hash is computed from the repo's present state, but it does not significantly enhance the parameter's meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool computes a 'deterministic root hash + file count' of 'an enrolled repo's current code', using a specific verb (compute/generate) and resource (repo code). It distinguishes itself from siblings like structure, diff, and status by focusing on a hash fingerprint.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The tool's purpose is narrow and the deterministic property ('Same code → identical hash across machines') implies a usage case for verifying consistency across machines. However, there is no explicit guidance on when to prefer this over siblings (e.g., diff or status), and no exclusions or alternative tool mentions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Store-wide health: schema version, integrity check, number of enrolled repos, db path.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description lists the output fields (schema version, integrity check, enrolled repos, db path), giving some transparency about return content. However, it does not disclose whether the integrity check is expensive, whether the tool is read-only, or any side effects, and no annotations are present to fill that gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded phrase 'Store-wide health' followed by a colon and a list of relevant items. Every word contributes, no filler, and it is easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema and no annotations, the description sufficiently communicates what the tool does and what information it provides. It could be more complete by addressing potential overlap with siblings, but the tool is simple enough that this is minor.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters, the input schema is trivially complete. The description adds value by enumerating the health data returned, which is the only semantic content needed for this parameterless tool. Baseline 4 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's function as a store-wide health check, listing specific items like schema version, integrity check, enrolled repos, and db path. This is specific enough to distinguish from siblings like structure or diff, though it doesn't explicitly contrast with 'status' which could be similar.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'status' or 'locate'. The description implies it is for overall health, but there is no explicit mention of scenarios or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Deterministically locate symbols in an enrolled repo: name → file:line (+ short body hash). Pass symbol to find a specific definition without grepping (a named lookup searches every kind); omit it to list all (capped, paginate with offset) — the unfiltered list defaults to functions+classes. Use this to verify a symbol exists before claiming it does: a zero-match result is definitive (parsed from the live AST), unlike grep, which can miss real symbols (formatting/whitespace variance, multi-line signatures) or hit false positives (comments, strings).
| Name | Required | Description | Default |
|---|---|---|---|
| kind | No | restrict to func|class|export|import (default: func+class) | |
| repo | Yes | name of an enrolled repo | |
| offset | No | skip this many matches before returning a page (default 0). Page again with the response's next_offset until it's absent. | |
| symbol | No | symbol to locate: matches by exact name, name prefix, or last dotted segment (e.g. "fetch" finds "Reader.fetch"). Omit to list all (capped). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It reveals deterministic parsing from the live AST, zero-match definitiveness, capped results, pagination via offset, and default filtering to functions+classes. These details far exceed minimal expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three dense sentences pack the core purpose, usage, and rationale without redundancy. The description is front-loaded with the primary action and organizes supporting details logically, earning its length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description defines the return format (file:line + body hash), covers cap and pagination behavior, and explains the zero-match result as definitive. Combined with the rich schema, the tool is fully comprehensible without further context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so a baseline of 3 is appropriate. However, the description adds a key behavioral nuance not in the schema: a named symbol lookup searches every kind. This supplemental meaning justifies a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('locate') and resource ('symbols in an enrolled repo') with an explicit output mapping (name → file:line + body hash). It clearly distinguishes itself from sibling tools like structure, diff, and hash by focusing on deterministic definition lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool ('verify a symbol exists before claiming it does') and contrasts it with grep, explaining why grep is unreliable. However, it does not explicitly name sibling tools or provide when-not-to-use exclusions, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Per-repo health: last indexed, staleness, parse errors, coverage %, snapshot count, latest stored hash, file cap.
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | name of an enrolled repo |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavior. It lists the output fields, which gives a good sense of what the tool returns, but it does not explicitly state that it is read-only, what happens for invalid repo names, or any performance considerations. The absence of side-effect disclosure is less critical for a status tool, but still a gap that prevents a higher score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that front-loads the core purpose ('Per-repo health') and then enumerates the specific metrics. Every word contributes meaning, with no redundancy or filler. It is extremely concise while retaining all essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no nested objects, no output schema), the description provides a solid list of return fields, giving the agent a clear idea of what to expect. However, it omits potential error behavior (e.g., repo not enrolled) and does not clarify whether results are real-time or cached. For a basic status tool, this is nearly complete, but the missing failure-mode context prevents a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single parameter 'repo', which is described as 'name of an enrolled repo'. The tool description does not add much beyond this, but the phrase 'Per-repo' reinforces the parameter's purpose. Since the schema already handles the parameter meaning, a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as providing per-repo health metrics, listing specific data points (last indexed, staleness, parse errors, coverage %, snapshot count, latest stored hash, file cap). While it lacks an explicit verb like 'get' or 'show', the resource and scope are clear. It distinguishes from sibling tools like 'health' by focusing on repository status, though not explicitly naming alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There are no explicit context cues, exclusions, or references to sibling tools. The description implies it is for checking repo health but does not explain when one might prefer 'health' or 'structure' instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Deterministic structure (files + symbols) of an enrolled repo's current code. Use to ground claims about what functions/types/exports exist. Scope with paths globs and pick a detail level to keep responses small.
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | name of an enrolled repo (see `health`/registry) | |
| paths | No | optional glob filters; return only matching files (e.g. "internal/mcp/**" or "*.go"). `**` matches across directories. Omit for the whole repo. | |
| detail | No | tree = file paths + symbol counts only (cheapest); symbols (default) = per-file symbols[] (name/kind/line, plus `doc` — the verbatim first line of the symbol's doc comment where it has one, absent otherwise; it is the one field NOT verified against the code, so treat it as what the author wrote, not as checked intent) + refs; hashes = symbols plus each symbol's content hash (~2.5x the tokens; only needed to detect body-level drift, which `hash`/`diff`/`status` answer far more cheaply); full = also the legacy imports/functions/classes/exports arrays + symbol_hashes (redundant with symbols[], for back-compat) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and excels: it discloses determinism, current-code snapshot, cost considerations for detail levels, and even flags that the `doc` field is unverified author intent. This is exemplary transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The single-paragraph description is dense yet readable, with every clause adding concrete value—no filler or repetition. It front-loads the core purpose before diving into parameter trade-offs.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity and rich enum parameter, the description covers all necessary operational context: what is returned per detail level, how to use paths, cost implications, and a caveat about data reliability. Without an output schema, this description fully compensates.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds substantial value beyond the schema by explaining each detail level's content, token costs, and when to avoid hashes. It also clarifies the `doc` field's caveat, which is critical for correct interpretation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the deterministic structure (files + symbols) of an enrolled repo's current code, with a specific use case: grounding claims about functions/types/exports. It distinguishes itself from sibling tools by focusing on structural inspection rather than diffs, hashes, or status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance is given for when to use the tool ('to ground claims about what functions/types/exports exist') and how to scope it with paths and detail levels. It does not explicitly mention alternatives, but the strong purpose statement effectively differentiates it from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0diffhashhealthlocatestatusstructureEach tool has a clearly distinct purpose: structure for code layout, diff for changes, hash for fingerprinting, status for per-repo health, health for store-wide health, and locate for symbol resolution. There is no meaningful overlap; even structure and locate are distinct (broad structure vs. specific lookup).
All tool names are single-word, lowercase, with no underscores or mixed casing. This is perfectly consistent, even though they mix nouns and verbs. The pattern is predictable and easy to learn.
Six tools is a well-scoped set for a code analysis server. Each tool covers a distinct aspect of the domain without redundancy or bloat, and the count is within the ideal 3-15 range.
The tools cover core workflows: inspecting structure, diffing snapshots, hashing, checking health, and locating symbols. However, there is no direct way to list enrolled repositories or manage snapshots, which are minor gaps that agents may need to work around.
Ground-truth code graph for your codebase: exact callers, callees, symbols & dependencies.
Deterministic context layer for your codebase: change impact, blast radius, answers with receipts.
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Ask a codebase what calls what: search, blast radius, paths between symbols, and diffs.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/inth3shadows/runecho'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
