Brain Scanner

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false. The description adds the specific detail that it 'releases its staged data', which is useful beyond the generic destructive flag. However, it does not disclose side effects like whether the sync record is deleted, if the operation is reversible, or any state prerequisites. With annotations covering the core safety profile, this is an adequate but not rich 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 with no filler. It communicates the action and outcome efficiently. It is appropriately concise, though it sacrifices helpful details for brevity.

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, multi-parameter operation with no output schema and zero parameter documentation, the description is far too sparse. It does not clarify the purpose of optional parameters like sessionId or executionId, nor does it explain the lifecycle position of an 'uncommitted' sync or how this relates to commit and seal. An agent would need to infer too much.

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 provides no explanation of any of the 5 parameters (syncId, projectId, sessionId, executionId, idempotencyKey). The agent must rely on parameter names and schema patterns alone, which is insufficient for a destructive operation with optional parameters. The description fails to compensate for the complete lack of schema 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 clearly states the verb 'Abort' on a specific resource 'an uncommitted hosted graph synchronization', and adds the effect 'release its staged data'. This distinguishes it from sibling tools like commit_project_sync or begin_project_sync without needing to inspect schemas.

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

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

The description specifies the target is 'uncommitted' syncs, giving clear context for when to use it. It does not explicitly name alternatives or exclusions, but the 'uncommitted' qualifier implicitly routes the agent away from commit or seal operations. Slight gap in not mentioning any conditions for abort (e.g., must be in progress).

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 provide idempotentHint=true, destructiveHint=false, readOnlyHint=false, but the description adds zero behavioral context. It does not disclose side effects, idempotency semantics, required permissions, or any operational traits. Since the description's role is to add value beyond annotations, and it adds none, this scores minimal.

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 vague sentence, which is short but not concise in a helpful way. It is under-specified rather than efficiently packed with information. It does not front-load any actionable guidance, making it more of a placeholder than a structured definition.

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 (nested objects, required parameters, no output schema), the description is completely inadequate. It does not explain return values, error conditions, or the purpose of the payload structure. An agent would have no idea what to expect or how to interpret the schema.

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 lack of parameter documentation. However, the description does not mention any parameters, their meaning, or relationships. The schema shows required fields (projectId, idempotencyKey) and optional ones, but the description offers no explanation, leaving agents to infer everything from schemas alone.

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 'Use the closed activity write capability family from the frozen Brain Scanner policy' is extremely vague. It does not state what the tool does, what operation it performs, or what resource it affects. It fails to distinguish from siblings like record_activity, context_write, or knowledge_write, all of which are write operations. It is more of an opaque reference than a purpose statement.

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 does not mention any conditions, exclusions, or alternative tools. An agent cannot determine when this is the appropriate choice among the many write tools in the sibling list.

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

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

The description adds no behavioral context beyond the annotations. Annotations already indicate idempotentHint=true and destructiveHint=false, but the description does not explain idempotency implications, safety, or any side effects. It also does not clarify that different operations within the oneOf schema might have different behavioral characteristics. With zero added context, it fails to help the agent understand what happens when calling this tool.

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

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

While the description is short (one sentence), it is severely under-specified rather than concise. It does not front-load any useful information and provides no structure to guide the agent. The sentence is essentially a vague directive that adds no value.

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 (five operations, nested payloads, required fields like idempotencyKey and expectedVersion), the description is completely inadequate. It lacks any explanation of the tool's purpose, parameter semantics, behavior, or usage context. There is no output schema to compensate, so the description is the sole source of guidance, and it provides none.

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, but it provides no information about the parameters. The schema has a complex oneOf structure with operation and payload fields, but the description does not explain the purpose of any parameter, such as projectId, nodeId, idempotencyKey, expectedVersion, or details. The agent is left to infer meaning purely from the schema, which is insufficient given the complexity.

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 does not state what the tool does. It only says 'Use the closed agent action capability family from the frozen Brain Scanner policy,' which is vague and does not mention any of the actual operations (finish_node_work, open_node_in_editor, relay_execute_local_action, run_selected_tests, start_node_work) that the schema defines. There is no specific verb+resource, and it fails to distinguish this from its many siblings, many of which share the same operation names.

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 is given on when to use this tool versus alternatives. It does not explain that this is a wrapper for multiple agent actions or when to choose this over the individual sibling tools like finish_node_work or start_node_work. No conditions, exclusions, or alternative references are provided.

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, idempotentHint=true, and destructiveHint=false, so the description doesn't need to repeat those. It adds 'privacy-filtered project metadata', hinting at a filtering behavior, but it's not specific about what that means for the caller. It doesn't disclose pagination, error cases, or authentication requirements.

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, but it's under-specified rather than concise. It lacks essential information and doesn't front-load the most useful details. It's short but not appropriately sized because it omits crucial 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 six parameters, no output schema, and only basic annotations, the description is grossly incomplete. An agent has no idea what 'analyze impact' is, what parameters do, or what to expect in the response. This is far from a minimal viable description.

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 for explaining the six parameters. It only mentions 'project metadata' indirectly, and none of the parameters (projectId, cursor, nodeIds, pageSize, sessionId, executionId) are explained. The description adds no value for parameter understanding.

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

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

The description states a verb 'Read' and a resource 'hosted analyze impact', but 'analyze impact' appears to be the tool's own name, making this nearly a tautology. The phrase 'privacy-filtered project metadata' adds context but doesn't clarify what the tool actually does or returns.

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 mention of when to use this tool versus other read tools like graph_read or project_read. No alternatives or exclusions are provided, leaving the agent without routing 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 idempotentHint=true, readOnlyHint=false, and destructiveHint=false, covering the basic safety profile. The description adds the behavioral trait 'privacy-filtered' and the append operation, but it does not disclose ordering requirements, validation behavior, or error handling. Given the annotation coverage, a mid-range score is appropriate.

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, tightly constructed sentence with a clear action and no filler. It is appropriately front-loaded and every word contributes to the core 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 the tool's complexity (10 parameters, reading/writing a chunked graph, and a multi-step sync lifecycle), the description is far too sparse. It does not explain the chunked upload protocol, the significance of chunkIndex and chunkDigest, or the idempotency guarantee in practice. With no output schema, the description should cover more ground, but it leaves critical workflow context unstated.

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 burden of explaining parameters. It does not clarify the roles of projectId, syncId, chunkIndex, chunkDigest, chunkSize, idempotencyKey, or how nodes and edges relate to the chunk concept. The phrase 'graph metadata chunk' only weakly hints at the arrays, leaving the agent to rely on parameter names alone.

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 ('Append'), a specific resource ('privacy-filtered graph metadata chunk'), and a destination ('hosted synchronization'). This clearly differentiates the tool from siblings like begin_project_sync, commit_project_sync, and seal_project_sync, which perform other stages of the sync process.

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 no guidance on when to use this tool versus alternatives. It does not mention that it should follow begin_project_sync, precede commit_project_sync, or how it relates to graph_sync or patch_project_graph. An agent cannot infer the correct step in the sync workflow from the description 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?

Annotations indicate readOnlyHint=false and destructiveHint=false, yet the tool clearly performs a state-changing operation (updating a meter change). Although not strictly contradictory (destructiveHint=false suggests non-destructive, which may be accurate for an update), the description does not disclose that this is a write operation, nor does it mention idempotency or that it requires a previous queue entry. With annotations only giving hints, the description adds little to behavioral transparency, and there is a slight tension with readOnlyHint=false. It doesn't explain error handling or side effects.

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

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

The description is a single short sentence with no unnecessary words, so it is concise. However, it is under-specified, not just concise. It front-loads the phrase 'Update hosted apply implementation meter change' but this is almost repetitive of the name. There is no additional structure; it is just a sentence.

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 (11 required parameters, multiple fingerprints and versions, no output schema), the description is very incomplete. It does not explain what 'apply' means, how it relates to pending changes, what the return value is, or how to handle errors. An agent would be left guessing about parameter semantics and the expected workflow. Sibling tools like 'get_pending_implementation_meter_changes' suggest a sequence, but this is not explained.

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%, meaning the description provides no parameter explanations. The schema alone gives names, types, and patterns, but complex concepts like 'baseSourceFingerprint', 'resultingMeterKey', 'expectedProjectVersion', and 'idempotencyKey' are not elaborated. The description mentions 'privacy-filtered project metadata', but this is vague and does not map to specific parameters. The tool has 11 parameters, all required, so the description should compensate for the lack of schema descriptions, but it does not.

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 'Update hosted apply implementation meter change using privacy-filtered project metadata.' is nearly a restatement of the tool name. It uses the same verb 'apply' and noun 'meter change' without clarifying what 'apply' means in this context (e.g., committing a meter update). It fails to distinguish from sibling tools like 'queue_implementation_meter_request' or 'get_pending_implementation_meter_changes', which are clearly related but not 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?

There is no guidance on when to use this tool versus alternatives. For instance, when should an agent call this tool instead of 'queue_implementation_meter_request' or when is it appropriate after a pending change? The description does not mention prerequisites, such as needing to retrieve a pending change first, nor does it explain the workflow 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?

The description aligns with annotations: 'Update' implies mutation consistent with readOnlyHint=falseemento, and no contradiction exists. It adds the behavioral detail 'privacy-filtered project metadata', but doesn't disclose idempotency mechanics, expectedVersion semantics, or effects beyond the annotation basics.

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 or redundancy. It front-loads the core action (update) and object (hosted archive context note) efficiently.

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 7 parameters, 4 required, a nested object, and no output schema, this description is severely incomplete. It gives no clue about expectedVersion semantics, idempotency key usage, or what the details object contains, making correct invocation purely dependent on the raw schema.

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 none of the parameter meanings. It fails to explain projectId, noteId, idempotencyKey, expectedVersion, or the details object, leaving all parameters to the schema alone.

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: 'Update hosted archive context note'. The modifier 'hosted archive' distinguishes it from generic updates like update_context_note or context_write, though it doesn't explicitly name those siblings.

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

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

There is no explicit guidance on when to use this tool vs alternatives like update_context_note or move_context_note. The phrase 'using privacy-filtered project metadata' hints at a use case but doesn't state conditions or exclusions.

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

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

Annotations already cover readOnly=false, destructive=false, idempotent=true, and openWorld=false, so the description is not the sole source of behavioral information. It adds only 'hosted' and 'privacy-filtered' context, but does not explain what side effect occurs when a new executionId is supplied or how idempotency is enforced. No contradiction with annotations exists.

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, so it is brief. However, the phrasing 'Update hosted begin agent execution' is grammatically awkward and under-specified, so brevity comes at the cost of clarity.

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 9-parameter tool with a nested object and no output schema, this description is far too thin. It does not explain when the call happens, what the call returns, or how it relates to other execution/session lifecycle tools, leaving the agent to guess from the schema alone.

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

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

With schema description coverage at 0%, the description needed to compensate, but it only vaguely references 'privacy-filtered project metadata'. It does not explain executionId, threadId, trigger, occurredAt, idempotencyKey, agentId, parentExecutionId, or the nested requestMetadata object.

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 says 'Update hosted begin agent execution' but it never states whether this tool begins, records, or modifies an agent execution. The verb 'Update' conflicts with the action implied by the tool name and is not differentiated from lifecycle siblings such as start_agent_session, finalize_agent_execution, or finish_agent_execution.

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 call this tool versus alternatives, no lifecycle context, and no prerequisites or exclusions. The only useful signal, 'privacy-filtered project metadata', suggests what data to pass but not when the operation is appropriate.

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 indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds little beyond 'bounded' and that the narrative sections are written manually; it does not explain side effects such as session creation, validation behavior, or how idempotency is applied. It does not contradict 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 a single sentence, front-loaded with the core verb and resource, and it includes a useful constraint about the narrative sections. It is concise without wasted words, though it could be better structured by separating the concept from the writing requirement.

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 12-parameter, mutation-oriented tool with a nested object, no output schema, and no parameter descriptions. The description does not explain the sync workflow, prerequisites, validation of declared counts, or the relationship to sibling tools. It is far from sufficient for an agent to invoke it correctly in context.

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 should compensate, but it only clarifies that changeNarrative has four plain-language sections. It leaves the many count declarations, expectedProjectVersion, idempotencyKey, projectId, and other parameters unexplained. Some property names are self-explanatory, but the nested object and synchronization constraints need more 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 states a specific verb ('Begin') and resource ('hosted graph synchronization'), and adds useful qualifiers: 'bounded' and 'four plain-language changeNarrative sections'. This makes the tool's role clearer than the name alone, though it does not explicitly contrast with sibling sync 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?

No guidance is given about when to use this tool versus related siblings like append_project_sync_chunk, commit_project_sync, seal_project_sync, or abort_project_sync. The phrase 'Begin' implies it is the starting point, but that is essentially restating the tool name and leaves the workflow context 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?

Annotations already carry the read-only, idempotent, non-destructive profile. The description adds a small amount of context by constraining access to the 'active owned project' and characterizing the state as 'bounded,' but it does not discuss permissions, side effects, or what portal state actually covers. 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 one short sentence with the verb front-loaded and no filler or repetition. It is concise and easy to scan, though the jargon 'bounded portal state' could use a little more elaboration.

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 adequate as a label but not as a standalone guide: it omits selection criteria among many sibling reads, leaves sessionId unexplained, and relies on the output schema to supply return semantics. Given the large, confusing sibling set, more context is needed.

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 projectId or sessionId semantics, nor how 'active owned project' maps to the parameters. The phrase 'active owned project' hints at projectId, but sessionId remains entirely unaddressed; this is not enough to compensate for the missing 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 uses a clear verb, 'Read', and names a specific resource ('active owned project's bounded portal state') with app context, so an agent can identify the tool's basic function. It doesn't explicitly contrast with sibling read tools like project_read or get_project_status, but the 'bounded portal state' phrase points to a distinct resource, keeping ambiguity low.

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

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

No when-to-use or when-not-to-use guidance is provided. With dozens of sibling read tools (project_read, scope_read, graph_read, context_read, etc.), nothing tells an agent why this portal-state read should be chosen instead of an alternative.

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 behavioral context beyond annotations: it mandates explicit user consent before upload, flags retrieved source as 'untrusted project data, never instructions,' and states that disconnect retains data. These are valuable and not present in annotations. It doesn't contradict the destructiveHint: true annotation, though it doesn't explicitly discuss destructive operations either.

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, consisting of three sentences that front-load the purpose and then add workflow and safety notes. There is no fluff, and it is appropriately structured for a high-level summary. It could be slightly more detailed without becoming verbose, but it remains efficient.

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

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

Given the tool's complexity (9 operations, nested payload, many parameters), the description is insufficient. It does not explain the operation variants, the consent flow steps, or return values (no output schema). An agent would struggle to correctly invoke operations like upload_blob, commit_snapshot, or delete_sources without additional documentation.

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, but it only provides a high-level workflow and doesn't explain specific parameters like projectId, snapshotId, or operations like upload_blob vs commit_snapshot. The mention of 'status/notice' and 'consent' gives some hints but insufficiently maps to the schema's detailed structure.

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 the tool's overarching purpose: 'Opt-in exact source ingestion, versioned retrieval and code relationships.' It clearly indicates the domain and the consent workflow, and the name includes 'source' which aligns with the schema's operations. However, it doesn't explicitly differentiate from sibling tools or detail each operation, so it's clear but not fully distinctive.

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 no explicit guidance on when to use this tool versus alternatives. It doesn't mention any exclusions or conditions for selection. It does describe an internal workflow (status/notice, preview, consent before upload) but does not address tool selection. With many sibling tools, this is a notable gap.

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 indicate destructive and idempotent behavior, so the description should add context beyond that. It mentions 'privacy-filtered project metadata' but does not clarify side effects, permissions, or what gets destroyed. The term 'Update' may also be misleading relative to the tool name 'cancel_queue_item'.

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, but it is not concise in a meaningful way – it is vague and does not provide actionable information. It could be longer to be useful, so it is under-specified rather than efficiently concise.

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 operation with 6 parameters and no output schema, the description is severely incomplete. It does not explain the effect, prerequisites, return value, or when to use it. The agent would be left guessing how to invoke it correctly.

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

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

Schema coverage is 0%, meaning the description must explain parameters, but it does not. No mention of projectId, queueItemId, expectedVersion, idempotencyKey, or sessionId/executionId. The phrase 'project metadata' does not clarify parameter semantics.

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

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

The description states a specific action ('Update') and a resource ('hosted cancel queue item'), which is fairly clear. However, it does not distinguish from siblings like 'update_queue_item' or 'cancel_queue_type', and the phrase 'using privacy-filtered project metadata' is vague and unexplained.

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 is given on when to use this tool versus alternatives such as 'cancel_queue_type' or 'preview_queue_type_cancel'. The description does not mention any conditions, exclusions, or recommended usage scenarios.

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 indicate idempotent and destructive behavior, but the description adds no behavioral context of its own. It does not say what state is replaced, that a preview should precede cancellation, or what side effects occur.

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

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

The definition is one tight sentence with no filler and the main verb is front-loaded. However, for a seven-parameter tool with no output schema, this brevity crosses into under-specification rather than useful conciseness.

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 seven parameters, no output schema, and destructive annotations, an agent needs prerequisites, effects, and relation to preview_queue_type_cancel to call this correctly. The description only states the target and the data source, leaving most operational context absent.

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

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

Schema description coverage is 0% and the prose explains none of the seven parameters. IdempotencyKey, previewDigest, snapshotVersion, and requestType are left entirely to naming conventions; the only clue is 'privacy-filtered project metadata,' which does not clarify any required field's role.

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

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

The description names a specific action ('Update') and target ('hosted cancel queue type'), and adds the data-source qualifier 'using privacy-filtered project metadata.' It is clear on the surface, though it does not explicitly differentiate from sibling tools such as preview_queue_type_cancel or cancel_queue_item.

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

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

No when-to-use guidance, no mention of the preview-then-update workflow, and no alternatives are named. The closest sibling, preview_queue_type_cancel, is not referenced, so an agent cannot learn conditions for choosing this tool over another.

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 behavioral context beyond the annotations: claims expire automatically and never block a publish, and are advisory in nature. This complements the idempotentHint and destructiveHint annotations, providing useful operational knowledge. 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?

Two sentences, no waste, and the core purpose is front-loaded. Every word earns its place.

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 too sparse for a tool with six parameters and no output schema. It omits lifecycle details (e.g., how to release the claim, what happens on conflict, meaning of TTL), and does not reference the sibling release_map_scope. An agent would need more information to use 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 has 0% description coverage, and the description provides no parameter explanations. While parameter names are somewhat self-explanatory, the description does not add meaning to fields like scopePrefix, idempotencyKey, or ttlSeconds. This is a significant gap for a tool with six parameters.

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: an advisory claim on a repository subtree to prevent overlapping work among concurrent mappers. It distinguishes itself from siblings like release_map_scope by implying a claim/release lifecycle, and from map_project by specifying the advisory coordination 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 indicates the scenario for use (when concurrent mappers need to avoid overlapping work) but does not explicitly mention alternatives or when not to use. It lacks a reference to release_map_scope, which is a sibling that presumably releases the claim. While the context is clear, no exclusions are given, so it falls short of the highest level.

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 mark destructive and idempotent; the description adds that prior versions stay restorable within retention, that the operation is auditable, and that the publishing agent must manually author four narrative sections. This is valuable operational context beyond the annotations, with no contradiction.

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?

Three short sentences each add distinct information: purpose/recoverability, retention behavior, and the narrative-writing requirement. No filler or redundant restatement; the most important fact 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 destructive mutation with no output schema, the description omits critical invocation details such as how expectedProjectVersion is used (optimistic concurrency), what idempotencyKey enforces, and what the response indicates. The retention and narrative guidance help, but an agent could still misuse the required parameters.

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

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

The description gives meaning to changeNarrative by specifying four plain-language sections, matching the schema's nested required fields. However, the four other parameters (projectId, expectedProjectVersion, idempotencyKey, sessionId) are left entirely undocumented, and with 0% schema description coverage the description only partially compensates.

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 names the exact operation—'Reset the published graph to empty'—with a specific verb and resource, and the phrase 'explicit, auditable operation' clarifies its distinct role compared to incremental patch or publish tools. It does not name sibling tools, but the reset-to-empty semantics are 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?

There are no explicit when-to-use or when-not-to-use statements, and no alternatives are mentioned. The notes that prior versions remain restorable and that the publishing agent must craft the narrative imply a deliberate, safety-conscious reset, but selection criteria relative to patch_project_graph or publish_project_graph are left to inference.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the base safety profile is known. The description adds 'Atomically,' which is a useful behavioral trait, but it does not explain what gets replaced or destroyed when publishing, or what state transitions occur.

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

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

The description is a single, front-loaded sentence with no filler. 'Atomically,' 'publish,' 'sealed,' and 'hosted graph version' each carry meaningful information.

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

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

Given a destructive, idempotent operation with seven parameters and no output schema, one sentence is insufficient. The description omits the sync workflow context, the concurrency purpose of expectedProjectVersion, idempotency semantics, and what happens after publication.

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 there are 7 parameters, yet the description mentions none of them. It does not explain the roles of sealedManifestDigest, expectedProjectVersion, idempotencyKey, or the optional sessionId/executionId, leaving the agent to infer meaning solely from parameter names and patterns.

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, 'publish', with a specific resource, 'a sealed hosted graph version,' so an agent knows this finalizes a version. It is clear, but it does not explicitly distinguish this from the sibling publish_project_graph or place itself in the project_sync lifecycle.

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 is given about when to call this tool versus alternatives such as seal_project_sync, abort_project_sync, or publish_project_graph. There is no mention of the required preceding sync/seal flow or when commit is appropriate.

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 meaningful behavioral nuance: expectedVersion concurrency, blocked/failed outcomes remaining active, special roadmap completion requirements, and the specific resolved-status path for closing a dashboard finding. This substantially enriches the agent's model of the tool.

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

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

The description is front-loaded with the core action and each subsequent sentence contributes essential operational nuance. It is dense but not bloated, with no filler or repetition of schema details.

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 the tool's main purpose, key preconditions, special task-type behavior, and finding-resolution semantics. It does not explain return values or error behavior, but it provides enough context for an agent to invoke the tool correctly in most inbox-completion scenarios.

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 must compensate for the input schema. It adds value for expectedVersion and details.status/summary, explaining the resolved pattern and the need for agent-reported evidence. However, it leaves idempotencyKey, sessionId, executionId, and referenceIds unaddressed, and their meaning is left to names and schema constraints.

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 'Record a task result with expectedVersion', which clearly identifies the action and object. It does not explicitly distinguish itself from the sibling inbox tools (inbox_claim, inbox_start, inbox_list), so it stops short of full 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 provides explicit conditions: 'Blocked or failed work stays active' and roadmap tasks complete only after 'published full meter advancement and confirmed linked evidence'. It also explains the resolved status behavior. However, it never names alternative tools or states when the agent should prefer a sibling, so it lacks explicit routing 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?

The annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint, and the description adds little beyond the word 'closed'. It does not disclose behavior such as how the two operations differ, what output to expect, or what projectId/sessionId/executionId scope means. There is no contradiction, but the description fails to add 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 short, but this is under-specification rather than effective conciseness. The single sentence provides no actionable information and does not earn its place.

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 tool has a moderately complex oneOf schema with two operations and nested payload requirements, yet the description explains none of this. With no output schema and no behavioral context, the description is inadequate for selecting or invoking the tool correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden for explaining operation, payload, projectId, sessionId, and executionId. It mentions none of these parameters or their roles. An agent cannot infer call requirements from the description alone.

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 'Use the closed context read capability family from the frozen Brain Scanner policy' essentially restates the tool name without stating a concrete verb, resource, or outcome. It does not say what data is read or how this differs from sibling tools like get_context_graph or get_context_overview.

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 is provided about when to use this tool versus alternatives such as get_context_graph, get_context_overview, graph_read, or knowledge_read. The reference to a 'frozen Brain Scanner policy' is vague and does not help an agent decide between sibling tools.

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 already indicate idempotent, non-read-only, and non-destructive behavior, so the description has a lower bar to meet, but it still adds almost nothing. It does not disclose that this is a multi-operation dispatcher, that payloads vary by operation, that expectedVersion enables optimistic concurrency, or what side effects occur. 'Closed' and 'frozen policy' hint at restrictions but do not explain 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 one short sentence, but this is under-specification, not conciseness. For a tool with nine operation variants and nested payload objects, the single sentence provides no useful structure or front-loaded information.

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

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

Given the complex oneOf schema, 0% parameter coverage, no output schema, and a large sibling list, this description is severely incomplete. An agent cannot determine how to pick an operation, construct a valid payload, interpret the result, or understand policy constraints.

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, but it explains none. It does not clarify what operation and payload mean, how to choose an operation, or what fields are required for each variant. The rich oneOf structure is left entirely for the agent to infer.

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 restates the tool name ('context write capability family') and adds only vague policy context ('frozen Brain Scanner policy'). It does not state a concrete verb-resource action, such as 'executes context-graph mutations' or 'dispatches context write operations', nor does it distinguish itself from sibling operation-specific tools like archive_context_note or update_context_note.

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 context_write versus the many sibling tools, some of which carry the same operation names as the enum values in the schema. The description merely says 'use' this family; it never explains when it is preferred, when it is not, or what alternatives exist.

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

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

Annotations already indicate a write operation (readOnlyHint false) and idempotency (idempotentHint true). The description adds a small behavioral note about 'privacy-filtered project metadata', which implies data handling, but it does not disclose effects on existing fields, versioning behavior, or error conditions. 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 a single short sentence, which is concise, but the content is vague and does not earn its place. It front-loads the verb and resource but omits essential clarifying details, so while it is brief, it lacks substance.

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

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

With 7 parameters, a nested object, no output schema, and no parameter documentation, the description is severely incomplete. It does not explain what 'convert' means, how idempotency/versioning work, or what fields can be updated. An agent would be unable to call this tool correctly based on this description.

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 parameter meaning, but it mentions no parameters at all. Terms like 'projectId', 'idempotencyKey', 'expectedVersion', and the 'details' nested object are entirely unexplained.

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

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

The description states a verb (update) and a resource (hosted convert context note), but the term 'convert' is ambiguous and not explained. It does not differentiate from the sibling tool 'update_context_note', making the purpose only partially clear.

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 is given on when to use this tool versus alternatives like update_context_note or move_context_note. The description does not mention any exclusions, prerequisites, or selection criteria.

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 indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description does not contradict these, but it also adds little behavioral context. It does not explain what 'update' entails, whether it creates or modifies a handoff, what side effects occur, or what 'privacy-filtered' means operationally. With no output schema and no additional behavioral disclosure, the description leaves the agent guessing about the tool's runtime 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 a single short sentence, so it is concise and front-loaded. However, it is under-specified: the sentence is grammatically awkward and packs vague jargon ('hosted create chat handoff', 'privacy-filtered project metadata') without earning its place. It is not verbose, but it sacrifices clarity for brevity.

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 six parameters, a nested object, no output schema, and no parameter descriptions, the description is far from complete. It does not explain the purpose of the handoff, the role of idempotencyKey, the meaning of 'privacy-filtered', or what a successful update returns. The sibling list includes related tools like record_chat_handoff_delivery, but the description does not help an agent choose among them.

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 six parameters, but it does not. It mentions 'project metadata' but does not explain how projectId, handoffId, sessionId, executionId, idempotencyKey, or details relate to the operation. The nested 'details' object with status, summary, and referenceIds is entirely unexplained. The description adds no parameter-level 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 says 'Update hosted create chat handoff using privacy-filtered project metadata.' The verb 'Update' is clear, but the resource 'hosted create chat handoff' is awkward and unclear—it is not obvious what a 'create chat handoff' is or what 'hosted' means. The phrase 'using privacy-filtered project metadata' hints at a data source but does not clarify the tool's core function. It does not distinguish itself from siblings like record_chat_handoff_delivery or create_presentation_request.

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 no explicit guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions. The only contextual clue is the phrase 'privacy-filtered project metadata,' which implies a specific data context but is too vague to serve as actionable usage guidance. An agent would have to infer when to call this tool from its name and schema 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?

The description adds minimal behavioral context beyond annotations. 'privacy-filtered' is vague and unexplained. Annotations already indicate a write operation (readOnlyHint=false) and idempotency (idempotentHint=true), but the description does not elaborate on side effects, authentication, or other behavioral traits. 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 short but not concise in a helpful way – it is under-specified and confusing. It does not front-load critical information and the single sentence is vague, making it hard for an agent to understand the operation.

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 complexity (5 parameters, nested details object, no output schema, zero schema descriptions), the description is grossly inadequate. It fails to explain what a 'finding' is, what 'privacy-filtered project metadata' means, or how the idempotency key works. An agent cannot correctly invoke this tool with the provided information.

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 must explain parameters, but it mentions none of the five parameters (projectId, idempotencyKey, sessionId, executionId, details). No meaning is added beyond the schema's type/pattern constraints.

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 'Update hosted create finding using privacy-filtered project metadata' is ambiguous. The tool is named create_finding but the description says 'Update', and 'hosted create finding' is unclear. It does not clearly state what the tool does or how it differs from siblings like update_finding or promote_insight_to_finding.

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. No mention of conditions, exclusions, or prerequisites. The description provides no context for choosing create_finding over similar tools.

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 signal idempotentHint=true, readOnlyHint=false, and destructiveHint=false, but the description adds meaningful behavioral context: the server persists only bounded metadata and an attested outcome. This is a useful privacy/storage disclosure beyond what the annotations provide, and no contradiction exists between the description and 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 one tightly worded sentence that states the core action and the key storage constraint first. There is no filler, redundant phrasing, or repetition of schema details.

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 six parameters, a nested details object, no output schema, and no schema parameter descriptions, this description is materially incomplete. It omits parameter semantics, return-value expectations, idempotency handling, and when to use this over siblings; only the storage-boundary insight adds contextual value.

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 six parameters, including required projectId and idempotencyKey. The agent is left without semantic meaning for parameters like details, reviewId, sessionId, or executionId, so the description does not compensate for the missing schema 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 clearly states the action ('Request the connected local agent to create') and the resource ('local change review'), and it adds the useful scoping detail that the server stores only bounded metadata and an attested outcome. However, it does not explicitly differentiate this from sibling tools like get_change_review, list_change_reviews, or refresh_local_change_review, so it stops short of 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?

No guidance is given about when to use this tool versus the related change-review tools, nor are any exclusions or prerequisites stated. The implied context ('connected local agent') is not enough to help an agent select this 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?

Annotations already declare this as a non-read, non-destructive, idempotent operation. The description adds only 'hosted' and 'privacy-filtered project metadata,' but does not explain what that means operationally (e.g., queue creation, replacement behavior, side effects). It does not contradict 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 single sentence is brief, but its ambiguity ('Update...create...') means it does not serve as a clear, front-loaded statement. Conciseness without clarity is not a strength here.

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 12 parameters, a required idempotencyKey, an anyOf branch, nested objects, and no output schema. The description omits the two invocation modes (scoped creation vs replacement context), idempotency semantics, and expected behavior, leaving an agent unable to construct a correct call.

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

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

With schema description coverage at 0%, the description must compensate, but it explains none of the 12 parameters. It mentions 'project metadata' abstractly without mapping to projectId, topic, description, idempotencyKey, replacementContext, or the meaning of the anyOf between scopeNodeId and replacementContext.

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 resource ('create presentation request') and a verb ('Update'), but the verb directly contradicts the tool name ('create'), leaving the core action ambiguous. It also does not distinguish this tool from sibling presentation-workflow tools such as publish_presentation_request or start_presentation_build.

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 is given on when to use this tool versus related siblings like retry_presentation_request, fail_presentation_request, or presentation_write. The description provides no context about the create-vs-replace modes implied by the anyOf schema or when each is appropriate.

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 indicate readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds no meaningful behavioral context beyond 'update,' and 'privacy-filtered project metadata' is undefined. There is no annotation contradiction, but the description does not disclose effects, idempotency semantics, or error-prone 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 short but not meaningfully concise: 'privacy-filtered project metadata' is jargon, and the verb 'update' conflicts with the tool name create_project. Under-specification and an internal mismatch make the sentence less useful than its brevity suggests.

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 four required parameters, no output schema, and no parameter descriptions, an agent cannot tell what create_project actually does, what a hosted link project is, or how idempotencyKey should be used. The create/update contradiction leaves the tool's core operation undefined.

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 four undocumented required parameters. It does not mention displayName, projectType, types, or idempotencyKey at all, leaving their roles and relationships entirely to inference from parameter 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?

The tool is named create_project, but the description says 'Update hosted link project using privacy-filtered project metadata.' This creates a misleading create/update mismatch and never states that a project is being created. 'Hosted link project' and 'privacy-filtered project metadata' are vague and do not distinguish this tool from siblings like project_write or create_chat_handoff.

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 offers no guidance about when to use this tool versus any alternative. It does not mention related siblings, prerequisites, or conditions under which create_project should be selected over project_write or other project tools.

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 convey idempotency and non-destructiveness, so the description doesn't need to reiterate those. It adds minor behavioral context ('paragraphs are preserved') and content constraints ('exclude secrets and source dumps'), but it doesn't disclose side effects such as visibility to others, whether the report can be edited/deleted, or what happens on duplicate idempotency keys. Overall, it adds only limited behavior beyond what the schema and annotations already 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 only two sentences with no filler. The core action is front-loaded, and each sentence earns its place—one states what the tool does, the other states required content attributes and constraints. This is an ideal size for a tool of this 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 9-parameter tool with no output schema, the description is incomplete: it doesn't explain what the tool returns, how idempotencyKey should be generated, or the purpose of sessionId/executionId. It does cover the essential content fields and mentions preservation of paragraphs, which provides a minimum viable context. Overall, it is adequate but has clear gaps regarding output and optional parameters.

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

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

Schema description coverage is very low (11%), so the description must compensate. It clarifies the meaning of the main content parameters ('distinct title, summary, and prose body') and adds useful guidance on formatting ('paragraphs are preserved'). However, it completely ignores other parameters like 'projectId', 'idempotencyKey', 'outcome', and 'attachments', leaving their semantics to inference from names rather than explicit explanation.

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 ('Publish') and resource ('Reports') and adds distinctive content requirements ('authored narrative report', 'distinct title, summary, and prose body'). It clearly distinguishes this tool from siblings like 'create_report_bug' (reporting a bug) and 'queue_report' (queuing a report) by focusing on publishing manually authored narratives.

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 to use the tool: when you have an authored narrative report to publish. However, it provides no explicit when-not-to-use guidance or references to alternative tools such as 'queue_report' or 'update_report'. The usage is implied rather than explicitly part of a decision tree.

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=false, destructiveHint=false, and idempotentHint=true. The description adds that it 'opens' a finding, implying a state change, and mentions optional linkage. However, it doesn't disclose side effects like whether this creates a report, updates an existing one, or requires specific permissions. The idempotentHint=true is consistent with the idempotencyKey parameter, so no contradiction.

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 that front-loads the core action and key parameters. It is concise and readable, though it could be slightly more structured by separating the action from the parameter list.

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 9-parameter mutation tool with no output schema and 0% schema description coverage, the description is somewhat thin. It covers the main purpose and several parameters but doesn't explain the relationship to reports, the meaning of 'canonical finding', or the role of sessionId/executionId. The idempotencyKey is mentioned in the schema but not in the description, which is a notable gap for a tool with idempotentHint=true.

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 names title, notes, severity, linkedNodeIds, and reportId, which covers 5 of 9 parameters. It omits projectId, idempotencyKey, sessionId, and executionId, though idempotencyKey is self-explanatory and projectId is common. The description adds some meaning (e.g., 'canonical finding', 'optionally linked to reportId') but doesn't fully compensate for the 0% schema coverage.

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

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

The description states a specific verb ('Open') and resource ('a canonical finding in Reports'), and mentions optional linkage to reportId. It distinguishes from generic create_report by specifying 'canonical finding' and 'bug' context, though it doesn't explicitly name sibling alternatives.

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 usage context (creating a bug report in Reports) but provides no explicit when-to-use or when-not-to-use guidance. It doesn't mention alternatives like queue_report_bug or create_finding, which appear in the sibling list and could be confused with this 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?

Annotations already declare the tool as non-destructive and idempotent, and the description aligns with the write operation (readOnlyHint=false). The phrase 'privacy-filtered project metadata' adds slight context about input, but no additional behavioral details such as side effects or response characteristics are disclosed. The description does not contradict 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 a single sentence with no wasted words, making it concise. However, it is so brief that it sacrifices substantive content; it is not well-structured to convey usage or context, but it is front-loaded with the primary action.

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 (5 parameters, a nested object, and no output schema), the description is grossly inadequate. An agent cannot determine what values to provide for 'details' or how to construct the request correctly. It lacks essential context about the curation workflow, required inputs, and expected behavior.

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 bears full responsibility for explaining parameters. It fails to explain the purpose or format of 'projectId', 'idempotencyKey', or the nested 'details' object with its sub-fields. The only hint is 'privacy-filtered project metadata', which does not map to any specific parameter.

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

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

The description states a clear verb ('Update') and a specific resource ('hosted curate scope panels'), which conveys the core action. However, it does not explicitly differentiate from similar sibling tools like 'scope_write' or 'claim_map_scope', though the unique noun phrase likely makes it distinct enough.

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 is provided on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions, leaving the agent to infer usage from the name and schema.

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, idempotentHint=true, and readOnlyHint=false, but the description adds no behavioral context. It does not state whether deletion is permanent, what happens to linked references, or any permission requirements; 'privacy-filtered project metadata' is too vague to be useful.

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 one short sentence but is syntactically garbled and confusing. 'Update hosted delete context note' obscures rather than clarifies, so the conciseness is not beneficial; the wording needs to be fixed and restructured to be useful.

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 a nested details object, four required parameters, and no output schema, this tool needs a much richer description. The current text gives no indication of return values, side effects on the project graph, how to compose the details object, or the implications of deletion, leaving the agent without essential information.

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 seven parameters, including required fields like projectId, noteId, idempotencyKey, and expectedVersion. It fails to explain their semantics, such as expectedVersion implying optimistic concurrency or idempotencyKey ensuring safe retries.

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 says 'Update hosted delete context note' rather than clearly stating it deletes a context note. The verb 'Update' conflicts with the tool name 'delete_context_note' and the destructiveHint annotation, making the purpose ambiguous and misleading.

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 is provided on when to use this tool versus siblings like archive_context_note, move_context_note, or update_context_note. The mention of 'privacy-filtered project metadata' is vague and does not convey any selection criteria or exclusion conditions.

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

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

The description says 'Update', which conflicts with the destructiveHint=true annotation and the delete_finding name, and it does not disclose that a finding will be removed. It adds no operational context such as idempotency, retry behavior, or permission requirements. The description actively obscures the tool's destructive behavior rather than clarifying it.

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 short, but it is grammatically awkward and not front-loaded with the core action. The word 'Update' at the start undercuts the delete operation and makes the sentence misleading. This reads as under-specification rather than effective conciseness.

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, idempotent tool with 7 parameters and no output schema, the description leaves out required fields, deletion semantics, versioning behavior, and results. Even though annotations provide some safety signals, the description adds almost no contextual completeness. An agent cannot invoke this tool correctly based on the provided text.

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 any of the 7 parameters, including projectId, findingId, idempotencyKey, or expectedVersion. It only vaguely references 'project metadata' without mapping to any schema field. With no enums or parameter-level documentation, the agent is left to infer everything from parameter 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?

The description uses 'Update' as the main verb while the tool is named delete_finding and requires a findingId, so it never plainly states that the tool deletes a finding. 'Hosted delete finding' is an unclear object phrase and does not distinguish this tool from update_finding or create_finding. This is misleading rather than informative.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative tools such as update_finding or record_delete are mentioned. The vague phrase 'using privacy-filtered project metadata' does not constitute actionable usage guidance. An agent cannot determine when delete_finding should be selected 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?

The description contradicts the annotations: it says 'Update' while destructiveHint is true and the tool name indicates deletion, which is a direct contradiction. It also adds no meaningful behavioral detail beyond the annotations—'privacy-filtered project metadata' is ambiguous and unexplained.

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, but it is not appropriately structured: it is under-specified and fails to front-load a clear purpose. The garbled phrasing makes it more of a hindrance than a concise, helpful summary.

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, idempotent tool with 7 parameters, 4 required, nested objects, and no output schema, the description is wholly inadequate. It does not address required fields, idempotency semantics, expectedVersion meaning, or what the tool does with the investigation—leaving agents unable to invoke it correctly.

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

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

With 0% schema description coverage, the description must compensate by explaining the parameters, but it does not mention projectId, investigationId, idempotencyKey, expectedVersion, or the nested details object. The vague 'privacy-filtered project metadata' adds no semantic value to 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?

The description 'Update hosted delete investigation using privacy-filtered project metadata' is confusing: the verb 'Update' conflicts with the tool name 'delete_investigation', and the phrase 'hosted delete investigation' is not a standard concept. It does not clearly state that the tool deletes an investigation, and it fails to distinguish this from siblings like save_investigation or delete_finding.

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 no guidance on when to use this tool versus alternatives such as save_investigation or list_investigations, nor does it mention prerequisites, conditions, or exclusions. An agent is left without any context to select this tool appropriately.

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 indicate destructiveHint true and idempotentHint true, but the description says 'Update', which typically implies non-destructive modification. This contradicts the destructive annotation and the tool name. The description fails to disclose that this operation likely deletes items or what the side effects are.

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, but it is vague and internally inconsistent. It is short but not concise in conveying meaning. The lack of clarity outweighs any brevity benefit.

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

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

With no output schema, the description should explain what happens on success/failure, but it does not. It also fails to cover required parameters, side effects, or any postconditions. The description is wholly inadequate for a destructive operation with multiple parameters.

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

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

Schema description coverage is 0%, so the description must explain parameter meanings, but it only vaguely mentions 'privacy-filtered project metadata' without clarifying how it relates to projectId or other parameters. It provides no information about items, idempotencyKey, sessionId, or executionId.

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 the verb 'Update' but the tool name suggests a delete operation on queue history items. This mismatch makes the purpose ambiguous. It does not clearly state what resource is affected or distinguish from siblings like delete_queue_item.

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. No mention of prerequisites, conditions, or exclusions. The description does not help an agent decide between this and delete_queue_item or other delete operations.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds useful context by noting that project metadata is privacy-filtered, but it does not describe what the returned capability data looks like or any other behavioral characteristics.

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

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

A single front-loaded sentence with no filler or repetition. Every phrase ('hosted', 'privacy-filtered project metadata') adds a piece of context, keeping the definition compact.

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, annotation-rich tool, this is nearly sufficient. The gap is the absence of a concrete statement about what the returned capabilities represent, especially since there is no output schema to fill that in.

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 zero parameters and an empty schema, there is no parameter documentation burden on the description. The mention of 'privacy-filtered project metadata' hints at ambient context, which is enough for a parameterless call.

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 ('Read') and resource ('hosted describe capabilities'), so it is not a tautology. However, 'hosted' and 'capabilities' are left somewhat vague, and the description does not clarify what kind of capabilities are returned or how this differs from sibling read 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?

Usage is implied by the name and description: an agent would call this to obtain capability descriptions. There is no explicit when-to-use guidance, no exclusions, and no alternative tools mentioned, so the agent must infer appropriateness from 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?

Annotations already declare this a safe, read-only, idempotent operation; the description adds that it returns the complete graph in canonical order. However, it does not mention pagination/cursor behavior despite cursor and pageSize parameters, and there is no output schema.

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

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

A single front-loaded sentence that conveys action, resource, output properties, and use cases with no filler or repetition.

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 core action and output ordering are clear, and annotations cover safety, so a basic call with projectId is feasible. But with no output schema and no parameter descriptions, pagination behavior and sessionId semantics remain gaps.

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

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

Schema description coverage is 0% and the description names none of the four parameters. Cursor, pageSize, projectId, and especially sessionId are left entirely unexplained, so the description adds no semantic value over 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?

Description uses a specific verb ('Read') and a specific resource ('the published graph'), and adds distinctive output traits ('complete and in canonical node order'). This clearly separates it from sibling tools like publish_project_graph or get_context_graph.

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

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

States the intended use cases ('for diffing, resuming, or verifying a mapping'), giving clear context for when to call it. It does not explicitly name alternatives or when not to use it.

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

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

Annotations already indicate non-read-only, non-destructive, and idempotent behavior. The description adds no behavioral detail beyond saying 'Update', which is redundant. It does not describe side effects, response behavior, or what changes occur.

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

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

The description is very short, but brevity here is under-specification, not efficiency. It lacks structure and does not front-load key information; it is a single vague sentence.

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 8 parameters, 4 required, a nested details object, and no output schema, the description provides almost no operational context. An agent would have no idea what the tool does, what it returns, or how to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must explain the parameters, but it does not. None of the eight parameters (projectId, requestId, idempotencyKey, expectedVersion, details, etc.) are mentioned or clarified. The vague 'privacy-filtered project metadata' does not map to any specific field.

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

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

The description states a verb ('Update') and a resource ('hosted fail presentation request'), but the meaning of 'fail presentation request' is unclear and not differentiated from siblings like publish_presentation_request or retry_presentation_request. The phrase 'privacy-filtered project metadata' adds confusion rather than 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?

There is no guidance on when to use this tool versus alternatives. No context about triggering conditions, prerequisites, or distinctions from other presentation-related tools is provided.

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 provide idempotentHint=true and destructiveHint=false, so the description does not need to repeat those traits. It adds a useful behavioral note about sending privacy-filtered project metadata, which is valuable beyond the schema. However, it does not disclose terminal statuses, idempotency key behavior, or that this is the final write for an execution.

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 short and not padded, which is positive. However, its brevity comes at the cost of clarity, and the phrase 'hosted finalize agent execution' is syntactically confusing. It is under-specified rather than efficiently 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?

For a 6-parameter, 5-required-field write operation with no output schema and no schema property descriptions, this description is severely incomplete. It omits terminal status values, idempotency semantics, the shape of changedProjects, and any return behavior. An agent cannot safely finalize an execution from 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 carries the burden of explaining parameters. It hints that changedProjects should contain privacy-filtered metadata, which adds meaning beyond the schema. But it does not explain executionId, terminalStatus, occurredAt, idempotencyKey, changedProjects structure, or summary; an agent must rely entirely on parameter names and schema constraints.

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 identifies the resource ('agent execution') and an update action, so an agent can roughly infer that it records a terminal state. However, the phrasing 'Update hosted finalize agent execution' is awkward and partially restates the tool name, and it does not state the key effect of marking an execution as completed, failed, cancelled, or interrupted. It also does not distinguish itself from sibling tools like begin_agent_execution or get_agent_execution_status.

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

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

No guidance is given for when to use this tool versus alternatives. There is no mention of 'use when an execution reaches a terminal state' or 'prefer get_agent_execution_status for checking current state.' The only contextual phrase, 'privacy-filtered project metadata,' is a data constraint, not a usage trigger.

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 indicate a write operation that is idempotent but not read-only. The description mentions 'privacy-filtered' which hints at data handling, but it does not disclose what side effects occur, whether it finalizes the session, or what happens on repeated calls. It does not contradict annotations, but it adds little beyond 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 a single sentence but is under-specified. Conciseness should not come at the cost of clarity; here the brevity results in an unhelpful definition. It does not front-load key information and leaves critical details omitted.

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 10 parameters, 6 required, and no output schema. The description does not explain the tool's role in the agent session lifecycle, how to construct a valid request, what the response contains, or error conditions. It is severely inadequate 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?

Schema description coverage is only 10%, with only the codeChanges parameter described in the schema. The tool description adds no parameter-level meaning for the other nine parameters, such as outcome, blockers, decisions, expectedVersion, or idempotencyKey. The description fails to compensate for the low schema coverage.

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 'Update hosted finish agent session using privacy-filtered project metadata' is vague and awkwardly worded. It does not clearly state the tool's purpose or what 'finish agent session' entails, nor does it distinguish itself from siblings like finalize_agent_execution or begin_agent_execution. The phrase 'privacy-filtered project metadata' adds confusion rather than 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, sequencing relative to other agent lifecycle tools, or any conditions that should trigger its use. The agent is left to infer context from the name alone.

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

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

Annotations already declare idempotentHint=true, readOnlyHint=false, and destructiveHint=false. The description adds a non-obvious behavioral detail: the server stores only bounded metadata and an attested outcome, which clarifies the side effects and the extent of data persistence. This goes beyond what the annotations alone convey, though it does not elaborate on failure modes or the agent's execution semantics.

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

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

The description is a single, front-loaded sentence with no filler. It states the action first and then provides a relevant side-effect note. While it is efficient, it could be considered slightly under-specified for such a complex tool, but that is more a completeness issue than a conciseness one.

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 tool has 7 parameters, a nested object, required fields, and no output schema. The description does not explain how the parameters interact, what the expected response is, what constitutes a successful finish, or any error handling. It is far from sufficient for an agent to call this tool correctly; it leaves critical operational details unexplained.

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 explanation, but it mentions none of the seven parameters. It does not clarify the meaning of required fields like idempotencyKey, expectedVersion, or the purpose of the nested 'details' object. The description provides zero parameter-level semantics, making it nearly impossible for an agent to properly construct a call.

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 ('finish') and resource ('node work'), clearly indicating the primary action. It also adds context by noting the server stores only bounded metadata and an attested outcome, which helps distinguish it from tools like validate_node or submit_node_instruction. However, it does not explicitly name sibling tools or provide a contrast, so it stops short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives such as start_node_work or submit_node_instruction. It does not state prerequisites, exclusions, or conditions that would route an agent to a different tool. The only contextual hint is 'connected local agent,' but that is not framed as a usage criterion.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds a small behavioral detail by mentioning 'privacy-filtered project metadata,' but it does not clarify what is filtered or what the response contains.

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 and front-loads the verb 'Read,' which is good. However, 'hosted get' is grammatically awkward and 'using privacy-filtered project metadata' is vague enough that the sentence does not read as cleanly as it could.

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

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

For a read-only status tool with one parameter, the description plus annotations are partially adequate, but there is no output schema and the description gives no indication of the response shape, status values, or polling behavior. The agent is left to infer important details beyond the parameter name.

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

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

Schema description coverage is 0%, and the description does not mention executionId or explain how it maps to the agent execution. The parameter name and schema pattern provide clues, but the description itself adds no parameter meaning and does not compensate for the missing 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 uses the verb 'Read' to identify this as a retrieval operation and 'agent execution status' names the resource, distinguishing it from lifecycle siblings like begin_agent_execution and finalize_agent_execution. It loses a point because it does not explicitly name alternatives and the phrase 'hosted get' is awkward.

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 this is the tool to use when an agent needs execution status, and 'privacy-filtered project metadata' hints at the data source. However, it does not explicitly state when to prefer this tool over related tools or describe exclusions, so usage context is only implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds 'privacy-filtered project metadata,' which hints at data filtering, but this is vague and unexplained. No other behavioral details (e.g., what is filtered, response format, error cases) are provided.

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, so it is concise in length, but the wording is awkward ('hosted get change review') and not front-loaded with the most useful information. It lacks clarity despite being short.

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 tool with two required parameters and no output schema, the description provides minimal context. It does not explain what a 'change review' is, what 'privacy-filtered' means, or what the return value looks like. The description is inadequate for an agent to understand the tool's full behavior.

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 any of the four parameters. It does not clarify what projectId, reviewId, sessionId, or executionId mean or how they relate to the operation. The description entirely fails to compensate for the lack of 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 states a verb ('Read') and a resource ('hosted change review'), which gives some sense of purpose. However, the phrasing 'hosted get change review' is awkward and could be misread. It does not explicitly distinguish from siblings like list_change_reviews or refresh_local_change_review beyond implying a hosted vs local distinction, which is not stated clearly.

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. Siblings like list_change_reviews, create_local_change_review, and refresh_local_change_review exist, but the description gives no criteria for selecting this tool over them. The agent must infer from the name alone.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds a small amount of context by indicating the graph is 'hosted' and that the data comes from 'privacy-filtered project metadata,' but it does not disclose return format, error behavior, or how optional identifiers affect 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 a single sentence with the main verb front-loaded and no filler. It is concise, though the redundant 'get' in 'hosted get context graph' makes it slightly less polished 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?

With no output schema, the description should convey what the tool returns, but it only names 'context graph' without defining its shape or contents. The optional sessionId and executionId parameters are also left unexplained, so an agent has insufficient context 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%, so the description must compensate, but it only vaguely references 'privacy-filtered project metadata.' It does not explain what projectId, sessionId, or executionId mean, nor how they relate to the graph being retrieved.

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 an explicit verb ('Read') and names a specific resource ('hosted ... context graph'), so the core operation is identifiable. However, the phrasing is awkward ('hosted get context graph') and it does not distinguish this tool from sibling read tools such as graph_read or get_context_overview.

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 prefer this tool over alternatives, no exclusions, and no context about which sibling tools cover similar graph-reading tasks. The phrase 'using privacy-filtered project metadata' hints at a use case but does not provide decision criteria.

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 idempotentHint=true, covering the safety profile. The description adds one useful behavioral note: 'privacy-filtered project metadata', which tells the agent the output respects privacy filters. This is a modest addition beyond the annotations, but it doesn't disclose what the overview includes, how it's filtered, or any response characteristics. With annotations covering the core safety aspects, a 3 is appropriate.

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, which is concise and front-loaded with the verb, but it is concise at the expense of content. It wastes no words but also conveys little useful information. There's no fluff, but it's not sufficiently informative to earn a higher score.

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 tool has no output schema, so the description is the only source for what the tool returns. It does not explain what a 'context overview' is, what data it includes, or how the three optional parameters affect the result. With no output schema and no parameter semantics, the description is incomplete for an agent to call this correctly and interpret the response.

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 the parameters, but it does not. projectId, sessionId, and executionId are listed in the schema with patterns and lengths, but the description offers no meaning, purpose, or usage hints for any of them. The agent is left to infer what 'context overview' needs these identifiers for, which is a significant gap.

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

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

The description states a verb ('Read') and a resource ('hosted get context overview'), but the resource is itself ambiguous – 'context overview' is not defined, and the phrase 'hosted get context overview' reads like a product label rather than a functional description. It does not differentiate from many context-related siblings like get_context_graph or context_read, and leaves the agent guessing what the overview contains or how it differs.

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. With a large sibling list including context_read, get_context_graph, project_read, and get_project_health, the description offers no situational triggers, exclusions, or comparisons. An agent cannot infer whether this is the right tool for a given task.

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, idempotentHint=true, and destructiveHint=false. The description adds 'privacy-filtered project metadata' as a behavioral nuance, indicating the result depends on privacy filtering, but it does not explain what this means for the returned state or error conditions.

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 short sentence with no fluff, but the awkward 'Read hosted get' construction hurts clarity. It is concise by length yet not cleanly front-loaded due to the garbled grammar.

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

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

With no output schema, the description should clarify what is returned; 'dashboard widget state' gives a hint but not the shape or content of the state. It also omits any relationship to open_dashboard_widget and the practical meaning of 'privacy-filtered' metadata.

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 does so only weakly: 'project metadata' hints at the role of projectId, and the parameter name is self-explanatory. Still, it does not explicitly say projectId selects the project whose metadata drives the widget state.

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 the core operation ('Read ... dashboard widget state'), so an agent can tell it is a retrieval tool. However, the phrase 'Read hosted get' is grammatically garbled and obscures the object, and it does not differentiate from the sibling open_dashboard_widget beyond the verb 'Read'.

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 is given about when to use this tool versus alternatives. It mentions a method ('using privacy-filtered project metadata') but never states use cases, exclusions, or relationships to sibling tools like open_dashboard_widget.

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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds a small behavioral hint about 'privacy-filtered' output, but it is vague and does not specify what filtering applies, what the return payload contains, or any limitations. With annotations carrying the load, this is adequate but not rich.

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, which is concise, but it is poorly structured and under-specified. It does not front-load the core purpose clearly (the phrase 'hosted get github app status' is awkward) and leaves the reader to parse the intended meaning. It is short but not 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?

There is no output schema, and the description does not state what the tool returns (e.g., a status object, a JSON blob, or a simple string). It also fails to explain how the three parameters relate to the operation or what 'status' means in this context. Given the large number of sibling read tools, the description is insufficient for an agent to call it confidently.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters (projectId, sessionId, executionId). Since the schema only provides patterns and no descriptions, the description should compensate by explaining how these IDs map to the operation, but it does not. The phrase 'using privacy-filtered project metadata' hints at projectId being relevant but does not clarify the others.

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 verb 'Read' and the noun phrase 'hosted get github app status' indicate a read operation for GitHub app status, but the phrasing is awkward and ambiguous. It does not clearly differentiate from sibling tools like get_project_status or get_agent_execution_status; the mention of 'privacy-filtered project metadata' is vague and does not explain what the tool actually retrieves.

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 no guidance on when to use this tool versus any of the nearly 100 sibling tools. It does not state prerequisites, context, or exclusions. An agent cannot determine whether this is the right tool for a given task without additional inference.

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

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

Annotations already declare readOnlyHint true, idempotentHint true, and destructiveHint false, and the description's 'Read' is consistent with these. It adds one behavioral clue beyond annotations: the result is based on 'privacy-filtered project metadata,' which suggests output filtering, but it does not mention pagination, limits, or return 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 a single compact sentence with no filler, which is good, but the phrasing 'hosted get graph scope' is unclear and the sentence does not organize information effectively. It is concise without being sufficiently 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 six parameters, no output schema, and zero schema description coverage, this one-sentence description is not enough for an agent to know what the tool returns or how to correctly form a request. The annotations cover safety, but not invocation semantics or response expectations.

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 needed to compensate, but it explains none of the six parameters. Required projectId and nodeId are implied only by the tool name and schema, and cursor, pageSize, sessionId, and executionId are completely unexplained.

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

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

The description states a read operation on a 'graph scope' resource, which is more than a tautology and distinguishes it as a read operation. However, 'hosted get graph scope' is awkward and never defines what a graph scope is or how it relates to sibling tools like get_context_graph, get_graph_wiki, or graph_read.

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 is provided about when to call this tool instead of the many similar read/graph tools in the sibling list. The description implies a generic read scenario but gives no conditions, exclusions, or 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the 'privacy-filtered' aspect, which hints at data transformation but does not explain behavior like return format, error conditions, or authentication. No contradiction exists, but the added context is minimal.

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 and not verbose, which is good for conciseness, but it is under-specified rather than efficient. It does not front-load essential information; it simply restates the tool name in a slightly expanded form.

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 severely incomplete for a tool with four parameters, no output schema, and no parameter documentation. It does not explain what a 'graph wiki' is, what the tool returns, how to select parameters, or when it should be used. The complexity is low (read operation), but the description still fails to provide the minimum context 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%, so the description must compensate, but it mentions only 'project metadata' without explaining any of the four parameters (nodeId, projectId, sessionId, executionId). The description provides no meaning for the required parameters, leaving the agent without guidance on what values to supply.

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 'Read hosted get graph wiki using privacy-filtered project metadata' uses a vague verb-resource combination. 'Graph wiki' is ambiguous and not defined, and the phrase closely mirrors the tool name without clarifying what the resource is or how it differs from siblings like get_graph_scope or get_context_graph. It does not distinguish this tool from other read operations.

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 does not mention any conditions, prerequisites, or exclusions, and with many sibling read tools available, the agent receives no help in choosing this one.

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 establish readOnly/idempotent/non-destructive behavior, and the description adds a meaningful behavioral trait: results are privacy-filtered via project metadata. There is no contradiction between the description and the readOnlyHint. It stops short of explaining response shape or permission needs, but the annotation coverage lowers the burden.

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

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

One sentence with no filler, and the core action is front-loaded. The wording is compact, though the awkward 'hosted get ownership' construction prevents a perfect score.

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, idempotent tool the safety profile is well covered by annotations, and the basic purpose is clear. However, with no output schema and no parameter explanations, the description leaves the agent to guess what is returned and how sessionId/executionId alter the call. Adequate but with clear gaps.

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

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

Schema coverage is 0%, so the description carries the burden of explaining parameters, but it does not. 'project metadata' loosely hints at projectId's role, while sessionId and executionId are never mentioned. An agent cannot tell how the optional parameters affect the ownership read.

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 the operation ('Read') and the resource ('ownership'), and the 'using privacy-filtered project metadata' qualifier helps distinguish it from generic project/status reads. It is not a full 5 because the phrase 'hosted get ownership' is grammatically awkward and never explains what 'hosted' adds.

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 this tool is for reading ownership information through privacy-filtered metadata, but it never states when to prefer it over the many sibling read/get tools or when not to use it. No alternative is named and no exclusion condition is given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the 'privacy-filtered project metadata' detail, which hints at behavioral filtering but is too vague to meaningfully explain what data is exposed or withheld. It does not contradict the annotations, but it also does not disclose pagination, ordering, or what happens with large result sets.

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 short and front-loaded with the verb, but the sentence is awkward and grammatically tangled ('Read hosted get pending implementation meter changes'). It earns some credit for brevity, but the unclear phrasing reduces its efficiency because an agent must re-read it to guess the intended 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 paginated read tool with no output schema and no parameter explanation, this description is incomplete. It does not define what 'pending implementation meter changes' are, how the privacy filtering works, or how cursor/limit should be used. The annotations cover read-only safety, but an agent still lacks enough context to invoke the tool confidently in a real workflow.

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 needed to explain the parameters but does not. It never mentions projectId, sessionId, limit, or cursor. The phrase 'using privacy-filtered project metadata' only loosely gestures at projectId and does nothing to clarify the pagination contract or the role of sessionId. The schema's property names and constraints carry nearly all the meaning here.

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

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

The description states a verb ('Read') and a resource ('pending implementation meter changes'), so an agent can infer the basic operation. However, the phrasing 'hosted get pending implementation meter changes' largely restates the tool name and does not clarify what 'hosted' means or what makes these changes 'pending.' It does not explicitly distinguish this from sibling tools like apply_implementation_meter_change or queue_implementation_meter_request, though the read vs. write contrast is implied by the name.

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 alternatives. Sibling tools such as apply_implementation_meter_change and queue_implementation_meter_request exist, but the description never mentions them or explains that this tool is the read-only way to inspect pending changes. The usage context is only weakly implied by the word 'Read.'

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a meaningful qualifier ('privacy-filtered project metadata') that hints at what the response will contain, but it does not disclose pagination, filtering behavior, or what 'pending' means beyond the name.

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 short, but the phrasing 'Read hosted get pending presentation requests' is awkward and unclear rather than cleanly concise. The sentence does not earn its place because it mostly repeats the tool name and adds confusion.

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 five parameters, no output schema, and no usage guidance, the description is far from complete. It gives no sense of what a returned request looks like, how the optional parameters act as filters, or how this differs from related presentation tools.

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 meaning to any of the five parameters. It does not explain that projectId is required, nor does it clarify the roles of requestId, sessionId, executionId, or presentationId. With zero schema coverage, the description was the only place to compensate, and it fails to do so.

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 reads as a near-tautology: 'Read hosted get pending presentation requests' essentially restates the tool name without defining what the tool actually does or returns. The phrase 'hosted get' is grammatically garbled, and there is no differentiation from siblings like list_presentations or get_presentation.

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 is given on when to use this tool versus alternatives such as create_presentation_request, fail_presentation_request, publish_presentation_request, or list_presentations. There are no exclusions, prerequisites, or context clues beyond the name itself.

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 idempotentHint=true, so the read-only, non-destructive nature is covered. The description adds the privacy-filtering qualifier, but doesn't disclose return shape, pagination, or what 'pending' means.

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 short and front-loaded, but the phrase 'hosted get' is awkward and the one sentence doesn't carry much information. It is concise in length but not necessarily in clarity.

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 3-parameter read tool with no output schema, there are major gaps: parameter meanings, return value, and when to use it are all missing. Rich annotations help the safety profile but not the invocation 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 never names or explains projectId, sessionId, or executionId. There is no compensation for the undocumented parameters.

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 the verb 'Read' and the resource 'pending scope organizations,' which is a specific operation. However, it doesn't distinguish this getter from sibling pending-getters like get_pending_implementation_meter_changes or get_pending_presentation_requests.

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

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

No when-to-use or alternative guidance is given. The phrase 'using privacy-filtered project metadata' hints at context but doesn't tell an agent when to choose this over siblings or when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'privacy-filtered project metadata' qualifier, which hints at a behavioral trait (filtering), but it does not explain what the filtering entails, what the response contains, or whether the tool can fail (e.g., missing presentation). With annotations carrying the safety burden, a 3 is appropriate.

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 wasted words, and the core action ('Read hosted get presentation') is front-loaded. It is concise, though it could be slightly more informative without becoming bloated.

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 tool has 5 parameters, no output schema, and no parameter documentation in the description. The description does not explain what 'privacy-filtered project metadata' means, what the return value is, or how the optional parameters (requestId, sessionId, executionId) affect the call. For a read tool with this many parameters, the description is under-specified.

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 any of the five parameters. The schema provides names and patterns, but the description does not clarify the roles of projectId, presentationId, requestId, sessionId, or executionId, nor which are required beyond the schema's required list. With zero coverage and no compensation in the description, the agent must guess parameter semantics.

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

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

The description states a specific verb ('Read') and resource ('hosted get presentation') and adds a qualifier ('using privacy-filtered project metadata'). It is clear enough to distinguish from siblings like list_presentations or get_presentation_authoring_brief, though it does not explicitly name an 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 description implies a read operation for a hosted presentation, and the readOnlyHint annotation reinforces when it is appropriate. However, it does not explicitly state when to use this tool versus alternatives like presentation_read, get_presentation_authoring_brief, or list_presentations, nor does it mention any exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the notion of 'privacy-filtered project metadata', which hints at some filtering behavior, but it is vague and does not explain what gets filtered, under what conditions, or what the tool returns (e.g., empty result vs error). For a read-only tool with annotations, this is still a thin addition.

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, so it is concise in length, but it is poorly structured. The phrase 'hosted get' is redundant and confusing, and the sentence does not front-load the most critical information (what the tool returns or when to use it). It reads like an auto-generated or truncated description, not a carefully crafted one.

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 0% schema coverage and lack of an output schema, the description must carry substantial explanatory weight. Instead, it provides almost nothing: no return format, no parameter meaning, no usage context, no differentiation from siblings. The tool is effectively unusable for an agent without external knowledge.

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

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

Schema coverage is 0% and the description mentions no parameters. The 5 parameters (projectId, requestId, sessionId, executionId, presentationId) have no explanatory text anywhere. The description fails to compensate for the complete lack of schema documentation, leaving agents guessing what values to provide and why.

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 the verb 'Read' and identifies the resource as 'presentation authoring brief', which is a specific artifact distinct from generic presentations. However, the phrase 'hosted get presentation authoring brief' is malformed ('hosted get' is redundant and likely a typo), and there is no explanation of what an 'authoring brief' is or how it differs from sibling tools like get_presentation or presentation_read.

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 no guidance on when to use this tool versus alternatives. It does not mention prerequisites, conditions, or exclusions. An agent has no basis to choose this over get_presentation, list_presentations, or presentation_read, all of which read presentation-related data.

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, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the phrase 'privacy-filtered project metadata,' which hints at a behavioral trait (data is filtered for privacy), but it is too vague to be genuinely useful. 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 short, but its brevity is not a virtue because it sacrifices clarity. The phrase 'hosted get project health' is awkward and likely a typo or artifact, and the sentence structure is confusing. It is concise in word count but not in communicative efficiency.

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 tool with no output schema and 0% parameter coverage, the description is incomplete. It does not explain what 'health' means, what data is returned, how privacy filtering affects results, or how this differs from get_project_status. The annotations cover safety but not the operational semantics an agent needs to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden of explaining parameters. It fails to do so: it does not explain what projectId, sessionId, or executionId mean, how they relate, or which are required. The description's mention of 'project metadata' only weakly maps to projectId and does not clarify the optional sessionId and executionId parameters.

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 'Read hosted get project health using privacy-filtered project metadata' is confusing and tautological. It repeats the tool name ('get project health') and the phrase 'hosted get project health' is grammatically awkward and unclear. It does not clearly state what the tool does or what 'health' means in this context, and it does not distinguish it from siblings like get_project_status or get_project_sync_status.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that get_project_status or get_project_sync_status might be more appropriate for specific needs, nor does it state any prerequisites or context for calling it. The only hint is 'privacy-filtered project metadata,' which is vague and not actionable.

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