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

No annotations are supplied, so the description carries the full burden, and it omits whether the operation mutates or only reads the file, whether 'authorized' is an enforced check or just a caveat, and any cost or performance characteristics of string scanning. The enumerated output fields are the only real behavioral disclosure, and the absence of an output schema makes that useful but insufficient for an unannotated 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?

A single front-loaded sentence with no filler; the output enumeration is compact. It is efficient, though it spends its one sentence on scope and outputs rather than on the gaps (parameters, read-only nature) that matter more.

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 no annotations and no output schema, the description's list of returned metadata partially substitutes for a return spec, which is a real contribution. But an unannotated two-parameter tool with 0% schema coverage leaves the agent without path requirements, mutation semantics, or parameter behavior, so it is only minimally complete.

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 0% for two parameters, and the description never mentions romPath or maxStrings, so it adds no meaning about path constraints, supported ROM extensions, or what maxStrings caps. 'String metadata' hints vaguely at the string parameter but gives no units, defaults, or the 1000 upper bound implications.

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 ('Analyze') and resource ('authorized local N64 ROM') and enumerates the produced metadata (format, region, entrypoint, checksum, code regions, strings), which is far more informative than the name alone. It does not, however, distinguish itself from close siblings such as rom_inspect, rom_identify_format, or rom_find_code_regions, whose names suggest overlapping output.

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 phrase 'authorized local' implies a precondition (legitimate, on-disk input) but there is no explicit when-to-use versus when-to-use-a-sibling guidance despite many overlapping ROM tools. The agent must infer that this is the broad metadata sweep and that narrower tools exist.

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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the 16-bit PCM WAV output and the N64 codebook refusal behavior, but it does not explain write gating, dry-run defaults, overwrite behavior, or what apply=true actually changes.

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 tight sentences with no wasted wording. The core purpose is front-loaded, and the important N64 caveat follows immediately.

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?

It covers the core decoding behavior and the N64 prerequisite well, which is important for correct invocation. However, with no output schema and no annotations, it leaves the write/apply behavior and output return semantics less explicit than ideal.

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 path, apply, format, and outPath. The description adds some context by naming the supported formats and the N64 codebook requirement, but it does not deepen parameter semantics beyond what the schema provides.

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 states a specific verb and resource: decode PS2 VAG/VAGi or N64 AIFC VADPCM files to 16-bit PCM WAV. It clearly distinguishes the supported formats and output type, though it does not explicitly differentiate from close siblings such as audio_decode_vag_block or audio_inspect.

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?

Usage is implied by the decode-to-WAV purpose and by the N64 prerequisite requiring the file's own VADPCMCODES codebook. However, there is no explicit when-to-use guidance, when-not-to-use guidance, or routing to alternatives like audio_inspect or audio_decode_vag_block.

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?

With no annotations, the description must carry the full behavioral burden, and it does add real substance: exact input size (16 bytes) and exact output cardinality and format (28 linear 16-bit PCM samples), which an agent could not infer otherwise. It says nothing about error handling for malformed hex, whether the block header/predictor/scale byte is parsed, or whether decoding is deterministic across blocks (state carried between blocks).

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?

One sentence, front-loaded with the action and resource, with zero redundant wording. The input size and output size/format are packed into the same clause rather than spread across filler text.

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 one-parameter primitive with no output schema, the description supplies nearly everything needed to call it correctly, including the return value's size and sample format. The only missing piece is failure behavior on invalid or mis-sized hex input, plus whether block-to-block predictor state matters for producing correct audio.

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 single parameter is already documented, which sets the baseline at 3. The description adds a modest constraint by fixing the expected length at 16 bytes, implying 32 hex characters, but it does not clarify accepted formatting (whitespace, 0x prefix, endianness of the block).

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 states a precise verb (decode) plus the exact resource (a 16-byte Sony PS2 VAG ADPCM block) and even the output shape (28 linear 16-bit PCM samples), which is far more specific than the name alone. It implicitly distinguishes itself from the file-level sibling audio_decode_file by scoping strictly to one block, but it never names that alternative or states the distinction explicitly.

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?

There is no when-to-use or when-not-to-use guidance. An agent cannot tell from the text whether this is the right tool for decoding a VAG stream (versus audio_decode_file or audio_inspect) or only for block-level work inside a decoding loop, and no prerequisites or alternatives are mentioned.

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?

No annotations are supplied, so the description carries the full burden. "Inspect ... to detect" reasonably implies a non-mutating read, and the enumerated formats tell the agent what inputs are accepted. However, it never explicitly states that the file is not modified, what happens on an unrecognized or malformed container, or whether detection can partially fail (e.g., compression identified but rate unknown).

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?

One sentence, front-loaded with the verb and resource, with the format list and extraction targets packed in without filler. Every clause carries information the agent needs; nothing is restated from the schema.

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 one-parameter inspection tool this is close to sufficient: supported formats and the reported properties (sample rate, channels, compression) are stated, which effectively describes the result in the absence of an output schema. The remaining gap is behavior on failure or unsupported containers, which matters because there is no annotation coverage at all.

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?

There is a single required parameter (path) with 100% schema description coverage ("Path to audio file in workspace"), so the schema already does the documentation work. The description adds no meaning about the path beyond the schema — nothing about workspace-relative versus absolute paths, or extension expectations for the three format families. 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?

The description pairs a specific verb ("Inspect") with a specific resource ("audio asset file") and enumerates the supported container formats (PS2 VAG, N64 bank, raw ADPCM) plus the attributes it extracts (sample rate, channels, compression). An agent can tell this is a metadata probe rather than a decoder. It stops short of naming the decode siblings (audio_decode_file, audio_decode_vag_block), so the inspect-vs-decode boundary is only inferable from the verb.

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?

There is no statement of when to reach for this tool versus alternatives. The adjacent tools audio_decode_file and audio_decode_vag_block are obvious candidates for the same input, and nothing here says whether to inspect first, whether inspection is a prerequisite for decoding, or what to do with an unrecognized format. The purpose implies a use case, but no explicit routing guidance is given.

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?

With no annotations, the description carries the burden alone. It does disclose a genuine behavioral trait, the policy of refusing console-specific instructions by default, but omits that the tool can write a .bin artifact to a workspace path only under a gated apply flag, and says nothing about the returned format.

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 tight sentences with the operation front-loaded and the refusal policy as a secondary clause. No filler or repetition of the tool name.

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?

No output schema and no annotations, so the description must stand in for behavior, and for a narrow translation utility it covers the core operation and the main safety behavior. The write/artifact path is left entirely to the schema, which is a modest gap but not a blocking one.

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 67%, so most parameters are already documented structurally. The description only indirectly maps to allowUnsupported and adds nothing about hex input format or that sourcePlatform/targetPlatform are constrained enums, leaving the two undescribed enums unmentioned.

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 a specific verb and resource ('Translate ... MIPS words') plus an explicit scope ('between N64 and PS2 endian representations'), which separates it from siblings like mips_disassemble or port_validate_translation. It stops short of naming any alternative tool, so it is clear but not fully differentiated.

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?

Usage is only implied: the agent must infer this is the tool for endian conversion of MIPS words rather than disassembly or validation. The clause 'unless explicitly allowed' hints at the allowUnsupported escape hatch but gives no when-not conditions or pointer to sibling tools for related tasks.

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?

With no annotations supplied, the description carries the full load, and it does disclose the key trait that nothing is executed and that safety warnings are surfaced. It stops short of describing scope limits (e.g., manifest formats recognized, what happens when no manifest exists, whether it recurses) or the shape of the report.

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?

One sentence, front-loaded with the verb and resource, with the output categories listed compactly. No filler or repetition of the tool name.

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 read-only tool with one optional parameter and no output schema, the description covers what is inspected and roughly what is reported. The main residual gap is the return format, which the absence of an output schema leaves partially unspecified.

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?

There is a single optional parameter whose schema description already states the default ('defaults to the configured workspace'), and schema coverage is 100%. The description adds no extra meaning about path resolution or behavior for that parameter, so the 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?

The description names a specific verb and resource (inspect build manifests) and enumerates what gets reported: build systems, scripts, targets, toolchain hints, safety warnings. The clause 'without executing commands' implicitly separates it from the sibling build_run, though it never names that sibling.

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 read-only, non-executing framing tells the agent this is the safe inspection option, which implies when to prefer it over build_run. However, there is no explicit when-to-use or when-not-to-use statement, and no guidance about relationship to look-alikes such as toolchain_probe or decomp_config_inspect.

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?

With no annotations, the description carries the full burden; it does disclose useful safety context — an allowlisted runner and a confirmation/write-gate requirement. It stops short of saying what the build mutates, whether it overwrites workspace state, how long it runs, or what a failure looks like.

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 short sentences with the action first and the gating requirements second — no filler. Slightly denser phrasing ('existing allowlisted build runner', 'RETRACE_ALLOW_WRITE=1') assumes knowledge but is efficient.

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 side-effecting build tool with no annotations, no output schema, and zero schema description coverage across four parameters, the description is too thin. It never explains what portPath expects, what args are passed to, or what the caller gets back.

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 0% for four parameters, and the description only alludes to 'confirm' without explaining its semantics. portPath, command (the make/cmake enum), and args are entirely undocumented in both the schema and the description, leaving the agent to guess.

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: building a PS2 port workspace via an existing allowlisted build runner. It does not, however, distinguish itself from siblings like build_run, build_analyze, or package_ps2_iso, which an agent could easily confuse with this one.

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?

It gives real preconditions (explicit confirmation, RETRACE_ALLOW_WRITE=1) that imply when this is callable, but it never says when to prefer it over build_run or other build-related siblings, nor what happens if confirmation is missing.

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?

No annotations are supplied, so the description carries the full safety burden and does it well: it discloses shell:false execution, workspace-bound cwd, a timeout, rejection of shell metacharacters, an environment gate, and an explicit confirm flag. It does not say what happens on failure or whether output is captured, keeping it short of a 5.

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 dense sentences with the safety constraints front-loaded and zero filler; every clause carries a distinct constraint an agent must respect before calling.

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 an execution tool with no annotations and no output schema, safety and eligibility are covered thoroughly. The gap is result behavior: with no output schema present, the description should say what a run returns (stdout/stderr, exit code, timeout behavior) so the agent knows how to consume the call.

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 80% and the enum plus descriptions already document command, args, cwd, and confirm, so the baseline is 3. The description reinforces the invariants (allowlisted tool, cwd constrained to workspace, restricted argument characters) but adds no syntax or default details 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?

Specific verb+resource: 'Run one allowlisted build command' plus the isolation model (shell:false, workspace-bound cwd). It does not explicitly contrast itself with sibling build tools like build_analyze or build_ps2, so the agent must infer that this is the raw execution tool.

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?

Given eligibility conditions (RETRACE_ALLOW_WRITE=1, confirm=true) and an implied one-command-per-call scope, which is useful when-to-use guidance. However, it never states when to prefer this over build_analyze or build_ps2, nor when not to use it, so alternative selection 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?

No annotations exist, so the description carries the full burden, and it does disclose the verdict vocabulary (exact|structural|probable|unknown) and a conservative-evidence guarantee that it never claims confirmed equivalence. However, it does not explain what distinguishes 'structural' from 'probable', what happens when inputs are mismatched or unreadable, or anything about cost or determinism.

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 written sentences with the comparison scope front-loaded and the return-value contract following. Nothing is redundant or padded.

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?

This is a complex tool: two nested objects with three mutually exclusive input modes (hex bytes, ELF path + symbol, path + address + size), two undocumented stack-frame parameters, and no output schema. The description covers only the verdict vocabulary and omits input-mode selection, architecture/endian requirements for raw hex, and what the stack-frame parameters do.

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 50% and the description adds no parameter-level meaning at all beyond the reference/candidate framing already present in the schema's property descriptions. The two stackFrameTarget/stackFrameCandidate parameters are undocumented in both the schema and the description, so an agent has no basis for supplying them.

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 states a specific verb and resource (compare two functions) plus the discriminating mechanism: comparison across N64 R4300i and PS2 R5900 by canonical instruction shape. That mechanism separates it from nearby siblings like diff_function or compare_rank without naming them, though no sibling is explicitly contrasted.

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?

Usage is implied by the architecture pairing ('across N64 and PS2') and by the two objects being labeled reference vs candidate in the schema, so an agent can infer this is a cross-architecture matching tool. There is no explicit when-not guidance, no mention of how it relates to equivalence_record or diff_function, and no prerequisites 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?

No annotations are supplied, so the description carries the full behavioral burden and does not meet it. It does not say whether results are sorted by descending similarity, what the similarity score looks like or its range, whether the limit truncates the candidate list before or after ranking, or how file/address resolution errors are surfaced.

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?

A single front-loaded sentence with no filler; the purpose is stated immediately. The brevity is efficient but tips into under-specification given the complexity of the input shape.

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?

This is a nested-object tool with two composite inputs, up to 200 candidates, no annotations, and no output schema. The description says nothing about the ranking output or scoring semantics, which is the primary value an agent needs, so it is thin relative to 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?

Top-level schema coverage is 0%, but the description does supply the key semantic mapping the schema lacks: `target` is the reference and `candidates` are the functions being ranked against it. Nested fields like hex/path/symbol/address are self-documented in the schema, but `limit` gets no explanation of default or ordering effects, which is a remaining gap.

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 (rank), the resources involved (candidate functions against a reference), and the metric (canonical instruction-shape similarity). An agent can tell this is a similarity-scoring tool rather than a byte-level diff, but the description never names the close siblings compare_functions or diff_function to sharpen the distinction.

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 on when to reach for this over compare_functions, diff_function, or rom_compare, and no prerequisites such as whether candidates must share an architecture with the target. The agent must infer usage purely from the name and the one-line purpose.

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?

No annotations are supplied, so the description carries the full burden. It adds real value by disclosing the internal steps (parsing PC/RA/SP/BadVAddr, symbol correlation) and signaling that output is heuristic ('formulates hypotheses'), which tells the agent results are probabilistic. However it says nothing about safety, side effects, performance/rate characteristics, or what happens if symbols are missing.

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?

A single sentence with the resource and the processing steps front-loaded; nothing is wasted. The compressed register list is dense but readable and earns its space by telling the agent what log content is expected.

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 two-parameter, annotation-free analysis tool with no output schema, the description covers inputs, processing steps, and the qualitative nature of the output, which is enough for an agent to decide to call it. The main gap is prerequisites and result format, but those are secondary for a diagnostic/read-style 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 description coverage is 100%, so both parameters are already documented, and the enum on arch constrains values. The description adds modest meaning by spelling out which register fields it looks for in logText and by naming the two emulator families that map to the arch enum. That is baseline-level added context.

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 a specific resource (crash log / register dump from PCSX2 or N64 emulators) and specific verb (analyze, parse registers, correlate symbols, formulate hypotheses). This clearly separates it from static-analysis siblings like mips_disassemble or analyze_n64_rom, though it never names those alternatives explicitly.

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?

Usage is implied by the input type: an agent holding a crash dump or register dump knows this is the tool. There is no explicit when-not guidance, no mention of prerequisites (e.g., that symbols must be available for correlation), and no pointer to siblings for related tasks.

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?

With no annotations, the description carries the full disclosure burden. 'Guarded' implies safety constraints but never says what is guarded (dry-run by default? overwrite protection? path validation?), whether files are written to disk, or what permissions are needed. For a scaffold-generating (likely write) operation this is a significant 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?

It is a single short sentence with no wasted clauses, which is good. However the front-loaded phrase 'Alias with an explicit pipeline name' spends the most prominent position on naming trivia rather than on what the tool produces.

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?

No annotations, no output schema, and 0% parameter documentation mean the description is the only source of behavioral information, and it supplies almost none. For a tool that generates a project scaffold on disk, it should at minimum describe the apply/dry-run behavior and the resulting directory layout.

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 0% across three parameters, and the description explains none of them. In particular the 'apply' boolean is undocumented anywhere, leaving the agent to guess whether it toggles dry-run versus actual writes; only the vague word 'guarded' gestures at that 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?

The description names a verb+resource ('generating the guarded PS2SDK project scaffold'), but frames the tool as an 'alias' without saying what it aliases (presumably the sibling generate_ps2_project) or how the two differ. An agent can guess the general domain but cannot tell why this alias exists or when its behavior diverges from the non-aliased tool.

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 when-to-use guidance is given, and the obvious alternative, generate_ps2_project, is never mentioned despite being a sibling. 'Explicit pipeline name' hints at a pipeline-oriented use case but does not state the condition that should select this tool over its sibling.

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?

With no annotations supplied, the description carries the full burden. It does disclose the write-gating environment variable, which is genuinely useful auth-style context, but says nothing about what gets overwritten, whether a backup is made, whether the write is atomic, or what happens if the file is invalid.

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 short sentences with the action front-loaded and the precondition second; nothing is wasted. It is arguably too terse for a write operation, but nothing qualifies as padding.

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 mutation tool with no annotations and no output schema, the description covers the verb, target, and gating env var, and the schema covers all parameters. It stops short of the things an agent most needs before writing: overwrite semantics, failure behavior, and how the 'approved proposal' relates to the propose/validate siblings.

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?

All four parameters are documented at 100% schema coverage, so the baseline is 3. The description adds no meaning beyond the schema — it does not explain the relationship between address and symbolName or clarify the apply-confirmation flag beyond what the schema already states.

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 gives a specific verb ('Apply') and resource ('decompilation configuration file') plus the object of the write ('an approved modification proposal'), which separates it from decomp_config_inspect/validate/propose_changes by implying this is the commit stage. It never names those siblings explicitly, so differentiation relies on the reader inferring the workflow.

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 phrase 'approved modification proposal' implies the propose/validate steps must happen first, and the RETRACE_ALLOW_WRITE=1 line states a concrete precondition. However, no sibling is named as the required predecessor, and there is no guidance on when not to use it or what to do if the proposal is unapproved.

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?

No annotations are supplied, so the description carries the full behavioral burden, yet it says nothing about whether the file is modified, how errors are surfaced for a missing or malformed file, or what the inspection returns. Listing the extracted entities (functions, segments, symbols) is the only behavioral hint, and it is thin for a tool with zero annotation coverage.

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?

A single front-loaded sentence that identifies the action, the target, the accepted formats, and the extracted content with no wasted wording.

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 single-parameter read tool with no output schema, the description states what it reads and what it extracts, which is adequate. But with no annotations and no output schema, an agent still lacks the read-only guarantee and the shape of the result, leaving a meaningful 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?

The schema provides 100% description coverage for the single 'path' parameter, so the baseline is 3. The description only loosely enriches this by naming the accepted file formats (YAML, JSON, splat), which mildly adds meaning to what a valid path might contain.

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 names a specific verb ('Inspect') and resource ('decompilation configuration file'), and enumerates the supported formats (YAML, JSON, splat) plus what is extracted (functions, segments, symbols). It does not, however, distinguish itself from the sibling decomp_config_validate, which an agent could easily confuse it with.

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?

There is no explicit guidance on when to use this versus decomp_config_validate, decomp_config_propose_changes, or decomp_config_apply_changes, nor any stated prerequisites. The verb 'Inspect' implies a read-only action, but the agent is left to infer the division of labor among the four config siblings.

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?

With no annotations, the description carries the full behavioral burden. It usefully signals that the operation is non-committal and that the output is a unified diff, but 'safe' is unsubstantiated: it does not say whether anything is written to disk, whether the proposal is persisted, what permissions are needed, or what happens on error.

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?

A single front-loaded sentence that names the action, the safety posture, and the verification artifact with no filler. Only the vague qualifier 'safe' slightly dilutes it.

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 three-parameter config-mutation proposal with no annotations and no output schema, the description covers the intent and the returned diff but leaves the write semantics, error behavior, and relationship to the apply step undocumented. Adequate but with clear gaps.

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 (path, symbolName, address) are already documented in the schema. The description adds no format or constraint detail beyond that, so the baseline of 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?

The description states a specific verb ('Prepare a safe proposed modification'), the resource ('decompilation config'), and the deliverable ('inspect the unified diff'). This clearly separates it from decomp_config_apply_changes and decomp_config_inspect even though no sibling is named explicitly.

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 phrase 'before applying' implies the propose-then-apply workflow and positions this as the preview step ahead of decomp_config_apply_changes, but that ordering is inferred rather than stated. It gives no guidance on when to prefer this over decomp_config_validate or decomp_config_inspect, nor any exclusions.

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?

No annotations are provided, so the description carries the full behavioral burden. It does not state that validation is read-only/non-mutating, does not say whether it returns a boolean, an error list, or throws, and does not describe severity levels or partial-validation behavior. Only the broad notion of 'syntax and structure' checking is conveyed.

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?

A single sentence with no filler, and the verb and target are front-loaded. Its brevity comes at the cost of missing detail rather than being padded, which is the right trade-off for this dimension.

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 validator with no annotations and no output schema, the description should say what a result looks like and what counts as valid, since the agent has no structured field to fall back on. Neither the return contract nor the validation scope beyond 'syntax and structure' is supplied, leaving a meaningful 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?

With one parameter at 100% schema description coverage, the schema already documents 'path' as the configuration file location. The description adds nothing about path constraints (must exist, absolute vs relative, must be a decomp config rather than arbitrary file), so 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 (validate) and resource (decompilation configuration file) with the scope of validation limited to syntax and structure. It is distinguishable from the mutation siblings decomp_config_propose_changes and decomp_config_apply_changes, but it never explicitly contrasts itself with decomp_config_inspect, which covers similar ground.

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?

There is no when-to-use guidance: nothing says to run this before propose/apply changes, whether it must be run on a file produced by decomp_config_inspect, or what to do on failure. The agent must infer the workflow position of this tool from the name alone.

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?

No annotations exist, so the description carries the full burden. It usefully discloses the return shape ('candidate C plus raw diagnostics') and a key caveat that candidate output must not be treated as recovered source, which is genuinely valuable context. It omits other behavioral facts an agent needs with zero annotation coverage: whether files are written, whether an external m2c binary must be installed, failure/timeout behavior, and permissions.

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 action and result, followed by the critical caveat. No filler or redundant restatement of the tool name.

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 no annotations, no output schema, and three undocumented parameters, the description should do more. It covers the output nature and the interpretive caveat well, but leaves the address and cwd parameters and the external tool dependency completely unexplained, which is a material gap for a decompilation 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 description coverage is 0% and the description mentions no parameters by name. Only 'assembly file' loosely maps to assemblyPath; the address and cwd parameters are entirely undefined in both the schema and the description, so the agent must guess their format and role.

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 names a specific verb and engine ('Run m2c over an assembly file') and states the output ('candidate C plus raw diagnostics'), which distinguishes it from disassembly siblings like mips_disassemble. It does not explicitly contrast with the closest siblings (mips_reconstruct_function, mips_analyze_function), so it stops short of a 5.

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 phrase 'authorized assembly file' implies a prerequisite (only run on files you are permitted to analyze) and the m2c reference implies when the tool applies. However, there is no explicit when-to-use/when-not guidance and no routing to alternative tools such as mips_disassemble or mips_reconstruct_function, leaving selection 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?

With no annotations, the description carries the full behavioral burden. It does disclose something meaningful beyond the name: the comparison runs through an 'internal canonical diff engine' and returns an 'unverified' match level, warning the agent that results are not a proof of equivalence. It stops short of explaining the match-level scale, determinism, or failure behavior.

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?

A single dense sentence with the core action front-loaded and no filler. It could have used the remaining space to document parameters rather than stopping where it does, but nothing 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?

For a 5-parameter tool with no annotations and no output schema, the definition is thin: the 'unverified match level' return value has no shape given, address parameters are unexplained, and the enum values for arch (r4300i/r5900) are only in the schema without context on why they matter.

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 0% across 5 parameters, so the description must compensate. It only implies that targetHex/candidateHex are hex byte strings of a function and that the domain is MIPS, leaving arch, targetAddress, and candidateAddress—and any format expectations for the hex strings—completely unexplained.

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 states a concrete verb+resource: 'compare two MIPS function byte strings', and even names the output ('an explicit unverified match level'). It does not, however, distinguish itself from closely related siblings such as compare_functions, compare_rank, or rom_compare, which an agent could easily confuse with this tool.

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?

There is no guidance on when to use this versus compare_functions or compare_rank, no mention of prerequisites (e.g., needing disassembled function bytes first), and no exclusions. The agent must infer selection criteria purely from the name.

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?

No annotations are supplied, so the description carries the full burden, and it discloses almost nothing: not whether the lookup uses symbol tables or heuristics, not what happens when the address falls inside a function versus at its entry, and not what is returned. Only the read-only nature is implied by 'locate'.

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?

A single tight sentence with no filler, and the key qualifier (by virtual address, PS2 ELF) is front-loaded. It is efficient but so terse that it omits information the tool needs.

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 no annotations and no output schema, the description should explain what a successful lookup yields (function name, bounds, symbol entry) and how failure is signaled. For a binary-analysis lookup tool, omitting the return shape leaves a significant 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% and the schema already explains both 'path' and the hex-or-integer 'address' format. The description adds no semantic detail beyond restating that the address is virtual, so 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 and resource: locate a function by virtual address in a PS2 ELF binary. The address-based lookup distinguishes it implicitly from symbol-listing siblings like elf_list_symbols, but it never names an alternative, so differentiation is inferred rather than stated.

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?

There is no explicit when-to-use guidance, no preconditions, and no mention of alternatives such as elf_list_symbols or mips_analyze_function. An agent must guess that this is the right tool when it already holds a virtual address.

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?

No annotations are supplied, so the description carries the full burden. It does disclose the output shape (header, machine type, entry point, section count, segment count) and read-only behavior is implied by 'Inspect', but it says nothing about failure modes for non-ELF input, whether the path is workspace-relative, or any side effects.

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?

One front-loaded sentence with the verb, the target, and the returned fields; no filler, no 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?

With no output schema and no annotations, the description compensates well by naming the fields returned, and the single required parameter is fully documented in the schema. It stops short of explaining behavior on malformed or non-MIPS binaries, which is the remaining gap for a file-inspection 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?

There is a single parameter with 100% schema description coverage ('Path to ELF binary in workspace'), so the schema already carries the semantics. The description adds nothing about path resolution or accepted forms, which is acceptable at this coverage level but not additive.

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 (Inspect) and resource (PlayStation 2 or MIPS ELF executable) and enumerates exactly which facts are surfaced. It implicitly separates itself from sibling listers like elf_list_sections and elf_list_symbols, but never names them, so the differentiation is left for the agent to infer.

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?

Usage is only implied: the agent can guess this is the first-pass orientation call before elf_list_sections, elf_find_function, or mips_disassemble. There is no explicit when-to-use, when-not-to-use, or mention of an alternative tool.

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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the return payload (addresses, sizes, permissions), but says nothing about whether the file must be a valid PS2 ELF, what happens on a non-ELF or non-PS2 input, or whether the operation is purely read-only.

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?

A single front-loaded sentence with zero filler; the target platform, resource, and returned fields all appear immediately. Nothing could be removed without losing 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 single-parameter read tool with no output schema and no annotations, the description covers what it does and what it returns, which is close to sufficient. The only real gap is failure behavior on invalid or non-PS2 ELF inputs.

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?

There is one parameter with 100% schema description coverage ('Path to ELF binary'), so the schema already documents it fully. The description adds no extra meaning about path format, relative vs absolute paths, or validation, so 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?

The description gives a specific verb ('List') and resource ('sections') scoped to a PlayStation 2 ELF binary, which distinguishes it from elf_list_symbols and elf_inspect by resource type. It stops short of explicitly naming those siblings as alternatives, but the resource is unambiguous.

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?

Usage is only implied: an agent can infer it should call this when it needs section layout, but the description never states when to prefer it over elf_inspect or elf_list_symbols, nor any prerequisites. No exclusions or alternatives are offered despite several closely related ELF tools in the sibling list.

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?

With no annotations supplied, the description carries the full behavioral burden; "List" does imply a read-only enumeration, and naming both .symtab and .dynsym is genuinely informative about what is scanned. It does not disclose what the output looks like, how stripped binaries or missing symbol tables are handled, or whether results are ordered or limited.

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?

A single front-loaded sentence with no wasted words, and the key scope (which symbol tables) comes early. Brevity here borders on under-specification rather than padding.

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 two-parameter read-only listing tool with no output schema and no annotations, the description covers the essential purpose and data source. The remaining gaps—output shape and the kind filter—are modest for a tool of this simplicity.

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 both path and the kind enum are already documented in the schema, establishing the baseline of 3. The description adds no meaning beyond the schema—it never mentions the kind filter even though a kind parameter with an enum exists.

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 names a specific verb ("List") and resource ("symbols") and scopes it to the .symtab and .dynsym tables of a PS2 ELF binary, which is more precise than a generic "list symbols". It does not, however, explicitly separate itself from nearby siblings such as elf_find_function or elf_list_sections.

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?

There is no explicit guidance on when to use this versus elf_find_function (lookup a single symbol) or elf_inspect (broader binary metadata). The listing intent is only weakly implied by the verb "List", and no exclusions or preconditions 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?

With no annotations supplied, the description carries the full burden; 'List' and 'recorded confirmed' usefully signal a read-only operation that returns only confirmed entries, which is real behavioral content. It says nothing about permissions, pagination, ordering, or return shape.

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?

A single front-loaded sentence with no filler or redundant restatement. The brevity is efficient rather than sloppy, though it leaves no room for the filtering details the tool needs.

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?

Four undocumented parameters, no annotations, and no output schema mean the description is the only source of behavioral and parameter detail, and it supplies almost none. For a filtered-list tool an agent cannot call correctly without guessing, this is inadequate.

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 0% across four parameters, so the description must compensate and only does so for 'workspace' via 'for a workspace'. It gives no indication of what file, n64Name, or ps2Name do, leaving three parameters entirely undocumented.

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?

Clearly states a specific verb ('List') and resource ('recorded confirmed N64<->PS2 equivalences') plus a scope ('for a workspace'). The word 'List' implicitly contrasts with the sibling equivalence_record, though the description never names that sibling.

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 when-to-use or when-not-to-use guidance is given, and no alternative is named. An agent must infer from the word 'List' that this is the read counterpart to equivalence_record rather than a lookup-for-translation tool.

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?

With no annotations, the description carries the full burden, and it does disclose that evidence is mandatory and that confirmation is gated. However, it is silent on whether recording an existing pair overwrites, errors, or duplicates, and on what the call returns — meaningful gaps for an unaannotated mutation 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?

Two short sentences, front-loaded with the action and scope, with the exclusivity claim second. Nothing is redundant and nothing could be trimmed without losing routing 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 13-parameter mutation tool with no annotations, no output schema, and 31% schema coverage, the description is too thin. It never explains the identity fields needed to pair the two functions or what a successful recording produces, leaving most of the calling contract undocumented.

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 only 31% across 13 parameters, so the description needs to compensate and does not. It echoes only the evidence/confirm requirements already stated in the schema descriptions and says nothing about the undocumented required fields (n64Name, n64Address, ps2Name, ps2Address, recordedBy) or the optional file/sha256/workspace fields.

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 ('Record a CONFIRMED N64<->PS2 function equivalence') with the scope qualifier 'mandatory evidence'. It also distinguishes itself from siblings by asserting exclusivity ('Only this tool can mark equivalence as confirmed'), which separates it from equivalence_list and compare_functions.

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 exclusivity claim gives a clear routing rule: use this when an equivalence must be marked confirmed rather than merely listed or compared. It stops short of naming prerequisites such as first running compare_functions or port_validate_translation to obtain evidence, and gives no explicit when-not guidance.

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?

With no annotations, the description carries the full burden, and it does disclose the most important behavioral fact: the default is read-only and file writes are gated behind an environment variable plus a flag. It stops short of saying where files land, whether an existing report is overwritten, or what the call returns, which leaves meaningful gaps for a tool with side effects.

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 short sentences, front-loaded with the purpose and followed immediately by the safety-relevant write gate. No filler, no restating of the tool name.

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 19-parameter tool with no output schema and no annotations, the description is thin: it explains format and the write gate but not the report's required structure, how evidence entries relate to hypotheses, or what happens to optional sections. An agent can start the call but must reverse-engineer the payload shape from the schema alone.

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 only 21% across 19 parameters, so the description must compensate and largely does not. It touches the format choice and the write flag, but says nothing about the many evidence, findings, hypothesis, and address fields that make up the report body, nor about the confidence enum 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?

The description gives a specific verb and resource ('Generate a structured forensic investigation report') plus the output formats, so the agent knows exactly what is produced. It does not distinguish itself from nearby reporting siblings such as save_finding or equivalence_record, which is the only thing keeping it from a 5.

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 write precondition (RETRACE_ALLOW_WRITE=1 plus write=true) is a genuinely useful invocation rule that tells the agent when a write will actually occur. However, there is no guidance on when to call this versus save_finding, or whether it should be invoked at the end of an investigation rather than incrementally, so usage is only implied.

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?

With no annotations, the description carries the full behavioral burden, yet it never says that files are written to disk, whether existing content in outputDir is overwritten, or what the 'apply' boolean toggles (presumably a dry-run vs. write gate). The only clue that this mutates the filesystem is the word 'Generate'; re-runnability and safety of the operation are left entirely to inference.

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?

A single front-loaded sentence with no filler or repetition, and the key artifacts are listed efficiently. It is well-formed but too terse for the amount of unknown behavior it is supposed to cover.

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 file-generating mutation tool with zero annotations, no output schema, and a write-gating boolean, the description omits the essentials: where files land, whether output is deterministic, and whether an existing scaffold is clobbered. An agent could invoke it but could not predict the consequences of that 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 0% across three parameters, so the description must compensate, and it does not. projectName, outputDir, and especially the 'apply' flag (whose semantics are non-obvious and potentially destructive) receive no explanation of format, path conventions, or side effects in either the schema or the description.

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 gives a specific verb ('Generate') and a concrete resource ('minimal PS2 port scaffold'), then enumerates the artifacts produced: CMake, a C entrypoint, and a pending-layer checklist. That is far more informative than the bare name, but it never separates this tool from the near-identical sibling 'create_ps2_project', so an agent must guess which generator to call.

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?

There is no when-to-use guidance, no exclusions, and no mention of alternatives such as create_ps2_project, port_project_plan, or port_start, all of which appear in the sibling list. Nothing says whether this is a first step, a re-runnable scaffold, or something to run only once per port.

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?

No annotations are provided, so the description carries the full behavioral burden. It mentions 'Headless' and 'reproducible,' but never explains whether it mutates the project, what the 'apply' flag changes, what permissions are required, or what side effects occur.

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?

It is a single front-loaded sentence with no obvious padding, so it is appropriately sized. The wording 'the same reproducible' is slightly opaque because the antecedent is missing, but the structure itself is efficient.

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 three-parameter Ghidra pipeline tool with no annotations and no output schema, the description is too thin. It omits parameter semantics, mutation behavior, and expected outcome, leaving the agent with insufficient information to invoke it confidently.

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 0%, and the description does not mention inputPath, project, or apply at all. It adds no meaning beyond the bare parameter names and types.

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 states a verb and domain: it runs a Ghidra Headless import/analyze step. However, the phrasing 'same reproducible ... under an explicit tool name' is vague and does not clearly distinguish this tool from siblings such as ghidra_import or decompile_function.

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?

It only hints at 'pipeline orchestration' and gives no explicit when-to-use, when-not-to-use, prerequisites, or comparison to alternative analysis tools. An agent has to infer the intended workflow from a single vague clause.

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?

With no annotations supplied, the description carries the full burden, and it does disclose one important trait: the call is a write operation because Ghidra materializes a project, and it demands explicit confirmation. It says nothing about whether an existing project at the same path is overwritten, whether the import is idempotent, how long the headless analysis runs, or what the caller receives back.

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 short sentences with the action front-loaded and the confirmation requirement immediately after, so nothing is buried. The word 'authorized' adds a small amount of policy flavor that could be trimmed, but overall there is no filler.

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?

This is a mutating, side-effecting tool with no annotations, no output schema, and zero parameter documentation, so the description should be doing far more work. Critical facts for correct invocation — project collision behavior, what 'apply' toggles, expected runtime, and the result of the call — are all absent.

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 0% across three parameters, so the description must compensate and largely fails to. 'Explicit write confirmation' gestures at the 'apply' boolean without naming it or stating its default, and neither 'romPath' (format, authorization expectations) nor 'project' (path? name? must it pre-exist?) is explained.

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 pair ('Import and analyze') and resource ('authorized ROM/ELF') and names the engine ('Ghidra Headless'), which is clear enough to act on. It does not distinguish itself from nearby siblings such as ghidra_analyze or analyze_n64_rom, so an agent cannot tell from the description alone which of these to pick.

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 mention of 'Requires explicit write confirmation because Ghidra creates a project' implies a prerequisite gate before invocation, which is useful context. However, there is no explicit when-to-use vs when-not guidance and no reference to the competing analysis/import siblings, so routing must be inferred.

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?

No annotations are supplied, so the description carries the full behavioral burden and largely fails it. It does not say whether props on an existing edge are merged or overwritten, whether duplicate edges are collapsed, whether nodes must pre-exist, or what the call returns. For a mutation tool with zero annotation coverage this is a significant 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?

A single front-loaded sentence with no filler, and the action verb leads. It is appropriately sized but leaves no room for the operational detail an upsert tool needs.

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 a mutation tool with no annotations, no output schema, and nested props, the description should address merge semantics and node existence requirements. Instead it only restates the operation, leaving an agent unable to predict the effect of a repeated call.

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%, including examples of relationship names like 'renders', 'calls', and 'crashed_at', so the schema does the heavy lifting. The description adds only the framing that 'from' and 'to' are the two endpoint nodes, which is the baseline expectation rather than extra meaning.

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 states a specific action ('Add or update') and resource ('a relationship edge between two nodes in the Knowledge Graph'), which cleanly separates it from graph_node_upsert (nodes) and graph_query_neighbors (reads). It does not explicitly name those siblings, but the node-vs-edge distinction lets an agent route correctly.

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?

There is no when-to-use guidance, no prerequisites, and no mention of the read-oriented siblings like graph_query_neighbors. The 'add or update' wording hints at upsert behavior but never states the condition that selects add vs update.

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?

With no annotations, the description carries the full burden, and it does disclose one substantive trait: extraction is limited to what is parsed and no decompilation occurs during ingestion, which usefully bounds cost and side effects. It says nothing about whether the operation is idempotent, what graph nodes/edges get created, how failures on malformed input are handled, or what the call returns.

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, no filler, and the negated behavior (no decompilation) is placed immediately after the purpose so the agent reads scope before mechanics. Nothing could be cut without losing 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?

It covers what it ingests and one important non-behavior, but for a mutation tool with no annotations and no output schema it leaves the agent guessing about side effects on the graph, result shape (node ids? counts?), and prerequisites. Adequate as a minimum viable definition, not complete.

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 the kind enum is documented in-schema, so the description adds nothing new about path, text or source. The enumeration of source types loosely mirrors the enum but provides no additional syntax or format guidance. 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?

Names a specific verb (Ingest), enumerates the accepted source types (ELF, N64 ROM, symbol table), and names the destination (Knowledge Graph). That destination is what separates it from read-only siblings such as elf_inspect, rom_inspect and split_rom, though those siblings are never named explicitly.

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?

There is no guidance on when to choose ingestion over elf_inspect / rom_inspect, no statement of prerequisites (a loaded project, a workspace path), and no mention of how it relates to graph_node_upsert or graph_edge_upsert. The agent must infer all routing decisions from the description.

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?

With no annotations, the description carries the full behavioral burden, and it omits the critical upsert semantics: whether existing `props` are merged or replaced on update, whether a partial node clobbers prior data, and whether the write requires an initialized project graph. 'Add or update' states that mutation occurs but nothing about its consequences or reversibility.

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?

A single front-loaded sentence with no filler; the verb, resource, and scope are all stated immediately and nothing is redundant.

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?

This is a mutation tool with no annotations and no output schema, so the description must explain merge/replace behavior, side effects on existing nodes, and what the call returns (e.g., the upserted node or its id). It covers none of these, leaving significant gaps for a write operation with a nested free-form `props` object.

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 `id`, `type`, `label`, and `props` are already fully documented, making 3 the baseline. However, the description's parenthetical list of node types is a strict subset of the enum (omitting address, memory_region, build, investigation, note), which adds no meaning and risks misleading an agent about valid types.

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 gives a specific verb ('Add or update') and a specific resource ('a node in the project Knowledge Graph'), which cleanly separates it from graph_edge_upsert and graph_query_neighbors by name. It falls short of 5 only because it names the sibling relationship implicitly rather than stating it.

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?

There is no explicit when-to-use guidance: nothing says when to prefer this over graph_ingest, when a node already exists, or what prerequisites (project/graph initialization) must be met. The only hint is the phrase 'in the project Knowledge Graph', which implies a persistence context but leaves the agent to infer it.

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?

No annotations are supplied, so the description carries the full behavioral burden. 'Query' implies a read, but nothing states read-only semantics, whether traversal follows edge direction, what edge/node types are returned, or whether large depths are rate-limited or expensive. For a graph traversal with zero annotation coverage this is a meaningful 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?

A single sentence with the core purpose front-loaded, followed by two short illustrative examples in parentheses. Every clause earns its place and nothing is padded.

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 two-parameter read tool with a fully described schema, the definition is close to sufficient, but with no annotations and no output schema the agent still cannot predict the shape of the response (neighbor node list? edges with types?) or the cost of higher depth values.

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, including the depth range (1 to 4, default 1). The description reinforces 'depth' as a traversal bound rather than raw numeric input, which adds modest meaning, but adds nothing about nodeId format or what a depth of 2 versus 4 actually expands to.

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 names a specific verb and resource ('Query related nodes in the Knowledge Graph') plus a traversal bound ('up to a given depth'), and the two parenthetical examples concretize what 'related' means. It is clearly distinct from the graph mutation siblings (graph_node_upsert, graph_edge_upsert, graph_ingest), though it never names them explicitly.

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 examples ('what textures does this function render?', 'What crashes are linked to this address?') implicitly convey when to reach for this tool, which is genuine usage signal. However there is no explicit when-not guidance, no prerequisites (does the node need to exist first via graph_node_upsert?), and no mention of alternatives.

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?

No annotations are supplied, so the description carries the full burden of behavioral disclosure, yet it says nothing about whether the tool is read-only, whether it persists anything, what permissions or prior analysis it requires, or what form the 'candidate structs' take. 'Infer' hints at analysis rather than mutation, but that is inference on the agent's part, not disclosed behavior.

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?

A single front-loaded sentence that states the operation, the input concept, and the output concept with no filler. Nothing in it is redundant.

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 no annotations, no output schema, and zero schema descriptions across three parameters, this one-sentence description is thin for the tool's complexity. It leaves open what the return value looks like, how 'address' should be supplied, and how results relate to downstream steps like validate_variable_map.

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 0% for three parameters, and the description never mentions any of them. It does not say that 'hex' is the input bytes, that 'arch' selects between r4300i and r5900, or what 'address' anchors (base offset for the scan?), so the agent must guess at required formats and defaults.

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 gives a specific verb ('Group') and resource ('repeated base-register offsets into candidate structs and fields') plus the domain ('N64-to-PS2 variable translation'), so an agent knows it produces struct/field candidates rather than variables. It stops short of naming how it differs from sibling infer_variables or suggest_variable_names, so sibling differentiation is only implicit.

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?

There is no explicit when-to-use or when-not-to-use guidance and no named alternative; the phrase 'for N64-to-PS2 variable translation' only loosely implies a pipeline stage. An agent facing both infer_structs and infer_variables has no stated basis for choosing one over the other.

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?

With no annotations, the description carries the full burden, and it does disclose one important trait: results are advisory candidates with evidence, not automatic source edits, implying a read-only analysis that does not mutate the repo. It leaves other behavioral facts unstated — whether a project/ROM must be loaded first, what the hex blob must contain, whether analysis is deterministic or expensive, and what the evidence structure looks like.

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 short sentences, front-loaded with the core capability and followed by the key caveat about output trustworthiness. Nothing is redundant or padded.

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 qualitative nature of the return value is described despite there being no output schema, which is valuable, but input requirements for a 3-parameter tool with zero schema documentation remain unexplained. An agent knows what the tool produces conceptually but not how to prepare a valid call.

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 0% across three parameters, so the description must compensate and does not. It never explains the required "hex" string (raw bytes? hexdump text? how much code?), what "address" anchors the dataflow to, or that "arch" selects between the N64 (r4300i) and PS2 (r5900) register models — all left for the agent to guess.

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 ("Infer") and resource plus a concrete enumeration of what is inferred: stack locals, globals, arguments, returns, register roles, and names the input source (MIPS dataflow observations). An agent can tell this apart from infer_structs or suggest_variable_names in substance, though no sibling is explicitly named.

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?

Usage is only implied by the reverse-engineering context (MIPS dataflow). There is no explicit when-to-use, no prerequisites, and no routing to the obvious alternatives in the sibling set such as infer_structs, suggest_variable_names, or validate_variable_map. The second sentence usefully frames how to treat the output but does not say when to call the tool.

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?

No annotations exist, so the description carries the whole burden. It discloses a prerequisite (an installed ISO reader) and bounds the claim to filesystem structure rather than gameplay, which is genuinely helpful. It does not state failure behavior, read-only nature, or what a negative result looks like.

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 action and check targets, followed by a single scope-limiting caveat. Nothing is redundant and nothing could be trimmed without losing meaning.

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 two-parameter, no-annotation, no-output-schema tool, the description covers the check scope and the reader prerequisite but omits the hash-verification path and any indication of the pass/fail result shape. Adequate but with a clear gap around expectedSha256.

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 0% for two parameters. The description implies isoPath (the ISO being verified) but never mentions expectedSha256, leaving the optional 64-character hash parameter entirely unexplained in both schema and prose, despite it being the only integrity-verification lever.

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 pairs the specific verb "Verify" with a specific resource ("PS2 ISO") and names the exact structural checks (SYSTEM.CNF and BOOT.ELF present). This clearly separates it from siblings like rom_validate, package_ps2_iso, and run_pcsx2, though it does not explicitly name which sibling to prefer.

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 sentence "This is a filesystem gate, not a gameplay claim" implies the tool is a pre-flight check that can be trusted only for structure, not for whether the ISO boots. That is useful scoping, but no explicit when-to-use trigger or alternative (e.g., use rom_validate for other formats) is given.

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?

No annotations are supplied, so the description carries the entire behavioral burden and largely fails to. It does not say whether the check is read-only, whether a shared boundary endpoint counts as a collision, whether all collisions are reported or the first one aborts, or anything about the result shape for a tool with no output schema.

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?

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity is also the source of the missing behavioral and usage detail rather than a virtue in itself.

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 tool with no annotations and no output schema, the description should explain the safety profile and at least sketch what a collision result looks like. It gives only the domain of the check, leaving the agent unable to predict the response or the exact collision criteria.

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 reported at 100% and the sole parameter is documented as "List of memory regions to check for collision," so the baseline is 3. The description adds nothing further, and the genuinely ambiguous semantics of start/end (units, whether end is inclusive or exclusive) are left unaddressed by both schema and description.

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 names a specific verb ("detect") and resource (memory layout collisions) and enumerates the region kinds involved (buffers, heaps, display lists, texture staging areas). An agent can distinguish it from memory_check_alignment and memory_inspect_region by domain, though the description never explicitly contrasts with those siblings.

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?

There is no when-to-use or when-not-to-use guidance, and no mention of the closely related siblings memory_check_alignment or memory_inspect_region. The agent must infer from the purpose sentence alone that this is the multi-region overlap check rather than the per-region inspection or alignment tool.

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?

No annotations are supplied, so the description carries the full behavioral burden. It does disclose the checks performed (alignment, nullness, arch range), which usefully implies a non-mutating validation, but it never says what the tool returns (boolean, structured report, error text) despite there being no output schema.

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?

A single front-loaded sentence with no filler, and the core action leads. The phrase 'architectural valid range' is slightly opaque and could have named the arch dependency instead of alluding to it.

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 two-parameter validation tool with no annotations and no output schema, the definition is minimally sufficient on inputs but silent on the result shape and on failure semantics (e.g., unaligned vs. null vs. out-of-range reporting). The complexity is low, so the gap is moderate rather than severe.

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 both parameters are already documented, and the description's mention of '4-byte or 8-byte' and 'architectural valid range' adds useful framing for how the n64/ps2 enum drives the check. It stops short of explaining the relationship explicitly, so it sits at the baseline rather than above it.

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 states a specific verb and resource ('Check a pointer') and enumerates the three checks performed: 4/8-byte alignment, nullness, and architectural valid range. It is clear what the tool does, but it never contrasts itself with adjacent siblings such as memory_inspect_region or memory_analyze_overlap, so an agent must infer the boundary.

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?

There is no statement of when to call this versus the sibling memory_* tools, no prerequisites, and no mention of what happens for an invalid address. The only guidance is implicit in the word 'Check', which an agent must interpret on its own.

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?

No annotations are supplied, so the description carries the full disclosure burden. It does disclose the substantive behavior (enumerating the regions it checks and the two architectures), which implies a read-only lookup, but it omits what happens for an unmapped or out-of-range address, whether it errors or returns 'unknown', and what the result looks like.

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?

A single front-loaded sentence that leads with the action and immediately clarifies the concrete output categories. Nothing is redundant or padded.

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 two-parameter read-only lookup this covers the essentials, but with no output schema and no annotations the description should still say what the return value contains (region name, offset, permissions) and how unmapped addresses are reported. Those gaps are meaningful for an agent trying to interpret results.

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% and both parameters are documented in the schema, including an enum for arch and an example address format. The description only restates the N64/PS2 choice already encoded by the enum and adds no extra meaning about address encoding (physical vs virtual, hex width), so it sits at 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 (inspect/check) and resource (virtual memory address) and enumerates the resolution targets (RDRAM, KSEG, Main RAM, GS registers, VRAM) plus the two supported architectures. It does not explicitly differentiate itself from close siblings like memory_check_alignment or memory_analyze_overlap, so it stops short of a 5.

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?

Usage is only implied: an agent can infer it should call this when it has a raw address and needs to know which memory region it falls in. There is no explicit when-to-use/when-not guidance, no mention of the related alignment/overlap siblings, and no stated prerequisites such as whether the ROM/arch context must be loaded first.

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?

No annotations exist, so the description carries the full burden. It helpfully discloses what the analysis yields (stack frame, saved registers, calls, jumps, basic blocks, pseudocode), but says nothing about whether the operation is pure/read-only on the hex string, what the output format is, or how malformed input is handled.

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?

A single front-loaded sentence with a compact detection list and no filler. It is efficient, though the flat enumeration could be sequenced to lead with the most decision-relevant outputs.

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 no output schema, the description must convey return shape, and it only partially does so by naming the detected artifacts without stating format (structured object vs. text pseudocode) or any failure behavior. Adequate for a pure analysis tool over a hex blob, but there are clear gaps.

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 hex, arch, and address all documented and arch constrained by an enum, so the schema does the heavy lifting. The description adds no meaning about parameter interaction, such as whether address affects jump/call resolution or whether arch changes register conventions.

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 (analyze) and resource (a MIPS function) and enumerates concrete outputs: stack frame size, saved registers, calls, jumps, basic blocks, pseudocode. That enumeration distinguishes it from siblings like mips_disassemble and mips_reconstruct_function, though the description never explicitly names the boundary between them.

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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. An agent must infer from the output list whether to pick this over mips_disassemble, decompile_function, or compare_functions, with no explicit routing.

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?

No annotations are supplied, so the description carries the full disclosure burden. It usefully names the underlying engine (Capstone) and clarifies that input is raw bytes rather than a file, but says nothing about the return format, how errors on malformed hex are handled, or any length/alignment constraints.

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?

A single front-loaded sentence with the action first and the qualifiers in a compact parenthetical. Nothing is redundant or padded.

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 no output schema and no annotations, the description should say more about what comes back (instruction listing with addresses?) and any input constraints such as hex length being a multiple of the instruction width. It is adequate for identifying the tool but leaves real gaps 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 coverage is 100%, so the baseline would be 3; the description goes further by mapping architecture values to platforms and endianness (R4300i→N64 big-endian, R5900→PS2 little-endian), which helps an agent pick coherent arch/endian combinations rather than reading the enums in isolation.

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 — 'Disassemble raw MIPS machine code instructions' — and names the concrete architecture variants it handles. It implicitly separates itself from siblings like mips_analyze_function or decompile_function by operating on raw hex rather than a binary/function, but it never explicitly draws that line.

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 parenthetical 'R4300i for N64 big-endian or R5900 for PS2 little-endian' gives an implied selection rule for the arch/endian parameters, but there is no explicit statement of when to use this tool versus mips_analyze_function, mips_reconstruct_function, or decompile_function.

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?

With no annotations at all, the description carries the full burden. It does add genuinely useful behavioral context by framing the output as 'heuristic pseudo-C' and explicitly disclaiming fidelity ('Never claims to be original source'), which sets the right expectation for the reconstruction. It says nothing about determinism, performance limits on input size, failure behavior for malformed hex, or whether arch/abi mismatches produce wrong-but-plausible results.

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 action and the returned artifacts, followed by a short honesty caveat that earns its place by preventing downstream misuse of the output. There is no padding, though the artifact list is delivered as a comma run rather than a structured enumeration.

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 no-annotation, no-output-schema tool with five parameters, the description is nearly sufficient: it describes the shape of the result the agent can expect, which substitutes for the missing output schema. The remaining gap is operational — no hints on error conditions or on how the arch/abi enums constrain interpretation of the hex input.

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 80% and the schema already documents hex, abi, name, and address, so the baseline of 3 applies. The description adds no parameter-level meaning whatsoever — notably it does not explain how the optional 'arch' and 'abi' choices interact with the required 'hex' input, which is the main ambiguity an agent faces here.

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 states a specific verb and resource ('Reconstruct a function's structure from MIPS instructions') and enumerates the concrete artifacts produced: CFG edges, stack frame, saved registers, parameters, loops, and pseudo-C. It does not name or differentiate itself from nearby siblings such as mips_disassemble or mips_analyze_function, so an agent must infer whether this supersedes or complements them.

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?

Usage is only implied: the tool clearly follows on from disassembly, but there is no explicit statement of when to choose it over mips_analyze_function or decompile_function, and no prerequisites are given (e.g., that hex must be raw function machine code rather than a whole ROM). Guidance is adequate but leaves routing decisions 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?

No annotations are supplied, so the description carries the full behavioral burden. It does disclose that the source tree and SYSTEM.CNF are left in place (non-destructive to the project), which is useful, but it says nothing about what happens to an existing outputIso, why a required 'confirm' gate exists, what external tooling must be installed, or what failure looks like.

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 tight sentences with the action front-loaded and the side-effect note second; nothing is padded. It is arguably too short for a four-parameter mutation tool, but that is a completeness issue rather than verbosity.

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 tool that writes a binary artifact, with no annotations, no output schema, and no documented parameters, the description is thin. An agent cannot confirm the meaning of 'confirm', the overwrite behavior of outputIso, or the distinction from build_ps2 without external knowledge.

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 0% across four required parameters. The description only indirectly touches elfPath ('authorized ELF') and projectRoot ('project tree'); outputIso, the destination path, and the mandatory boolean 'confirm' are never explained, nor are path format constraints (relative vs absolute).

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 artifact ('Build a PS2 ISO') plus the inputs ('authorized ELF and project tree') and the underlying mechanism (mkisofs/genisoimage). It does not differentiate itself from the sibling build_ps2 or explain how it relates to iso_verify, so an agent must guess which packaging/build tool to pick.

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?

There is no explicit when-to-use or when-not-to-use guidance. The word 'authorized' hints at a precondition, but the description never says to prefer this over build_ps2, when iso_verify should run afterward, or whether the project must already have been generated via create_ps2_project/generate_ps2_project.

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?

With no annotations, the description carries the full behavioral burden. 'Evidence-driven' hints at sourcing but does not say whether the tool reads analysis artifacts, writes files or state, requires prior graph/repo analysis, or is idempotent. The gate list conveys plan structure only, not side effects or prerequisites.

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?

A single front-loaded sentence with no filler or redundancy. It is tight, but the brevity edges into under-specification rather than earning every word through usefulness.

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?

No output schema, no annotations, and two wholly undocumented parameters leave the agent guessing at the return shape and preconditions. For a tool that appears to orchestrate a multi-phase porting plan, the description is far too thin to call correctly without trial and error.

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 0% and the description never mentions sourcePlatform or targetPlatform. The enums make the value space self-evident, but nothing clarifies whether the two must differ, which direction the plan is built for, or what happens if source equals target.

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 gives a specific verb ('Build') and resource ('porting plan') scoped to N64/PS2, and names the plan's dimensions (ISA, ABI, runtime, asset, validation gates). That is enough to distinguish it from siblings like port_validate_translation or port_status, though it never says what the plan actually is (document? graph entries?) or how it relates to port_start.

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 when-to-use guidance and no alternatives named, despite an obvious cluster of adjacent tools (port_start, project_autopilot, project_intake, binary_translate). The agent must infer that this is the planning phase that precedes actual translation work.

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?

No annotations are supplied, so the description carries the full burden. It does not say whether the tool merely reads and reports, or also writes/creates a manifest (the name and 'manifest' framing suggest possible output artifacts), what happens on failure, or whether it mutates project 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?

A single front-loaded sentence with no filler; the purpose and the timing cue arrive immediately. It is efficient, though its brevity is part of why other dimensions are underspecified.

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 no output schema, no annotations, and zero parameter documentation, the definition should explain what a successful vs. failed verification looks like. Instead it leaves the agent guessing about return values, pass/fail semantics, and the two path parameters.

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 0% for both parameters. The description only loosely hints that 'project' maps to projectRoot and 'generated source' maps to sourceDir, with no explanation of the optional sourceDir's default behavior, path resolution, or why one would override it.

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 clear verb ('Verify') and enumerates the specific resource contents checked: generated source, translated variables, and provenance. It is distinguishable from siblings like port_validate_translation or package_ps2_iso, though the term 'inspectable' is jargon that leaves the exact criteria slightly fuzzy.

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 phrase 'before packaging an ISO' implies a precondition/gate usage relative to package_ps2_iso, which is real guidance. However, it never explicitly says when not to use it or how it differs from adjacent checks such as port_validate_translation or port_status.

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?

With no annotations, the description carries the full burden, and it does disclose meaningful traits: the job is resumable, the source ROM is preserved, and the tool will not report success before validation. It leaves out what is written to disk under projectRoot, whether an existing project is overwritten, and what the call returns (a job identifier?), which matters for a stateful creation 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?

Two tight sentences with the core action and its guarantees front-loaded and no filler. 'Evidence-driven' is somewhat jargon-heavy, but it still conveys a real behavioral property rather than padding.

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 creation tool with four undocumented parameters, no annotations, and no output schema, the description should explain the destination of the job, the meaning of profile and confirm, and what a successful call yields. None of that is present, so an agent cannot call this confidently beyond the two required paths.

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 0% across four parameters, so the schema supplies no meaning at all. The description only indirectly touches romPath via 'preserves the ROM' and says nothing about projectRoot, profile, or the confirm flag, leaving the agent to guess at required inputs.

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 ('Create') and a specific resource ('resumable, evidence-driven N64-to-PS2 port job'), so an agent immediately knows this initiates a porting job. It does not name the near-siblings (port_project_plan, project_intake, port_status) that could be confused with it, so differentiation is only partial.

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?

There is no explicit when-to-use or when-not-to-use guidance, no prerequisites, and no mention of alternatives such as port_project_plan or project_intake. The agent must infer from the word 'Create' that this is the entry point of a workflow.

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?

With no annotations, the description carries the full burden; it does establish read-only semantics ('Read') and discloses what the result contains, which is meaningful beyond structured fields. It says nothing about failure behavior when no job exists, where the persisted state lives, or whether the read has side effects such as refreshing 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?

A single sentence with no filler, leading with the verb and resource before listing the payload contents. Front-loaded and efficient, though the trailing list is dense enough that some readers may skim it.

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?

There is no output schema, and the description does partially compensate by naming the returned categories. It remains incomplete for a persistence-backed read: empty-state behavior, staleness guarantees (how 'last' is determined), and the sole parameter are all unaddressed.

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 0% and the single parameter projectRoot is undocumented. The description never mentions projectRoot, so it does not explain that the job is located by project root, nor whether paths are absolute or relative — the agent gets no help beyond the bare schema key.

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: 'Read the last persisted port job', and enumerates the payload (blocked stages, tool versions, artifacts, source provenance). This separates it from the mutating port_start/port_apply siblings, though it never names an alternative explicitly.

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 last persisted port job' implies this is a post-run inspection tool, so usage is inferable. However, there is no explicit when-to-use guidance, no mention of what to do if no job has been persisted yet, and no routing to overlapping siblings such as project_state or port_project_plan.

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?

With no annotations, the description carries the full burden, and it does disclose one real behavioral guarantee: validation is exact round-trip only, not semantic. That is genuine added context. But it says nothing about whether the operation is read-only or mutating, what the return value looks like, whether mismatches raise errors or return a result, or any cost/limit.

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?

A single tight sentence with the scope statement front-loaded and the key exclusion trailing. Nothing redundant.

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?

Three required parameters with zero schema documentation, no annotations, and no output schema, in a tool whose result format (pass/fail vs. failing offset) materially affects how an agent uses it. The description cannot answer how to interpret a failure or what to pass in hex without inference.

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 0%, so the burden falls on the description, which mentions none of the three parameters. The names hex, sourcePlatform, and targetPlatform are largely self-explanatory and the two platform parameters are enum-constrained, which limits the damage, but the hex encoding format, byte order, and whether source and target may be identical all remain unstated.

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 a specific verb ('Validate') and a specific resource ('supported N64/PS2 encoding translation round-trips'), and adds a boundary clause distinguishing it from semantic-equivalence checking, which separates it from equivalence_record/compare_functions. It stops short of naming a sibling outright, so the differentiation is implied rather than explicit.

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 clause 'this is not a semantic equivalence proof' implies when this tool is the wrong choice for proving behavioral equivalence, which is useful routing information. However, there is no positive guidance on when an agent should reach for this versus binary_translate, equivalence_record, or texture_decode_n64/ps2, and no stated prerequisites.

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?

With no annotations, the description carries the full burden, but it does deliver real behavioral facts: only installed adapters run, and blocked stages are recorded rather than simulated. It still omits whether execute mode writes or mutates the project, what artifacts are produced, and whether the run is idempotent or long-running.

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 tight sentences, front-loaded with the core action and followed by the key behavioral constraint; no padding 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?

For a six-parameter, two-required-parameter orchestration tool with no annotations, no output schema, and near-zero schema coverage, the description is far too thin. It never names the pipeline stages, the required inputs' purpose, or what a caller receives back.

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 only 17% — just the confirm flag — so the description needed to explain romPath, projectRoot, configPath, and refresh, and it explains none of them. The one useful hint (blocked stages) relates to behavior, not to any parameter's meaning or format.

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 gives a specific pair of verbs (plan/execute) tied to a named resource (the N64-to-PS2 pipeline), so the agent knows the general operation. It does not distinguish this pipeline runner from close siblings such as port_project_plan, port_start, or project_intake, which is the main clarity gap.

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?

There is no guidance on when to pick this tool over port_project_plan or port_start, and nothing in the prose explains when to choose plan versus execute mode (the enum exists only in the schema). The agent must infer usage entirely from the name and sibling list.

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?

No annotations are supplied, so the description carries the full behavioral burden. 'Create' implies persistence, but the description never says where the record lives, whether repeat calls are idempotent, what the record contains, or what happens when rightsConfirmed is false. 'Read-only' is also ambiguous — it could be misread as a pure read operation even though the tool writes a record.

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?

A single front-loaded sentence with no filler; every qualifier (read-only, reproducible, authorized) earns its place. It is arguably too terse for a six-parameter mutating tool, but nothing 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?

For a record-creating mutation tool with no annotations, no output schema, and half the parameters undocumented, the description should cover the record's contents, storage location, idempotency, and failure mode when authorization is not confirmed. None of that is present, so an agent has to guess at the tool's real contract.

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 only 50%: root, romPath and rightsConfirmed are documented in the schema, while name, sourcePlatform and targetPlatform are not. The description adds nothing about any parameter except an oblique hint that authorization (rightsConfirmed) is required; it does not explain the platform enum semantics or the N64→PS2 pairing constraint.

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 concrete verb and artifact ('Create ... intake record') with explicit scope (N64 to PS2 port project) and qualifiers (read-only, reproducible). It does not name the sibling it replaces or precedes (port_project_plan, port_start, port_source_manifest), so sibling differentiation is left implicit.

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 phrase 'for an authorized N64 to PS2 port project' implies the precondition (rights confirmed) and the lifecycle stage (intake, before planning/build tools). There is no explicit when-to-use versus port_project_plan/port_start, and no when-not-to-use or re-run guidance.

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?

No annotations are provided, so the description carries the full behavioral burden. It indicates that writes are possible ('persist') but says nothing about overwrite semantics, the role of the 'confirm' parameter, required permissions, or what a read or write returns, which is a significant gap for a read/write state 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?

The description is a single front-loaded sentence with no filler, so it is concise. Its terseness contributes to completeness gaps, but within this dimension there is little wasted wording.

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 four-parameter, nested-object read/write tool with no annotations, no output schema, and 0% schema description coverage, a single sentence is not enough. It omits the operational behavior and parameter details 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 0%, so the description must explain the four parameters. It only implies the action enum via 'read or persist' and calls the payload a manifest; projectRoot, state, and confirm are left unexplained, and the nested state object has no 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?

The description states a specific verb ('Read or persist') and resource ('reproducible project manifest') and links it to the autopilot context. It is clear what the tool operates on, but it does not distinguish itself from adjacent autopilot/project tools such as project_autopilot or port_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?

It gives context that the manifest is used by the N64-to-PS2 autopilot, but offers no explicit when-to-use guidance, no read-vs-write selection criteria, and no alternatives for inspecting or updating project state. The agent must infer invocation conditions.

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?

With no annotations, the description carries the full disclosure burden. It usefully mentions external CLI execution and diagnostics, but omits filesystem writes, the effect and default of apply, whether a dry run is supported, overwrite behavior, failure handling, and any safety or authorization requirements beyond the vague config phrase.

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 compact and front-loads the concrete action and CLI name. Its scope qualifier is awkwardly phrased, but there is little redundant wording; the larger problem is missing substance rather than excessive 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?

For a compiler-like execution tool with four undocumented parameters, no annotations, and no output schema, this is not complete enough for reliable invocation. The opaque apply flag and missing side-effect, prerequisite, output-location, and sibling-routing details are substantial gaps.

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 0%, and the description only indirectly adds meaning to configPath by calling it authorized. It provides no guidance on ROM or output path requirements and leaves the potentially behavior-changing apply flag entirely unexplained.

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 operation as running the installed N64Recomp CLI and mentions generated output and diagnostics. However, it does not explain what recompilation produces, and the statement that it "never claims a PS2 port" only broadly distinguishes it from the PS2-oriented siblings.

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?

Requiring an "authorized config" supplies an implied prerequisite, and the PS2 statement sets a scope boundary. It does not explain what authorized means, when recompilation is appropriate, or whether to use siblings such as decomp_config_validate, binary_translate, or generate_ps2_project first or 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?

No annotations are supplied, so the description carries the full burden of behavioral disclosure, and it falls short. It does not say whether the tool is read-only, whether it parses manifests recursively or only at the top level, how conflicting or unresolvable dependency declarations are reported, or what the resulting structure looks like.

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?

A single front-loaded sentence with the resource and the ecosystems listed compactly; nothing is redundant. The brevity edges into under-specification rather than padding, so it is efficient but thin.

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 no annotations and no output schema, the description is the only source of behavioral information, and it does not explain what 'analyze' yields (a dependency list, a graph, detected conflicts, or build-health findings). For a repo-scanning tool whose return value is entirely undocumented, that is a real 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?

The single 'root' parameter is fully documented in the schema, including its default to the workspace root, so the schema does the work here. The description's phrase 'in the repository' loosely aligns with that parameter but adds no scoping or path-format meaning beyond it, which is the expected baseline when schema coverage is 100%.

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: analyze dependencies declared in build files, with concrete examples of the ecosystems (Make/CMake/Cargo/npm). It partially distinguishes itself from nearby siblings like build_analyze and repo_inspect by naming build-file dependency declaration as the target, though 'Analyze' leaves the actual output ambiguous.

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?

There is no guidance on when to choose this over build_analyze, repo_inspect, or repo_get_architecture, all of which could plausibly cover build configuration. No prerequisites, exclusions, or alternative routing are stated; usage must be inferred entirely from the name.

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