tmodloader-mcp

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

Beyond the annotations (readOnlyHint=true, destructiveHint=false), the description reveals that the tool reads from assembly metadata without loading or running the game assembly, builds and caches an index per tModLoader version, invalidates that cache on update, may take a few seconds on first call after an update, and refuses instead of returning stale results when the SDK is missing. These are precise behavioral traits that an agent needs to predict performance and failure modes.

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 front-loaded with the core purpose and has compact argument bullets. The later paragraphs are dense and useful, though the caching/metadata explanation could be trimmed slightly without losing meaning. Overall, almost every sentence earns its place, but the prose is a bit more elaborate than the minimum needed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers what is searched, how to phrase queries, how results are limited, why it is trustworthy, how caching affects latency, and what external prerequisites exist. Since an output schema is present, the tool's return value details do not need to be described here. Nothing an agent needs to invoke and interpret this tool correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description carries the full burden for parameter meaning.It does so well: query is defined as a case-insensitive name fragment or type with concrete examples, kind is narrowed to type/field/property/method, and limit is described as controlling how many best-first matches are returned. This adds real semantic value beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The first line states the exact resource being searched ('the INSTALLED tModLoader') and the specific entities returned ('type, field, property or method'). The description distinguishes this from a code compiler in the same sentence, making it unmistakably an API-discovery tool rather than a validation or documentation 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?

The description explicitly says to use this before writing code, when you need to know what exists rather than whether an existing call compiles. It contrasts with a compile stepcars, notes that it is not a prose documentation source, and states the .NET SDK requirement up front. This gives clear guidance on when to call the tool and what it cannot do.

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?

Both annotations are neutral (readOnlyHint=false, destructiveHint=false), so the description carries the full disclosure burden — and it delivers exceptionally. It discloses timeout semantics (reports timeout rather than a fake compile failure), the tModLoader game-open refusal with its fix, and the unreliability of the exit code, teaching the agent to read success from output. This is precisely the context that prevents misdiagnosing a time-out or game-open error as a syntax failure.

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 front-loaded with the purpose, followed by a param section and then two behavioral paragraphs. It is somewhat long, but every paragraph earns its place: each behavioral note conveys critical, non-obvious information that an agent needs to interpret build results correctly. No wasted sentences.

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 1 optional parameter, an output schema (relieving the description of return-value duty), and no nested objects, the description is complete. It covers the purpose, the single parameter, and all three failure modes (timeout, game open, unreliable exit code). An agent has everything needed to invoke it correctly and 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 0%, so the description must compensate — and it fully does for the single timeout parameter. It specifies units (seconds), explains why the default may be inadequate on slow machines, and describes the failure-reporting nuance. This adds real meaning beyond the bare schema, which only had a title and default value.

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 opening sentence 'Compile the configured mod source into a .tmod' states a specific verb, resource, and output artifact, making the purpose unmistakable. Among the 25 siblings (launch, restart, stop, commands, diag), none compete as a build tool, so it is naturally distinct — though the description doesn't explicitly name any alternative.

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 purpose implies when to use it (when you want a compiled .tmod from the configured source), but there is no explicit when/when-not guidance, no named alternatives, and no exclusion criteria. The behavioral paragraphs describe failure modes, not usage context, so the guidance is implied rather than 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?

The description adds meaningful behavior beyond the readOnly/destructive annotations: it discloses that output is names, not paths, and explains why paths are intentionally avoided. The ordering behavior ('newest last') is also stated directly.

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 extremely concise: one sentence states the core behavior and ordering, and a second explains the names-not-paths design decision. Every sentence earns its place, and the most important information is front-loaded.

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-argument list tool, the description is complete: it specifies what is returned, the ordering, and how the returned names relate to read_capture. The presence of an output schema further reduces the need to describe return values in prose.

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 input schema has zero parameters, so there is no parameter semantics to document. The baseline for a no-parameter tool is 4, and the description adds no irrelevant parameter information.

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 and scope: listing every capture in the save directory, ordered newest last. It also distinguishes the tool from read_capture by explicitly saying it returns names, not paths.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear context: the tool exists to provide capture names, and read_capture deliberately accepts only a name, so captures is the natural source for those names. It does not explicitly enumerate when not to use it, but the purpose is obvious enough that no exclusion is necessary.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description goes beyond them by explaining the responder field, the false/error distinction, and that the list is published at load time. It also clarifies that server and client lists differ, adding significant behavioral context not in annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is longer than typical but every sentence contributes value, including historical context that clarifies the tool's design. It is front-loaded with the core purpose and structured with an Args section. Slightly verbose but appropriately sized for the complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given an output schema exists, the description covers the essential behavioral aspects: what the tool returns, how to interpret edge cases, and the optional parameter. It leaves no critical gaps for an agent to call the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description is the sole source for parameter meaning. It explicitly explains the 'server' parameter: ask the dedicated server rather than the client, and notes the lists are not always the same. This fully compensates for the schema's lack of 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 clearly states the tool reads what the running mod serves, and explains it is read from the mod itself. It is specific about the resource and action, but does not explicitly differentiate from sibling tools, so it falls 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 description provides clear context for when the responder field is useful and distinguishes between 'false' and error states, but does not explicitly state when to use this tool versus alternatives or provide exclusions. It gives strong interpretive guidance but lacks direct tool-selection direction.

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

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

Beyond the readOnly and non-destructive annotations, the description discloses important behavioral details: the timeout covers the whole call including the promised dump, large worlds take longer, and the null-vs-zero distinction prevents misreading missing data. It also reveals that record bodies were previously parsed and discarded, adding historical context. No contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well structured and front-loaded: first the core behavior, then each parameter, then return semantics. Every sentence adds useful information, including the concrete example of fields vs records. It is detailed without 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?

Despite having zero schema description coverage, the description compensates fully by explaining parameter roles, return semantics, null behavior, and the cross-side comparison use case. With an output schema present and readOnly annotations provided, nothing essential is missing for an agent to correctly select and invoke the tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description carries full weight for the three parameters. It explains 'server' as switching to the dedicated server view, 'target' as addressing a specific client by name, and describes 'timeout' with a precise one-budget semantics and a performance caveat. This is substantive semantic value the schema alone does not provide.

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 opens with 'Ask one side of the session what it currently sees, parsed,' which names a specific action, a concrete resource, and a precise scope. This clearly distinguishes it from general-purpose logs or capture tools among the 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?

The description gives clear context for when the tool is useful, especially the explicit note that asking both sides at the same moment is the only way to answer 'the client reports no NPC'. It does not explicitly list when-not-to-use cases or name alternatives, so it stops short of a full 5.

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?

The description discloses extensive behavioral details: reads off disk, requires no session, returns both sides simultaneously, and explains the data structure nuances (the `clients` list, the `player: null` entry, and how a real client is identified). It explains why it works without a session due to failed launches not storing one. This goes far beyond the readOnlyHint annotation, providing critical context that affects how results are interpreted.

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 long but well-structured: it leads with the core purpose, then explains the failure context, enumerates the four causes with bullet points, clarifies the `clients` list format, and concludes with rationale for the design. Each sentence adds value, though it could be slightly tightened. The use of bullet points and bolded terms aids readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is remarkably complete given the tool's complexity. It covers when to use it, what it returns, how to interpret the data (including edge cases like the null player entry), and why it works without a session. The output schema exists but the description adds interpretive context that schema alone cannot provide. Nothing an agent needs to call it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are zero parameters, so the input schema is trivially 100% covered. The description correctly omits parameter details, and the baseline for zero parameters is 4. No additional explanation is needed, and the description doesn't attempt to fabricate parameter info.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Read the mod's heartbeat' and expands on its purpose as the diagnostic for why the game is not answering. It distinguishes itself from siblings by explaining it's the only tool useful when nothing else is and that it reads off disk without a session, unlike other tools that require a session. This makes the purpose 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?

The description explicitly explains when to use this tool: when a launch fails and the error 'no live heartbeat within 300s' is encountered. It contrasts with `launch` which already reads the file but discards the detail, making `heartbeat` the fallback for deeper diagnosis. It also notes it's the only tool useful when nothing else is, giving strong situational 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it explains the distinction between `enabled` and `built_here` as separate facts, warns against collapsing them into `installed`, and describes the `path_win` field as the exact string `launch(world=...)` wants. This goes beyond the annotations and helps the agent interpret the data correctly.

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 well-written and front-loaded with the core purpose, but it is somewhat long and digresses into a narrative about why `installed` would be a bad abstraction. The first sentence earns its place; the later paragraphs are informative but could be tightened. It's not bloated enough to be a 2, but it's not as crisp as the best examples.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter read-only tool with an output schema, the description is quite complete. It explains the key output fields and their semantics, warns about a common misinterpretation, and connects the data to `launch` and `commands`. The only minor gap is that it doesn't explicitly describe the full list of output fields, but the output schema presumably covers that. Overall, an agent has enough context to use this tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the schema is trivially complete (100% coverage). The description doesn't need to explain parameters. It instead explains the meaning of the output fields (`enabled`, `built_here`, `path_win`), which is more valuable for a zero-parameter read-only inventory tool. Baseline 4 for zero params 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 opens with a clear statement: 'The worlds, characters and mods on this machine.' This identifies the resource (inventory of worlds/characters/mods) and distinguishes it from sibling tools like `launch`, `commands`, or `log_watch`. However, it doesn't explicitly name a sibling alternative or contrast itself with a specific sibling, so it's 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?

The description provides strong contextual guidance: it explains that `launch` states preconditions that this tool can verify, and it clarifies how the mods data relates to `commands` reporting. It implicitly tells the agent to use this tool to check preconditions before `launch` and to disambiguate mod states. It doesn't explicitly say 'use this instead of X' but the context is clear enough.

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

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

Beyond annotations, the description explains non-obvious behavior: it waits for THIS client's own tokened heartbeat, not a new process; it rejects the unsuffixed shared heartbeat slot because that could return against the existing game; and it notes that stop will take the joined client down with the session. This is exactly the kind of behavioral context an agent needs.

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 key information is present and front-loaded, but the middle paragraph is dense and indirect ('This is that, with the waiting done properly') and the protocol-history framing adds cognitive load. It could be tighter without losing the important heartbeat caveats.

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 tool with an output schema, the description covers preconditions, timeout semantics, heartbeat subtleties, how to address the joined client via diag/shot, and teardown via stop. Nothing critical appears missing for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description fully compensates. It explains player is a pre-existing character name, that -player does not create one, and that the name must not already belong to the session in any casing. It defines timeout as seconds to wait for a live, world-ready heartbeat. This is strong semantic value beyond the bare field names.

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?

Description opens with a specific action and target: 'Bring another character into the session that is already running.' It clearly differentiates from siblings such as launch and stop by emphasizing 'second client' and 'already running.' No ambiguity about what operation this performs.

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 intended use is clear: use when an additional client must join an existing running session. It gives context about why this is needed and what must already be true. It does not explicitly name alternatives or exclusions, so it misses the top tier.

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

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

Annotations only say non-read-only and non-destructive; the description carries the behavioral burden. It explains the readiness wait, distinguishes stale vs not-ready heartbeats, and states why singleplayer/server modes are impossible – all beyond annotation data.

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 long but dense; the first line gives the core purpose, the Args section is organized, and the closing heartbeat paragraph justifies nuanced behavior. No sentence is 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?

For a complex launch tool with five parameters, an output schema, and a readiness protocol, the description covers all parameter semantics, failure distinctions, and typical adjustments. Nothing the agent needs to call it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, this description compensates fully: each of the five parameters gets a purpose, constraint, and failure mode, e.g., player must already exist, world must be a Windows path. It adds substantial meaning beyond the raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The first sentence states a specific action: start tModLoader and wait until it is ready. It distinguishes from sibling tools by naming the launch/readiness behavior and later explains the only supported mode, so an agent can tell it apart from join or restart.

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 explicit conditions for parameter use: only server_client mode works, port should be changed only if needed, timeout raised on slow machines, and WSL world paths are refused. However, it does not name sibling tools as alternatives (e.g., join for an existing session), so it misses the explicit alternative routing that would earn a 5.

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

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

Annotations already declare readOnlyHint and destructiveHint, and the description adds value by explaining the dynamic, disk-read behavior and the example of a server-only session. This goes beyond the structured annotations without contradicting them, though it does not cover every possible edge case or performance implication.

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 fluff, and the core purpose is front-loaded. Every sentence adds meaningful information about what the tool does and why the result can vary, making it concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with an output schema and safety annotations, the description covers the essential dynamic behavior. Nothing an agent needs to decide to call it or interpret its purpose is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the baseline is 4. The description correctly avoids any parameter talk, and since there is nothing to document, it fully satisfies this dimension.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists logs and archive counts, with a specific verb and resource. It distinguishes itself by noting the result is read off disk rather than a constant, but it does not explicitly name or contrast a sibling tool, so it misses the top mark.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives contextual guidance about when the tool is appropriate (e.g., server-only sessions produce no client.log) but does not explicitly state when to use this tool over alternatives like 'logs' or 'log_watch'. The implied usage is clear, but exclusions and explicit alternatives are absent.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the `contains` filter is applied to the whole log before tailing (so it returns the last N matching lines, not matches among the last N), and negative line counts are refused. It also explains the log rotation behavior that makes `previous` necessary. This goes beyond the annotations without contradicting them.

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 well-structured with a clear one-line summary, a parameter breakdown, and a usage rationale. It is slightly longer than strictly necessary, but every sentence earns its place: the parameter details are non-obvious and the launch-failure context is genuinely useful. The front-loaded summary makes the purpose immediately clear.

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 read-only log tool with 4 optional parameters and an output schema, the description is nearly complete. It covers parameter semantics, the filtering behavior, and the real-world scenario where the tool matters. The only minor gap is that it doesn't describe the output format, but the presence of an output schema reduces the need for that. The launch-failure context and log-rotation explanation make it complete enough for an agent to use 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 carries the full burden of explaining parameters. It explains all four parameters: `name` (with concrete examples of which logs exist and what they contain), `previous` (with the rotation context), `contains` (with the case-insensitive whole-log behavior), and `lines` (with the zero/negative semantics). This is strong compensation for the schema's lack of descriptions, though it could be slightly more explicit about the default values.

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 opens with a specific verb and resource ('Tail one of tModLoader's logs') and immediately distinguishes itself from siblings by naming `log_files` for discovering available logs and `log_since`/`log_watch` as alternatives. It clearly states what the tool does and how it differs from related tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use this tool: 'Useful when a launch fails' and explains why the log is the right place to look. It also explains the purpose of the `previous` parameter in the context of a failed launch followed by a retry, which is exactly the kind of when-to-use guidance an agent needs.

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

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

The annotations declare readOnlyHint=true and destructiveHint=false, and the description adds substantial behavioral detail: offset is in bytes, fingerprints detect rotation, and on rotation the read restarts at zero while signaling via `restarted`. It also warns about the failure mode of quiet continuation. This is far beyond the annotation baseline.

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 front-loaded with the core meaning, then structured into argument definitions and behavioral caveats. Although it is long, every sentence adds needed context about byte offsets, rotation, or live-tail impossibility. No sentence merely repeats the schema or annotations.

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 four parameters, rotation-sensitive behavior, and a non-obvious resume protocol, the description covers all necessary calling details: how to resume, how filtering works, how rotation is detected, and which return field to check. The output schema covers return structure, so its absence from the description is not a 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 0%, so the description carries full weight. It explains all four parameters: name, offset (with the crucial 'BYTES, not lines' warning), contains (case-insensitive, applied only to new lines), and fingerprint (rotation detection). This adds real semantic meaning beyond the raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a precise statement of scope: 'Only what a log has gained since you last looked.' It names the specific operation (incremental read) and the resource (a log file), and later distinguishes itself from `logs` by saying `logs` re-reads the whole file while this returns the new part.

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 explicitly says this is 'the read between calls' and contrasts with `logs`, which re-reads a growing file. It also states a hard exclusion: 'NOT A LIVE TAIL, and it cannot be one,' explaining the synchronous limitation. This is enough for an agent to know when to choose this tool over 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?

The description goes far beyond the readOnly/destructive annotations. It discloses that the tool blocks, that it polls internally, that each line is matched exactly once, that a non-match returns `matched: false` rather than raising, that a missing log raises, and that `restarted` indicates log rotation. This is rich behavioral context that annotations alone could not provide.

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 long but every paragraph earns its place: the first paragraph defines the parameters, the second explains the core mechanism, and the third clarifies error semantics. The 'THE OFFSET IS THE MECHANISM' section is front-loaded with the most important behavioral insight. It could be tightened slightly, but the length is justified by the tool's complexity.

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 blocking, stateful, polling tool with 6 parameters and no schema descriptions, the description covers all the essential context: how to resume, what history means, what happens on timeout/non-match, what rotation means, and how it differs from `log_since`. The output schema exists, so return values don't need to be spelled out in prose. Nothing critical is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description carries the full burden, and it delivers. It explains `name` as coming from `log_files`, `contains` as case-insensitive and required, `offset` as the resume mechanism with history semantics, `fingerprint` as a resume token from earlier calls, `timeout` as whole-call budget, and `poll` as seconds between reads. This is far more than the schema's bare titles.

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 opens with a specific verb and resource: 'Block until a log line matches' a named log file, and immediately contrasts itself with the sibling `log_since` ('instead of polling `log_since` by hand'). This clearly distinguishes it from the closest alternative and states the tool's core behavior.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly explains when to use this tool versus `log_since`, including the offset mechanism for resuming, the meaning of `contains` being required, and the semantic difference between 'not matching' and a missing log. It also gives concrete guidance like 'did the mod load' being a question about history, which tells an agent exactly when to use offset 0.

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

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

Annotations already declare destructiveHint=true, and the description goes well beyond that: it explains the `keep` parameter is required to prevent accidental deletion, that `keep=0` removes all captures, that only files matching this mod's capture pattern are touched, that each file is re-checked for containment, that the whole set is validated before any unlink (so a refusal costs nothing), and that newest is determined by MTIME not filename index. This is rich behavioral disclosure that adds significant value beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured and front-loaded with the core action. It uses paragraphs to explain rationale, safety, and edge cases. It is somewhat long, but every sentence earns its place by explaining a non-obvious behavior or safety property. The only minor deduction is that some rationale could be tightened 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 destructive tool with one required parameter, the description covers everything an agent needs: what gets deleted, how the keep count works, what happens with keep=0, the containment check, the validation-before-delete behavior, and the MTIME ordering. The output schema exists, so return values need not be described. This is 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%, so the description carries the full burden. It explains `keep` in detail: it is required, deliberately has no default, `keep=0` is a real request that removes all captures, and it is compared against MTIME to decide which captures survive. This fully compensates for the schema's lack of 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 opens with a specific verb and resource: 'Delete all but the newest `keep` captures, and say which went.' It clearly distinguishes this from siblings like `shot` (which creates captures) and `read_capture` (which reads them). The purpose is unambiguous and immediately actionable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly explains when to use this tool: when captures have accumulated and need pruning. It contrasts with `shot` (which writes captures) and `read_capture` (which reads them), and explains the containment rule is the same as `read_capture`. It also warns against accidental destructive calls, making the usage context very clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it returns image content (PNG), is a separate call for performance reasons (tens of kilobytes before base64), and implies that calling it is unnecessary if the pixels aren't needed. It doesn't mention error handling or what happens if the name is invalid, but given the annotation coverage and simple nature, the added context earns a 4.

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 concise and well-structured. It opens with a one-sentence summary, then a short paragraph explaining the rationale for the separate call, and finally a focused argument description. Every sentence adds value; there is no filler or redundant phrasing. The purpose is front-loaded, making it easy for an agent to quickly grasp the tool's role.

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 single-parameter read tool with annotations covering safety, the description is nearly complete. It explains the purpose, why it exists as a separate call, and the parameter format. It references `captures.read` for additional containment details, which covers deeper context. The only missing piece is what happens on error (e.g., if the name doesn't exist), but that's a minor gap for a simple read operation and the description is otherwise sufficient.

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 compensate for the parameter documentation. It does so thoroughly: it explains that `name` is a capture filename from `captures`, provides a concrete example format (`<mod>-shot-<token>-001-topleft.png`), and clarifies that it is a name, not a path, pointing to `captures.read` for structural containment reasons. This gives the agent everything needed to supply a valid argument.

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 exactly what the tool does: 'Return one capture's PNG as image content.' It also distinguishes itself from the sibling `shot` tool by explaining that `shot` returns a filesystem path, which is useless to an agent not on that machine, and that this tool retrieves the actual image. The verb and resource are specific, and it clearly names the sibling it is not.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use this tool versus alternatives. It explains that `shot` returns a filesystem path and that this tool is the way to get the actual picture, and it explicitly states that callers who only need to know a capture succeeded should not call it due to the size cost. This gives the agent a clear decision rule and names the 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?

The description discloses critical behavioral traits beyond the annotations: the order of operations matters because building while the game is open fails misleadingly; it uses session settings rather than arguments; it records the world to avoid loading a different one on relaunch. These details explain side effects and pitfalls, going well beyond the minimal readOnlyHint/destructiveHint flags.

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 well-structured: purpose first, then args, then the critical order explanation, then session settings, and finally prerequisites. Every sentence adds value, from the explicit ordering warning to the world-selection pitfall. It is detailed without being bloated, and the key points are front-loaded.

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 with build, stop, and relaunch phases plus session-specific settings. The description covers all necessary aspects: what it does, why order matters, what settings are reused, and the prerequisite of a running session. It also explains potential failure modes (false compile errors, wrong world loading). Given the complexity and the presence of an output schema, the description is fully 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?

With schema description coverage at 0%, the description fully compensates by explaining each parameter: build ('Compile the mod between stopping and starting... On by default'), timeout ('Seconds to wait for readiness on the relaunch'), and build_timeout ('Seconds to allow the compile'). It also explains the default behavior and rationale, making the parameters self-documenting.

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 opens with a specific verb and resource: 'Stop, rebuild, and start again with the session's own settings.' It clearly distinguishes itself from siblings like launch and build_mod by explaining that it reuses the running session's configuration and enforces the correct order. The title 'Rebuild and relaunch the session' matches and adds specificity.

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 explicitly states when to use the tool ('Needs a running session') and when not to ('With nothing running there is nothing to reuse — call launch'). It also explains why the single call is preferable over three separate calls, providing clear context for choosing this over alternatives. The guidance is unambiguous and actionable.

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?

The description adds substantial behavioral detail beyond the destructiveHint annotation: it explains that the current state is saved to 'auto-before-restore' and returned as 'undo', making an incorrect restore recoverable. It also discloses refusal conditions. This is rich, honest context that exceeds what annotations alone provide.

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 well-structured: it starts with the core action, then explains the destructive behavior and the safety mechanism, then lists refusals. Each sentence adds value. It is slightly verbose but not wasteful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (which presumably documents return values), the description covers the key behavioral aspects: what happens on success (overwrite), the undo mechanism, and failure conditions. It does not explicitly describe the output format, but that is covered by the output schema. It is complete enough for an agent to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema provides only a bare 'label' parameter with 0% description coverage. The description compensates by explaining that 'undo' is a valid label and that the tool lists existing labels when a given one is invalid. This gives the parameter contextual meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'Overwrite the world and characters with a snapshot.' The title adds a synonym. It is clearly a restore operation, distinct from save_snapshot. However, it does not explicitly name sibling alternatives or differentiate them, so a 4 is appropriate.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides some usage context: it refuses while the game is running, implying you should stop the game first, and it refuses non-existent labels, listing valid ones. But it does not explicitly state when to use this tool versus alternatives like save_snapshot or capture tools. No direct when-to-use/when-not-to-use 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?

Beyond the annotations, the description discloses important behavioral traits: it refuses while the game is running, names the copied file types (.wld, .twld, .plr/.tplr), and explicitly excludes the whole Worlds directory and .bak files. This gives the agent a precise model of what the tool will and will not do.

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 longer than strictly necessary, but it is well-structured with bolded section headers and front-loaded purpose. The detailed rationale about mutating verbs, file sizes, and the running-game refusal earns its place because it directly affects when and how the tool should be invoked.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers when to use the tool, what files are copied, and the running-game refusal, and an output schema exists so return values do not need explanation. However, the required label parameter is left undefined, which is a meaningful gap for an agent trying to call the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There is one required parameter, label, with 0% schema description coverage, and the description never explains what label means, what format it should take, or how it is used to identify the snapshot for later restoration. The 'before a run' phrasing only weakly implies the label may identify the run, which is not enough to compensate for the missing documentation.

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 clear verb and resource: it copies the configured world and its characters aside so a run can be undone. It also names save_restore as the companion for after the run, but it does not explicitly distinguish this tool from the sibling save_snapshots, so it lacks full sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says to take a snapshot before a mutating run and use save_restore after it, and it warns that the tool refuses while the game is running and tells the agent to stop the session first. This gives clear context and an exclusion, though it does not discuss alternative tools such as save_snapshots for listing existing snapshots.

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?

The description goes well beyond the readOnlyHint and destructiveHint annotations by disclosing ordering, time units, and the significant behavior that unreadable manifests are omitted rather than shown as empty. It also explains why this is intentional, referencing the danger of restoring nothing and reporting success.

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?

Both sentences earn their place. The first states the core result and ordering; the second clarifies an edge case with a concrete reason. There is no redundant or filler content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, read-only listing tool with an output schema presenthol and safety annotations, the description covers everything an agent needs: what is listed, ordering, age units, and the handling of unreadable snapshots. No critical invocation details are missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so schema coverage is effectively complete and no parameter documentation is needed. The baseline of 4 applies because the description does not need to add parameter semantics and correctly omits 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 title 'List the saved copies' names a specific verb and resource, and the description expands to 'Every snapshot on this machine, newest first, with its age in seconds.' This clearly distinguishes the tool from siblings like save_snapshot and save_restore, which imply creation and restoration rather than listing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description makes clear this is a listing operation, so an agent can infer when to use it, but it does not explicitly state when to choose this over save_snapshot or save_restore, nor does it give exclusion criteria. The mention of save_restore is behavioral rationale, not usage 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?

Beyond the readOnlyHint/destructiveHint annotations, the description discloses meaningful behavior: it captures the back buffer rather than the screen, includes interface elements and dust, and only returns a path once the PNG bytes are complete. It also warns about the file-existence race condition, which is valuable operational context.

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 front-loaded with the core purpose and organized into clear sections for arguments and behavior. It is somewhat verbose, especially the final paragraph's phrasing, but the extra detail is substantive and not 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 tool with three parameters and an output schema, the description covers the purpose, parameter semantics, capture source, edge-case behavior, and timeout handling. Nothing needed to call the tool correctly appears to be missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, and the description fully compensates by explaining every parameter. It enumerates valid region values and their rationale, clarifies that target addresses a specific client, and gives precise semantics for timeout as a single budget for the whole call including the PNG write.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool captures a region of the game's back buffer and returns a PNG path, which is specific and actionable. It distinguishes the capture source from the screen and from the in-game capture camera, but it does not explicitly differentiate this from sibling tools like captures or read_capture.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives useful context for when the tool is appropriate, such as reading the game's rendered output rather than the screen, and explains why the region parameter is required. However, it does not explicitly name alternatives among the sibling tools or state when not to use this tool, leaving tool-selection guidance largely implicit.

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?

Goes beyond the readOnlyHint and destructiveHint annotations by disclosing that it reports only what the server believes it started, does not re-query the process table, and cannot detect externally closed games. This is valuable behavioral context that prevents misinterpretation of 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?

The description is compact and front-loads the core purpose. The additional sentences about read-only superiority and limitation on external process changes are relevant, though the phrasing could be tightened 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?

Given zero parameters, rich annotations, and an output schema, the description is complete. It covers what the tool reports, its reliability limits, and how it fits among sibling tools, leaving no critical gap for agent 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?

The tool has zero parameters, so there is no parameter semantics to convey. The baseline for zero-parameter tools is 4, and the description adds no unnecessary parameter information.

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 exactly what the tool does: reports whether a session is running and what it is. It also distinguishes itself as 'the only read-only way to ask', contrasting with launch and diag, so an agent can tell it apart from 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?

Explicitly explains when to use this tool: when an agent has lost track of session state and needs a read-only check. It contrasts with launch/diag, which fail depending on state, and notes that stop is needed to verify against reality, providing clear context on limitations.

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

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

Beyond the destructiveHint annotation, the description adds critical behavior: it fails if any pids survive, deliberately keeps the session, retries exactly those pids on the next call, and explains why premature verification causes false refusals. It also clarifies that killed_pids means verified-gone pids, not merely targeted ones.

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 front-loaded with a one-sentence mission, then structured into argument explanation, rationale, and failure semantics. Every sentence contributes operational value, and the structure makes the longer content easy to parse.

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 destructive teardown tool with one parameter and an output schema, the description covers invocation behavior, failure semantics, retry behavior, and consequences for subsequent launches. Nothing an agent needs to call it correctly and safely is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, so the description carries the full burden for the only parameter, settle. It explains the unit, the failure mode when too low on Windows with /F, and when to raise it on a loaded machine, which is fully actionable.

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 opens with a specific verb and resource: 'Kill only the processes this session started, and confirm they are gone.' It clearly scopes the operation to session-owned processes siege, and the 'Surgical on purpose' note distinguishes it from a broad tModLoader-wide kill.

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 clear context for when this tool is appropriate: a scoped teardown that avoids killing a developer's own game, and it explains that calling stop again retries surviving pids. It does not name explicit sibling alternatives, but the scope is clear enough that an agent can choose it over destructive broader kills.

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

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

Beyond the sparse annotations, it discloses failure semantics: unserved commands are refused before disk writes, unknown game responses are indistinguishable from hangs, refusals are reported separately from `ok`, and capture locks serialize across sessions with deadline/age-based takeover. No contradiction with readOnlyHint/destructiveHint.

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 definition is long but dense and well-structured: a one-line purpose, an Args block, then two paragraphs for response semantics and capture-lock behavior. Every paragraph adds information an agent needs to interpret replies correctly, and the purpose is front-loaded.

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, 1-required tool with subtle refusal/hang/capture behavior, the description covers invocation, response interpretation, side effects, and cross-session concurrency. It names the `commands` sibling for discovery and explains `note` as the only out-of-band field, so an agent has everything needed to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description carries the entire burden for all five parameters: `command` is dynamic and must be discovered at runtime, `target` defaults to the session's player, `server` selects a different authoritative side, `argument` is command-dependent, and `timeout` interacts with capture locking. This more than compensates for the empty schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific action and resource: 'Ask the running game to do something, and return what it said.' It frames trigger as the channel for dev commands served by the mod, and points to the sibling `commands` tool to enumerate them, so it is easy to tell apart from list-only sibling tools.

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 explicit conditional guidance per parameter: call `commands` to see valid commands, use `target` only for a different client, use `server` for server-authoritative commands, and pass `argument` only when a command reads one. These read as when-to-use rules and route the agent away from the discovery 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?

Beyond the annotations (readOnlyHint=true, destructiveHint=false), the description discloses critical behavioral details: the typed comparison semantics (ints vs bools), the refusal of conditions that can never be true, the return of `matched: false` with the last reading, and the timeout/poll mechanics. This is substantial added value over the structured metadata and gives the agent a complete mental model of the tool's 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?

The description is long but well-organized into clear sections: a terse opening, a detailed Args block, and three focused notes on typing, impossible conditions, and non-match returns. Every sentence adds information, but some parts (e.g., the typed comparison examples) could be trimmed without loss. Still, the structure front-loads the core purpose and keeps related details together, so it remains effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (7 params, 0% schema coverage, and a rich behavioral profile), the description covers everything an agent needs to call it correctly: parameter semantics, type handling, error behavior, and timeout/poll semantics. The presence of an output schema (not shown) means return format is already structured, but the description still explains the `matched: false` case, which is essential context. No significant gaps remain.

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 schema description coverage at 0%, the description carries the full burden of parameter documentation. It explains every one of the 7 parameters in the Args section: `field` (top-level only, not paths), `op` (enum-like list), `value` (text converted to field type), `server`/`target` (view selection), `timeout` (whole-call budget), and `poll` (interval). This fully compensates for the absent schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a precise verb and resource: 'Poll `diag` until one of its fields satisfies a comparison.' This clearly identifies the tool's action and distinguishes it from sibling tools like `diag` (direct read) and `log_watch` (log watching). It also explicitly states when to prefer it over sleeping and taking a `diag`, reinforcing its unique role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit guidance: 'Use this instead of sleeping and taking a diag' and explains why a guessed sleep is wrong in both directions. It also clarifies behavior for impossible conditions and non-matching outcomes, which helps the agent decide when the tool is appropriate. The parameter docs for `server` and `target` further specify use cases for client vs. server views.

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