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

With no annotations, the description carries the full burden. It discloses the required scope (learning:arbiter:write), the governance by Arbiter constitutional policy, and the ProofLink receipt, which is valuable. However, it does not mention what happens after approval, potential side effects, 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 compact, uses two short paragraphs, and every sentence adds key information: purpose, required parameter, scope, and receipt behavior. There is no redundancy or filler.

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

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

For a simple one-parameter tool, the description covers the core purpose, required input, and important security/governance context. It could mention the return value or receipt specifics, but the absence of an output schema and the low complexity make this adequate.

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

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

The input schema already provides 100% coverage of the single parameter, including its origin ('Pattern ID from get_learning_queue'). The description merely repeats 'requires pattern_id' without adding extra semantic detail like format or constraints, so it stays at the schema-driven baseline.

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

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

The description clearly states the specific action ('Approve a Tier 2 learning pattern') and the target resource ('promotion to Agent Brain'). It distinguishes this from sibling tools like approve_sie_finding by identifying the unique resource type (Tier 2 learning pattern).

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

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

The description provides clear context on when to use it, specifically for approving Tier 2 learning patterns, and names the required parameter pattern_id. It does not explicitly mention alternatives or exclusions, but the resource specificity makes the intended use unambiguous.

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

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

With no annotations, the description carries the full burden and explicitly discloses that this modifies files on disk, seals an immutable ProofLink receipt, and requires the scope sie:queue:write. This goes beyond a simple 'approve' and alerts the agent to side effects and governance.

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

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

The description is well-organized with the purpose first, followed by side effects and prerequisites. It is slightly verbose with the capitalization of 'EXECUTE CLASS' and policy phrasing, but each sentence contributes 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?

The description covers the tool's purpose, side effects, prerequisite, and required scope. However, it does not describe the return value or failure behavior, which is notable since there is no output 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?

The schema provides 100% coverage for the single index parameter, including instructions to use get_sie_queue. The description adds no additional syntax or format details beyond the schema, so baseline 3 applies.

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

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

The description clearly states it approves a specific SIE security finding by queue index, distinguishing it from sibling tools like get_sie_queue (listing) and approve_learning_item (different resource). It also details the actions taken (applies fixer, seals receipt, removes from queue), making the purpose unambiguous.

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

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

The description explicitly instructs to get the index from get_sie_queue first, providing clear prerequisite guidance. However, it does not mention explicit alternatives or when not to use this tool, though the sibling list implies distinct use cases.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses that the tool is read-only, requires a specific scope, is governed by Arbiter policy, and returns a ProofLink receipt, which goes beyond minimal expectations. No contradictions found.

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

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

Two sentences, front-loaded with the core purpose and supplemented with essential scope and side-effect context. 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?

For a zero-param, no-output-schema tool, the description covers purpose, usage context, behavioral constraints, and side effects. It could potentially describe the return format or the receipt more, but the provided information is sufficient for invoking the tool.

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

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

The input schema has zero parameters, so the description doesn't need to explain any. Baseline is 4 for zero-param tools, and the description correctly omits irrelevant parameter details.

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 returns the live compliance audit summary (specific verb+resource), and explicitly identifies itself as an alias for get_compliance_status, distinguishing it from sibling tools. This meets the 5-level standard.

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

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

It specifies the intended audience/context (CISO/auditor review) and identifies the read-only nature, but does not explicitly provide when-not-to-use scenarios or alternative selection guidance beyond naming the alias. Thus it's a 4.

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

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

With no annotations, the description carries the transparency burden. It discloses the output directory (blog-audio/), return fields (mp3_url and filename), and the side effect of sealing a ProofLink receipt. Additional details like auth or error behavior are absent, but the core behavior is well covered.

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 four short, information-dense sentences with no filler or redundancy. It is front-loaded with the primary action and then lists side effects and outputs.

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

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

For a low-complexity tool with 2 parameters and no output schema, the description covers what it does, where it saves output, and what it returns. The 'Seals a ProofLink receipt' adds context but could be clearer; still, overall it is sufficiently complete.

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

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

Schema description coverage is 100%, and the schema already describes title and content well. The tool description doesn't add extra parameter-specific meaning, so the baseline of 3 applies.

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

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

The description clearly states a specific verb and resource: 'Generate MP3 audio version of a blog post via Deepgram TTS.' It also specifies the save location and return values, distinguishing it from generic TTS tools like deepgram_tts.

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 description: use when you need an MP3 of a blog post. However, there is no explicit comparison to sibling tools like deepgram_tts, nor any when-not-to-use guidance.

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

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

With no annotations, the description carries the burden of disclosing side effects and output behavior. It does mention returning transcript, confidence, and timestamps, and it states 'Seals a ProofLink receipt,' which is a notable side effect. However, it does not discuss permissions, reversibility of the receipt, error handling, or any rate limits, leaving gaps in full behavioral 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 three short, front-loaded sentences. The main purpose is stated first, followed by the return values and the side effect. Every sentence provides distinct information with no fluff 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?

For a tool with two optional parameters and no output schema, the description covers the main aspects: purpose, input modes, return fields, and a side effect. It does not clarify what happens if neither parameter is provided, but given the simplicity and the schema's explicit optionality, the description is reasonably complete.

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

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

The input schema provides 100% coverage with descriptions for both parameters (audio_url and audio_file_path). The description adds no new meaning beyond restating that audio can come from URL or file path, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific verb ('Transcribe'), resource (audio), and method ('using Deepgram Nova-2'). It differentiates from siblings like deepgram_tts (text-to-speech) by focusing on speech-to-text and the unique side effect of sealing a ProofLink receipt.

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 use case is implied by the verb 'Transcribe', but the description does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. Sibling tools such as deepgram_tts are clearly different, but no guidance is given for choosing between them.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It transparently reveals key side effects: saving an MP3 to a specific directory, sealing a ProofLink receipt, and returning an mp3_url. While it does not cover error handling or prerequisites, it effectively communicates the tool's non-obvious behaviors and outputs.

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 three concise sentences: purpose, side effects, and return value. Each sentence earns its place with no redundancy or filler. The most important action is front-loaded, making it easy to scan.

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

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

For a tool with 3 parameters and no output schema, the description provides an unusually complete picture: it specifies the input (text), the processing model, the output file location, the receipt side effect, and the return type (mp3_url). It does not mention potential prerequisites like API keys or error conditions, but given the simplicity and the presence of a schema, this is sufficient. The description covers essentially all key operational aspects.

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

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

The input schema already provides 100% parameter descriptions, so the baseline is met. The description adds contextual information about the output format and destination, but it does not provide additional detail about individual parameters beyond what the schema already states. The description's mention of MP3 and mission-videos/ indirectly informs the output_filename parameter, but not enough to exceed the baseline.

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

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

The description clearly states 'Convert text to speech via Deepgram Aura' with a specific voice model, and further distinguishes itself from siblings like deepgram_transcribe by mentioning the MP3 output saved to mission-videos/ and the ProofLink receipt. It uses a specific action verb and resource, fully differentiating this tool.

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

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

The description implies a use case (saving audio to mission-videos) but does not explicitly state when to use this tool versus alternatives like deepgram_blog_audio. It lacks explicit when-to-use or when-not-to-use guidance, so the context is present but not formally articulated.

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

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

The description goes beyond basic purpose by disclosing the multi-agent pipeline, the SEMI_AUTO behavior (plan returned for human review, execution gated by SecurityGatekeeper), the required scope 'ag2:incident:invoke', and the ProofLink receipt. With no annotations provided, this rich disclosure is valuable, though it leaves some details (e.g., rejection behavior) unstated.

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 moderately long but each sentence adds value, including the use-case list and auth requirement. It is front-loaded with the primary purpose and gets more specific later, which is good structure.

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

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

Given the tool's complexity (a multi-agent dispatch with no output schema or annotations), the description covers the process, return values, use cases, and security context well. Minor gaps like error handling or return format prevent a perfect score.

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 already provides 100% description coverage for all three parameters (service, severity, description). The description adds no additional parameter-level meaning, so a baseline score of 3 is appropriate.

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

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

Clearly states the action (dispatch an IT incident to the AG2 GroupChat for autonomous diagnosis), describes the routing chain, return value, and lists concrete use cases. This differentiates it from sibling incident-related tools like get_incident_details or list_recent_incidents that read rather than dispatch.

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

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

Explicitly says 'Use for real incidents' followed by concrete examples, giving clear when-to-use context. However, it doesn't mention alternatives or when-not-to-use scenarios, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does so effectively. It discloses prerequisite scope requirements, upstream behavior (no auth, live computation from soc2-tracker.json), and that every call is governed by policy and sealed with a ProofLink receipt. This adds meaningful behavioral context beyond a simple 'get scores' statement.

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

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

The description is concise and front-loaded, with the core purpose and deliverables in the first sentence, followed by behavioral and prerequisite details in the second. It is dense but avoids filler, and every sentence contributes 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 the zero-parameter interface and absence of an output schema, the description covers the necessary contextual elements: what the tool returns (specific scores, evidence status, gap analysis, source tracker file), prerequisites (scope), and behavioral notes (live computation, receipt). It is complete enough for correct invocation, though the output format is only listed as components rather than a detailed structure.

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

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

The tool has zero parameters, and the schema coverage is trivially 100%. Per the rubric, a zero-parameter tool gets a baseline of 4, and there is no parameter-specific information needed beyond the schema. The description does not mention parameters, which is appropriate 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 clearly identifies the action ('Get') and the resource ('live compliance scores for the iTechSmart platform'), and specifies the exact frameworks (NIST CSF, HIPAA, SOC 2). It is specific and informative, though it does not explicitly distinguish itself from sibling tools like compliance.audit_summary or get_platform_briefing.

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

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

The purpose implicitly suggests when to use the tool (when compliance scores are needed), but there is no explicit guidance on when not to use it or how it compares to alternative tools. The description provides clear context but lacks exclusionary or alternative-referencing information.

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

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

With no annotations, the description carries the full burden and does well: it discloses the required permission scope, mentions governance via Arbiter constitutional policy, and notes that every call is sealed with a ProofLink cryptographic receipt. It does not mention error behavior, rate limits, or idempotency, but the key side effects and constraints are covered.

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

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

The description is two sentences, front-loaded with the primary purpose, and every clause adds value: the list of returned data, the scope requirement, and the receipt behavior. No unnecessary filler.

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

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

For a tool with one parameter, no output schema, and no annotations, the description is notably complete. It enumerates the specific data categories returned, the required permission, and a unique behavioral aspect (ProofLink sealing). This gives an agent sufficient context to select and 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 coverage is 100%, so the baseline is 3. The description adds context about what the incident_id refers to ('a specific autonomous remediation incident') but does not provide additional format, validation, or usage syntax beyond what the schema already states.

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

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

The description uses a specific verb ('Fetch details') and clearly identifies the resource ('a specific autonomous remediation incident'), enumerating the exact content: ProofLink receipt, remediation actions, system state, time metrics, and NIST mappings. This differentiates it from sibling tools like list_recent_incidents, itsm_get_incident_timeline, and prooflink.verify_receipt.

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

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

The description states a required scope ('incident:classify:read') and implies use when a specific incident ID is available, but it does not explicitly discuss when to choose this over alternatives like itsm_get_incident_timeline or mission.list_incidents. There is no exclusionary guidance, only implied 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?

Since no annotations are provided, the description carries the full disclosure burden. It explicitly states required scope ('iself:journal:read'), governance by Arbiter policy, and ProofLink receipt sealing, and describes the return content in detail. While it doesn't explicitly label the operation as read-only, the verb 'Retrieve' and the read scope imply safety; missing are error conditions or rate limits, but these are not essential for basic invocation.

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 main purpose is front-loaded in the first sentence, and the second paragraph succinctly list access and governance requirements. However, the claim 'has healed 11+ incidents' is arguably promotional rather than instructional, and the sentence about iSELF frequency could be considered extraneous; despite this, the overall length is appropriate and well-organized.

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

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

For a simple tool with one optional parameter and no output schema, the description is quite complete: it explains the return content, the scope requirement, and the governance/security context. It covers everything an agent likely needs to decide whether and how to call it. The only minor gaps are potential error handling or response specifics, but these are not critical given the schema already documents the parameter.

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

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

The schema covers the sole 'limit' parameter with a full description (default 20, max 100), so the schema does the heavy lifting. The description adds nothing about parameter behavior beyond what the schema already states, matching the baseline expectation for high 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 opens with the specific verb 'Retrieve' and names the exact resource 'iSELF (Self-Healing Loop Framework) healing history', immediately distinguishing it from siblings like list_recent_incidents or get_platform_briefing. It further clarifies the content (service failure, diagnosis, patch, success, confidence), making the tool's function unmistakable.

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

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

The description provides clear context by explaining that iSELF runs every 5 minutes and what the journal covers, which implies when an agent would need this data. However, it does not explicitly state when not to use it or name alternatives (e.g., for general incidents), so it stops short of full exclusion guidance.

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

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

With no annotations, the description discloses that calls require a specific scope, are governed by constitutional policy, and produce a ProofLink receipt. This adds valuable context beyond the name, but it doesn't specify the return format, whether the operation is purely read-only, or any side effects beyond the receipt.

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

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

The description is two concise sentences with no filler. The first sentence states the purpose and metrics, the second adds scope and governance context, making it efficient and 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 zero-parameter tool with no output schema, the description covers the purpose, required scope, and unique behavioral traits (policy and receipt), and lists the metrics returned. It could elaborate on the response structure or what constitutes a 'cycle,' but these are minor gaps for tool selection.

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

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

The input schema has zero parameters, so the description correctly avoids adding parameter details. Per the rubric, zero parameters gives a baseline of 4, and the description does not need to compensate for schema shortcomings.

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 retrieves Learning Arbiter cycle metrics and enumerates the specific metric types (processed, promoted, rejected, known patterns). It is distinct from sibling tools such as get_learning_queue, which focuses on queue items rather than cycle-level metrics.

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 when cycle metrics are needed and states a scope requirement, but it does not explicitly contrast with alternatives or provide when-not-to-use guidance. It relies on the tool name and first sentence to convey context, making usage mostly 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?

No annotations are provided, so the description carries the full burden. It discloses the required auth scope, the governing constitutional policy, and the fact that every call is sealed with a ProofLink cryptographic receipt. This goes beyond typical descriptions, though it does not detail side effects (e.g., whether receipt generation affects state) or error/response 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 two sentences: the first front-loads the core purpose and scope, the second adds essential context (auth and receipt). Every word earns its place with no fluff 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?

For a zero-parameter retrieval tool with no output schema, the description explains what it returns (patterns pending approval), the filter (Tier 2, score 50-85), and important contextual details (scope, policy, receipt). It is complete enough for an agent to select and invoke correctly, though it does not specify return format or pagination, which are not critical for basic usage.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter detail (none exists), and the schema already covers everything (100% coverage). No further semantics needed.

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 ('Get') and identifies the exact resource ('patterns pending human approval from Learning Arbiter') and scope ('Tier 2 items, score 50-85'). This clearly distinguishes it from sibling tools like approve_learning_item (which approves) and get_learning_metrics (which gets metrics).

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

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

The description provides clear context: it is for retrieving Tier 2 items (score 50-85) pending human approval, implying use when you need to review items in the approval queue. It also states a required scope (learning:arbiter:read), serving as a prerequisite. However, it does not explicitly mention when not to use it or name alternative tools for other queue types.

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

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

With no annotations, the description carries the full disclosure burden. It states the required scope, mentions governance by Arbiter policy, and notes that every call is sealed with a ProofLink receipt—valuable behavioral context. It does not explicitly state whether it is read-only or has performance implications, but the 'briefing' wording and return list imply a read snapshot.

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 yet informative, front-loaded with the primary purpose and followed by a compact list of returned data. The second paragraph efficiently covers access scope and side-effect receipt behavior. No wasted words.

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 parameters, no output schema, and no annotations, the description fully compensates by enumerating all returned data points, stating the use case, and disclosing access requirements and receipt behavior. It is complete for an AI agent to select and invoke this tool correctly.

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

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

The tool takes zero parameters, and schema coverage is 100% (vacuously). The baseline for 0 params is 4; no additional parameter explanation is needed since there are none to describe.

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 it 'Get[s] a full real-time platform health briefing' for the iTechSmart UAIO platform, listing the exact contents (service statuses, SIE queue counts, disk usage, etc.). This specific verb+resource combination distinguishes it from sibling health checks like langfuse_health or mesh_health.

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

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

Provides clear usage context: 'Use this for an instant one-shot snapshot of everything running on the platform.' It implies this is the go-to tool for a broad overview instead of querying multiple individual health tools, but does not explicitly exclude alternatives or list when-not-to-use.

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?

Description discloses the required scope 'ledger:audit:read' and mentions governance and cryptographic sealing, adding meaningful context beyond the absent annotations. However, it does not explain behavior when tampering is detected or return format specifics.

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, front-loaded with the primary purpose, and uses two compact paragraphs covering function, output, and access requirements. No redundant words.

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?

Even without an output schema, the description states that receipts are returned chronologically with full chain verification, covering the main expected outcome. Scope and governance details are present, but alternative tool comparison and edge-case behavior are missing.

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

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

Input schema provides full descriptions for both parameters (limit and container), and the description adds no extra parameter semantics. High schema coverage (100%) warrants the baseline score of 3.

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 clearly states 'Fetch and verify the complete ProofLink receipt chain from iTechSmart's production ledger', with a specific verb and resource. It distinguishes itself from sibling verify/search tools by emphasizing the complete chain and chronological order.

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 use for retrieving the full receipt chain but does not explicitly contrast with siblings like prooflink.search_receipts or prooflink.verify_chain. No when-not guidance is provided, forcing the agent to infer usage.

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

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

There are no annotations, so the description carries the full burden. It discloses the required scope ('sie:queue:read'), the governance policy ('Arbiter constitutional policy'), and the receipt guarantee ('sealed with a ProofLink cryptographic receipt'). The verb 'retrieve' strongly implies a read-only operation, and no side effects are mentioned, providing useful behavioral context 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 concise and front-loaded: the first sentence states the core purpose, the second lists return fields, the third gives usage context, and the second paragraph covers auth and receipt. No filler or redundant information; every sentence 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?

For a read-only tool with no output schema, the description provides a good overall picture: what it returns, when to use it, and required permissions. It does not mention ordering or potential error conditions, but these are minor for a simple queue-reading tool. The description is complete enough given the context signals and 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?

The input schema has 100% coverage with clear descriptions for all three parameters. The main description does not add significant meaning beyond the schema; it merely lists detector types and fix classes in the return fields, which redundantly echoes the schema. Baseline 3 is appropriate as the schema handles 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 clearly states the tool's purpose: 'Retrieve the current SIE security finding queue.' It specifies the resource (SIE queue), the action (retrieve), and the type of data (security findings). It also lists the return fields (severity, detector type, fix class, affected file paths, remediation action), making it distinct from sibling tools like 'get_learning_queue' and 'approve_sie_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 a clear usage context: 'Use to inspect what security issues SIE has flagged for human approval.' This implies when to use the tool and distinguishes it from approval or scanning tools, though it does not explicitly name alternative tools as the calibration high example does.

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

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

With no annotations, the description carries full burden. It discloses the scope requirement and the ProofLink sealing behavior, but doesn't detail side effects, reversibility, or success/failure behavior.

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

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

The description is brief and front-loaded with the main action, but repeats the ProofLink sealing information in both sentences, which is redundant.

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

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

Given no annotations, no output schema, and 4 parameters with no descriptions, the description leaves many gaps: no return value explanation, no time format, no indication of how to handle failures. It covers only the basic purpose and one side effect.

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

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

The input schema has 4 parameters with 0% description coverage, and the description provides no parameter details whatsoever. It fails to explain what contact_id, calendar_id, start_time, end_time mean or their formats.

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+resource: 'Book a calendar appointment for a GHL contact.' It also notes it seals a ProofLink receipt, distinguishing it from sibling GHL tools like ghl_create_contact or ghl_send_email.

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 does not provide explicit when/when-not usage or alternatives. It implies usage via its clear purpose but only adds a scope requirement, not guidance on selecting it over other 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?

With no annotations, the description carries the full behavioral disclosure burden. It discloses that the operation requires a specific write scope and that it seals a ProofLink receipt, adding some transparency. However, it does not mention side effects, failure modes, or idempotency, leaving gaps for an agent.

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 two sentences that front-load the core purpose and follow with the scope and receipt information. Every sentence adds distinct value without redundancy.

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

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

Given the absent schema descriptions and lack of output schema, the description is under-specified for a six-parameter tool. It fails to clarify required fields, parameter formats, or return behavior, leaving significant information gaps for an agent to select and 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?

The schema provides no descriptions for the six parameters, and the description does not compensate by explaining their meaning or format. The description only names the tool's purpose, offering no additional semantic guidance for parameters such as first, last, email, phone, company, or tags.

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 (create a contact) and the target system (GoHighLevel CRM), distinguishing it from sibling tools like ghl_update_contact and ghl_send_email. The additional mention of ProofLink receipt sealing adds a secondary behavior but does not obscure the primary purpose.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. It mentions a required scope but lacks any exclusions or alternative tool references. The usage is only implied by the verb 'create', not elaborated.

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

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

With no annotations, the description carries the full burden of revealing behavioral traits. It does disclose that every call is governed by Arbiter policy and sealed with a ProofLink cryptographic receipt, which adds value. However, it does not mention potential side effects beyond the receipt, such as reversibility or impact on related records, nor does it clarify whether the tool is purely mutating or potentially destructive.

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 exceptionally concise—two short sentences that cover the primary action, the side effect, the required scope, and governance. There is no redundant or filler content; every phrase contributes meaningful information, making it easy for an agent to parse quickly.

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 just two parameters and no output schema, the description is mostly complete: it states the action, the key side effect (ProofLink receipt), and the required scope. It does not explain the return value or the meaning of the ProofLink receipt, but given the simplicity and the presence of related prooflink siblings, the agent likely has enough context to invoke 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 input schema has a 0% description coverage, and the description does not explicitly explain the parameters. Although the parameter names (opportunity_id, stage_id) are intuitive and consistent with the tool's purpose, the description adds no explicit semantics. The move action implies stage_id is the target stage and opportunity_id is the item to move, but this is inferred rather than stated.

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 primary action: 'Move a GHL opportunity to a new pipeline stage.' This is a specific verb, resource, and destination that distinguishes it from sibling GHL tools like ghl_update_contact or ghl_trigger_workflow. The additional mention of sealing a ProofLink receipt adds a secondary purpose without confusing the main one.

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

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

The description provides some context like the required scope and governance policy, but does not explicitly state when to use this tool instead of alternatives. It implies usage through the action itself, but there are no exclusions or comparison with sibling tools. The context is present but not decisive.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that emails may be held by the Judge gate if flagged, that every call is governed by Arbiter policy, and that a ProofLink receipt is sealed. It also states the required scope. These are meaningful behavioral traits, though the exact meaning of 'flagged' and the holding mechanics are not detailed.

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 primary action, but it redundantly mentions the ProofLink receipt sealing in both the first and second sentences. Despite this minor repetition, it avoids unnecessary detail and remains 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?

The description covers the essential purpose, scope, and key behaviors, but without an output schema or annotations, it omits details on return values, error conditions, and the meaning of 'flagged'. For a tool with five parameters and no annotations, the description is only partially complete, leaving some ambiguity about the email-sending flow.

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 provides no parameter-specific information, despite the schema having 0% coverage. It only implies that contact_id identifies the recipient ('GHL contact'), while subject, body, from_name, and from_email are not elaborated. The schema property names are self-explanatory, but the description doesn't 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 clearly states the tool sends an email to a GHL contact, specifies the Judge gate mechanism, and mentions the ProofLink receipt. This distinguishes it from sibling GHL tools like ghl_create_contact or ghl_trigger_workflow, which perform different actions.

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 for sending emails to GHL contacts and provides a prerequisite (scope: ghl:messaging:write), but it does not explicitly state when to use this tool over alternatives or when not to use it. Among sibling tools, no other email-sending tool exists, so the use case is fairly clear but not explicitly guided.

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

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

With no annotations, the description carries the full burden. It discloses a required scope, states that every call is governed by Arbiter constitutional policy, and mentions the ProofLink receipt sealing. This goes beyond a simple 'triggers a workflow' statement, though it does not detail failure behavior or response format.

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

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

The description is two sentences with the main action front-loaded. Every word earns its place—no filler, no redundancy. It is appropriately sized for a simple two-parameter tool.

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 core action and side effects but does not mention the return value or any response format, and there is no output schema. For a tool that seals a receipt, the agent might need to know what the receipt is or how it is returned. The lack of this detail is a clear gap for full invokability.

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

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

Schema coverage is 0%, so the description must compensate. It implies that 'workflow_id' identifies the workflow and 'contact_id' the contact, but it does not explicitly define each parameter or provide format/context. The meaning is partially conveyed, but not enough to fully 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 clearly states the action ('Trigger') and the resource ('GHL workflow for a contact'), distinguishing it from sibling GHL tools like ghl_create_contact or ghl_move_pipeline. It also mentions the ProofLink receipt, which adds specificity about the tool's unique side effect.

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

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

The description provides clear context: this tool is for triggering a workflow on a contact. It does not explicitly mention when not to use it or alternatives, but the clear action and resource imply its usage scope relative to other GHL 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?

No annotations are present, so the description must disclose behavior. It mentions requiring scope ghl:contacts:write and sealing every call with a ProofLink receipt—useful behavioral context. However, it does not describe side effects, return values, or error behavior, so it only partially carries 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?

The description is brief and front-loaded with the purpose. The final sentence repeats the ProofLink sealing already mentioned, introducing minor redundancy, but overall it is efficient.

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

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

With no output schema, no parameter descriptions, and minimal usage guidance, the description is insufficient for an agent to understand what fields to provide or what to expect in return. The added scope and sealing context are useful but not enough for full operational clarity.

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 beyond the parameter names. 'fields' is an untyped object with no explanation of expected structure, keys, or value formats, which is a serious 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 starts with a specific verb and resource: 'Update GHL contact fields.' This clearly distinguishes it from sibling tools like ghl_create_contact, ghl_move_pipeline, and ghl_send_email.

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 does not explicitly state when to use this tool versus alternatives. The scope requirement is a prerequisite, not usage guidance. 'Update' implies modifying existing contacts, but no explicit when/why 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?

No annotations are provided, so the description carries the burden. It discloses the required scope 'integrations:status:read' and the governance/receipt behavior ('governed by Arbiter constitutional policy and sealed with a ProofLink cryptographic receipt'). It does not address potential error states or network effects, but for a read-only health check this is adequate.

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

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

The description is two sentences: first states the function and response, second states requirements. No filler or repetition, front-loaded with the core purpose.

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 is simple (zero params) and the description lists all affected services, the response format (ok:true/false and metadata), and access requirements. Since there is no output schema, a slightly more detailed return contract would help, but the current coverage is sufficient for an agent to invoke this tool correctly.

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

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

The input schema has zero parameters, so there is no parameter documentation burden. The description doesn't need to explain parameters, and it doesn't introduce any ambiguity about inputs.

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

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

The description uses a specific verb phrase 'Parallel health check' and enumerates the exact integrations (Langfuse, RAGflow, Shuffle, Tactical RMM, MeshCentral, Probo compliance). It clearly indicates it aggregates status across all services, distinguishing it from individual sibling health-check tools.

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

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

It presents a clear context: a holistic overview of all wired integrations. However, it does not explicitly state when to prefer this over individual health checks or provide explicit alternative tool references, so it misses the explicit 'when-not' guidance.

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

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

With no annotations, the description carries full burden and does well: it discloses the HTTP endpoint, required scope ('octoai:pipeline:invoke'), governance ('Arbiter constitutional policy'), and the output shape ('final_answer with a confidence score'). It could be improved by noting whether the call has side effects or is read-only, but it covers important behavioral context beyond a simple invocation.

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 tight and well-structured: the first paragraph introduces the core function, routing, and output; the second adds security and policy context. Every sentence contributes, and there is no redundant filler.

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

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

For a tool with no output schema and moderate complexity, the description gives a solid overview including the multi-agent chain, output fields, endpoint, and required permissions. It omits details like error handling or response format specifics, but the provided information is sufficient for most invocation 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?

Schema description coverage is 100%, so the parameters are already well documented. The description adds minimal extra meaning (e.g., calling the prompt 'free-form') but does not deepen understanding of session_id or prompt semantics beyond the schema. Baseline of 3 is appropriate when schema carries the load.

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 ('Invoke') and a specific resource (the OctoAI 7-node cognitive pipeline), and clearly differentiates it from siblings by describing its multi-agent reasoning chain and synthesized final_answer. It is instantly clear what the tool does and why it stands apart from deterministic infrastructure lookup 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?

Explicitly states when to use: 'Use for open-ended platform questions, decision support, or anything that needs OctoAI's reasoning rather than a deterministic infrastructure lookup.' This provides clear context and excludes alternative use cases, effectively distinguishing it from sibling tools like get_platform_briefing or query_uaio_status.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It does disclose a significant side effect (ProofLink seal trigger), but it does not mention other important behaviors such as idempotency, permissions required, or whether the action is reversible. The single side effect disclosure is useful but not comprehensive.

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, front-loads the primary action, and includes the key side effect. Every word contributes value, making it highly concise and well-structured.

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

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

Given the tool's low complexity (two required parameters, no output schema, no annotations), the description provides adequate context: it states the action, the resolution requirement, and a side effect. It does not elaborate on edge cases (e.g., already-closed tickets) but covers the essentials for a straightforward action tool.

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

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

Schema coverage is 100%, but the schema descriptions are minimal ('Ticket ID to close' and 'Resolution description'). The description adds a phrase 'with a resolution note' which reinforces the 'resolution' parameter, but it does not add meaningful extra semantics beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the primary action ('Close and resolve an ITSM ticket') with a specific verb and resource, and it distinguishes the tool from sibling ITSM tools like get/create/list. It also adds a unique side effect ('Triggers ProofLink seal'), further clarifying its purpose.

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

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

The description implies the tool is for closing/resolving tickets, but it does not explicitly state when to use it over alternatives or provide exclusions (e.g., 'Use this only when the ticket is ready for closure'). There is no mention of when not to use it, so guidance is only implied.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It states two non-obvious behaviors: 'Assigns priority based on severity' and 'Returns ticket ID.' This goes beyond the obvious 'creates a ticket' and provides useful context about internal logic and output. However, it doesn't mention side effects like notifications or permissions, but for a create tool, the described behaviors are significant.

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

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

The description is two well-structured sentences: the first states the main purpose, the second provides behavioral and output details. There is no fluff, and it is front-loaded with the core action. Every sentence 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?

Given the tool's moderate complexity (5 params, no output schema), the description covers purpose, behavior, and return value. It is not overly rich, but it provides enough for a straightforward create operation. The lack of usage alternatives is a minor gap, but overall it is complete for the tool's simplicity.

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

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

The schema already provides 100% parameter descriptions, so the baseline is 3. The description adds extra semantic meaning by linking 'severity' to priority assignment, which is not fully captured in the schema. This helps the agent understand how the severity parameter influences the outcome.

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 purpose with a specific verb and resource: 'Create an ITSM ticket for an incident.' It also distinguishes from siblings like itsm_get_ticket and itsm_close_ticket by focusing on creation. The additional details about priority assignment and returning a ticket ID reinforce the unique function.

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

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

The description gives clear context for when to use the tool: to create a ticket for an incident. It doesn't explicitly list alternatives or exclusions, but the phrase 'for an incident' helps the agent understand the intended scenario. No competing create-ticket sibling exists, so the usage is fairly clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses the returned metric categories, and 'Get' implies a read-only operation, but it does not mention data freshness, access requirements, aggregation caveats, or any side effects. It is minimally adequate but not rich in behavioral context.

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

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

The description is a single, front-loaded sentence with a colon-delimited list of specific fields. Every word is informative, with no fluff 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?

For a zero-parameter, no-output-schema tool, the description fully enumerates what the agent should expect: open count, resolved today, avg MTTR, top failing services, and ProofLink sealing rate. This is sufficient for an agent to invoke and interpret the result.

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

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

The tool has zero parameters, so there is nothing to explain; the baseline of 4 applies. The description instead clarifies the output content, which is useful given the absence of an output 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 uses a specific verb ('Get') and clearly identifies the resource ('ITSM dashboard summary'), then enumerates the exact output fields (open count, resolved today, avg MTTR, top failing services, ProofLink sealing rate). This clearly distinguishes it from sibling tools like itsm_get_mttr_stats or itsm_list_open_incidents.

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 high-level dashboard overview, but it does not explicitly state when to use it versus the many more specific ITSM sibling tools, nor does it mention exclusions or alternatives. Usage context is only 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?

There are no annotations to provide safety or side-effect context, so the description carries the full burden. It only states 'embed' without disclosing that this modifies an existing ticket, any required permissions, reversibility, or what the response contains. This is a significant transparency gap for a mutating tool.

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

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

The description is a single, front-loaded sentence with no redundant or filler content. It conveys the essential action, resource, and target 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?

This is a mutation tool with no annotations and no output schema, yet the description only offers a high-level action. It fails to explain how the receipt is embedded, whether the ticket body is replaced or appended, what success/failure looks like, or any other behavioral context needed for correct invocation.

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

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

Schema coverage is 100% (all three parameters have descriptions), so the schema already documents the parameters. The description adds marginal value by clarifying the receipt is SHA-256, but it does not explain the distinction between receipt_id and receipt_hash or when to provide each, so the baseline of 3 is appropriate.

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

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

The description uses the specific verb 'Embed' and identifies both the resource ('ProofLink SHA-256 receipt') and the target ('existing ITSM ticket body'). This clearly distinguishes it from sibling tools like itsm_verify_receipt or itsm_create_ticket.

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 any prerequisites, exclusions, or explicit use cases beyond the basic action, and sibling verification tools are not referenced.

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

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

With no annotations, the description carries the full burden of behavioral transparency. It conveys a read-only nature via 'Return' and describes the output, but it does not disclose potential side effects, permission requirements, or error cases. For a simple status check, this is adequate but lacks depth.

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 ('Return status...') with no redundant words. It communicates purpose and scope 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 no-parameter tool with no output schema, the description provides enough information to select and invoke it. It states what is returned ('status and last-scan results') and the scope ('all 5'). A richer description of output structure would be helpful, but the simplicity of the tool keeps this adequate.

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

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

The tool has zero parameters, and the schema is empty. The description explains that the tool covers 'all 5' sources, so no input selection is needed. This meets the baseline for no-parameter tools, as there is no parameter semantics to add.

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 ('Return') and resource ('status and last-scan results for all 5 ITSM incident detection sources'). It is specific about the scope ('all 5') and distinguishes the tool from sibling ITSM tools that handle tickets or trigger actions.

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 explicit usage guidance is given, such as when to use this tool versus alternatives. However, the description implies a read-only monitoring use case, and the tool's purpose is clear from the wording. It does not mention exclusions or point to alternative tools like itsm_trigger_detection.

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

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

With no annotations provided, the description carries the burden of transparency. It discloses that the tool returns a timeline covering the entire incident lifecycle, which is helpful behavioral context. However, it does not mention permissions, pagination, or response format, but for a simple read tool, this is acceptable.

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 concisely lists the lifecycle stages, with no filler words. It is well-structured and 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?

Given the tool's simplicity (one parameter, no output schema), the description provides sufficient context about what the tool does. It could enhance transparency by mentioning output structure, but overall it is complete enough for a simple retrieval at this level.

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 already provides 100% coverage for ticket_id with 'Ticket ID'. The description does not add further semantic detail about the parameter, such as format or where to find it. Baseline 3 is appropriate since schema covers the parameter.

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

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

The description clearly states the tool retrieves the full lifecycle timeline of an incident, listing specific stages (detected, ticketed, diagnosed, remediated, verified, sealed). This distinguishes it from sibling tools like get_incident_details or list_recent_incidents.

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 timeline retrieval, but does not explicitly state when to use it instead of other incident tools like get_incident_details or get_remediation_history. No exclusions or alternatives are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explicitly state that the operation is read-only (though 'Get' hints at this), nor does it describe the output structure, permissions, side effects, or any edge cases. The only added context is the data source 'resolved ITSM tickets', which 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, concise sentence that front-loads the core purpose without any fluff. It is appropriately sized for the tool's simplicity and contains zero wasted words.

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 and no annotations, so the description should compensate by explaining what the returned statistics look like. It does not, and also fails to address edge cases like insufficient ticket count. While the tool is simple, the lack of return-value detail makes it incomplete for an agent without prior 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?

The schema fully covers the single parameter 'last_n' with a clear description ('Analyze last N resolved tickets (default 10)'), so the description adds no additional parameter semantics. Baseline 3 is appropriate since schema coverage is 100%.

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

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

The description uses a specific verb 'Get', a clear resource 'MTTR statistics', and a source qualifier 'resolved ITSM tickets'. This precisely distinguishes it from sibling tools like itsm_list_tickets or itsm_get_incident_timeline, making the purpose unmistakable.

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

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

The description implies the tool should be used when MTTR statistics from resolved tickets are needed, but it does not explicitly state when to use this tool versus alternatives (e.g., itsm_get_remediation_history) or mention any exclusions. The usage context is clear but not elaborated.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states that it 'gets' history and includes MTTR/success rate, but does not reveal whether it is read-only, how results are ordered, whether historical data is bounded by default, or if any side effects occur. This is minimal disclosure for an unannotated tool.

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

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

The description is a single, well-structured sentence that gets straight to the point. It is front-loaded with the core action and resource, and every word adds value without redundancy.

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

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

For a simple getter with two optional params and no output schema, the description is adequate but not comprehensive. It does not differentiate itself from similar sibling tools like itsm_get_mttr_stats, nor does it mention any behavioral caveats or return format, which could lead to incorrect selection in a tool-rich environment.

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

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

Schema description coverage is 100% (both limit and service have descriptions), so the baseline is 3. The description itself adds little parameter detail beyond the schema, but it does imply that 'all' actions are returned unless service filtering is applied, which is a slight enhancement.

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 says 'Get the history of all auto-remediation actions' with a specific verb and resource, and it mentions MTTR and success rate as output details. It is distinct enough from siblings by focusing on 'history' and 'remediation actions', though it does not explicitly call out alternatives like itsm_get_mttr_stats.

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 usage context is implied: one would use this tool to retrieve remediation history. However, there is no explicit guidance on when to prefer this over related tools (e.g., itsm_get_mttr_stats) or any exclusions. It does not say 'use for X, not for Y'.

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

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

With no annotations, the description carries the full burden. It adds one useful behavioral detail: the ticket includes an embedded ProofLink receipt if sealed. However, it does not mention other behavioral aspects like error handling, permissions, or the absence of a receipt for unsealed tickets. This is adequate but sparse.

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, focused sentence that front-loads the action and includes the key additional detail about ProofLink. No unnecessary words; every part 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?

For a simple single-parameter retrieval tool without an output schema, the description provides enough context: the action, the key conditional behavior (receipt if sealed), and the ID parameter is self-explanatory. It could mention what happens if the ticket is not found, but that is a minor gap given the tool's simplicity.

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

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

The schema already describes the only parameter (ticket_id) with 100% coverage. The description's 'by ID' adds no new semantic meaning beyond what the schema provides. Baseline 3 is appropriate since the schema fully documents the parameter.

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

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

The description clearly states a specific action ('Retrieve a single ITSM ticket by ID') and adds contextual detail about the embedded ProofLink receipt. It distinguishes from sibling tools like itsm_list_tickets (multiple tickets) and itsm_create_ticket (creation).

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 clearly implies when to use this tool: when you have a specific ticket ID and need a single ticket. However, it does not explicitly mention alternatives or exclusions (e.g., 'use itsm_list_tickets for multiple tickets'), though the context is unambiguous.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly states the filter (status=open) and the sort (by severity), which are useful behavioral details. It does not mention pagination or access scope, but for a simple list operation this is adequate.

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

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

The description is a single, concise sentence that is front-loaded with the action ('List') and includes the essential details (scope, filter, ordering). 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?

For a simple list tool with no parameters and no output schema, the description covers purpose, filter, and ordering. It does not specify the response format, but that is not critical for this type of tool given the surrounding 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?

The tool has zero parameters, so the schema is fully complete. The description does not need to explain any parameters, and there is no ambiguity to resolve. Baseline for 0 params is 4.

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 'list', the resource 'open incidents', and specifies the exact filter (status=open) and ordering (by severity). It distinguishes this tool from siblings like itsm_list_tickets, which likely includes closed tickets.

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

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

The description implies the tool is for retrieving open incidents but does not explicitly compare to alternatives like itsm_list_tickets or itsm_get_ticket. No when-to-use or when-not-to-use guidance is provided, so usage is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool lists tickets and can filter, but does not describe the return format, ordering, pagination, or whether it is read-only (though this is implied). The description adds minimal context beyond the basic action.

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, succinct sentence that immediately states the action and key options. It contains no filler or redundant information, making it highly concise and well-structured.

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

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

The tool is simple, and the schema covers parameters well, but there is no output schema, so the description should indicate what the tool returns. It does not. Additionally, it gives no context on how this tool relates to the many similar ITSM tools in the sibling list, leaving the agent without enough information to make a fully informed selection.

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

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

Schema coverage is 100%, with each parameter having a description and enums. The description adds no new meaning, only restating that filters are optional. It actually omits the 'all' enum value for status, which could be slightly misleading, but the schema fully documents it. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'List ITSM tickets' with optional filters for status and severity. It uses a specific verb and resource, but does not explicitly distinguish it from sibling tools like itsm_list_open_incidents, so it loses a point for missing sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternative ITSM listing tools. It doesn't mention any exclusions, prerequisites, or scenarios where a different tool would be more appropriate. The sibling list contains similar tools, but no comparison is offered.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It mentions the webhook receives ticket state changes and lists event types, but does not clarify whether registration overwrites existing webhooks, verifies the URL, or any side effects. The lack of detail on lifecycle or error behavior leaves gaps.

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 redundant wording. It efficiently conveys the action, target, and event types.

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

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

For a simple one-parameter tool without output schema or annotations, the description covers the core purpose but omits operational details like whether registration is idempotent, how to manage multiple webhooks, or what a successful registration returns. This makes it adequate but not fully complete for an agent.

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

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

The schema fully describes the only parameter (url) as "Webhook URL to POST events to", giving 100% coverage. The description adds value by specifying the exact event types (OPENED, UPDATED, RESOLVED) and connecting the URL to the purpose, enriching the meaning of the parameter beyond the schema.

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

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

The description clearly states the tool registers a webhook URL to receive real-time ITSM ticket state changes, listing specific event types (OPENED, UPDATED, RESOLVED). It uses a specific verb (register) and resource (webhook URL), and stands out from sibling ITSM tools like itsm_create_ticket or itsm_get_ticket.

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 when real-time notifications are needed but does not explicitly contrast with alternatives like polling via list/get ticket tools. No when-not-to-use instructions or alternative tool names 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?

With no annotations, the description must carry the burden of behavioral disclosure. It lists the pipeline steps and return value, but omits key side effects such as service restarts (only implied by the dry_run schema) or potential production impact. The step list gives some transparency, but deeper consequences are not mentioned.

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 exceptionally concise, using a compact step list and stating return values in two sentences. Every word earns its place; no filler or redundant prose.

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 (orchestrating 6 steps), the description covers the workflow well but lacks prerequisites, failure behavior, and safety warnings. The existence of a dry_run parameter is in the schema, but the description does not fully explain the consequences of running the full loop in production, leaving gaps for a complex, likely impactful operation.

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 covers the only parameter (dry_run) with a clear description, giving 100% schema coverage. The tool description itself adds no additional parameter context, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool triggers the full 6-step ITSM ProofLink loop with a specific sequence (DETECT -> TICKET -> DIAGNOSE -> REMEDIATE -> VERIFY -> CLOSE+SEAL), which distinguishes it from individual ITSM actions like itsm_create_ticket or itsm_close_ticket. It also specifies return values (sealed ticket IDs and receipt hashes), making the purpose concrete.

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 like itsm_run_test or the individual ITSM step tools. The dry_run parameter is described in the schema but the description does not position it as a usage condition or explain when to prefer this over more granular 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?

With no annotations provided, the description carries full responsibility for disclosing side effects. It states the operation is 'synthetic' and lists outputs, but does not mention whether persistent state is modified, whether external services are called, permission requirements, or any cleanup behavior. This is a meaningful transparency gap for a tool that 'injects' incidents.

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

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

Two sentences, front-loaded with the core action, and every word adds value. The first sentence states the action and scope; the second lists the expected return values. No redundancy or filler.

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

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

For a zero-parameter tool with no output schema, the description covers the action and return values adequately. However, it leaves ambiguity about what 'full ITSM ProofLink loop' entails, why this differs from 'itsm_run_loop', and what side effects occur. Some additional context about the loop's stages or non-production intent would improve completeness.

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 zero parameters, so the baseline is 4 per the rubric. The description does not need to add parameter details, and it avoids inventing any.

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 ('Inject') and resource ('synthetic test incident through the full ITSM ProofLink loop'), clearly distinguishing it as a test-oriented end-to-end operation. It also names key return values (ticket ID, receipt hash, embedded receipt block). However, it does not explicitly differentiate from the very similar sibling 'itsm_run_loop'.

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 for testing via 'synthetic test incident', but offers no explicit when-to-use guidance or exclusions. Given closely related siblings like 'itsm_run_loop' and 'itsm_create_ticket', the lack of alternatives or a 'use instead when...' statement leaves the agent to infer the distinction.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that the tool runs all detectors, returns raw findings, and does not create tickets, which covers the primary non-mutating behavior. However, it doesn't disclose potential side effects such as triggering network scans, resource usage, or how failures are handled, leaving gaps in transparency.

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

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

The description is a single, concise sentence that is front-loaded with the verb and resource. It efficiently lists the detectors and the key non-ticket behavior without any fluff or repetition, earning a perfect score for conciseness and structure.

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

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

There is no output schema, so the description must explain return values, but it only says 'raw findings' without specifying format, structure, or potential variations. The tool's purpose is clear, but the nature of the output and any failure modes are underspecified, making it somewhat incomplete for an agent needing full 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?

The tool has zero parameters, and the baseline for zero parameters is 4. The description adds contextual meaning about the tool's action and output, which goes beyond the empty input schema, fulfilling the semantic requirement.

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 'Run' and explicitly names all 5 incident detectors (iSELF, Prometheus, Wazuh, NetworkScanner, OctoAI), making the tool's scope unmistakable. It also distinguishes itself from ticket-creating tools by stating 'without creating tickets', which aligns with sibling tool names like itsm_create_ticket.

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 clearly conveys the tool's purpose: run all detectors and return raw findings without escalating to tickets. This implies use cases requiring aggregated raw output rather than ticket creation, but it doesn't explicitly state when to prefer this over running individual detectors or mention exclusions. The context is clear, yet lacks explicit 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?

With no annotations provided, the description carries the full burden for behavioral disclosure. It does state the return values (hash, chain position, verification URL), which gives some insight into the verification outcome. However, it does not mention side effects (e.g., is it read-only?), failure modes, or prerequisites (e.g., the receipt must have been embedded via itsm_embed_receipt). This partial disclosure earns a mid-range score.

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

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

The description is two sentences, front-loaded with the action, and contains no redundant information. It efficiently conveys the purpose and the key output fields without wasteful text.

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

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

For a simple one-parameter tool with no output schema, the description covers the essential context: it verifies a receipt in an ITSM ticket and enumerates the return values. It does not explicitly note that the ticket must already have a receipt embedded (via itsm_embed_receipt), but given the low complexity and the presence of sibling tools with similar names, the description is sufficiently complete for selection and invocation.

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

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

Schema coverage is 100% and the only parameter (ticket_id) is described as 'Ticket ID to verify'. The description adds no meaning beyond the schema; it simply restates the use case. The baseline of 3 applies because the schema already fully documents the parameter.

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

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

The description states a specific verb ('Verify') and resource ('ProofLink receipt embedded in an ITSM ticket'), clearly distinguishing it from sibling tools like prooflink.verify_receipt or verify_prooflink_receipt by specifying the ITSM context. The scope is unambiguous.

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

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

The description implies the tool is used when verifying a ProofLink receipt that is embedded in an ITSM ticket. It gives clear context for when to use it, though it does not explicitly name alternatives or exclusions. No competing tool is directly referenced, but the embedded-in-ITSM qualifier provides enough guidance.

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

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

With no annotations, the description carries the full transparency burden. It discloses a required scope (integrations:observe:read), policy governance, and ProofLink receipt sealing, which provides meaningful context beyond the schema. It also states what it returns, though it does not detail error conditions or exact output formatting.

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

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

The description is two sentences that are front-loaded with the primary purpose, followed by necessary scope and policy context. Every word earns its place, with no redundancy or filler.

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

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

For a simple health-check tool, the description covers the main bases: purpose, return values, required scope, and policy context. It does not specify the exact structure of 'ok status' or how to interpret unhealthy responses, but given the tool's simplicity, this is a minor gap.

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

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

The tool has zero parameters, so the schema fully covers parameter semantics. The description adds no parameter detail, but with no parameters to explain, the baseline of 4 is appropriate.

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

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

The description clearly states the specific verb 'Check' and the exact resource 'Langfuse LLM observability platform health', distinguishing it from sibling health tools like ragflow_health or shuffle_health by naming the platform. It also specifies what is returned (ok status and org name), adding concrete scope.

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 context is implied by the tool name and description: use this when you need Langfuse platform health. However, there are no explicit when-to-use instructions, exclusions, or references to alternative tools, leaving the agent to infer the appropriate situation.

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

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

With no annotations, the description discloses key behavioral traits: it's a write operation requiring 'integrations:observe:write' scope and it produces a ProofLink cryptographic receipt with governance. This goes beyond a bare 'create' statement, though it doesn't detail side effects, idempotency, or return format.

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

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

Two sentences, front-loaded with the action and resource, no filler. The second sentence adds required context (scope, receipt) without bloat.

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 is a create operation but has no output schema and the description doesn't state what it returns (e.g., trace ID or receipt), leaving agents uncertain about how to reference the created trace. It also doesn't explain the ProofLink receipt's role or how it connects to sibling verify 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?

All 7 parameters already have schema descriptions (100% coverage), so the description adds little beyond what's in the schema. It echoes 'input, output, model, metadata' but doesn't clarify relationships or provide additional usage nuances.

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+resource ('Create a Langfuse trace') and states the exact purpose ('to log an LLM interaction'), clearly distinguishing it from sibling tools like langfuse_health or other logging/ITSM 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?

Provides clear context for when to use (logging an LLM interaction) and even specifies the required scope. However, it doesn't explicitly name alternatives or exclusions, so it stops short of 5.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses the chronological ordering, the exact fields returned, the required permission scope, and the always-on governance/receipt behavior. It stops short of discussing error conditions or rate limits, but the provided context is substantial.

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: the first states the purpose and return fields; the second covers scope and governance. Every sentence earns its place, and it's front-loaded with the core purpose. No fluff 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?

For a list tool with no output schema, the description compensates by listing the return fields (incident ID, timestamp, trigger type, etc.). It also includes the scope requirement and receipt behavior, making the tool's behavior reasonably complete. It could mention pagination or default limit, but the schema covers defaults.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (limit, since) with types and meanings. The description adds no additional parameter semantics, which is acceptable under the high-coverage baseline. It does not need to compensate.

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 explicitly states the verb 'List', the resource 'recent autonomous IT remediation incidents', and the platform 'iTechSmart UAIO platform'. It also enumerates the return fields, making the tool's function unambiguous and distinct from siblings like mission.list_incidents or itsm_list_incidents.

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 mentions a required scope (incident:classify:read), but it provides no guidance on when to use this tool versus the many sibling tools that also list incidents, such as mission.list_incidents or itsm_list_incidents. There are no explicit alternatives 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?

With no annotations provided, the description carries the full burden. It discloses the required scope ('integrations:mesh:read'), implying read-only access, and mentions governance policies and ProofLink receipts. This provides useful transparency beyond the basic list action, though it does not detail potential errors, pagination, or side effects (which are unlikely for a list operation).

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, front-loaded with the core functionality and followed by essential access/governance context. Every sentence earns its place with no redundancy or fluff.

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

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

For a simple 0-parameter list tool with no output schema, the description covers the main aspects: what it returns, the required scope, and governance. It does not mention pagination or result limits, which might be relevant for 'all devices', but overall it is sufficiently complete for an agent to use the tool correctly.

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

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

The tool has 0 parameters, and the schema coverage is trivially 100%. Per the rubric, a 0-parameter tool receives a baseline of 4. The description adds no parameter details because none exist, which is appropriate.

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

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

The description clearly states a specific verb and resource: 'List all devices enrolled in MeshCentral' and enumerates the returned fields (hostname, OS, connectivity, group info). This distinguishes it from sibling tools like mesh_health or trmm_agents, which focus on health or other platforms.

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

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

The description provides clear context for when to use this tool: whenever a list of MeshCentral devices is needed. While it does not explicitly name alternative tools or exclusion criteria, the purpose is specific enough that an agent can infer usage. Siblings like mesh_health are obviously different in scope.

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

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

With no annotations, the description carries the full burden. It discloses the required permission scope and the ProofLink receipt behavior, adding useful context. It does not explicitly state read-only or side-effect-free, but the term 'health check' implies a safe operation.

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

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

The description is two concise sentences: the first states purpose and output, the second lists a requirement and a behavioral guarantee. Every sentence adds value with no redundancy.

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

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

For a zero-parameter health check, the description covers purpose, required scope, return data, and a notable receipt behavior. The sibling prooflink tools give additional context for the receipt, and the description is complete enough for an agent to use correctly.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The schema is empty and the description correctly focuses on return values instead of parameter details.

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 checks MeshCentral health and returns specific data (ok status, admin user, device count). This verb+resource phrasing distinguishes it from sibling tools like mesh_devices and other platform health checks.

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

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

The description provides clear context for when to use it (health check of MeshCentral) and mentions a required scope, but does not explicitly name alternatives or exclusion criteria. This qualifies as 'clear context, no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers read-only behavior, required scope (mission.cluster_health), governance by Arbiter constitutional policy, and ProofLink cryptographic receipt sealing. This is rich contextual information beyond a simple read-only hint.

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

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

The description is compact, with the main purpose front-loaded in the first sentence. The additional sentences convey important scope, policy, and receipt information without unnecessary elaboration. Every sentence contributes 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?

This is a simple zero-parameter health-check tool with no output schema. The description fully covers what the tool does, its read-only nature, required permissions, and governing policies. The agent has enough context to select and invoke it correctly among many health-related siblings.

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

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

The tool has zero parameters and schema coverage is 100%, so the description need not explain parameter details. The baseline of 4 applies because there are no parameters to document.

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 returns live cluster health, using a specific verb ('return') and resource ('cluster health'). It also explicitly labels itself as read-only mission scope, distinguishing it from execution or remediation tools. The alias note adds additional clarity.

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

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

The description specifies that this is a read-only health check and explicitly notes it does not grant execution or remediation rights, implying it should be used for observation only. It does not name specific sibling alternatives, but the read-only framing provides clear usage context.

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

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

With no annotations, the description adds valuable behavioral context: it is read-only, requires the mission.list_incidents scope, and every call is governed by Arbiter policy and produces a ProofLink cryptographic receipt. This goes beyond a bare listing, though it omits details about return format or pagination 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 compact, with the first sentence describing purpose and scope and the second covering authorization and compliance. It is front-loaded and mostly concise, though the governance language in the second sentence is slightly verbose.

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

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

For a simple list tool with two optional parameters and no output schema, the description provides adequate context: purpose, read-only guarantee, scope requirement, and receipt. However, it does not describe the response shape or fields, which could be helpful given the absence of an output 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?

Both parameters (limit and since) are fully described in the input schema with 100% coverage, so the description adds no extra parameter meaning. The schema already explains defaults, maximums, and the ISO 8601 format.

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

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

The description clearly states a specific verb and resource: 'list recent autonomous IT incidents' with a read-only scope. It distinguishes itself from sibling tools like get_incident_details by noting it is an alias for list_recent_incidents and specifying the audit/operations review context.

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

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

The description provides clear context for when to use it (audit and operations review) and notes the read-only nature and required scope. It also mentions the alias relationship with list_recent_incidents, but does not explicitly state when not to use it or offer alternatives for related tasks beyond the alias.

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

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

No annotations are provided, so the description carries the full burden. It adds meaningful behavioral context: a required read scope, governance by Arbiter policy, and a ProofLink cryptographic receipt for every call. This goes beyond a bare list operation, though it does not describe the response format or pagination 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?

Two concise sentences: the first states the tool's purpose and output fields; the second adds auth scope and behavioral guarantees. No redundant or fluff content; every sentence 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?

For a simple list tool with no parameters and no output schema, the description is quite complete: it states the resource, scope ('all'), the displayed attributes (status, category, description), the required permission, and the ProofLink receipt behavior. Lacks explicit mention of response shape, but the fields listed in the purpose serve as that.

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

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

The tool has zero parameters and the schema coverage is 100% (empty schema). With no parameters to document, the baseline is 4. The description adds no parameter-specific info, but none is needed.

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 'List all Probo compliance controls with status, category, and description (SOC2/EU AI Act)', using a specific verb ('List') and resource ('Probo compliance controls'), and clarifies scope ('all') and the returned fields. This clearly distinguishes it from sibling tools like probo_risks or get_compliance_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 implies usage when one needs to enumerate compliance controls, but does not explicitly state when to use this tool versus alternatives or provide exclusions. The statement 'Requires scope: integrations:probo:read' is a prerequisite, not a usage guideline.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds value by stating the required OAuth scope, the governance/checking via Arbiter, and the ProofLink receipt sealing. This gives meaningful context beyond a simple health check, though it does not explicitly state read-only behavior, which is implied.

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 three sentences, front-loaded with the primary purpose, followed by the return value and two contextual details. Every sentence earns its place, with no redundancy or fluff.

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

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

For a simple zero-parameter health check, the description is complete. It discloses the return type, required scope, and additional governance/receipt behavior. The absence of an output schema and parameters makes this sufficient, though more details about possible failure modes or response formats could be added, but are not necessary for the tool's simplicity.

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

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

The tool has zero parameters, and the schema reflects that. According to the rubric, a zero-parameter tool gets a baseline of 4. The description correctly does not include parameter information since there are none to explain.

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

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

The description clearly states a specific action ('Check') and resource ('Probo compliance platform health'), and further specifies the return value ('ok status and control count'). This distinguishes it from sibling tools like probo_controls, probo_risks, and probo_summary, which focus on other aspects.

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 for health checks but does not explicitly state when to use this tool over alternatives. It mentions the required scope but no exclusions or alternative tool references. The context is clear, but explicit guidelines are absent.

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

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

No annotations are provided, so the description carries the full burden. It discloses the required OAuth scope ('integrations:probo:read'), indicating a read permission, and adds context about governance and a ProofLink receipt. However, it could be more explicit about the read-only nature and return format, but the 'List' verb and 'read' scope imply safety.

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

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

The description is two sentences, front-loaded with the primary purpose, followed by important context (scope, policy, receipt). Every sentence contributes value without unnecessary repetition or fluff.

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

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

For a no-parameter list tool with no output schema, the description adequately states what is returned (severity level and status) and provides context on permissions and a receipt. It might have explained the Probo domain or the ProofLink receipt, but it is sufficiently complete for an agent to understand the tool's core function.

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

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

The tool has zero parameters, so the description does not need to explain them. Baseline is 4, and the description does not attempt to describe any parameter semantics beyond what the empty schema provides.

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

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

The description states a specific action ('List all') on a specific resource ('Probo compliance risks') and identifies the key returned fields ('severity level and status'). It clearly distinguishes from sibling tools like probo_controls or probo_summary by focusing on compliance risks.

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

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

The description provides clear context (list all risks) but no explicit when-to-use vs alternatives, and no exclusion criteria. The 'List all' phrasing implies a full retrieval, but there is no mention of when to prefer this over related tools like probo_controls or probo_summary. This is implied usage rather than explicit guidance.

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

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

With no annotations, the description adds some behavioral context by naming required OAuth scope (integrations:probo:read), governance policy, and cryptographic receipt sealing. It doesn't explicitly state the operation is non-destructive or describe error conditions, which leaves some transparency gaps.

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 concise sentences deliver all necessary information with no extraneous content. The first sentence describes the function and output, the second covers prerequisites and unique behavioral traits.

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 simplicity (no parameters, no output schema), the description covers the data points returned, access requirements, and the ProofLink sealing. It does not specify formatting or error behavior, but for an aggregate summary this is likely sufficient. A short note on receipt verification could have pushed it to a 5.

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

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

The tool has zero parameters, so the schema coverage is trivial. The description correctly avoids unnecessary parameter details, and the baseline score of 4 applies as there is nothing to compensate.

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 'Get Probo compliance aggregate summary' and enumerates the exact data returned: control pass/fail, risk levels, and task counts. This distinguishes it from sibling tools like probo_controls and probo_risks, which likely provide detailed individual records.

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 use for a high-level aggregate overview, but does not explicitly state when to prefer this over sibling summary tools like compliance.audit_summary or itsm_dashboard_summary. No alternatives or exclusions are mentioned, leaving the use-case inference to the agent.

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

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

With no annotations provided, the description compensates by disclosing the read-only audit scope, the required OAuth scope, and the governance/sealing behavior. It adds meaningful context beyond the schema, though it does not address error handling or output details.

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

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

The description is two short paragraphs with every sentence earning its place: purpose, filter reference, scope requirement, and governance. It is front-loaded with the primary function and avoids redundancy.

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

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

For a tool with two optional parameters and no output schema, the description covers purpose, filter compatibility, auth scope, and safety profile. It does not describe the return format, but the simplicity of the tool makes this a minor omission.

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

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

Schema coverage is 100% and both parameters (limit, container) are already documented in the schema. The description adds the 'recent' qualifier and notes parity with get_receipt_chain, but no additional semantic detail beyond what the schema provides.

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

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

The description clearly states the tool searches recent ProofLink receipts for audit/reconstruction purposes, using a specific verb ('search') and resource. It also references get_receipt_chain to convey filter compatibility, distinguishing it from chain-based retrieval.

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

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

It provides a clear use case ('ledger-backed post-hoc reconstruction') and notes that the same filters as get_receipt_chain apply, but it does not explicitly say when to use this tool versus alternatives or provide exclusion 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?

With no annotations, the description carries the full burden. It discloses read-only nature, safety for production, scope requirement, and governance by Arbiter policy. The alias disclosure adds transparency about tool equivalence, which is valuable.

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 concise sentences with front-loaded 'Read-only audit scope'. Every sentence earns its place, covering purpose, safety, scope, and governance without fluff.

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 is simple (2 optional params, no output schema). Description covers purpose, safety, scope, and alias, which is sufficient for an agent to select and invoke correctly. Minor gap: return structure not described, but not essential for this read-only tool.

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

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

Schema description coverage is 100%: both parameters have detailed descriptions (limit with default and max, container optional). The tool description adds no extra parameter semantics, so baseline of 3 applies.

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

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

Description clearly states the tool verifies the ProofLink receipt chain for EU AI Act Article 12, CISO, and auditor workflows. It also explicitly identifies as an alias for get_receipt_chain, distinguishing it from receipt-verification tools like verify_receipt and search_receipts.

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

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

Provides clear usage context: read-only audit scope, safe for production API keys without admin rights, and requires specific scope prooflink.verify_chain. It doesn't explicitly say when not to use, but the read-only and alias framing strongly implies the intended scenario.

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

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

With no annotations, the description carries the burden, and it does well by explicitly stating 'Read-only' and 'without granting mutation rights'. It also adds governance context (Arbiter policy, cryptographic receipt sealing) and permission requirements, but it omits error behavior and result format.

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

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

The description is concise and front-loaded, stating the primary purpose in the first sentence. It packs essential context into four sentences without redundancy or unnecessary detail.

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

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

For a tool with no output schema and no annotations, the description covers purpose, scope, and safety, but does not explain what the verification result looks like or what happens on invalid/nonexistent receipt IDs. This gap prevents a higher score.

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

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

Schema coverage is 100% and the only parameter, receipt_id, is already described with type and format. The description's 'by ID' adds no new semantic detail beyond the schema, so the baseline score of 3 applies.

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

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

The description opens with 'Read-only audit scope: verify one ProofLink receipt by ID', which clearly states the verb and resource. It explicitly distinguishes from mutation rights and identifies it as an alias for verify_prooflink_receipt, differentiating it from siblings like get_receipt_chain.

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

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

The description provides clear context by positioning this as a read-only audit tool and stating the required scope. It does not explicitly compare to alternatives beyond the alias, but the use case is well implied by 'Read-only audit scope'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the required permission scope and that every call is governed by Arbiter policy and sealed with a ProofLink receipt, adding valuable context. It does not explicitly confirm read-only behavior, but the nature of a status query is clear enough.

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

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

The description is two sentences: the first front-loads the purpose and key return metrics, and the second covers requirements and policy. There is no fluff or unnecessary repetition; every sentence 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?

Since there is no output schema, the description appropriately lists the main data points returned (container health, ProofLink receipts, compliance scores, overall status). It also includes auth and policy context. It could be more specific about the response format, but for a no-parameter status endpoint, it is largely complete.

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

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

The tool has zero parameters and the schema coverage is 100% (trivially), so the baseline is 4. The description adds no parameter semantics, but none are needed since the input schema is empty.

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 purpose with a specific verb ('Get') and resource ('operational status of the iTechSmart UAIO platform'), and enumerates the specific metrics returned. However, it does not explicitly distinguish itself from sibling tools like get_platform_briefing, so it lacks sibling differentiation.

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

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

The description provides clear context about what the tool returns (real-time platform status, ProofLink receipts, compliance scores, etc.), implying when it should be used. It also mentions a required scope, but does not explicitly name alternative tools or exclusion 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 are absent, so the description carries the burden. It discloses the required OAuth scope, Arbiter policy, and ProofLink receipt, which are useful behavioral traits. It doesn't explicitly state read-only, but 'check health' implies it. This is more than minimal but not exhaustive.

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

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

Two sentences, front-loaded with purpose, then necessary auth/receipt context. No filler.

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

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

For a simple health check with no parameters and no output schema, it states what it returns (ok status, dataset count), the required scope, and the receipt guarantee. It doesn't give details about the format or edge cases, but for this simplicity, it's adequately complete.

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

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

There are zero parameters, so the baseline is 4. The description adds no parameter semantics (none needed), and the schema already indicates no 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 uses a specific verb 'Check' and specific resource 'RAGflow RAG platform health', clearly distinguishing it from sibling health tools for other platforms. It also states the return values (ok status and dataset count).

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

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

It provides clear context: use this to check RAGflow health. It doesn't explicitly name alternatives or when-not-to-use, though the sibling list has other platform health checks. This falls short of explicit exclusion guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses a required scope ('integrations:rag:read') and the behavioral guarantee of a ProofLink cryptographic receipt on every call. It does not describe return format or rate limits, but for a query tool this is reasonable additional context beyond the 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?

The description is two sentences: the first states the action and optionality, the second covers authentication and governance. Every sentence earns its place with no redundancy or filler.

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

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

With only 2 parameters, no nested objects, and no output schema, the tool is low-complexity. The description covers the essential functional and security context, and the schema documents parameters fully. The lack of return-value detail is acceptable given the straightforward query action, though not ideal.

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

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

The input schema covers both parameters with clear descriptions (100% coverage). The description's mention of 'optionally filter to specific dataset IDs' merely reiterates the schema's dataset_ids parameter, adding no new granularity or syntax details. The baseline of 3 applies since the schema does the heavy lifting.

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

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

The description clearly states the tool's action ('Query'), the resource ('RAGflow knowledge base'), and the input ('natural-language question'), distinguishing it from sibling tools like ragflow_health. It also mentions an optional filter, which adds specificity.

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

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

The description clearly implies when to use this tool—when querying the RAGflow knowledge base—and notes an optional dataset filter. However, it does not explicitly name alternatives or exclusion scenarios, though the broad sibling set makes the intended use clear enough.

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

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

With no annotations, the description takes on the full burden. It discloses the required permission scope ('infrastructure:logs:read'), notes that calls are 'governed by Arbiter constitutional policy' and 'sealed with ProofLink', and indicates the 'live' nature of the logs. It does not detail error handling or output format, which prevents a perfect score, but it provides meaningful behavioral context beyond the 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?

The description is three sentences long, with the core purpose front-loaded and usage guidance following. Every sentence contributes value: it defines the action, explains return behavior, gives a use case, and states requirements. No fluff or redundancy.

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

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

The description covers purpose, usage, permissions, and a high-level idea of the return value ('matching log lines from journalctl'). However, without an output schema, it does not specify the exact format of the returned lines (e.g., timestamps, JSON structure) or any ordering/pagination behavior. For a log search tool with three simple parameters, this is reasonably complete.

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

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

Schema description coverage is 100% with each parameter (service, lines, pattern) already documented in the input schema. The description adds only minor context, such as example service names ('itechsmart-api', 'djuane-ai', 'iself') and the phrase 'check last N lines' referring to the 'lines' parameter. Since the schema carries the heavy lifting, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Search live systemd journal logs for any iTechSmart service' and 'Returns matching log lines from journalctl filtered by service name and optional keyword pattern.' This is a specific verb+resource combination that distinguishes it from sibling tools like 'get_iself_journal' (which likely targets a single service) and other logging/monitoring tools.

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

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

The description explicitly says 'Use for real-time troubleshooting: find errors, trace restarts, check last N lines of any service.' This provides clear context for when to use the tool, though it does not mention alternatives or 'when not to use' cases, so it stops short of a perfect 5.

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

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

With no annotations, the description carries the transparency burden. It discloses the required auth scope, the return values, and a notable behavioral trait: every call is governed by Arbiter policy and sealed with a ProofLink cryptographic receipt. It does not explicitly state 'read-only,' but 'Check' and 'Returns' strongly imply a non-mutating operation.

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

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

The description is two short sentences, with the purpose and key outputs front-loaded. The second sentence adds necessary context about scope and governance without unnecessary 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?

For a zero-parameter health check, the description adequately covers what the tool does, what it returns, and what is required to call it. It lacks an explicit note about error handling or interpretation of the 'ok status,' but for a simple health check this is sufficient.

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

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

The tool has zero parameters, so the baseline is 4. The description appropriately says nothing about inputs, and no parameter details are needed.

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

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

The description opens with a specific verb and resource: 'Check Shuffle SOAR platform health.' It further clarifies the tool's output by listing 'ok status, user, and workflow count,' which differentiates it from sibling health-check tools targeting other platforms (e.g., langfuse_health, ragflow_health).

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 explicit guidance is given about when to choose this tool over alternative health checks or when to avoid it. It only states the required scope, leaving the agent to infer usage from the tool name and description.

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

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

No annotations are provided, so the description carries the full burden. It reveals an authorization scope (integrations:shuffle:invoke), governance via Arbiter policy, and ProofLink receipt sealing. It does not detail side effects or errors, but adds meaningful context beyond the basic action.

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

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

The description is two sentences, front-loaded with the core purpose, and adds only necessary extra context (scope and receipt). No fluff or redundancy.

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

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

For a simple two-parameter trigger, the description covers purpose, auth requirement, policy governance, and receipt generation. It lacks explicit return format or async behavior, but the mention of ProofLink receipt implies the output. No output schema exists, but the tool is simple enough that this is acceptable.

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

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

The input schema already provides descriptions for both parameters (workflow_id as UUID, body as optional JSON). The description merely restates these concepts without adding new details, so baseline 3 applies given 100% 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 clearly states the action ('Trigger'), the resource ('Shuffle SOAR workflow'), and the key parameters (workflow ID, optional body). This distinguishes it from sibling tools like shuffle_health (health check) and ghl_trigger_workflow (different platform).

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 does not explicitly compare this tool to alternatives or state when to use it over other trigger tools. Usage is implied by the name and purpose, but no exclusions or alternative references are given. The scope requirement is a prerequisite, not usage guidance.

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

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

With no annotations, the description fully discloses behavior: simulated event injection, the 5-phase pipeline, return of a ProofLink receipt, required scope, governance policy, and sandbox-only restriction. This goes beyond basic mutation and provides critical safety and expected output context.

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

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

The description is two focused sentences plus a brief scope/policy sentence. Every sentence adds value: purpose, simulation details, sandbox restriction, and security requirements. No filler or redundancy.

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

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

For a tool with no output schema, the description adequately covers expected return (ProofLink receipt with 5 phases), preconditions (scope, governance), and behavioral constraints (sandbox only). It is complete enough for an agent to select and invoke the tool correctly, with no major 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 100%; the single parameter attack_type is fully described in the schema with enum and default. The description lists the enum values but adds no extra semantic detail beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool's verb (Trigger), resource (simulated infrastructure attack on the iTechSmart break-it sandbox), and the specific simulation flow (injects OOMKilled/connection_exhausted/disk_full/crashloop, runs the UAIO loop, returns ProofLink receipt). It distinguishes itself from siblings by emphasizing sandbox-only simulation and the UAIO demonstration context.

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

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

Explicitly says 'SANDBOX ONLY — no production systems are affected', which serves as a strong when-not to use in production. It also specifies required scope (digitaltwin:simulate:read) and mentions governance by Arbiter policy, giving clear prerequisites. Though no alternatives are named, the context of demonstrating the UAIO loop provides a clear use case.

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

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

With no annotations provided, the description carries the full burden. It discloses that apply mode 'modifies files and seals receipts', requires the scope 'sie:scan:invoke', and is governed by Arbiter policy. It also states background execution. It does not cover reversibility or return format, but the key behavioral traits are well covered.

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, front-loaded with the core purpose, and each sentence provides distinct value: modes, background execution, status pointer, permission requirement, and governance seal. No waste or redundancy.

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

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

Despite having no output schema, the description tells the agent what will happen, what modes exist, where to check results, what permission is needed, and what side effects occur. For a tool with two optional params and background execution, this is complete enough for correct selection and invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining what 'dry-run' and 'apply' actually do (detect/rank vs apply safe_auto and queue rest), which enriches the parameter semantics. The use_llm parameter is not mentioned in the description, but the schema already documents it.

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

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

The description opens with 'Kick off a fresh SIE scan of the iTechSmart platform,' providing a specific verb and resource. It clearly distinguishes the tool as the trigger action, contrasting with siblings like get_platform_briefing and get_sie_queue that query 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 explains the two modes (dry-run vs apply) and explicitly points to 'check get_platform_briefing for queue count' as a follow-up action, giving clear context for when to invoke the scan. It does not explicitly state when not to use it, but the alternative is implied.

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

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

With no annotations, the description carries the full burden. It discloses a required scope (`integrations:trmm:read`) and mentions the Arbiter constitutional policy and ProofLink receipt generation, which informs the agent about permission needs and side effects. It doesn't describe failure modes or pagination, but for a simple read-only list, this is adequate.

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

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

The description is two tightly-focused sentences: the first states the purpose, the second covers access and behavioral constraints. No wasted words, and the core action 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 zero-parameter, no-output-schema listing tool, this description is fully sufficient. It names the resource, the returned fields, the required permission, and the receipt side-effect, providing everything an agent needs to decide to call it.

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

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

There are zero parameters, so there is nothing to document beyond the empty schema. The description adds value by specifying the fields included in the response (status, OS, site, last-seen), which helps an agent understand what the listing contains.

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

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

The description opens with a specific verb 'List' and identifies the exact resource 'Tactical RMM managed agents' along with the data fields returned (status, OS, site, last-seen). This clearly distinguishes it from sibling tools like trmm_health or trmm_summary, which suggest aggregate/status operations rather than a per-agent listing.

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

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

The description states the action and the data returned, which implies when to use it (when you need a listing of all agents). However, it does not explicitly reference alternatives or exclude cases, such as when to use trmm_summary for overall statistics or trmm_run_script for actions.

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

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

With no annotations, the description carries the full burden. It discloses authentication requirements (scope needed), governance policy (Arbiter constitutional policy), and the ProofLink cryptographic receipt behavior. It does not explicitly state that the operation is read-only, but the phrasing 'Check health' and 'Returns ok status' implies no mutation, giving sufficient context beyond just the tool's 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?

Two sentences, front-loaded with the core purpose. The first sentence states what the tool does and returns. The second adds necessary security/permission context. Every sentence contributes meaning, with no filler or redundancy.

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

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

For a zero-input, no-output-schema health check, the description is remarkably complete. It covers the action, the return values, permissions, and the receipt behavior. No significant gaps are evident for the tool's simple scope.

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

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

The tool takes zero parameters, and the schema already reflects this with 100% coverage. Baseline for zero-parameter tools is 4, and the description adds value by naming the return fields ('ok status and enrolled agent count') which helps set expectations even though there are no parameters to explain.

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 purpose with a specific verb ('Check') and resource ('Tactical RMM health'), and it directly names the key outputs ('ok status and enrolled agent count'). This distinguishes it from sibling tools like trmm_agents or trmm_summary.

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 does not provide guidance on when to use this tool versus alternatives. Among siblings there are many health-check tools (e.g., langfuse_health, ragflow_health, mesh_health), but no explicit comparison or exclusion criteria is given. The purpose is clear but the usage context is left entirely 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?

The description discloses the required scope and mentions governance by policy and ProofLink receipts, adding useful context beyond the raw tool name. However, it does not warn about the potentially destructive nature of running arbitrary scripts or describe side effects, which is a notable gap given there are no 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 two sentences, front-loaded with the core purpose followed by one sentence on operational context. Every sentence earns its place, and there is no verbose or redundant language.

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, yet the description does not state what the tool returns (e.g., script output, receipt, exit code) or whether execution is synchronous. It also lacks detail on the impact of running scripts, leaving a key part of the behavioral 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?

The input schema already provides complete descriptions for both parameters (agent_id, script_id), and the description only restates them without adding new meaning. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Run') and identifies the exact resource ('saved script on a Tactical RMM agent') with the required inputs (agent ID, script ID). It clearly distinguishes this from sibling tools like trmm_agents or trmm_health, which serve different purposes.

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 when to use the tool by stating what it does, but it does not explicitly compare with alternatives or provide exclusion criteria. The scope requirement adds context but does not tell the agent when to prefer this over similar tools like itsm_run_test.

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