Diogenes Context Compression, Code Patching & Deterministic Solver MCP

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered, and the description correctly aligns ('Read-only call'). It adds real operational context beyond annotations: a 32 KB size cap, 60 RPM rate limit, payment paths ('?demo=true' or L402 75 sats), and an HTTP 400 failure mode. It stops short of 5 only because it leaves some ambiguity (e.g., which limit the 32 KB applies to) and adds no non-obvious behavioral caveats beyond these.

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?

Front-loads the core capability and then the routing rule before operational details, and every clause carries information. It is dense and slightly run-on, packing output shape, routing, rate limits, payment, and errors into a compressed block, but not wasteful.

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?

An output schema exists, so return values need not be restated, and annotations carry the safety profile. Combined with the enumerated outputs, explicit sibling routing, and operational limits (size, rate, payment, error), nothing an agent needs to invoke this correctly is missing.

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% with only two parameters, so the schema already documents 'code' and the 'language' enum default. The description merely acknowledges them ('accepts code (with enum defaults)') without adding format, size, or language-selection guidance beyond what the schema states. Baseline 3 applies when the schema does the heavy lifting.

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?

States a specific verb and resource ('Extracts imports, exports, classes... call edges, complexity, Halstead volume') with exact scope and enumerated languages. It explicitly distinguishes itself from the sibling audit_module_dependency_cycles by routing cross-file analysis elsewhere, so an agent can separate the two without opening either schema.

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?

Gives both a strong when-to-use ('mapping internal functions, call graph, and complexity hotspots of a source file before refactoring') and an explicit when-not with a named alternative ('for cross-file import DAGs... use audit_module_dependency_cycles instead'). This is exactly the routing guidance the dimension rewards.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint/idempotent/non-destructive, so the safety profile is covered, but the description adds real operational context: 32 KB payload cap, 60 RPM rate limit, '?demo=true' or L402 payment at 75 sats, and HTTP 400 on invalid input. It does restate 'read-only call' which the annotation already provides, but the auth/limit/error disclosure is substantive.

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?

Front-loaded with purpose and usage before operational details, and every sentence carries information. The final sentence is dense and run-on (rate limits, payment, status codes crammed together), which slightly hurts readability but not substance.

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?

An output schema and rich annotations exist, so return values and safety needn't be spelled out, and the description still covers auth, quota, payload size, and failure mode. It is complete enough for correct invocation; only the ambiguous enum attribution leaves a small gap.

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 all three parameters are already documented in the schema, giving a baseline of 3. The description adds little beyond noting enum defaults and mentions original_code, but its phrasing 'accepts original_code (with enum defaults)' is slightly misleading since the enum belongs to fuzz_strategy, not original_code.

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?

States a precise verb+resource: applying unified diffs (@@ ... @@) or SEARCH/REPLACE blocks, with the specific mechanism (sliding-window token similarity). It also names analyze_ast_symbol_graph as the sibling for the non-mutating inspection case, so an agent can route without opening schemas.

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 when-to-use: 'when healing and applying a code edit or diff that failed exact line matching due to line-number drift or whitespace differences'. It also gives an explicit when-not/alternative: use analyze_ast_symbol_graph for inspecting signatures, call trees, and complexity without modifying code.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile, and the description layers substantial extra context: 32 KB payload ceiling, 60 RPM rate limit, the demo/L402 auth paths (75 sats), and HTTP 400 behavior on invalid input. This is far beyond what the structured annotations disclose.

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 tightly packed sentences with the purpose, routing, and operational constraints front-loaded. It is dense rather than bloated, though the parenthetical rate/auth/error clauses make the second sentence quite compressed.

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?

An output schema exists so return values need not be described. Combined with stated auth, limits, and error behavior, the description is complete enough for an agent to invoke the tool correctly.

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 both parameters (modules_json and the analysis_scope enum) are already fully documented in the schema. The description only alludes to 'enum defaults' without adding format or meaning beyond the schema, so the baseline 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?

States a specific verb and resource (audit module dependency cycles), names the exact algorithm (Tarjan SCC), and enumerates the three outputs (cycles, topological build waves, blast radius). It also distinguishes itself from the sibling it is not by contrasting scope with analyze_ast_symbol_graph.

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?

Gives explicit trigger conditions ('auditing multi-file import graphs for circular cycles' or 'determining which downstream files must be re-tested after an edit') and names the alternative tool plus the condition that selects it ('for function-level symbols ... use analyze_ast_symbol_graph instead').

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive/closed-world, yet the description adds substantial operational context the annotations don't carry: 32 KB payload limit, 60 RPM rate limit, ?demo=true or L402 (60 sats) auth/payment paths, and an HTTP 400 failure mode. It doesn't detail output structure, but that is covered by the output schema, so this is strong 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?

Front-loaded with purpose before usage, alternatives, and operational limits. It is dense—three heavily packed sentences with parentheticals—but each clause carries information; the minor cost is readability rather than waste.

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?

An output schema exists, so return values need no explanation. The description covers purpose, usage, the sibling alternative, operational limits, auth/payment, and error behavior—everything an agent needs to invoke it correctly.

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 the schema already documents root_name, strictness, and sample_json fully. The description adds only marginal param meaning ('accepts sample_json with enum defaults'), which largely restates the schema. Baseline 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?

States a specific verb (compiles) and the concrete resources produced (TypeScript interfaces, Zod schemas, Pydantic v2 models, JSON Schema Draft 2020-12) from a sample JSON payload, plus the inference set (UUID, ISO-8601, email, int/float, array items). It explicitly names the sibling analyze_ast_symbol_graph as the thing it is NOT, so an agent can distinguish it without opening a schema.

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 when-to-use clause ('Use when generating static type definitions and runtime validators in TypeScript and Python from a sample JSON response') paired with an explicit alternative for the adjacent task ('for extracting existing function/class symbols... use analyze_ast_symbol_graph instead'). When, why, and the routing alternative are all present.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, non-destructive, closed-world, but the description adds operational context the annotations cannot: 32 KB payload ceiling, 60 RPM rate limit, L402 payment (75 sats) or ?demo=true fallback, and an HTTP 400 failure mode for invalid input. These are exactly the non-safety behavioral traits an agent needs before invoking.

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?

Front-loads purpose, then usage, then the alternative, then operational constraints — a sensible order with no filler sentences. It is dense and packed into few sentences, which slightly hurts readability, but every clause carries distinct 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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. The description fills the remaining gaps (cost/payment, rate limit, size limit, error behavior, sibling disambiguation), leaving nothing an agent needs in order to call it correctly.

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 the schema already documents contract_format, baseline_schema_json, and candidate_schema_json, establishing the baseline of 3. The description restates the baseline parameter name and adds a cryptic note about 'enum defaults' but does not clarify format expectations, size handling, or how auto_detect resolves — so it adds little 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?

States a specific verb (compares/detects) and precise resources (OpenAPI 3.1 specs, JSON Schemas, MCP tool manifests), and enumerates the change classes detected (removed fields, new required inputs, narrowed enums, type mutations). It explicitly distinguishes itself from the sibling compile_polyglot_type_schemas, so an agent can route correctly without opening either schema.

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?

Gives an explicit when-to-use condition (auditing contract revisions for backward compatibility before deployment) and names the alternative tool plus the condition that selects it (compiling new TypeScript/Zod/Pydantic schemas from a sample payload). Nothing about routing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, yet the description adds real operational context beyond them: size/rate limits (32 KB, 60 RPM), auth paths ('?demo=true' or L402 at 50 sats), and failure behavior (HTTP 400 if invalid). This is unusually rich disclosure for a read-only tool.

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?

Front-loaded with the core operation and outputs, followed by usage routing and operational constraints. Dense and largely waste-free, though the '(with enum defaults)' clause is mildly confusing and attached to the wrong parameter, slightly muddying an otherwise tight structure.

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?

An output schema exists, so return values need not be explained; the description instead covers scope, alternatives, limits, auth, and error behavior. For a read-only diff tool with full schema coverage, nothing an agent needs to invoke it correctly is missing.

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 the schema already documents all three parameters, making 3 the baseline. The description references 'previous_state_json' and 'enum defaults', but the enum actually belongs to conflict_strategy, so the added parameter detail is slightly imprecise rather than value-adding.

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?

States a specific verb+resource (computes structural diffs between two agent state snapshots) and enumerates the exact outputs ('added_keys', 'mutated_keys', 'removed_keys'), plus belief-contradiction flagging, RFC 7396 patch generation, and hashing. It also names the sibling it is not (plan_context_token_budget), so an agent can distinguish it without opening either schema.

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?

Explicitly states when to use it ('checkpointing agent state or transmitting minimal RFC 7396 state deltas across multi-agent handoffs') and names the alternative with the contrasting condition (token counting / Lost-in-the-Middle auditing → plan_context_token_budget). Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, non-destructive, closed-world), and the description adds genuinely new operational context: 32 KB payload limit, 60 RPM rate limit, auth options (?demo=true or L402 at 60 sats), and HTTP 400 on invalid input. That is exactly the kind of constraint info the annotations cannot carry.

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 core purpose and the routing rule are front-loaded in the first two clauses, with operational details trailing in a compact parenthetical. It is dense but largely waste-free; the parenthetical is heavily compressed to the point of being cryptic, which costs a point.

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?

With an output schema present, return values need not be re-explained, and the description still covers test coverage, inputs, auth, rate limits, size limits, and error behavior. Nothing an agent needs to invoke this tool correctly is missing.

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 the schema already explains control_json, treatment_json, and the significance_level enum with its default, giving a baseline of 3. The description adds only the ambiguous claim that "'treatment_json' defaults to 'standard'", which actually conflicts with the schema marking treatment_json as required and does not clarify parameter semantics.

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?

States a precise verb and resource ('Computes Welch's two-sample t-test or two-proportion z-test') and enumerates the exact outputs (two-tailed p-values, Cohen's d, relative lift %, Bayesian P(Treatment > Control)). It also names the sibling it is not, evaluate_deterministic_math, so an agent can route without opening either schema.

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?

Gives an explicit use case ('whether a prompt change, model benchmark, or A/B experiment produced a statistically significant improvement') and an explicit exclusion with a named alternative ('for evaluating single algebraic formulas or NPV/IRR cashflows, use evaluate_deterministic_math instead'). Both the when and the when-not are stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds substantive traits they do not carry: a 32 KB payload cap, a 60 RPM rate limit, demo/L402 (40 sats) access, and an HTTP 400 failure mode. That is meaningful operational context beyond the structured fields.

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?

Front-loaded with the purpose and tightly packed; the when-to-use, alternative, and operational constraints are all in a compact block. Slightly dense with parenthetical jargon (Shunting-Yard AST, Newton-Raphson, L402) but every sentence carries actionable 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?

An output schema exists, so return-format explanation is unnecessary, and the description covers access, limits, and error behavior. The one flaw is the contradictory precision default, which leaves the agent with conflicting guidance on an actual input parameter.

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 the baseline would be 3, but the description actively misleads: it says 'precision_digits' defaults to '2_decimals' while the schema states it 'defaults to 8_decimals when omitted.' Supplying a wrong default is worse than staying silent, so this falls below the baseline.

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?

States a specific verb ('Evaluates') and enumerates concrete resource classes: algebraic/scientific formulas, financial NPV/IRR, Kelly criterion, and dataset stats. It explicitly names the sibling it is not (evaluate_ab_statistical_significance) so an agent can distinguish it without opening either schema.

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?

Gives an explicit when ('exact arithmetic formulas, cashflow NPV/IRR, or descriptive statistics without LLM floating-point guesswork') and an explicit when-not with the alternative ('for two-sample A/B hypothesis tests... use evaluate_ab_statistical_significance instead'). This is exactly the routing information an agent needs.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive/closed-world, yet the description adds material context beyond them: a 32 KB payload ceiling, a 60 RPM rate limit, the auth paths ('?demo=true' or L402 at 65 sats), and the HTTP 400 failure mode for invalid input. These are exactly the operational facts an agent needs and that annotations cannot express.

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?

Purpose and the sibling exclusion are front-loaded, which is correct. The final sentence is a dense parenthetical cramming size, rate limit, auth, and error code together, so it is efficient but slightly overpacked rather than perfectly clean.

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?

With an output schema present, the description needn't describe return values, and it covers the remaining gaps an agent would care about: input size limit, throughput, payment/auth requirement, and failure behavior. Nothing needed to invoke the tool correctly is missing.

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% and both parameters carry their own descriptions plus a default, so the schema already does the heavy lifting. The description only restates that 'schema_or_signature_json' accepts enum defaults, adding little semantic depth beyond the structured fields; baseline 3 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?

States a specific verb ('Synthesizes') and a precise resource ('deterministic unit-test vectors from a JSON Schema or function signature'), and enumerates the coverage classes (equivalence partitions, numeric/length boundaries, adversarial Unicode/null). It also explicitly distinguishes itself from the sibling apply_fuzzy_code_patch, so an agent can route without opening a schema.

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?

Gives an explicit when-to-use clause ('generating exhaustive edge-case unit test payloads and fuzz vectors for an API endpoint or function') and a when-not-to-use clause that names the alternative tool ('for healing and applying unified diffs ... use apply_fuzzy_code_patch instead'). No inference required.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), but the description adds operational facts beyond them: a 32 KB payload cap, 60 RPM rate limit, L402 payment (50 sats), a ?demo=true escape hatch, and an HTTP 400 failure mode. It also confirms runtime_hint defaults to auto_detect. This is meaningful operational context layered on top of the annotations.

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?

Front-loaded with the core action, then usage, then operational constraints. It is dense but every clause carries information; the final sentence packs rate/payment/error details that are slightly terse but still earned.

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 an output schema exists and annotations are rich, the description covers supports-languages, input constraints, auth/payment modes, and error behavior. Return values are correctly left to the output schema. Only minor gaps remain around size-exceeded or rate-limited recovery guidance.

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% and both parameters are documented in the schema, so the description only restates the runtime_hint default (already in the schema) and adds no syntax or format guidance for raw_log. Baseline 3 is correct when the schema does the heavy lifting.

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?

States specific verbs and resources: parses CI/terminal logs and multi-language stack traces, strips node_modules/stdlib frames to isolate the innermost failing user-code frame, and clusters logs into Drain templates. It explicitly distinguishes itself from prune_context_skeleton, so an agent can route without opening either schema.

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?

Gives explicit when-to-use (triage-debugging test failures, crash dumps, repetitive server error logs) and names the alternative for the adjacent-but-different task (compressing source/prose → prune_context_skeleton). Both the selection condition and the exclusion are stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations declare the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), and the description adds substantial operational context on top: a 32 KB payload cap, a 60 RPM rate limit, the '?demo=true' or L402 (30 sats) access path, and HTTP 400 on invalid input. That is exactly the kind of constraint detail annotations cannot carry.

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 purpose is front-loaded and every clause carries information (capabilities, triggers, alternative, constraints, error code). It is a dense semicolon-chained run-on, however, so the when-to-use versus when-not split reads less cleanly than it could.

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?

An output schema exists so return values need no explanation, and annotations cover the safety profile. The description fills the remaining gaps — access modes, rate/size limits, failure behavior, and the sibling boundary — so an agent has everything needed to invoke it correctly.

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 the schema already documents all three parameters and their defaults, making 3 the baseline. The description only restates that segments_json is accepted 'with enum defaults', adding almost nothing beyond the schema text.

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?

Names three concrete operations (counting subword BPE tokens across segments, detecting instructions in the 35%–72% attention trough, computing USD/satoshi costs across frontier LLMs) with a clear verb+resource structure. It also explicitly distinguishes itself from the sibling prune_context_skeleton, so an agent can route without opening either schema.

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?

Gives explicit when-to-use triggers ('auditing prompt token budgets, reordering prompt sections for primacy/recency attention, or comparing model API costs') and an explicit when-not with the named alternative ('for actively compressing and stripping low-salience lines from a single large file, use prune_context_skeleton instead'). No inference required.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnly/idempotent/non-destructive annotations, the description discloses the compression magnitude, the 100% preservation guarantee, a 32 KB call size and 60 RPM rate limit, payment options (?demo=true or L402 at 50 sats), and the HTTP 400 failure mode. This is substantial behavioral context the annotations do not carry.

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?

Front-loaded with purpose, then usage and alternatives, then operational constraints. Every clause carries information, though the final sentence is densely packed with limits and auth details. Efficient and well-ordered overall.

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?

An output schema exists, so return values need not be described. The description covers purpose, sibling routing, resource limits, authentication, and error behavior, leaving no material gap for correct invocation.

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 the parameters are fully documented in structured data and the baseline is 3. The description only restates 'content' and alludes to enum defaults without adding semantics the schema lacks. No compensation is required, but no value is added either.

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?

States a specific verb (compresses) and resource (source files, logs, transcripts) with a concrete outcome (50–80% reduction while preserving signatures, imports, error frames). It explicitly distinguishes itself from the sibling plan_context_token_budget, which does token counting without altering text. An agent can identify the tool's function without opening the schema.

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?

Gives an explicit when-to-use condition ('shrinking oversized source files or logs before feeding them into an LLM prompt') and names the alternative with the contrasting condition (counting BPE tokens/costs without altering text). Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only/idempotent/non-destructive, but the description adds real extra context: 32 KB payload cap, 60 RPM rate limit, auth path (demo=true or L402 at 50 sats), and HTTP 400 on invalid input. These operational constraints are not encoded anywhere else.

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?

Front-loads the algorithm and pipeline purpose, then usage routing, then operational constraints — good ordering. It is dense and jargon-heavy (k1, b, RRF, MMR, L402), but nearly every clause carries actionable 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?

With an output schema and rich annotations present, the description needn't explain return values, and it covers scope, routing, rate limits, and auth. The only gap is the inaccurate 'documents_json defaults to standard' note, which contradicts the required-parameter declaration and could confuse an agent.

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%, so the schema already documents all four parameters, including the ranking_mode enum and top_k default. The description adds little beyond algorithm context, and its stray claim that 'documents_json defaults to standard' conflicts with the schema marking it required, which could mislead.

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?

States a specific verb+resource ('reranks and deduplicates candidate RAG or search chunks') and names the exact algorithmic pipeline (BM25, RRF, MMR). It explicitly differentiates from the sibling prune_context_skeleton, so an agent can select it without opening either schema.

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?

Provides an explicit when-to-use ('selecting top-K highest-signal, non-redundant passages from vector search or grep results') and a when-to-use-otherwise routing to prune_context_skeleton for the contiguous-file case. Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered; the description goes further with operational context: 32 KB payload cap, 60 RPM rate limit, ?demo=true, L402 pricing (80 sats), and HTTP 400 on invalid input. It does not state whether the payment path or demo mode changes results, a minor 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?

Front-loaded with the core purpose, then usage routing, then operational constraints in a single dense sentence. It is information-packed and every clause earns its place, though the trailing parenthetical cramming rate limit, payload size, payment, and error codes is a bit dense.

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?

An output schema exists, so return values need not be explained, and the description covers purpose, routing, cost/auth, and limits. The one gap is the contradictory default for 'time_unit', which leaves an agent unsure of the effective default when the field is omitted.

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%, so the baseline would be 3, but the description actively misleads: it says 'time_unit' defaults to 'minutes' while the schema states it 'defaults to hours when omitted.' That is a direct conflict on the default value, which is exactly the kind of detail an agent would rely on when omitting the parameter.

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?

States a specific verb (solves) plus resource (task dependency DAG) and enumerates the concrete outputs (ES/EF/LS/LF, float, makespan, critical path). It explicitly names the sibling it is not (audit_module_dependency_cycles), so an agent can separate the two without opening schemas.

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?

Gives an explicit when-to-use trigger ('scheduling dependent engineering milestones or workflow steps to find the minimum project duration and zero-slack bottleneck path') and an explicit when-not with the named alternative for durationless import/blast-radius analysis. Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), yet the description adds substantial operational context beyond them: deterministic/reproducible seeding, a 32 KB payload cap, a 60 RPM rate limit, auth via ?demo=true or L402 (70 sats), and an HTTP 400 failure mode for invalid input.

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?

Purpose and output list are front-loaded, followed by routing guidance, with operational details last. The final sentence is dense, packing rate limit, auth, payment, and error handling into one line, but each clause conveys useful information so little is wasted.

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?

With an output schema present, return values need not be explained, and the description covers the remaining gaps: reproducibility, limits, payment path, and error condition. For a two-parameter, well-annotated simulation tool, nothing an agent needs to invoke it correctly is missing.

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 both parameters are already documented, making 3 the baseline. The description only restates that variables_json carries 'enum defaults' and adds nothing about distribution_model meaning or format that the schema does not already convey.

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?

States a specific verb (runs a simulation) and resource (seeded Mulberry32 Monte Carlo over uncertain cost/latency/duration variables), and names the concrete outputs (P10/P50/P90/P95, VaR, CVaR). It also names the sibling it is not (evaluate_deterministic_math), so an agent can distinguish it without opening schemas.

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 when-to-use ('modeling stochastic uncertainty, tail risk, probability of meeting a budget or SLA target') and an explicit exclusion with an alternative ('for evaluating deterministic single-point algebraic formulas or exact NPV/IRR cashflows, use evaluate_deterministic_math instead'). The routing decision is fully specified.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.