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

The description discloses that files are written only below NEON3_APP_ROOT, which is a valuable safety boundary. However, it omits other behavioral traits such as overwrite semantics, whether it creates directories, or what happens if the destination already exists. With no annotations, this is a partial disclosure.

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 that immediately conveys the core action. Every word contributes: bounded, Python or Node, and the root restriction. 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?

Without annotations or output schema, the description is all an agent has. It covers the basic operation but omits critical context such as how overwrite behaves, the relationship between destination and NEON3_APP_ROOT, and what the template contains. This is insufficient for reliable invocation, especially since two parameters are required.

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 explain parameters. It references 'Python or Node' which maps to the runtime enum, and 'NEON3_APP_ROOT' hints at destination scope, but it doesn't clarify the destination parameter or the overwrite flag. The overwrite behavior is entirely undocumented, leaving the agent uncertain how to set 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?

Clearly states it creates a Neon3 application template with a specific verb and resource. The 'bounded' qualifier and mention of Python/Node scope it relative to sibling tools like neon3_project_assets or neon3_app_run. Distinct enough that an agent can identify its 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?

No guidance on when to choose this tool over siblings. It does not mention alternatives or conditions, such as when to use neon3_project_assets or neon3_app_run. The only implied usage is when initializing an app, but this is not explicit.

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 must carry the full behavioral burden. It mentions a fixed executable profile and bounded timeout, but does not disclose side effects of executing arbitrary code, timeout behavior, or any safety guarantees. This is a significant gap for a tool that runs user-provided code.

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 sentence with no waste, which is good for conciseness, but it omits essential information needed for correct invocation. The lack of structure or additional context makes it less useful than it could be.

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 5 parameters and no annotations or output schema, the description is too sparse. It does not explain what 'generated' means, what the fixed executable profile entails, how to specify code, or the meaning of the bounded timeout. An agent would need to infer most call details.

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 adds no parameter explanations. It does not mention cwd, args, entry, runtime, or timeout_ms semantics. The schema's enum for runtime is the only guidance, leaving the agent to guess parameter intent.

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 runs a generated Python or Node app with a fixed executable profile and bounded timeout. The verb 'Run' and the resource 'app' are specific, and it distinguishes itself from siblings like neon3_app_init (initialization) and neon3_app_test (testing) by focusing on the execution step.

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 implies usage for executing an app but does not explicitly contrast with alternatives like neon3_app_test or neon3_app_init. The description gives no when-to-use guidance beyond the underlying action, so an agent must infer context from the tool 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?

With no annotations, the description carries the behavioral burden and does add useful traits: checks are deterministic, local, and make no live Neon3 service contact. However, it does not disclose possible side effects, failure behavior, or what the tool reports 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?

A single, front-loaded sentence with no filler or redundant phrasing. Every word contributes to the tool's core behavior, making it easy to scan.

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 test tool with no output schema and no annotations, the description should explain what a successful check looks like and how runtime, cwd, and timeout relate to execution. It gives good high-level context but lacks the invocation-level details an agent needs.

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 names none of the three parameters. The parameter names and runtime enum are self-explanatory, but the description does not clarify what cwd should point to or how timeout_ms is applied to the checks.

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 ('Run') and resource ('deterministic local protocol checks') and includes a distinguishing qualifier ('without contacting a live Neon3 service'). This sharply differentiates it from siblings like neon3_app_run or live-service checks.

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 'without contacting a live Neon3 service' implies the offline/local testing context, but no alternative tools are named and no explicit when-not-to-use guidance is provided. The usage intent is inferable 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. 'Query' implies read-only behavior, but the description does not explicitly state that no modifications occur, nor does it explain behavior when zero, one, or multiple endpoints are supplied.

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 well-front-loaded sentence with no filler, putting the verb and resource first. It is concise, but the brevity contributes to missing usage and parameter context.

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 semantically undocumented optional parameters, the description is not complete enough for an agent to reliably select and invoke the tool. It only conveys the high-level operation and return value, not endpoint semantics or invocation strategy.

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 explain ui_endpoint, wgpu_endpoint, or projectd_endpoint. The endpoint names are mildly self-descriptive, but the description adds no meaning about how these parameters map to Neon3 services or how they should be selected.

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 operation ('Query service.describe') and the returned data ('current capabilities and epochs'), so the tool's purpose is clear. It does not explicitly differentiate itself from sibling tools like neon3_diagnose or neon3_nui_inspect, so it stops short of full sibling-focused clarity.

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 states what the tool does but gives no guidance on when to use it versus alternatives. It also does not explain whether the three optional endpoints are alternatives, mandatory in some combination, or optional for querying all services.

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 burden. It only says the tool 'aggregates' data, without disclosing whether it is read-only, what side effects or outputs occur, whether it requires specific permissions, or what the response format looks like. For a diagnostic tool, 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?

The description is a single concise sentence with no unnecessary words. It fronts the main action and context, but its brevity comes at the cost of critical detail. It is appropriately sized, though not the most informative.

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 3 parameters (all optional), no output schema, and a crowded sibling set, this description is incomplete. It does not explain what happens when called with no arguments, what the aggregated output looks like, or how it differs from neon3_ui_snapshot and neon3_nui_inspect. An agent cannot confidently decide when or how to invoke it.

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 parameters. It mentions the data types ('service snapshots, UI revisions, interaction trace') but does not map them to ui_endpoint, wgpu_endpoint, or interaction_id. It never explains what these endpoints are or how they relate, leaving the agent to guess their meaning and required 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 uses a specific verb ('Aggregate') and names the data sources (service snapshots, UI revisions, interaction trace) for a defined context (Neon3 authoring issue). It distinguishes the tool's role as aggregator, but does not explicitly contrast with siblings like neon3_ui_snapshot or neon3_nui_inspect, leaving some ambiguity about its uniqueness.

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 tool versus the many sibling tools that also handle UI snapshots or inspection. The description implies it is for diagnosing an authoring issue, but does not state conditions, prerequisites, or preferred scenarios. The agent must infer usage context.

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 bears full responsibility for behavioral disclosure. It states a read-like operation ('Return') but never explicitly confirms no side effects, nor does it mention error behavior, required context, or any constraints. The lack of any behavioral detail beyond the output list is a significant gap 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?

The description is a single, compact sentence that efficiently lists the returned items. It is concise and not padded with fluff, though it lacks any structural breaks or emphasis on key aspects.

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 returns a rich set of artifacts (IR, schemas, state machines, etc.) with no output schema, the description should at least hint at the format or structure of the return. It does not. Moreover, it fails to clarify the input parameter, leaving agents without enough context 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?

The schema has one required parameter 'source' with no description, and the tool description does not explain it at all. Since schema coverage is 0%, the description must compensate, but it does not clarify what 'source' refers to (e.g., a path, an ID, or a reference). This is a critical omission.

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 a specific action ('Return') and a detailed resource list (canonical IR, schema, state machines, etc.), making it unambiguous what the tool produces. However, it does not differentiate from sibling tools like neon3_nui_validate or neon3_nui_reference, so an agent might not know when to pick 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?

There is no guidance on when to use this tool versus alternatives. The description only enumerates the returned artifacts, with no mention of context, prerequisites, or exclusions. An agent is left to infer usage from the tool 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'Read' indicates a non-mutating operation, which is helpful, but it does not describe the return format, whether any side effects occur, or any prerequisites. For a read-only look-up tool, this is acceptable but not exhaustive.

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—two short sentences—and front-loads the core action ('Read') followed by a list of topics. It avoids unnecessary detail and is easy to scan, but a bulleted list could slightly improve structure.

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

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

Given the simplicity of the tool (one enum parameter, no output schema), the description provides the essential topics and a clear action. However, it omits details about what the response will contain, such as the format or extent of the reference text, which an agent might need to set expectations. With no annotations and no output schema, this gap is notable.

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 only one parameter ('topic') with an enum, and the description explicitly lists the same topics ('overview, grammar, components, statecharts, interactions, diagnostics'). This reinforces the schema and adds clarity about the valid values, compensating for the schema description coverage of 0% by providing the enum values in prose.

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 action ('Read') and the resource ('authoritative Neon3 NUI Flow V1 reference'), making the purpose unambiguous. It lists the topics covered, which helps differentiate it from action-oriented siblings like neon3_nui_validate or neon3_nui_inspect, but it does not explicitly name or contrast 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?

The description implies the tool is for retrieving reference material on NUI Flow topics, but it provides no explicit guidance on when to choose this tool over alternatives. It neither lists exclusions nor names sibling tools that might be better suited for other tasks, leaving the agent to infer usage context.

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 burden of disclosing side effects. It describes a two-step behavior (validate, then submit) and implies a write operation, but does not state whether submission is destructive, reversible, or idempotent (despite the idempotency_key parameter). It also lacks details on failure handling or return behavior. The high-level flow is present but shallow.

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 sentence with no filler words, efficiently conveying the main action. However, it is so terse that it sacrifices necessary context for other dimensions. It earns a 4 for brevity, but the structure lacks any breakdown or elaboration where 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?

For a tool with four parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the purpose of ui_endpoint, idempotency_key, or expected_revision, nor what happens after submission. An agent cannot correctly construct a call or interpret results based on this description 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 0%, so the description must compensate by explaining parameter meaning. However, it mentions none of the four parameters (source, ui_endpoint, idempotency_key, expected_revision). 'source' is presumably the NUI Flow code, but this is never stated. The description adds zero semantic value beyond the schema's bare property 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 clearly states the tool validates NUI Flow locally and then submits it through ui-runtime to the WGPU runtime. It uses a specific verb (validate, submit) and resource (NUI Flow, ui-runtime, WGPU runtime), and distinguishes itself from sibling 'neon3_nui_validate' by explicitly adding submission as part of the pipeline.

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 no guidance on when to use this tool versus alternatives. It does not mention 'neon3_nui_validate' or any other sibling, nor does it state when to choose validation-only versus submission. Usage is only implied by the pipeline itself, which is insufficient for an agent to confidently select this tool over its 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 burden of behavioral disclosure. It states that the tool parses and compiles and explicitly says it does not submit. However, it does not describe what happens on compile failure, whether there are side effects, or what the response looks like, so transparency is partial.

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 no wasted words. The core action is front-loaded, and the critical safety caution 'Never submit automatically' earns its place as a separate, memorable instruction.

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 validation tool, the description covers the core action and a key safety constraint. But with no output schema and no mention of result/error semantics, an agent still lacks some context about what a successful or failed validation will actually return.

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. It never explicitly describes the 'source' parameter, though the phrase 'Parse and compile NUI Flow' implies the source should contain NUI Flow content. This is only indirect inference, not clear parameter guidance.

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 phrase, 'Parse and compile NUI Flow', which clearly names the resource and the action. It also implicitly distinguishes itself from the sibling 'neon3_nui_submit' by ending with 'Never submit automatically,' though it does not explicitly name the 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 instruction 'Never submit automatically' gives meaningful usage context, implying this tool is a validation/compile step that should not be chained into submission. However, it does not explain when to prefer this over siblings like neon3_nui_inspect or neon3_nui_reference, leaving some routing ambiguity.

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 burden. It does state 'Read', which suggests a safe read operation, but it does not disclose endpoint behavior, error conditions, output format, or any other side effects. The word 'stable' hints at output behavior but is too vague to provide meaningful transparency.

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

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

The description is a single, direct sentence with no filler. It front-loads the action and object and is appropriately concise for a tool with one optional parameter.

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, no annotation, and no endpoint or usage context. An agent is left without enough detail about how to supply 'projectd_endpoint', what 'projectd' refers to, or how this tool fits alongside the many related sibling tools. The bare statement of what it reads is not enough for reliable selection and 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 never mentions 'projectd_endpoint' or explains how it should be used, whether it is optional in practice, or what format it should take. The schema only provides the property name, type, and minLength, so the description adds no parameter-level 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 uses a clear verb ('Read') and names specific resources ('project summary', 'stable AssetRef entries') plus the source ('projectd'). It is reasonably distinguishable from sibling tools like the nui_* and app_* tools, though it does not explicitly contrast itself with 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 guidance about when to use this tool versus its siblings, nor any stated conditions, prerequisites, or exclusions. The intended usage must be inferred entirely from the tool name and the one-line 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?

The description implies a read-only operation via the verb 'Read,' which is a behavioral hint, and it lists what is included in the snapshot. However, with no annotations, it does not disclose potential errors, side effects, or any constraints such as required authorization. The extra detail about contents adds some transparency, but it remains thin.

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 that quickly states the core action and its scope. There is no extra wording or redundancy; every word contributes to the 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 a parameter that is unexplained and no output schema, the description leaves significant gaps. An agent would not know how to supply the ui_endpoint or what to expect in return, making the tool under-specified for a single-parameter 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?

The schema has a single parameter 'ui_endpoint' with no description (coverage 0%), and the description does not mention or explain this parameter at all. With no compensation from the description, an agent cannot know what value to provide or what effect it has.

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 action ('Read') and the resource ('current UI runtime snapshot'), and adds specificity by mentioning 'active fragment and input revisions.' It does not explicitly name a sibling tool for differentiation, but the verb and resource are concrete enough to convey the tool's purpose.

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 tool versus siblings. The description says nothing about context, prerequisites, or alternatives, leaving the agent to infer usage from the name and siblings alone.

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