Loading ToolBench
Intent-aware code-knowledge index for LLM agents, built on intent-db: index a repo once, query it by intent, cut the token cost of re-reading files.
Strong tool design with clear intent-aware code search patterns. All 12 tools have explicit schemas and descriptions. Naming is verb-forward (code_*, note_*). Descriptions are detailed (100-250 chars typical), explaining WHAT, WHEN, and WHY. Parameters are well-typed with enums where appropriate (layer, direction, intent). However, several parameters lack descriptions (e.g., 'full' in code_index, 'budget' in code_map), and output schemas are not documented. Error handling guidance is absent, tools do not indicate what to do on failure (symbol not found, index corruption, etc.). No tool annotations (readOnlyHint/destructiveHint) despite clear read/write semantics. Missing parameter constraints (e.g., k range, budget_tokens bounds).
Assemble the full bodies of a symbol AND what it calls, in call order, packed to a token budget. One call shows how a function works end to end instead of chasing callees by hand.
Report whether a search hit was actually useful. Trains per-intent ranking. Call after using (or discarding) a result.
Return the ordered call sequence inside a function: each call in source order with its resolved target location. See control flow and ordering without reading the whole body.
Incrementally (re)index the repository. Only changed files are re-parsed and only changed symbols re-embedded. Call once before searching, and after edits.
Return the PageRank-ranked repo map: the most important symbols with signatures and file:line, packed to a token budget. Read this at session start instead of globbing the tree.
Trace a symbol's callers, callees, or importers (blast radius / flow) without reading files. Edges are name-based and approximate.
No output schemas documented. Tools return results but LLMs cannot plan downstream calls or extract fields without trial-and-error. E.g., code_search returns 'ranked hits' but structure is undefined.
Missing parameter descriptions for 'full' (code_index), 'budget' (code_map), 'covers' (note_put). LLMs cannot infer what these control without explicit text.
No error handling guidance. Tools do not indicate what to do if symbol not found, index is stale, or embedding fails. E.g., code_read with invalid symbol returns nothing, should guide LLM to search first.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | C | 60 | 2026-07-28+ | v2 |
Return a symbol's FULL source span, untruncated, resolved from the index by doc_key, qualname, or name. Read exact body logic without globbing for the file or guessing line numbers.
Search the code-knowledge index. Returns ranked hits with a file:line location, the symbol's signature card, and a score breakdown. The SAME query ranks differently per intent. Read only the returned spans instead of re-reading whole files.
Index statistics: document/file counts, intents, embedder.
Read a knowledge note by id.
List notes whose covered files have changed (need a refresh).
Write or update a durable knowledge note (a gotcha, an invariant, a control/data-flow explanation). Persists across sessions so it is never re-derived. List the files it covers so it can be flagged stale when they change.
No tool annotations (readOnlyHint/destructiveHint). code_index and note_put are clearly write operations; code_search, code_read, etc. are read-only. Annotations enable safer agent planning.
Missing numeric constraints. 'k' (code_search, code_neighbors) and 'budget_tokens' (code_context) lack min/max bounds. LLMs may pass absurd values (k=999999, budget=1000000) causing timeouts.