FoundryNet — Industrial Machine Intelligence

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

No annotations provided, so description carries full burden. It details that the tool creates a live trigger, monitors telemetry, fires actions via webhooks with variable interpolation, and activates on every subsequent normalize_telemetry call. However, it omits concurrency limits or error states, leaving minor 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?

Well-structured with clear sections: summary, input list, return info, usage notes. Front-loaded. Slightly verbose with detailed interpolation fields, but organized effectively.

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?

Covers behavior, parameters, return value (id), and lifecycle. Missing error handling for invalid machine_id and references external Forge API. Reasonably complete given complexity and sibling 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?

With 0% schema description coverage, the description fully explains each parameter: machine_id (ID formats), name (≤80 chars), condition (simple vs compound, ops), actions (list with overrides), enabled (default true). Adds significant meaning beyond schema.

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

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

Description clearly states it activates a parsed automation trigger, using verb 'Activate' and specifying the resource as an automation trigger. It distinguishes from siblings like create_automation (which returns parsed_trigger) and delete_automation.

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 call: 'Call this AFTER create_automation returns a parsed_trigger and the user explicitly confirms they want to arm it.' Also warns: 'Never call this tool without explicit confirmation.' Provides clear context and exclusions.

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

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

No annotations provided, but description discloses that OEE is computed from already-collected telemetry and handles insufficient data with available:false and a reason. This covers key behavioral aspects.

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?

Well-structured with sections for definition, args, and usage. Slightly verbose but each sentence adds value. Efficient for the amount of information conveyed.

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 two parameters and presence of output schema, description covers purpose, usage, parameters, return values, and edge case. Adequate for correct tool 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 0%, but description fully explains both parameters: machine_id with example, period with allowed values and default. Adds significant meaning beyond the schema.

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

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

Description clearly states OEE computation for one machine over a period, defines the formula, and lists return values (three-factor breakdown, letter grade, available:false). This distinguishes it from sibling fleet_oee, which covers fleet-level OEE.

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?

Explicit 'USE WHEN' section guides the agent to use this tool for reporting machine performance, locating losses, or producing a single line number. No explicit when-not-to-use, but context is 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?

With no annotations, the description fully explains behavioral traits: corrections are recorded as signals for retraining, not hot-patched, so noisy feedback doesn't affect others. It also describes the return structure and safety properties.

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

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

The description is well-structured, starting with purpose, then usage, then parameter details. It is longer but each sentence adds value, making it concise without being wasteful.

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

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

Given the tool has 7 parameters and no annotations, the description covers the feedback mechanism, safety, and return structure (output schema exists). It is complete enough for an agent to use effectively.

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

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

Schema description coverage is 0%, but the description explains the required parameters (source_field, confirmed_canonical, original_canonical) and optional ones (oem, mapping_id). However, it does not detail sample_value and confidence, which are in the schema but not described.

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: to correct wrong canonical mappings from normalize_telemetry. It uses specific verbs like 'correct' and 'teach', and distinguishes from sibling tools by focusing on fixing mapping errors.

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 states when to use the tool (when normalize_telemetry returns wrong canonical or abstains) and gives examples. It does not explicitly state when not to use it, but the use case is clear enough.

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

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

With no annotations, the description fully discloses behavior: the tool does not auto-activate, returns a parsed_trigger for human review, and requires a separate API call to activate. It also mentions confirmation_required and notes for fuzzy matches.

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

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

The description is well-structured with sections and examples, but slightly longer than needed. Every sentence is valuable, though some repetition could be trimmed.

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 2 required params and no nested objects, the description covers the workflow comprehensively: input, processing, output (parsed_trigger JSON), and post-call steps. It even addresses edge cases like fuzzy matches.

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?

Despite 0% schema coverage, the description adds rich meaning: mint_id identifies the machine, instruction is the natural language command with multiple examples. This fully compensates for missing schema descriptions.

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

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

The description clearly states that this tool creates automations by wiring machine telemetry to business systems via natural language instructions. It distinguishes from sibling tools like activate_automation and delete_automation by focusing on creation and providing concrete examples.

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?

An explicit 'USE WHEN' section tells the agent when to use this tool (setting up monitoring/automations). It also instructs to show the parsed_trigger to the user and ask for confirmation before activation, providing clear action steps.

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 fully bears the behavioral disclosure burden. It details soft-deletion mechanics (30-day recovery, row persistence with deleted_at, audit trail, permanent deletion option with ?permanent=true) and specific side effects on /v1/normalize calls.

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 structured with two paragraphs: one for behaviour and one for usage guidance. It is front-loaded with the core action. Though slightly long, every sentence serves a purpose 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 tool has one parameter, no annotations, and an output schema (not shown), the description covers recovery, audit, and usage well. It lacks explicit error conditions or permission requirements, but overall is sufficient for the stated 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?

Schema coverage is 0%, but the description does not explicitly describe the trigger_id parameter beyond its use in context. The parameter is self-explanatory given the tool name, but the description could add value by specifying how to obtain the ID or any constraints.

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

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

The description clearly identifies the action as a soft-delete that is recoverable for 30 days, and distinguishes it from hard deletion. It specifies the resource (trigger/automation) and states immediate effects like stopping evaluation and hiding from list_automations.

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 WHEN' section explicitly advises using this tool when the user wants to remove an automation, highlighting recoverability as safety. It contrasts with hard delete and mentions restore_automation, but does not directly compare to disable_automation sibling.

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

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

No annotations provided, so description carries full burden. It discloses that the tool is faster and cheaper (no ML inference), works on short series (≥4 points), and cross-references normal ranges. It also specifies return value structure. Minor gap: no mention of error handling or prerequisites beyond length constraint.

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?

Well-structured with summary, parameter list, and usage guidance. Front-loaded with key info. Pricing detail is somewhat extraneous but not detrimental. Could trim slightly, but overall efficient.

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

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

Given the complexity (3 params, output schema exists), the description is thorough: explains method, constraints (≥4 points), usage context, and return values. Output schema presumably covers detailed return fields, so no further elaboration needed.

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

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

Schema has 0% description coverage, but the description fully explains each parameter: 'values' (series to scan, ≥4 points), 'canonical_field' (enables normal-range context), 'sensitivity' (z-score threshold with default and interpretation). Adds meaning beyond type and default.

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 specific verbs 'Flag anomalies' and details the method (z-score, IQR, trend/rate-of-change). It distinguishes from siblings like predict and predict_breach by explicitly stating when to use each, making its unique purpose clear.

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

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

Explicit 'USE WHEN' section with concrete examples (real-time monitoring, spot check). Specifically tells when not to use: for predictions use predict or predict_breach. Provides clear alternatives and 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 carries the full burden. It discloses that the tool runs LLM reasoning over telemetry, performs anomaly detection, and returns cause, evidence, and action. This is sufficient transparency for a read-only analysis tool, though it could mention that no destructive actions are taken.

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

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

The description is concise and well-structured: a clear purpose statement, an Args section, and a usage directive. 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?

The description covers inputs thoroughly, and with an output schema present, it appropriately does not detail return values. It mentions that the tool returns 'likely cause, evidence, and recommended action', which is sufficient for the agent to understand the output. Minor gap: no mention of edge cases or error handling.

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?

Despite 0% schema description coverage, the description includes docstring-style explanations for each parameter: machine_id (machine's id), event_time (ISO 8601, defaults to now), and symptom (e.g., 'machine stopped'). This adds meaning beyond the bare schema names.

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

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

The description clearly states the tool's purpose as 'Automated root-cause analysis for a machine event' and details its methodology (correlates telemetry, anomaly detection, LLM reasoning). This distinguishes it from sibling tools like 'detect_anomalies' or 'predict' which serve different functions.

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

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

The description explicitly advises using the tool when 'something went wrong and your agent needs a first-pass root cause to reason from'. It also mentions the cost ($0.25/call). However, it does not provide exclusions or alternatives beyond implicit differentiation from siblings.

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

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

The description explains that the trigger stops evaluating against incoming calls but preserves configuration, history, and actions. This covers the main behavioral traits. However, it does not mention required permissions or error conditions, but given no annotations, it is reasonably transparent.

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 with two paragraphs, each serving a distinct purpose: behavior and usage. Every sentence adds value, no fluff. Front-loaded with the core action.

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

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

For a single-parameter tool with an output schema, the description covers purpose, usage, behavior, and even follow-up steps. It does not discuss error handling or prerequisites, but given the tool's simplicity, 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?

The schema has 0% description coverage, but the parameter 'trigger_id' is implied by the tool's purpose ('pause an automation trigger'). The description does not explicitly describe the parameter's format or how to obtain it, but the context is clear. A more explicit parameter description would be better.

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 pauses an automation trigger without deleting it, and explicitly distinguishes it from delete_automation (permanent). The verb 'disable' with 'automation trigger' is specific and actionable.

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

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

The 'USE WHEN' section provides clear scenarios (temporary stop, planned maintenance) and explicitly contrasts with delete_automation. It also suggests re-enabling via PATCH, guiding the agent on next steps.

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 provided, so description carries full burden. It states the tool is derived from a cumulative counter, uses baseline comparison, and includes anomaly detection. However, it does not explicitly state if it's read-only or destructive, nor mention permissions or side effects.

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

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

Description is two short paragraphs with no fluff. The first paragraph explains functionality, the second gives usage guidance. Every sentence adds value.

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

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

Given an output schema exists, description doesn't need to cover return values. It covers input parameters and use cases. Minor gaps like error handling or baseline absence are not critical.

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

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

Schema description coverage is 0%, so description must compensate. It explains period values ('shift', 'day', 'week') and default, and describes machine_id as 'the machine's id'. This adds basic meaning but could be more detailed about format or constraints.

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

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

Description clearly states the tool computes energy consumption and cost for a machine over a period, with baseline comparison and anomaly detection. It uses specific verb 'compute' and resource 'energy consumption and cost', distinguishing it from siblings like detect_anomalies.

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?

Explicit 'USE WHEN' section tells the agent to use it for computing machine cost or catching energy anomalies. Lacks explicit 'when not to use' and does not distinguish from the sibling detect_anomalies tool, which may overlap.

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 transparently describes the HTTP POST to /sandbox/echo, the hashing and attestation process, and the return values. It also discloses the free tier and lifetime limit, ensuring the agent understands the sandbox 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 concise with three focused paragraphs. It front-loads the purpose, provides technical detail, and ends with usage conditions. Every sentence adds value, making it efficient for an AI agent to parse.

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

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

Given the presence of an output schema (not shown but indicated as existing), the description sufficiently covers the tool's purpose, behavior, parameters, and return values. It mentions the three return fields (echo body, tx_signature, verify_url) and operational context, making it 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%, so baseline is 3. The description does not add significant new meaning beyond the schema, but it provides a default example for 'message' and context for 'condition_text'. This is adequate but not exceptional.

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 'Demo the full Forge watch→fire→settle loop against a built-in sandbox endpoint', which specifies the verb 'demo' and the resource 'Forge watch→fire→settle loop'. It clearly distinguishes from sibling tools that perform real automation or machine operations.

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

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

The description includes a 'USE WHEN' section that explicitly states when to use: when a developer is evaluating Forge without onboarding machines or paying for Pro tier. It also mentions the limitation of '10 fires lifetime per fnet_ key', providing 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?

No annotations are provided, so the description carries full burden. It details the argument shape, bucketing logic for thresholds, and mentions premium tier and cost. However, it does not explicitly state whether the operation is read-only or has side effects, though the nature of a dashboard suggests it is non-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 well-structured with a clear opening, argument description, and usage section. It is slightly lengthy but every sentence adds value; 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?

Given the tool's complexity (aggregating predictions into a dashboard) and that an output schema exists (not shown but noted), the description covers input, output components, usage guidance, and even pricing. It is sufficiently complete for an agent to use correctly.

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

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

Schema description coverage is 0% (bare schema with only 'additionalProperties: true'), yet the description thoroughly explains the 'machines' parameter: shape, fields (id, canonical_field, values, threshold, direction), constraints (list ≤100), and meaning of threshold for risk bucketing.

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 rolls up fleet predictions into a health dashboard with specific output components (fleet health score, risk distribution, per-field rollups, maintenance queue). It also distinguishes from sibling predict_batch by stating 'For raw per-machine numbers use predict_batch.'

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 includes a 'USE WHEN' section explicitly listing scenarios like 'how healthy is my fleet' and provides an alternative tool (predict_batch) for raw numbers. This gives clear when-to-use and 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?

Describes output structure (per-machine cards, fleet average, sorting) and input options. But no annotations, so missing details on data source, freshness, or side effects. However, for a read-like aggregation 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?

Concise header and structured Args section. Slight verbosity in line breaks but still 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?

Covers purpose, usage, and parameter fully. With an output schema present, return format is not needed. Lacks error handling info but complete for a simple 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 only parameter 'period' is fully documented with the list of valid values ('shift', 'day', 'week') and default, adding meaning beyond the schema's type and default.

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 'Fleet-wide OEE' with per-machine cards and fleet-average, and surfaces worst performers first. This is specific and distinguishes from sibling tools like 'calculate_oee' (per-machine) or 'fleet_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?

Explicit 'USE WHEN' guidance: 'assess the whole floor in one call and surface the worst performers' with example query. This is clear and actionable.

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

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

The description discloses that trust scores are computed from attested kernel history, not self-reported, and that omitting agent_id returns a built-in card. Since no annotations are provided, this behavioral detail is valuable and beyond a simple 'retrieve' 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 relatively concise with two short paragraphs and inline argument documentation. It effectively communicates the key points without unnecessary detail, though a slightly more structured format could improve readability.

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

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

Given the single optional parameter and the presence of an output schema, the description provides sufficient context about purpose, usage, and parameter semantics. It does not discuss return format but that is covered by the 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 input schema has 0% description coverage but the tool description fully explains the 'agent_id' parameter, including its purpose and the special case when omitted. This adds substantial meaning beyond the schema definition.

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 an agent's identity card listing capabilities, trust scores, governance constraints, and work history. The verb 'retrieve' and specific resource 'agent card' are distinct, and the tool's purpose is well differentiated from sibling tools which focus on automation and machine diagnostics.

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 advises when to use the tool: when an agent needs to present credentials or evaluate another agent's qualifications. It does not explicitly cover when not to use or alternatives, but the guidance is clear and contextual.

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 provided, but the description discloses that unknown OEMs still normalize (gate disables itself). For a read-only introspection tool, this behavioral context is sufficient. Does not cover rate limits or auth, but those are less critical here.

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 sized with a clear structure: what the tool does, optional parameter usage, and when to use. A few sentences could be trimmed, but it remains efficient and front-loaded with key information.

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

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

For a simple 1-parameter introspection tool with an output schema, the description covers all necessary aspects: purpose, usage, parameter behavior, and context. No gaps identified.

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 only parameter, 'oem', has 0% schema description coverage, but the description adds meaning: passing an OEM shows which vertical it resolves to and whether the cross-vertical gate engages. This compensates for the schema 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 clearly states that the tool asks Forge what it can normalize, listing specific outputs (OEM verticals, field families, field list per family). It distinguishes from siblings like normalize_telemetry by advising to call this first.

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?

Explicit 'USE WHEN' section advises starting a new integration or before calling normalize_telemetry. Also explains that absence of an OEM is a soft signal, not a hard block, guiding decision-making.

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 describes the behavioral traits: it fuses all sensor readings, returns health score, trend, degradation rate, remaining useful life, and top factors. It implicitly indicates a read-only compute operation. Could explicitly state read-only or destructive nature, but the detail is strong.

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

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

The description is very concise: two short, front-loaded paragraphs. First sentence states purpose and method, second gives usage guideline, third lists outputs. 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?

Given the tool's complexity (multi-sensor fusion, multiple outputs) and presence of an output schema, the description covers the core behavior and return values well. It could mention prerequisites (e.g., sensor data must be available) or the effect of the `period` parameter, but overall 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?

Schema description coverage is 0%, but the description does not explain `machine_id` or `period` beyond the general context. While `machine_id` is self-evident, `period` (with default 'shift') is not elaborated (e.g., allowed values or meaning). The description should compensate for the missing 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 uses a specific verb ('Compute') and resource ('composite health index'), clearly states the output range (0-1), and distinguishes itself from sibling `predict_breach` by highlighting multivariate fusion for gradual degradation.

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 'USE WHEN' with a specific scenario (assessing overall health from multiple sensors) and contrasts with univariate `predict_breach` for detecting gradual degradation, providing clear when-to-use and 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?

Despite no annotations, the description discloses idempotency ('calling again with the same... returns the same mint_id with `created: false`'), the return format ('MINT-xxxxxx'), and the scope of supported equipment. This provides sufficient behavioral transparency for an idempotent creation tool.

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

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

The description is well-structured with a clear first sentence and a separate 'USE WHEN' section. The long list of OEMs is somewhat redundant but adds clarity about the tool's broad applicability. It is concise overall without unnecessary 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?

Given the existence of an output schema (though not shown) and no annotations, the description covers key aspects: purpose, idempotency, return format, and usage context with sibling tools. It does not mention error handling or rate limits, but for a simple identify tool, these omissions are minor.

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

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

With 0% schema description coverage, the burden is on the description to clarify parameters. It implicitly explains the three required parameters (oem, model, serial) by stating the tool works 'by OEM/model/serial.' However, the optional parameters 'site' and 'metadata' are not mentioned at all, leaving a gap for those.

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: 'Provision or retrieve a persistent identity (mint_id) for any industrial machine.' It lists many specific machine types and OEMs, ensuring the scope is well-defined. It also distinguishes from siblings by mentioning 'before normalize_telemetry or create_automation.'

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 WHEN' section explicitly states when to use this tool: when a user references a specific machine by OEM/model/serial and needs a stable handle. It further advises to 'Always call this first when a new machine is introduced... before normalize_telemetry or create_automation,' offering clear guidance on ordering and alternatives.

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

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

No annotations are provided, so the description carries full burden. It reveals a key behavioral trait: trust is computed from attested history and cannot be gamed. It implies the operation is read-only (discovery). However, it does not mention authentication needs, rate limits, pagination, or whether the query is live or cached. Given no annotations, this is adequate 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 efficiently structured: a general purpose statement, usage guidance with an example, and a clearly labeled Args section. Every sentence adds value without redundancy. It is well 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 has 3 optional parameters, no annotations, and an output schema, the description covers purpose, usage, parameters, and a behavioral note. It mentions return fields (cards with trust, jobs, first-fix rate). However, it does not discuss potential error conditions, default behavior when no filters are applied, or result ordering/limits. It is largely complete but could be slightly more thorough.

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

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

Schema description coverage is 0%, but the description compensates fully with a clear Args section. Each parameter is explained with type, purpose, and examples (e.g., capability substring match, min_trust_score range, machine_id filter). This adds significant meaning beyond the JSON 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 verb 'Discover' and resource 'other agents connected to this kernel', listing what is returned (capabilities, trust scores, machine access). It distinguishes from sibling 'get_agent_card' by indicating that this tool lists multiple agents while the sibling likely returns a single agent's card.

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 states when to use: 'when your agent needs to find another agent with a specific capability to coordinate with or delegate work to'. It provides an example (bearing fault to maintenance agent). However, it does not mention when not to use or alternative tools like get_agent_card, so it falls 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?

No annotations provided, so the description carries full burden. It states the tool lists 'active' automations and enumerates return fields (id, name, condition, etc.), implying read-only behavior. No mention of side effects, but for a list operation this is sufficient.

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

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

The description is concise and well-structured: a one-line purpose, a bullet list of returned fields, and a 'USE WHEN' section. Every sentence 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 list tool with one parameter and an output schema, the description covers purpose, usage, parameter details, and return values completely. No 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?

The only parameter (machine_id) has no schema description (0% coverage), but the description adds significant meaning: 'Always pass the machine's mint_id (or internal_id — both resolve)'. This tells the agent exactly what values to use.

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 'List all active automations / triggers configured for one machine', using a specific verb (list) and resource (automations/triggers). It distinguishes from sibling tools like create_automation or delete_automation.

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?

Includes an explicit 'USE WHEN' section with example user queries ('what automations do I have on this machine') and clarifies to pass the machine's mint_id or internal_id. Lacks explicit when-not-to-use or alternative tools, but the context is 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 must cover behavioral traits. It discloses the multi-step processing, requirement of history for forecasting, and mentions a single payment. However, it lacks details on potential side effects (e.g., cost, data modification) and does not explain what 'attested' means.

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

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

The description is verbose and packs many details into a long, run-on paragraph. It front-loads the purpose but could be more concise by separating the list of operations or using bullet points. Every sentence adds value but structure could be improved.

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 (multi-step pipeline, 4 parameters, existing output schema), the description covers the overall flow, key conditions (normalization triggered by oem, history needed for forecasting), and the output includes health score and maintenance queue. It is largely complete but could mention prerequisites like sensor data format.

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%, yet the description only explains the 'oem' parameter's role (normalize when given). It does not clarify machine_id, telemetry, or thresholds beyond their names. With no schema descriptions, the description should compensate but fails to do so for most parameters.

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

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

The description clearly states it performs a complete intelligence pipeline from raw telemetry in one call, listing the sequence of operations: normalize, anomaly detection, forecast, breach prediction, health score, and maintenance queue. It distinguishes itself from sibling tools by being the all-in-one endpoint.

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 frames this as the full-stack one-call solution, implying it should be used when comprehensive analysis is needed. However, it does not explicitly contrast with individual-step siblings like normalize_telemetry or detect_anomalies, nor provide 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?

No annotations provided, so the description carries full burden. It discloses auto-provisioning, side effects (writing history, evaluating triggers), async webhooks, and mapping_id feedback mechanism. However, it omits error conditions, rate limits, or auth requirements. The description is transparent but not exhaustive.

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

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

The description is well-structured with clear sections: purpose, example, auto-provisioning, side effects per call, and USE WHEN every sentence adds value. It is slightly long but remains focused and organized, earning a high score.

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

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

Given tool complexity (mapping, side effects, triggers, auto-provisioning) and no annotations, the description is fairly complete. It covers input, behavior, output and mentions mapping_id and triggers_fired. It does not cover error scenarios or limitations, but with output schema assumed present, the overall completeness is good.

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

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

Schema description coverage is 0%, so description must compensate. It explains the required 'data' parameter and mentions 'machine_id', 'oem', 'model', 'serial' in context of auto-provisioning. However, it does not describe the 'site' parameter at all. Coverage of 6 parameters is incomplete, scoring below the baseline 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?

The description clearly states the tool normalizes raw vendor telemetry into a canonical schema (FCS), with specific verb 'normalize' and resource 'telemetry data'. It provides example field mappings and distinguishes from siblings like identify_machine, query_machine_history, and correct_mapping.

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 includes an explicit 'USE WHEN' section listing three scenarios, providing clear context for usage. It also mentions auto-provisioning as an alternative to identify_machine. However, it does not explicitly state when not to use the tool or compare directly with siblings like predict or diagnose_machine.

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 provided, so description carries the burden. It discloses no per-machine training, kernel normalization, auto-detection of cadence, and receives quantile output. However, it does not mention rate limits or explicit read-only nature, though inference implies read-only. Good but not perfect.

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?

Front-loaded with main purpose, followed by args in a structured list, then usage guidance. Every sentence is informative and necessary.

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 output schema exists (not shown but noted), description covers needed behavioral context. Mentions output type (point forecast + quantile bands) and key constraints. No gaps for this use case.

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 has 0% description coverage; description explains each parameter's meaning and constraints (e.g., time_series oldest->newest, horizon range 1-256, frequency for forward-compat). Adds significant value beyond 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 it forecasts the next horizon readings of a canonical telemetry series using TimesFM, specifying output as point forecast plus quantile uncertainty bands. It distinguishes from sibling tools like predict_breach and remaining_life.

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 WHEN' for trend questions and directs threshold/failure questions to alternatives. Also notes premium/pro tier and approximate cost, providing clear when-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?

No annotations provided, so description carries full burden. Describes operation as batch prediction, mentions output format, but lacks details on side effects, authentication, rate limits, or data handling. Reasonable 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 concise sentences, each adding value. First states core functionality, second provides concrete example and clarifies outputs. No redundant 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?

High-level purpose and output are clear, but lacks input formatting details required for correct invocation. With an output schema existing but not shown, return values might be implicit, but input structure remains underdescribed.

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?

Only one parameter 'machines' (array of objects). Description says 'pass them all here' but does not specify expected structure or fields per machine object. Schema coverage is 0%, and description fails 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 it predicts for an entire FLEET in one call, contrasts with per-machine requests, and specifies outputs (scored fleet overview plus per-machine predictions). This distinguishes it from sibling tools like 'predict'.

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 contrasts with one request per machine and provides a concrete example (200-machine factory). Implies when to use (multiple machines) and suggests alternative (single machine use 'predict'), though not explicitly stated.

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

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

No annotations exist, so the description fully discloses behavior: returns multiple fields, includes cryptographic hash, audit capability via mint_id and settle, and cost of $0.05/call. No contradictory or hidden behaviors.

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?

Description is well-organized with a clear header, bullet-like args, and a use-case block. Every sentence adds value; 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?

Covers purpose, parameters, return values, cost, and examples. Missing error conditions or data quality requirements (e.g., minimum series length recommendation noted but not required). Output schema exists but description still adequately summarizes results.

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

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

Input schema has 0% description coverage, but the description's 'Args' section explains every parameter's purpose, defaults, and constraints (e.g., direction default 'above', horizon range 1-256). Compensates fully for schema gaps.

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 it predicts whether a threshold will be crossed and when, using terms like 'parametric-insurance primitive'. It gives concrete examples and clearly differentiates from generic predict tools by focusing on breach prediction.

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 WHEN' section provides clear scenarios and examples. It mentions premium cost but does not explicitly state when not to use or compare to sibling tools like 'predict' or 'predict_batch', leaving some ambiguity.

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

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

No annotations provided, so description carries full burden. It discloses the tool is free, accuracy improves over time, and predictions are logged with tamper-evident hash. It does not mention side effects but as a read-only report, no contradiction.

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

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

Description is well-structured with a concise overview, then a highlighted free nature and use case section. Slightly verbose but efficient overall.

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

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

Given zero parameters and the presence of an output schema, the description fully explains the output content and context. It ties into the broader use case of verifying trust before spending, making it 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?

No parameters exist, so schema coverage is 100% by default. The description compensates by detailing what the output contains (total counts, accuracy %, etc.), adding meaning beyond the empty 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 reports prediction accuracy metrics (total/evaluated counts, breach accuracy %, MAE, breakdown by field). It distinguishes itself from siblings like predict and predict_breach by positioning itself as a trust signal.

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 WHEN' to gauge trust before spending on predictions, and directly advises checking it before paying for a prediction. Provides clear context for when to use this tool versus 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, description fully covers behavior: explains output format (canonical rows), query options, and summary mode. Highlights that summary is 'Always cheap.' No contradictions.

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?

Well-structured with sections and front-loaded purpose, but slightly verbose. Each sentence adds value, though some redundancy exists. Efficient overall.

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 presence of an output schema (not shown but indicated) and tool complexity, description fully covers output format (rows and summary) and usage patterns. No missing 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?

Despite 0% schema description coverage, description adds rich semantics: explains from_dt/to_dt as ISO-8601 timestamps, fields as comma-separated FCS names, limit range, and summary behavior. Completely compensates for schema 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?

Description clearly states the tool retrieves 'operational history' for a machine, using specific verbs and resources. It distinguishes from siblings by focusing on history and data exploration.

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?

Explicit 'USE WHEN' section provides clear guidance on when to use this tool, including a recommendation to start with summary=true. It implicitly differentiates from other tools like diagnose_machine or predict.

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 provided; description carries full burden. Details return limits (default 10, max 200), output fields, and settlement reference behavior. Mentions soft-deleted query capability.

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?

Single paragraph with clear front-loading of purpose, followed by return details and usage scenarios. Efficient 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?

Despite no annotations, description covers output fields, limit behavior, and edge case (soft-delete). Output schema exists to document return values, so description is appropriately 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 has 0% description coverage. Description explains limit parameter (default/max) but does not explicitly describe trigger_id beyond 'for a trigger'. Partial 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?

Clearly states the tool shows webhook delivery history for a trigger, listing specific data like HTTP status codes and response times. Distinguishes from siblings which are about automation management and predictions.

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?

Explicit USE WHEN section with concrete user queries. Mentions soft-deleted triggers for forensic audits. No explicit alternatives, but siblings are unrelated.

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 bears the full burden. It details the return fields (remaining_steps, recommendation, etc.) and notes that remaining_steps can be None. It mentions provenance and settlement but does not cover all behavioral aspects like required data length or error conditions. Still, it adds significant transparency beyond the bare minimum.

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

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

The description is well-structured with sections for purpose, return values, arguments, and usage. It is front-loaded with the main action. While somewhat long, every sentence serves a purpose, and the structure aids readability. A slight trim could improve conciseness, but it remains efficient.

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

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

Given the tool's complexity (7 parameters, 2 required, no annotations) and the presence of an output schema, the description covers purpose, parameters, returns, and usage adequately. It does not elaborate on the output schema but specifies the returned fields, which suffices for an AI agent to understand the tool's behavior.

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

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

Schema description coverage is 0%, but the description includes an 'Args' section that explains each parameter, including default values and allowed ranges. This provides the meaning that the schema lacks, making the tool easily usable. The description compensates fully for the schema 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 explicitly states the tool estimates remaining useful life and provides maintenance recommendations. It clearly distinguishes itself from the sibling 'predict_breach' by framing it as a maintenance-planning reframing, thus scoring a 5.

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

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

The 'USE WHEN' section provides concrete examples of user queries that warrant this tool, such as 'how long until this bearing needs service'. It does not specify when not to use it or name alternatives beyond predict_breach, but the guidance is clear and actionable, earning 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?

Describes re-enabling the trigger to evaluate against calls, return values (restored trigger row with restored: true and restored_at), and error codes (410, 409). No annotations provided, but description fully covers behavioral traits.

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?

Concise and well-structured with a 'USE WHEN' section. Slightly redundant in mentioning re-enabling and return values, but overall 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?

Completely covers behavior, error conditions, use cases, and return format. Output schema exists but description adds value by explaining return fields. Suitable for a simple restore 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?

Only one parameter (trigger_id) with 0% schema description coverage. The description does not explicitly describe the parameter, but its purpose is reasonably inferred from context. Could have benefited from a brief note on expected format or meaning.

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

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

The description explicitly states the tool restores a previously soft-deleted automation trigger within a 30-day window, with clear verb and resource. It distinguishes from siblings like delete_automation and disable_automation by mentioning the recovery window and being the 'undo' half of a flow.

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 explicit 'USE WHEN' section with specific scenarios (accidental deletion, undo flow) and even suggests pairing with disable_automation. Implicitly advises against use when trigger not deleted (409) or past 30 days (410).

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 states the report is auto-generated at each shift change and requires no spreadsheet, but does not disclose read-only nature, authorization needs, or rate limits. With no annotations, it partially covers behavioral traits but lacks completeness.

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

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

The description is well-structured with front-loaded purpose, an Args section, and a USE WHEN block. It is slightly verbose but every sentence serves a purpose. Minor improvement could be brevity.

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

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

Given the simplicity (one optional parameter, output schema present), the description covers purpose, usage, and parameter meaning adequately. It does not detail output but the output schema exists to provide 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 description includes an 'Args' section that fully explains the 'which' parameter with three options (current, last, recent), adding meaning beyond the input schema which only specifies type and default. This is excellent for a single-parameter tool.

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 generates a shift handover report with OEE, energy, alerts, and actions per machine plus an AI narrative. The verb 'generate' is implied, and the resource is 'shift handover report'. It distinguishes from siblings by being a comprehensive fleet-wide report.

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?

Explicit 'USE WHEN' section tells the agent to use this for generating a shift handover or written summary without a spreadsheet. It provides clear context but does not explicitly mention when not to use or list 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, the description fully discloses behavior: hash-chained records, external ledger anchoring, mode-specific processes (Merkle root in batch, deterministic hashing in single-payload), return fields (merkle_root, payload_hash, tx_signature, etc.), and cost-efficiency recommendations. No contradictions.

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

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

The description is well-structured with headings for modes and usage. While slightly verbose, every sentence adds value. Front-loaded with purpose and mode overview. Could be shortened slightly but remains clear.

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

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

Given the tool has 3 parameters (all explained), an output schema (return values detailed), and no required parameters, the description provides complete context for selection and invocation. No gaps remain.

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

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

Schema coverage is 0%, but the description compensates fully: explains batch (boolean) and its implications, mint_id required in batch mode, payload required in single-payload mode, with defaults and return values. Adds crucial context beyond the raw schema.

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

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

The description clearly states the tool's purpose: 'Create a tamper-evident, independently verifiable record of work.' It distinguishes two modes (batch and single-payload) and contrasts with sibling tools (none of which appear to perform similar recording).

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 explicit when-to-use guidance: 'USE WHEN: a user wants tamper-proof evidence...' with concrete examples. Also advises on mode selection (batch vs single-payload) and instructs to include the verify_url in replies. Differentiates from siblings effectively.

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