Loading ToolBench
AI-native architecture platform. Diagrams from prompts, 14-framework code export, drift detection, persistent code graph. 36 tools for Cursor, Claude Code, Codex, Windsurf.
Tentra MCP presents 27 well-intentioned tools with comprehensive descriptions and documented schemas. However, several critical issues prevent a higher score: (1) Output schemas are not explicitly defined in the source code, responses are described narratively but not as JSON Schema; (2) Many tools lack explicit error handling guidance ('must say so' per pattern:command-tool); (3) Security considerations are under-addressed for write operations; (4) Parameter descriptions occasionally lack constraint details (ranges, formats, character limits); (5) Tool composition could be tighter, some tools like 'index_code' combine multiple responsibilities (tier-1 static extraction + tier-2 semantic enrichment + batching). Strengths: tool names follow verb_noun convention consistently; parameter descriptions are generally 50-200 chars and include context; the schema definitions visible in the source show proper type annotations and enums for constrained inputs (tier, entity_type, status, etc.); composite tools like 'index_code_continue', 'record_semantic_node', and 'explain_codebase' are sensible. The Tentra platform context (architecture diagrams, code indexing, contract alignment) is well-articulated. Average per-tool score: 68/100.
Link a code symbol (handler, controller, etc.) to a specific endpoint/method in a service contract. Used to establish code-spec traceability.
Compare two snapshots: show new/deleted/changed files, symbols, and god-nodes. Useful for drift detection and change summaries.
Trace and explain the data flow or call path from one symbol to another. Returns the shortest path with intermediate steps and edge types.
Generate a structured summary of a codebase or service: high-level architecture, key files, core patterns, inter-file dependencies, and risk hotspots.
Find all cross-file and within-file references to a symbol. Returns call sites, edge types (sync/async/db), and caller/callee fan counts.
Output schemas not explicitly documented. Tool descriptions state what is returned (e.g., 'Returns matches with line ranges, kinds, fan-in/fan-out counts') but actual JSON Schema output structures are not visible in the source code. This violates pattern:tool which requires structured output documentation.
Incomplete error handling guidance. Write operations (index_code, record_semantic_node, record_embedding, set_service_mapping, set_domain_membership, record_contract, bind_contract, record_decision, link_decision) lack explicit error messages and recovery steps. Per pattern:command-tool, these should document what can fail and what the LLM should do next.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | C | 64 | 2026-07-28+ | v2 |
Semantic search: find code sections with similar responsibility, patterns, or behavior to a given symbol or query string. Uses embeddings.
List all contracts for a service with endpoint counts, versions, and binding status.
List all ADRs linked to a code entity (symbol, file, service) or show decisions related to another ADR.
Query the status of an indexing job. Pure read — does not advance the job. Returns job state, file/symbol counts, and any errors.
Look up code ownership records for a file, symbol, or service. Returns team/owner, responsibility, and contact info if recorded.
Identify quality hotspots: high-complexity files, high-fan-in symbols, test coverage gaps, cyclic dependencies, and anti-patterns.
Export the code graph (symbols + edges) for a service as a structured JSON: nodes with fan counts and metadata, edges with type (sync/async/db/grpc).
Measure alignment between a service's code graph and its declared API/contract specification (OpenAPI, gRPC, AsyncAPI). Returns coverage, drift, and unimplemented endpoints.
Find the immediate call/dependency neighbors of a symbol. Returns up to k calls in or out with context (file, line, edge type).
Tier-1 + tier-2 code indexing with Tree-sitter static extraction and optional agent-in-the-loop semantic enrichment. Walks a repository recursively, extracts symbols and dependencies, creates a snapshot, and optionally returns the first tier-2 batch for semantic tagging.
Advances a tier-2 indexing job by one batch. Polls the job status, returns pending work or done signal to drive the agent-in-the-loop enrichment loop.
Associate an ADR with code entities (symbols, files, services) or other ADRs. Used to trace architecture decisions through the codebase.
Identify high-fan-in symbols (god nodes) that are called by many other symbols. Ranked by fan-in count with context (file, kind, references).
List all snapshots for a repository with metadata: creation time, commit SHA, file/symbol counts, and freshness relative to current HEAD.
Substring search across all indexed symbols in a snapshot. Returns matches with line ranges, kinds (function/class/module), fan-in/fan-out counts, and test tagging.
Ingest an API contract (OpenAPI 3.x, gRPC .proto, AsyncAPI) for a service. Stores endpoints/methods and their parameters for spec alignment checks.
Document an architectural decision record (ADR). Captures decision ID, status (proposed/accepted/deprecated), rationale, and alternatives considered.
Store a custom embedding (vector) for a symbol, file, or domain entity. Used for semantic search and similarity queries.
Tier-2 semantic enrichment: tag a file with purpose/responsibility text, architectural patterns, owned entities, and custom metadata. Called per-file during the agent-in-the-loop loop after index_code.
Identify all locations where a symbol would need to be renamed to avoid conflicts. Cross-file analysis with collision detection and risk assessment.
Tag files, symbols, or services as members of a domain (business capability or bounded context). Used for cross-cutting concern tracking.
Assign files in a snapshot to services on the architecture canvas. Maps relative file paths to service_ids.
index_code combines two distinct responsibilities: tier-1 static extraction (Tree-sitter) and tier-2 agent-in-the-loop semantic enrichment, controlled by a 'tier' enum. Per pattern:tool, each tool should do one thing. Consider splitting: 'index_code_static' (tier1 only) and 'index_code_semantic' (tier2 orchestration) to allow independent invocation.
Parameter constraint documentation incomplete. Several numeric parameters (batch_size, limit, threshold, depth) specify defaults and ranges verbally but lack explicit JSON Schema minValue/maxValue constraints. E.g., 'batch_size' says 'capped at 50' but LLMs cannot read implementation bounds, they need schema constraints or strict input validation with actionable error messages.
Security considerations under-addressed for write tools. No explicit permission gates, audit trail design, or scope declarations (e.g., 'requires write:architecture'). Per pattern:scope-declaration, each write tool should declare what permissions it requires and how operations are logged.
Tool chaining context gaps. Tools like 'index_code' return a job_id, which must be passed to 'index_code_continue'. Tools like 'query_symbols' return symbol_id, which tools like 'find_references' accept, but response structures do not explicitly show all IDs needed for downstream calls. Per pattern:tool-chain, each response should include all IDs needed by likely follow-up tools.
Results not capped or paginated in several tools. list_god_nodes, list_snapshots, get_quality_hotspots, and find_similar_code all accept a 'limit' parameter but do not document whether they return total_count or next_cursor for pagination. Per pattern:paginated-result, tools returning lists should support offset/limit pagination and return metadata enabling agent iteration.