Security Recipes

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

No annotations are provided, so the description carries full behavioral burden. It only lists what is returned and gives no detail about side effects, filtering behavior, defaults, or whether this is strictly read-only. 'Return' hints at a read operation but is not explicit.

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 fluff, which is concise. However, it is under-sized for a tool with three undocumented parameters and a 0% schema description coverage, so it is not fully 'appropriately sized' for the information an agent needs.

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 output schema exists, so return shape is covered, but usage context, parameter semantics, and behavioral details are missing. The tool sits among many similar trust-related siblings with no annotations, leaving the description insufficient for reliable selection and invocation.

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

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

Schema coverage is 0% and the description does not explain the meaning, usage, or relationships of decision, risk_tier, and profile_id. The nouns 'intake profiles', 'trust controls', and 'sample decisions' loosely align with the parameter names, but no explicit mapping or format guidance is given.

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 gives a specific verb ('Return') and resource ('A2A Agent Card intake profiles, trust controls, and sample decisions'). It clearly points to a A2A-specific trust profile tool, though it does not explicitly differentiate itself from the many trust-related sibling tools such as recipes_agent_trust_fabric_pack.

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

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

There is no statement about when to use this tool versus alternatives, no prerequisites, and no exclusions. With dozens of similarly named trust/control/pack tools, the agent is left to infer usage purely from the tool name and a loose 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the return type ('risk scores') but does not mention whether this is read-only, whether it performs computation, what inputs drive the risk tier, or whether results vary by workflow state. The phrase 'residual risk scores' implies aggregation, but that behavior is not explicit.

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 redundancy. It front-loads the core action and avoids filler. However, it is so brief that it sacrifices useful behavior detail, making it concise but under-informative.

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

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

The tool has 4 optional-looking parameters, no output schema details in the description, no annotations, and no usage context. The description is too shallow for an agent to reliably select and invoke this tool among many risk-related siblings. Even with a provided output schema, the input semantics gap makes the description incomplete.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It does not. The parameters 'decision', 'risk_tier', 'workflow_id', and 'minimum_residual_score' are left entirely unexplained; the description gives no hint about how they relate to the returned risk scores or which are required for a meaningful call.

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

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

The description 'Return capability-based residual risk scores for agentic workflows' names a specific verb ('Return'), resource ('capability-based residual risk scores'), and scope ('agentic workflows'). It is reasonably clear about what the tool does, though it does not distinguish itself from similar risk-related sibling tools by name.

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

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

The description provides no indication of when to use this tool versus the many sibling tools with risk-related names, such as recipes_agentic_aivss_risk_scoring_pack or recipes_agentic_catastrophic_risk_annex. There is no context about the scenario, prerequisite data, or alternatives.

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

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

No annotations are provided, so the description carries the full burden. 'Return' implies a read operation, but the description does not disclose how the optional parameters affect results, what happens when none are provided, or any other behavioral 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 a single concise sentence with no filler; the main verb and resource are front-loaded. It is efficient, even though it leaves substantive gaps.

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

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

With four optional filter-like parameters and no annotations, the definition does not explain how parameters combine or what is returned when arguments are omitted. The existence of an output schema reduces the need to describe return values, but parameter semantics and usage remain underspecified."

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

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

Schema description coverage is 0% and the description does not mention any of the four parameters. An agent cannot determine the meaning or expected format of decision, protocol, profile_id, and workflow_id from the tool definition alone.

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

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

The description uses a specific verb, 'Return', and names a concrete resource: agent handoff boundary profiles, protocol controls, and workflow maps. It is reasonably distinguishable from sibling boundary packs by the 'agent handoff' domain, though it does not explicitly contrast with them.

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

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

No guidance is given about when to use this tool versus any sibling pack, nor are there prerequisites, conditions, or exclusions. The only usage signal is implicit in the listed content 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 behavioral burden. 'Return' implies a read-like operation, but it does not disclose side effects, authentication or authorization requirements, how the four optional inputs affect behavior, or what 'evidence' includes.

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

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

A single sentence with no filler; the key noun phrases are listed up front. It is appropriately short, though the brevity comes at the cost of missing parameter and usage detail covered in other dimensions.

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 presence of an output schema helps with return values, but the description remains incomplete for a four-optional-parameter tool amid dozens of similar recipe_pack siblings. It lacks any explanation of input semantics, filtering behavior, or when the pack applies.

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% for four parameters, so the description must compensate. It does not mention decision, risk_tier, workflow_id, or action_class_id at all or explain how they influence the returned data. Parameter names hint at filters, but no semantics are added.

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 concrete verb ('Return') and identifies specific resources: action classes, workflow action envelopes, runtime policy, and evidence. This makes the basic purpose clear, though it does not explicitly contrast with the many sibling recipe_pack tools.

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

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

No guidance is given for when to use this pack versus alternatives such as recipes_agentic_run_receipt_pack or recipes_workflow_control_plane. The context implies a runtime/action retrieval use case, but neither exclusions nor selection criteria are 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates the tool 'return[s]' outputs, implying a read-like operation, but it does not explain filtering behavior, default handling, authentication needs, side effects, or what 'hosted MCP wedges' means operationally.

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

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

The description is a single compact sentence and front-loads the main return purpose. However, it trades clarity for brevity by using domain jargon ('wedges') and omitting any parameter or usage context, so it is not optimal.

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?

Although an output schema exists, the definition is incomplete for an agent deciding whether to invoke this tool: it has no annotations, no parameter semantics, and no guidance among dozens of similar recipe packs. The tool has five optional, undocumented parameters that could materially change the request.

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

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

Schema description coverage is 0%, so the description was required to compensate, but it does not mention any of the five parameters. The names owner, severity, scenario_id, minimum_score, and runtime_default_decision are only weakly self-explanatory and the description provides no values, formats, or intended combinations.

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 ('Return') and names a concrete resource ('AIVSS-aligned agentic risk scores, SLAs, evidence, and hosted MCP wedges'), which distinguishes it from generic sibling tools. It loses a point because 'hosted MCP wedges' is unexplained jargon and it does not explicitly contrast with closely related risk-related recipe packs.

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

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

The description gives no guidance on when to use this tool versus the many sibling packs such as recipes_agentic_risk_register, recipes_agentic_readiness_scorecard, or recipes_agentic_posture_snapshot. No conditions, exclusions, or alternative routing 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 bears the full burden for behavioral disclosure. 'Return generated... profiles and decisions' suggests a read-only query, but it does not explain whether decisions are precomputed, how filtering works, whether results are singgle vs. array, or any side effects. The output schema helps somewhat, but behavior are largely undisclosed.

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

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

The description is a single short sentence with no wasted words. However, it is under-specified: it only conveys the basic purpose and does not include any additional guidance that would justify a higher structure score. It is concise but not meaningfully informative beyond the tool's name.

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 five optional filter parameters, no annotations, a large sibling set, and no guidance on parameter semantics, ordering, or result shape, the description is not complete enough. The output schema may define return values, but the selection logic and use context are missing. For an agent evaluating among nearly 80 recipe tools, this description is insufficiently disambiguating.

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

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

Schema description coverage is 0%, so the description must compensate. It does not. However, the parameter names (app_id, decision, risk_tier, buyer_stage, minimum_score) are self-explanatory and imply a filtering/query tool. There is no detail on how the parameters combine, what values are accepted, or output ordering, but the names alone provide moderate semantic value.

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

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

The description states a specific verb ('Return') and resource ('generated agentic app launch-review profiles and decisions'), so an agent can understand the tool's primary output. However, it does not distinguish this tool from many sibling recipe tools that also relate to agentic risk, trust, or readiness profiles, leaving some ambiguity.

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

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

There is no explicit guidance about when to use this tool versus the dozens of sibling recipe tools. The description implies a lookup/filter behavior but does not state prerequisites, typical use cases, or exclusions. An agent must guess whether to use this or a closely related tool such as recipes_agentic_readiness_scorecard.

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, but it only states that the tool returns content. It does not reveal whether this is a pure read operation, whether it depends on external systems, whether it enforces approval workflows, or what side effects—if any—exist.

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 and front-loaded, with no filler words. However, the brevity sacrifices necessary detail, making it under-specification rather than effective conciseness.

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

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

Despite having an output schema, the description is insufficient for an agent to safely and correctly invoke the tool: parameter semantics are absent, no usage context is given, and there is no explanation of what 'scope-bound' means. The combination of five undocumented parameters and no annotations leaves a substantial 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 input schema has five parameters with zero description coverage, and the description does not explain `decision`, `risk_tier`, `workflow_id`, or `action_class`. 'Scope-bound' is too vague to compensate for the complete absence of 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 names a specific verb ('Return') and a resource ('scope-bound approval receipt profiles, workflow requirements, and evidence'), so the core purpose is somewhat clear. It does not explicitly distinguish itself from sibling tools like recipes_agentic_run_receipt_pack, but the approval-receipt focus separates it enough to avoid complete ambiguity.

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

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

No guidance is provided about when to use this tool instead of the many similar sibling 'pack' tools. 'Scope-bound' hints at a scoping mechanism but does not explain what scope means or how it relates to the parameters.

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, but it only states what is returned. It doesn't disclose side effects, authentication requirements, read-only nature, whether output is generated or static, or how filters affect behavior. 'Return' implies retrieval, but significant behavioral context is missing.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the tool's primary output types efficiently, though it gives up completeness for brevity.

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

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

Given the tool has two mysterious optional parameters, no annotations, and many similar sibling packs, the description is too thin. It doesn't explain what an 'assurance pack' is, what the parameters control, or how the output relates to other recipes. An output schema exists, but the description alone doesn't let an agent confidently select and invoke this tool.

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

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

Schema description coverage is 0%, and the description makes no mention of control_id or workflow_id. The parameter names are mildly self-explanatory, but the description adds no meaning about how they filter, how they combine, or what values are valid, so it fails to compensate for the schema's lack of descriptions.

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

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

The description uses a clear verb ('Return') and specifies three concrete artifact types: enterprise assurance controls, workflow evidence, and AI/Agent BOM seed. This is clear enough to understand the tool's topic, though it doesn't explicitly distinguish from sibling pack tools with overlapping terms like 'BOM' or 'control plane'.

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

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

No guidance is given about when to use this tool versus the many sibling pack tools. The description is purely declarative and never mentions alternatives or contextual signals that would help an agent decide between, say, recipes_agentic_assurance_pack and recipes_agentic_system_bom.

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, but it only says 'Return', which implies a read operation. It does not disclose what the annex contains, how the optional filters affect results, or any operational constraints, so an agent cannot anticipate behavior beyond generic retrieval.

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

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

The description is a single front-loaded sentence with no filler; the verb and object appear immediately. It is economical, though it achieves conciseness by omitting material parameter and usage 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 5-parameter schema has zero inline descriptions and no enums, so the one-line description leaves the request schema almost entirely unexplained. Although an output schema exists and return shape need not be described, the input side and selection criteria remain opaque, making the tool insufficiently invocable for a specific query.

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

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

Schema description coverage is 0%, and the description does not mention any of the five parameters (status, control_id, scenario_id, buyer_view_id, impact_domain) or their roles. An agent has no semantic grounding for how to populate these optional filters.

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 ('Return') and a specific resource ('severe-risk annex for high-impact agentic AI runtime decisions'), so it is not a tautology and gives an agent a clear sense of what artifact is fetched. It does not explicitly distinguish this annex from the many risk-related sibling tools, but the resource name is specific enough to be useful.

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

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

The phrase 'for high-impact agentic AI runtime decisions' implies a use context, which gives some guidance on when to invoke the tool. However, it does not explain when to choose this over alternatives like recipes_agentic_aivss_risk_scoring_pack or recipes_agentic_threat_radar, nor does it provide exclusions or 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 full behavioral burden, but it only states that the tool 'returns' data. It does not disclose whether the optional parameters filter or select the result, whether this is a read-only operation, or what the response contains beyond the named artifact. The output schema exists, but it isn't described.

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

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

The description is a single front-loaded sentence with no filler; 'Return' immediately communicates the action. It is concise and well-shaped, though the brevity sacrifices useful content.

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

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

Given the large sibling set and three optional parameters, the description is too sparse; it gives no hint of how status/layer_id/question_id affect the returned blueprint and no differentiation from related recipes. The presence of an output schema covers return values, but the description remains incomplete for selecting and calling the tool.

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

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

Schema description coverage is 0%, and the description doesn't mention status, layer_id, or question_id at all. An agent cannot infer what these filters mean or which combinations are valid, leaving the only documentation to the schema's bare type/null/default fields.

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

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

The description uses a clear action verb ('Return') and identifies a specific artifact: the acquisition-ready agentic control plane architecture and buyer evidence map. This gives the agent a concrete resource to retrieve, though the jargon ('acquisition-ready') and similarity to recipes_workflow_control_plane keep it from fully distinguishing the tool from siblings.

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

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

The description offers no guidance on when to use this blueprint versus the dozens of sibling recipe tools, no context for acquisition/sales scenarios, and no exclusion criteria. It doesn't mislead, but it leaves all usage decisions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Return' hints at a read-only operation, which is a useful hint, but nothing else is revealed: how 'expiring' is determined, what 'scope evidence' means, whether the pack aggregates multiple data sources, or whether any side effects or permissions apply. The behavior beyond the verb hint is opaque.

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

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

A single 12-word sentence with the verb front-loaded and zero filler. Every word earns its place, and the list of returned content is compactly expressed. It is appropriately brief as prose, even though that brevity sacrifices completeness elsewhere.

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 6 undocumented parameters, no annotations, and an output schema, this description is too thin. It doesn't clarify the 'pack' semantics (whether the tool bundles multiple artifacts beyond the three listed items), how the filters shape the result, or when the tool is applicable. The output schema documents the return structure, but key selection and invocation context is still missing.

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

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

Schema description coverage is 0% — none of the 6 parameters are documented in the schema. The description must compensate for this but explains none of the parameters: what namespace, risk_tier, access_mode, identity_id, workflow_id, or entitlement_id mean, or how they filter the returned data. Only the ID parameter names are self-evident; the rest are ambiguous, and the description adds nothing.

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 ('Return') and names concrete resources: expiring agent entitlement leases, access reviews, and scope evidence. This gives an agent a clear idea of what the tool produces. However, it doesn't explicitly differentiate this from the many similarly themed governance packs among the siblings (e.g., recipes_agentic_assurance_pack, recipes_agentic_readiness_scorecard, recipes_agentic_posture_snapshot), so it falls short of a 5.

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

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

The description offers no guidance on when to call this tool versus any alternative. There are no use-case conditions, no exclusions, and no mention of sibling tools. Given a large sibling list full of similar 'pack' tools, an agent has no signal to select this one over the others.

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

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

With no annotations, the description carries the behavioral burden. It does disclose that this is a read-style operation ('Return'), that results are ordered by risk ('risk-ranked'), and that the graph spans multiple entity dimensions. However, it does not explain how filters interact, whether the graph is computed live vs stored, or what sensitivity/auth considerations exist.

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 fluff: 'Return risk-ranked...' immediately communicates the action and resource. However, the brevity contributes to the missing contextual depth, so it is concise but not maximally helpful.

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

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

For a tool with 8 optional parameters, no annotations, no parameter descriptions, and a complex graph-query domain, the description is far too sparse. The presence of an output schema covers return-shape requirements, but an agent still cannot determine how to build a query, what filters mean, or when this tool is the right choice.

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 8 optional parameters with 0% description coverage, and the description does not mention any of them. node_id, path_id, decision, namespace, identity_id, workflow_id, minimum_score, and path_class_id remain unexplained. The high-level phrase 'across context, identities, MCP tools, and evidence' only vaguely maps to some of these and leaves the rest ambiguous.

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

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

The description states a clear, specific operation: 'Return risk-ranked agentic exposure paths' and lists the dimensions it covers: context, identities, MCP tools, and evidence. It differentiates itself from the many sibling recipe/risk tools by describing a graph-oriented, risk-ranked exposure query rather than a pack or scorecard.

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 vs the many sibling risk, trust, and exposure-related tools. It does not mention alternatives, exclusions, prerequisites, or typical query scenarios. An agent must infer usage entirely from the tool name and vague scope statement.

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. The word 'Return' implies a read-only retrieval, but the description does not state whether all content is returned by default, what happens when parameters are null, whether filters are applied, or whether any state is changed. This is minimal transparency for a tool with four optional inputs.

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 wasted words. It is concise, but the compressed noun list ('classes, phases, workflow matrix, and evidence') is somewhat dense and would benefit from a bit more structure or context.

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

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

An output schema exists, so return-value structure is partly covered, but the description still leaves major gaps: the meaning and effect of the four optional parameters, how they combine, and when to select this pack among the dozens of sibling recipe tools. For a tool with no annotations and 0% schema coverage, this is incomplete.

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

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

Schema description coverage is 0% and the description provides no explanation for any of the four parameters (decision, severity, workflow_id, incident_class_id). Their names hint at possible filters, but the description adds no meaning beyond the schema and does not compensate for the lack of parameter documentation.

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

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

The description uses an explicit verb ('Return') and names the resource ('agentic incident response classes, phases, workflow matrix, and evidence'), so an agent can tell it is a retrieval tool for incident-response recipe content. It is not a tautology and is distinguishable by subject from the many sibling recipe packs, though it does not clarify exactly what 'agentic incident response' means or how it relates to similar packs such as SOC detection or red team drills.

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

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

There is no guidance on when to use this tool versus any of the many sibling recipe packs. No conditions, exclusions, or alternatives are mentioned, and the optional parameters are not described, so an agent cannot determine when to call this tool instead of a related pack.

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. The description merely restates the purpose and gives no information about what 'measurement probes' contain, whether the operation is read-only or mutating, how results are aggregated or filtered, or what the output structure looks like. Even though an output schema exists, the description itself adds no 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 sentence with minimal waste. It front-loads the core verb+resource immediately. It is appropriately sized for what it conveys, though it sacrifices useful detail for brevity.

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

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

With an output schema present and 6 unrequired filter-like parameters, this looks like a query/list tool, but nothing explains what the probes contain, how filters combine, or which scenarios call for this pack versus sibling packs. For a pack whose name suggests a non-trivial domain concept, the definition leaves too much for the agent to infer.

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

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

Schema description coverage is 0%, so the description must compensate for the six parameters (status, class_id, decision, probe_id, workflow_id, minimum_score) that have only type/default information. It does not. The description mentions none of the parameters and doesn't explain what they do, how they interact, or what valid values look like. For a tool with 6 undocumented parameters, this is a significant gap.

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

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

The description states a clear action (return measurement probes) and a specific resource (agentic workflow traceability and readiness). It distinguishes itself reasonably from the many sibling tool packs by focusing on 'measurement probes' specifically. However, 'traceability and readiness' is broad and could overlap with siblings like recipes_agentic_readiness_scorecard or recipes_agentic_assurance_pack, so it doesn't fully differentiate.

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

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

The description provides no guidance on when to use this tool versus any of the dozens of related sibling packs (readiness_scorecard, assurance_pack, posture_snapshot, etc.). It doesn't state what criteria would lead an agent to select this over alternatives, nor does it mention any exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden, and it only reveals that the tool returns a pre-generated snapshot. It does not disclose whether filters are applied, whether a single object or a collection is returned, whether the call can create or refresh anything, or what authorization or resource requirements exist.

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

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

The single sentence is readable and front-loads the action and object, but it is also under-specified. The shortness is not harmful, yet the missing parameter and usage detail means the structure is minimal rather than fully useful.

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

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

For a tool with five optional but undocumented parameters and no annotations, this definition is incomplete: it does not explain filter semantics or how the snapshot is selected. Having an output schema helps with the return shape, but not with the input contract or when to call this tool.

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

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

Schema description coverage is 0%, and the description mentions none of the five parameters (finding_id, workflow_id, minimum_score, risk_factor_id, posture_decision). An agent cannot tell what minimum_score means, whether filters are combined, or which identifier is required to retrieve a specific snapshot.

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

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

The description names a specific action (Return), a specific resource type (generated enterprise posture snapshot), and a domain (agentic AI and MCP operations), so an agent can tell this is a retrieval tool. It does not explicitly distinguish among the many recipe_* siblings, such as recipes_get or recipes_agentic_readiness_scorecard, so it misses full sibling differentiation.

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

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

There is no statement about when to use this snapshot over the many sibling recipes, when not to use it, or whether it should be called before generating or refreshing a snapshot. The word 'generated' weakly implies an existing artifact, but no alternative or precondition is 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, the description carries the behavioral burden. 'Return' signals a retrieval/report-like operation, which is a useful non-destructive cue, but it does not disclose whether checks run live, whether drift controls take action, or what inputs are required. Minimal but not misleading.

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

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

A single sentence with no filler and the main noun phrase front-loaded. 'Buyer-ready drift controls' is jargon, but the structure is concise and 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 four optional inputs, zero annotations, and dozens of closely related sibling tools, a one-sentence description is insufficient. The output schema may cover return values, but input semantics and tool-selection context 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?

Schema description coverage is 0% and the description does not explain check_id, decision, source_id, or protocol_id. An agent cannot tell whether these are filters, identifiers, output selections, or configuration decisions; the parameter names provide only weak guesses.

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?

Names a specific deliverable (MCP/A2A protocol conformance evidence and buyer-ready drift controls) with a clear verb (Return), so an agent can tell what the tool does. It is distinguishable from generic sibling packs by its explicit protocol-conformance focus, though 'buyer-ready drift controls' remains somewhat vague.

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

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

There is no guidance about when to use this tool versus the many sibling conformance, evidence, and control packs. The description implies a protocol-conformance use case, but it never states prerequisites, alternatives, or exclusion conditions.

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

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

With no annotations, the description must carry the full behavioral burden. It only says the tool returns generated decisions; it does not disclose whether the call has side effects, how the decision categories are derived, whether this is read-only, or how the output schema relates to the decision value.

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

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

The description is a single front-loaded sentence with no filler. It is appropriately brief, though its brevity comes at the cost of useful parameter and usage 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?

The tool has three optional parameters and no annotations, but the description provides no context about how to construct a valid request or which decision tiers map to which inputs. The presence of an output schema covers return values, but not invocation semantics.

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%, yet the description mentions none of the three parameters (decision, workflow_id, minimum_score). An agent cannot infer what values these optional parameters expect, so the description fails to compensate for the missing schema documentation.

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

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

The description uses a clear verb ('Return') and identifies the resource: generated scale, pilot, gate, or block decisions for agentic workflows. It conveys the essential function but does not explicitly differentiate it from the many sibling readiness and recipe tools.

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

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

No guidance is given about when to invoke this tool versus alternatives such as recipes_agentic_assurance_pack or recipes_workflow_control_plane. The intended context is only implicit in the term 'readiness scorecard,' so an agent cannot tell if it should call this tool before or after other 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, the description carries the full behavioral burden, but it only says the tool returns drills. It does not describe whether parameters act as filters, whether all optional fields can be omitted, what happens with null values, or any limits or side effects.

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

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

The description is one tight sentence with no filler and front-loads the main action. It could be too terse for the decision an agent must make, but on conciseness alone it avoids waste.

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 an output schema existing, the description leaves too much unspecified for a 3-parameter tool with no annotations and zero parameter documentation in the schema. There is no advice on how to choose parameters or how this drill pack relates to the many sibling recipe packs.

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

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

Schema description coverage is 0%, and the description does not mention scenario_id, workflow_id, or attack_family at all. The parameter names are mildly self-explanatory, but the agent gains no additional semantic detail about value formats, relationships, or filtering behavior from the description.

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

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

The description states that the tool returns adversarial drills and scopes them to agentic remediation workflows and MCP controls. It is clear about the core deliverable, but it does not explicitly differentiate this from adjacent sibling tools such as recipes_agentic_red_team_replay_harness.

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

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

No guidance is provided about when to choose this tool over sibling alternatives. The phrase 'for agentic remediation workflows and MCP controls' gives only a broad domain context, not concrete selection criteria, exclusions, or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Return' suggests a read-only lookup, but the name 'harness' implies potentially more complex behavior, and the description does not clarify side effects, required context, failure modes, or what distinguishes a replay fixture from a live drill.

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

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

The description is a single compact sentence with no wasted words and front-loads the primary output types. It is concise, though the brevity contributes to under-specification in other dimensions.

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 five optional but undocumented parameters, no annotations, and a large sibling set; the description does not explain how filters interact, what a valid call looks like, or what kinds of replay fixtures the agent should expect. The output schema helps, but the description leaves too much unspecified for reliable selection and invocation.

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

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

Schema description coverage is 0%, so the description must compensate by explaining how parameters such as severity, replay_id, scenario_id, workflow_id, and attack_family relate to the returned fixtures. It does not mention any of these parameters, leaving the agent to guess their meanings from names alone.

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

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

The description clearly states a specific action ('Return') and a specific resource ('replay fixtures, expected decisions, and evidence gates for red-team drills'). This is specific enough to distinguish it from sibling tools like recipes_agentic_red_team_drill_pack, though it does not explicitly name or contrast those siblings.

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

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

The description implies the tool is for red-team drill replay scenarios, but it gives no guidance on when to prefer this over the many sibling recipe tools, nor any when-not-to-use conditions or alternatives. The agent must infer usage from the name and context rather than from explicit direction.

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

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

The description indicates a read-only retrieval action ('Return'), which implies no side effects. However, with no annotations provided, it does not disclose how optional parameters affect the returned templates, whether there is filtering or scoring behavior, or whether these are static templates or dynamically generated.

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, scannable sentence that front-loads the verb and resource and then lists the template categories. There is no wasted wording, and the structure makes the core purpose immediately readable.

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?

An output schema exists, so return structure is covered, but the description still leaves major gaps: optional parameter semantics are unexplained, there is no use-case guidance, and the relation to many sibling receipt/pack tools is unclear. A more complete description would explain how the optional IDs and minimum_score shape 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?

Schema description coverage is 0%, and the description does not explain any of the three parameters. receipt_id, workflow_id, and minimum_score are left entirely to inference, and the description provides no compensation for the lack of schema-level documentation.

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

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

The description states a specific verb and resource: it returns agent run receipt templates, and it lists the domains covered (identity, context, tools, egress, approval, evidence). This makes the core purpose clear, though it does not explicitly differentiate from widely overlapping sibling 'pack' 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?

There is no guidance about when to use this tool versus alternatives such as recipes_agentic_approval_receipt_pack or other pack tools. The description only says what is returned and provides no context for selecting it, no exclusions, and no preferred scenarios.

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

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

No annotations are supplied, so the description must disclose behavior itself. 'Return' implies a read-only style operation, but it does not describe whether this is a lookup, a generator, what side effects might exist, or how results are structured. This is a thin behavioral profile for a tool with zero annotation support.

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

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

The single sentence is concise, front-loaded, and contains no fluff. It earns its place for purpose clarity, though it is too terse to cover usage or parameter details.

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

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

Given no annotations, no output schema, and four undocumented optional parameters, the description leaves out invocation details, return-value expectations, and filter semantics. It is enough to know the general domain, but not enough to confidently 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 input schema has four parameters with no descriptions (coverage ~0%), and the description does not explain rule_id, decision, severity, or event_class at all. An agent cannot infer acceptable values or formats from either the schema or the description.

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

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

The description states a specific deliverable ('SIEM-ready detections') and a clear scope ('agentic AI and MCP telemetry'), with the verb 'Return', so an agent can understand what the tool produces. It does not explicitly compare itself to siblings, but the SIEM detection output is distinct from other recipes_* pack names.

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

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

There is no guidance about when to choose this tool over any of the many sibling recipes_* packs, nor any exclusions or alternative routing. The description only says what it returns, not when it should be used.

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 indicates a read-style 'Return' operation but gives no detail on scope, side effects, caching, or limitations. The behavioral transparency 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 one concise, front-loaded sentence with no redundancy. It could be more structurally informative, but it is appropriately brief for its level of 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 7 opaque optional parameters and no annotations, this description is too thin for correct invocation. The presence of an output schema helps expectations about return values, but it does not compensate for the missing parameter semantics and usage guidance.

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 7 parameters with 0% schema description coverage, and the description explains none of them. An agent cannot tell what decision, source_id, freshness_class, publisher_family, watched_source_id, source_class_family, or primary_watchlist_id mean or how they affect the result.

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

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

States a specific verb and resource: 'Return source-freshness and standards-drift evidence for SecurityRecipes.' This clearly communicates what the tool does and is distinct from generic recipe tools, though it does not explicitly contrast with any sibling.

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 source-freshness or standards-drift evidence is needed. However, it offers no explicit when-to-use guidance, no exclusions, and does not route the agent to any alternative among the many sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says the tool 'returns' mappings. It does not mention read-only behavior, filtering effects, data source, authentication, or any operational characteristics beyond the bare 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 short sentence that front-loads the action and resource. It is appropriately concise, though it sacrifices useful detail in favor of brevity.

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

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

For a tool with five optional parameters, no annotations, and no schema-level descriptions, the description is too thin to let an agent reliably know how to filter or interpret the mappings. The output schema exists, but the operational context and parameter semantics 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?

Schema description coverage is 0%, and the description adds no parameter information. The five parameter names (status, source_id, control_id, standard_id, capability_id) are somewhat self-explanatory as filters, but the description does not explain how they combine or constrain the returned mappings.

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 names a specific action ('Return') and resource ('standards-to-evidence mappings'), scoped to agentic AI, MCP, and prompt-injection guidance. It is not a tautology and conveys what the tool produces, though it does not explicitly contrast with any sibling tools.

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

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

No guidance is given about when to use this tool rather than one of the many similar 'recipes_*' siblings. The intended use is only implied by the resource phrase; there are no conditions, exclusions, or alternative tool references.

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

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

With no annotations, the description carries the behavioral disclosure burden. The verb 'Return' conveys a read-only retrieval operation, which is useful, but nothing is said about authentication needs, scoping behavior, side effects, or what happens when filters are omitted. This is minimally adequate but not rich.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to identifying the resource and its scope, making it very efficient for an 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?

Despite having an output schema, the description omits key context: how the four optional parameters interact, whether filters are additive, what the default behavior is when all are null, and why an agent would choose this over siblings. The tool is simple on the surface, but the lack of filter semantics leaves meaningful gaps.

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

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

Schema description coverage is 0%, so the description must compensate for the four undocumented parameters. It mentions content categories that loosely map to component types, but it never explains how namespace, agent_class, workflow_id, and component_type act as filters, how they combine, or what values they accept.

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 ('Return') and a precise resource ('Agentic System BOM'), and enumerates the content categories: workflows, agents, identities, MCP tools, and evidence. This clearly distinguishes it from the many sibling pack/risk/trust tools, which focus on different artifacts.

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

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

No guidance is provided about when to use this tool versus alternatives such as recipes_agentic_posture_snapshot or recipes_agentic_exposure_graph. There are no stated conditions, prerequisites, or exclusions, so an agent must rely on the tool name alone to infer applicability.

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

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

No annotations are provided, so the description must carry the full behavioral burden. 'Return the ... contract' implies a read-only retrieval but does not disclose whether the contract is static or dynamically generated, what the returned content contains, whether any side effects occur, or what response shape to expect.

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, which is positive, but it is more under-specified than appropriately concise. It conveys the basic return value in one sentence but omits enough context that the brevity does not fully serve the agent.

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

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

For a tool with 5 undocumented optional parameters, no annotations, and a large sibling family, the description is incomplete. It does not explain parameter meaning, output specifics, or selection criteria, leaving critical information for the agent to guess.

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 5 parameters with 0% description coverage, and the tool description names none of them. The parameters check_id, decision, workflow_id, signal_class_id, and required_attribute remain entirely unexplained, so an agent cannot know how to set them or what they filter.

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

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

The description states a clear action (Return) and a specific resource (OpenTelemetry-aligned agentic telemetry and redaction contract), which conveys the tool's core purpose. However, it does little to differentiate this from the many sibling 'recipes_*' contract/pack tools, some of which also return contracts.

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

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

There is no guidance on when to use this tool versus the numerous sibling recipe tools, nor any mention of alternatives or exclusions. The 5 optional parameters suggest some context-specific selection, but the description does not explain when or why to invoke this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only operation via 'Return', but it does not disclose data source freshness, authentication requirements, pagination, or side effects. For a tool that returns source-backed signals, more behavioral context is needed.

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

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

The description is a single front-loaded sentence with no filler. Qualifiers like 'current' and 'source-backed' add useful meaning and 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?

An output schema exists, so return-value documentation is less critical, but the tool still lacks parameter semantics, usage context, and behavioral detail. With 5 optional filters and many similarly named agentic tools, the description alone is not enough for confident invocation beyond calling with no arguments.

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 5 parameters with 0% description coverage and no enums, and the tool description does not define horizon, priority, signal_id, capability_id, or minimum_score. The parameter names are somewhat self-explanatory, but accepted values and semantics are left entirely to the agent.

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 ('Return') and a clear resource ('current source-backed agentic AI threat signals and product priorities'). It tells the agent what the tool produces, though it does not explicitly differentiate from the many agentic risk-related sibling tools.

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

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

No when-to-use guidance or alternatives are named. The qualifiers 'current' and 'source-backed' weakly imply a freshness-oriented use case, but they do not explain when to choose this over siblings like recipes_agentic_aivss_risk_scoring_pack or recipes_agentic_risk_register.

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 verb 'Return' indicates a retrieval operation rather than a mutation, which is a meaningful behavioral signal in the absence of annotations. However, the description does not disclose how the optional parameters affect the result, whether there are any implicit scope constraints, or what 'contracts' entails beyond the output schema.

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

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

The description is a single short sentence with no filler. It front-loads the action and resource, making it easy to scan, though the dense list of contract types could be slightly clearer in 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?

For a tool with three optional parameters, no annotations, and a large set of related sibling tools, the description is under-specified. It does not explain parameter semantics, usage context, or how this ledger relates to the surrounding trust-profile and boundary-pack tools, even though an output schema exists.

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 mentions none of the three parameters: agent_class, identity_id, or workflow_id. With no parameter documentation in either the description or the schema, an agent cannot know how these optional fields filter or shape the returned contracts.

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 'Return' and names a clear resource: agent non-human identity, delegation, scope, and audit contracts. It is clear enough to understand the general purpose, but it does not explicitly distinguish this tool from the many similar sibling pack/recipe tools like recipes_agent_card_trust_profile or recipes_agent_handoff_boundary_pack.

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

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

No guidance is provided about when to use this tool versus alternatives. With roughly 60 sibling tools covering related security, trust, and contract concepts, the description gives no selection criteria or exclusion hints, so an agent must infer usage entirely from the name.

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 behavioral disclosure burden. 'Return' suggests a read-only operation, but the description does not explain whether the tool computes, retrieves, or generates these values, how TTLs and persistence decisions are derived, or what side effects, if any, occur.

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

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

The description is a single, efficient sentence with no filler and front-loads the primary verb and resource. It is appropriately concise, though it sacrifices necessary detail for brevity.

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

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

With no annotations, 0% parameter coverage, and four optional parameters, the description is too thin to enable correct invocation. The presence of an output schema partially helps, but the lack of parameter semantics and behavioral context leaves significant gaps.

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

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

Schema description coverage is 0%, so the description must explain the four optional parameters. It mentions memory classes, workflow profiles, TTLs, and persistence decisions, but does not map them to decision, persistent, workflow_id, or memory_class_id, nor explain how these parameters filter or affect the returned data.

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

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

The description states a clear action ('Return') and identifies a specific set of resources: agent memory classes, workflow profiles, TTLs, and persistence decisions. This distinguishes it from sibling boundary packs focused on handoff, browser, context egress, or stdio launch, though it does not explicitly name those alternatives.

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

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

There is no guidance on when to use this tool versus the many sibling boundary packs or other recipes tools. The phrase 'agent memory' implies the context, but no explicit conditions, exclusions, or alternative routing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Return' weakly implies a read-like operation, but the description does not state whether the tool invokes other processes, creates artifacts, requires permissions, or has side effects. It also does not disclose failure modes or preconditions.

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, and the core noun phrase is front-loaded. It is concise and easy to parse. It could be considered slightly undersized, but conciseness itself is handled well.

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

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

With five optional parameters, no annotations, and no input-schema descriptions, the definition is not complete enough for an agent to know what inputs matter or how to choose this pack over similar siblings. An output schema exists and presumably defines return values, but that does not resolve the missing input semantics or selection guidance.

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

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

Schema description coverage is 0%, and the description does not compensate for any of the five parameters. Parameter names like 'decision', 'platform', 'risk_tier', and 'minimum_score' are left entirely undefined; the agent cannot know valid values or how they relate to 'provenance, permission, isolation, and supply-chain decisions.' This is a serious gap for invoking the tool correctly.

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

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

The description names a specific verb ('Return') and a concrete subject ('agent skill provenance, permission, isolation, and supply-chain decisions'), so an agent can broadly understand what the tool produces. However, it does not differentiate this from many sibling recipe packs that also appear to return governance or risk-related decisions, so it stops short of a 5.

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

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

The description gives no explicit guidance on when to use this tool versus the dozens of sibling recipe packs, such as recipes_agent_capability_risk_register or recipes_agent_trust_fabric_pack. There is no mention of alternatives, exclusions, or selection conditions. The only implied usage is 'when you want supply-chain decisions,' which is too weak given the large sibling set.

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

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

No annotations are provided, so the description must carry the full behavioral disclosure burden. The verb 'Return' suggests a read-only operation, but the description does not discuss filtering behavior, optionality semantics, or any side effects. It is not misleading, but it is too thin to be transparent given the absence of annotations.

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

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

The description is a single, front-loaded sentence with no filler and clearly communicates the tool's output categories. It is concise, though the brevity contributes to the lack of usage and parameter guidance.

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?

An output schema exists, so the return shape does not need to be spelled out, and the four optional parameters are listed in the schema. However, with no annotations, no parameter explanations, and no usage guidance, the description is not complete enough for an agent to know how to select or parameterize 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?

Schema description coverage is 0%, and the description does not explain how status, trust_tier, workflow_id, or dimension_id affect the result. Parameter names give some hint, but the tool description adds no meaning beyond the raw schema and does not compensate for the complete 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 names a specific verb ('Return') and a specific resource ('Agent Trust Fabric dimensions, workflow tiers, source evidence, and buyer proof'), so an agent can tell this is a retrieval tool focused on trust-fabric data. It does not explicitly differentiate itself from nearby sibling tools like recipes_secure_context_trust_pack or recipes_a2a_agent_card_trust_profile, but the wording is specific enough to convey the core purpose.

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

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

There is no guidance on when to use this tool versus the many sibling trust/risk/pack tools, nor any mention of what scenarios favor this pack. The description implies a read/query use case but provides no context about prerequisites, 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?

There are no annotations, so the description must carry the full disclosure burden. It indicates a read-like 'Return' behavior but does not explain how the optional parameters influence results, whether filters combine, or what categories of 'evidence' are returned. The behavioral model is too shallow for a tool in a large recipe family.

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

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

The description is a single front-loaded sentence with no filler words. It lists the key return categories efficiently, though the brevity comes at the cost of crucial parameter and usage context.

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

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

Given four undocumented parameters, no annotations, and a large set of sibling recipes, a single sentence is insufficient. The output schema exists, but the description still fails to clarify how an agent should construct a call or what decision/risk_tier represent in this browser-agent context.

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

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

Schema description coverage is 0%, so the description must compensate, but it only loosely maps "workspace classes" and "task profiles" to workspace_class_id and task_profile_id. There is no explanation of decision or risk_tier, nor how the optional attributes are used.

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 'Return' and names the resource: browser-agent workspace classes, task profiles, controls, and evidence. This distinguishes it from other boundary-pack siblings by indicating browser-agent scope, though it could more explicitly explain what a 'boundary pack' is.

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 state when to use this tool versus any alternative, nor does it describe when not to use it. The only usage signal is the implicit browser-agent scope, which is largely repeated from the tool name; no alternatives or exclusions are given.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. 'Return' implies a read-only operation, but the description does not explain what a 'pack' is, whether the optional parameters filter or alter the output, or what happens when all parameters are omitted.

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

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

The description is a single sentence with the verb front-loaded and no filler. It is concise, but the brevity leaves out important usage and parameter context that would make it genuinely useful.

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

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

With no annotations, no parameter descriptions, and 0% schema coverage, the description is the only source of guidance for this tool. An output schema exists, so return values may be covered elsewhere, but parameter semantics and tool-selection context are still missing for a tool with four optional inputs.

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 none of the four parameters have descriptions. The description loosely echoes some parameter names ('data classes', 'destination classes') but does not explain how source_id, data_class, workflow_id, or destination_class are used, which is a significant gap.

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

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

The description uses a specific verb ('Return') and names three concrete outputs: context egress data classes, destination classes, and workflow boundary policy. It is clear that this is a retrieval-style tool, though it does not explicitly differentiate itself from the many sibling boundary-pack 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?

There is no guidance on when to use this tool versus the numerous boundary-pack siblings such as recipes_agent_memory_boundary_pack or recipes_mcp_elicitation_boundary_pack. The description states only what the tool returns, with no conditions, prerequisites, or alternatives.

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

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

With no annotations provided, the description carries the full burden of explaining behavior. It states that scan results are returned, but does not disclose whether the tool runs a new scan or returns cached results, whether results are limited by default, whether any write or side effect occurs, or what authentication/access assumptions exist.

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

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

The description is a single short sentence with no wasted words and the main action is front-loaded. However, it is under-specified rather than deliberately concise: it needs additional clauses for usage, behavior, or parameter semantics to be genuinely helpful.

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?

Although an output schema exists, the tool still has six optional but undocumented parameters, no annotations, and no usage context. The description alone is not enough for an agent to know how to set filters like decision, severity, or actionable_only, or what 'registered secure-context sources' requires.

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

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

Schema description coverage is 0%, and the description provides no information about the six parameters (limit, rule_id, decision, severity, source_id, actionable_only). The agent receives no guidance on accepted values or how filters interact, so this dimension is severely under-served.

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

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

The description uses a clear verb ('Return') plus a specific resource ('context-poisoning scan results') and bounds the scope to 'registered secure-context sources.' It is not a tautology and the topic clearly separates it from most sibling tools, but it does not explicitly contrast with related secure_context or guard-pack siblings.

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

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

There is no explicit guidance about when to choose this tool over alternatives. The phrase 'for registered secure-context sources' hints at a prerequisite, but with dozens of similar secure-context and guard-pack siblings, the description does not help an agent decide 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 provided, the description carries full behavioral burden, but it only says 'Return the generated... profile'. This weakly implies read-only retrieval, but it does not disclose whether generation is triggered, what happens with optional parameters, whether side effects occur, or what prerequisites exist. This is similar to mutation tools with no annotation coverage that only name the 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 a single brief sentence with no wasted words, but its brevity comes from omitting substance rather than condensing useful content. The phrase 'critical-infrastructure secure-context profile' largely restates the tool name, so the sentence adds only minimal value beyond the identifier.

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 five optional inputs, no annotations, and many closely related siblings, yet the description provides no selection criteria, input semantics, or behavioral detail. The output schema helps with return shape but not with when to call this tool or what parameters mean.

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

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

Schema description coverage is 0%, and the description names none of the five parameters. An agent cannot infer the meaning or effect of decision, sector_id, control_id, buyer_view_id, or readiness_status, since all are string/null with defaults and no descriptions.

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

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

The description states a specific action ('Return') and a named resource ('the generated critical-infrastructure secure-context profile'), so an agent can tell it is a retrieval-style tool for that profile. However, it does not differentiate this from the many sibling secure-context and pack tools, and 'profile' is left undefined.

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

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

There is no guidance on when to use this tool versus alternatives such as recipes_secure_context_trust_pack, recipes_secure_context_buyer_diligence_brief, or recipes_secure_context_evidence_contract. The description does not provide context, exclusions, or alternative routing.

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. 'Return' communicates a read-only info operation and the description lists the output dimensions (scope, coverage, provenance, counts), which is useful. It does not explicitly state side-effect-freeness, freshness, auth requirements, or whether the catalog is filtered differently from other CVE tools, but it does not contradict annotations and is a straightforward retrieval.

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

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

A single, front-loaded sentence names the action, resource, and output content without wasted wording. It is appropriately sized for a zero-parameter info 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?

With no parameters and an output schema present, the description covers the agent's needs: it names exactly what catalog aspects will be returned. No additional caveats or return-value detail is necessary for this simple retrieval 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 tool has zero parameters, so there is no parameter semantics burden on the description. Baseline 4 applies because there is nothing for the description to clarify 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 begins with the specific action 'Return' and identifies a concrete resource: the Medium/High/Critical CVE catalog's scope, coverage, provenance, and counts. This clearly distinguishes it from sibling tools like recipes_cve_get and recipes_cve_search, which target individual CVEs or search results rather than catalog-level metadata.

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

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

There is no explicit when-to-use or when-not-to-use statement and no mention of alternative tools. However, the phrasing 'complete ... catalog scope, coverage, provenance, and counts' implies this is the catalog-wide overview tool, so a capable agent can infer usage from context, but the contrast with cve_get/cve_search is left 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?

With no annotations, the description carries the behavioral burden. 'Get' signals a read operation, and it discloses the specific output dimensions: evidence, recipe authority, and a bounded code/config/file change plan. This is reasonably transparent, though it does not explicitly assert zero 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?

A single sentence that is front-loaded with the primary action and indicates what the returned content covers. Every word contributes to the 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 single-parameter lookup tool with an output schema, the description is largely sufficient. It identifies the exact input needed and summarizes the output. It lacks only a more explicit usage note distinguishing it from related CVE tools, but the output schema compensates for return-value details.

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

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

The input schema provides only a string field named 'cve' with no description (0% schema coverage). The description adds that the value must be 'one exact CVE,' which tells the agent to pass a precise CVE identifier rather than a query or partial identifier, but it does not provide format expectations or examples.

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 and resource combination: it retrieves evidence, recipe authority, and a bounded change plan for one exact CVE. This clearly distinguishes it from search-oriented siblings like recipes_cve_search and from generic getters like recipes_get.

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

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

The phrase 'for one exact CVE' implies the tool should be used when a specific CVE identifier is already known, not when searching or browsing. However, it does not explicitly name alternatives or state when not to use this tool, leaving some inference required.

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 behavioral burden. It discloses the CVE severity scope and signals that this tool does not return complete details. It does not mention result limits, pagination, ordering, or how filters like kev_only and published_year affect the search.

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

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

The description is a single compact sentence with no filler. The core scope is front-loaded and the pointer to recipes_cve_get is delivered in an efficient clause.

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 gives a clear high-level purpose and useful sibling routing, and the output schema can cover return shape. However, with five parameters, zero annotations, and no parameter semantics, the agent is left to infer too much about query behavior, filter combinations, and the meaning of 'in-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?

Schema description coverage is 0%, yet none of the five parameters (query, limit, kev_only, severity, published_year) is explained in the description. The phrase 'Medium/High/Critical' hints at severity scope but does not clarify parameter formats, defaults, or query behavior.

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 and resource: 'Search every in-scope Medium/High/Critical CVE'. It also distinguishes itself from recipes_cve_get by pointing there for 'complete details', so an agent can tell search from detail lookup without opening schemas.

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

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

It names the sibling recipes_cve_get as the place for complete details, giving clear routing guidance for when richer output is needed. It does not explicitly state when not to use this tool, but the alternative is identified clearly.

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. The verb 'Return' implies a read/retrieval operation, but the description does not state whether the output varies with the seven filter parameters, whether any state changes occur, or what a 'design partner pilot motion' actually contains. This falls well short for an annotation-free 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 sentence with zero filler and the action verb front-loaded. It is clean and scannable; the brevity comes at the cost of substance, but structurally it earns a high mark for efficiency.

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

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

For a tool with 7 optional parameters, no annotations, and no schema descriptions, a 14-word description is severely under-specified. The output schema covers the return shape, but nothing explains the domain concept ('design partner pilot motion'), how parameters shape the result, or how to choose this pack over adjacent 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?

Schema description coverage is 0% across 7 parameters, so the description must compensate, but it mentions none of them. The parameter names (risk_id, phase_id, wedge_id, metric_id, segment_id, question_id, status) hint at a filter-by-ID pattern, but there is no guidance on valid values, how parameters combine, or what effect each has on the returned pack.

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 ('Return') and names a resource ('the design partner pilot motion') with a stated purpose, so it goes beyond a tautology. However, 'design partner pilot motion' is undefined jargon, and the description does not differentiate this pack from the ~70 sibling recipe packs that overlap in theme (e.g., recipes_hosted_mcp_readiness_pack, recipes_secure_context_customer_proof_pack).

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 clause 'for buyer proof and hosted MCP validation' implies when to use the tool, giving some contextual anchor. But there are no explicit use conditions, no exclusions, and no references to alternative packs, which is a notable gap given how many sibling packs cover adjacent concepts like customer proof or hosted MCP readiness.

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

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

No annotations are provided, so the description must carry the full behavioral disclosure burden. 'Return' implies a read-only retrieval operation, and 'bundled' hints at aggregation, but the description does not explain what bundling entails, whether filters are applied, or whether any state changes occur. This is insufficient behavioral context 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 concise sentence with no filler, and the core purpose is front-loaded. However, it is so brief that it omits important semantics, so it does not fully earn a 5.

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?

An output schema exists, so return formatting is covered, but the sole input surface of five optional nullable parameters is undocumented. There is no guidance on how the parameters interact, what 'bundled' means, or how this export relates to the many sibling diligence and trust tools. For a tool with this many optional parameters, the description is not complete enough for correct invocation.

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

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

Schema description coverage is 0% and the description does not mention any of the five parameters. The parameter names (status, pack_id, category, section_id, question_id) provide some intuition, but their values, meaning, and interrelationships are entirely unexplained. With low schema coverage, the description needed to compensate and did not.

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

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

The description states a specific verb and resource: 'Return the bundled enterprise trust-center export'. It also names the intended audience ('buyer and platform diligence'), which helps scope the tool. It does not explicitly differentiate from siblings, but the 'export' noun makes it reasonably distinct among the recipe 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 phrase 'for buyer and platform diligence' implies a use context, but there is no guidance on when to choose this tool over alternatives, nor any exclusions. With many similar sibling tools like recipes_secure_context_buyer_diligence_brief, explicit routing guidance would be valuable.

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 behavioral disclosure burden. It clearly implies a read-only operation, which is useful, but it does not mention error behavior, authorization requirements, or what happens when the slug/path does not exist. This is adequate but not rich.

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

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

The description is a single efficient sentence that front-loads the action and resource. Every word earns its place, and there is no repetition 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 one parameter and an output schema present, the description does not need to explain return values. It gives the essential retrieval mechanism. It only lacks richer context about failure modes and relationship to sibling lookup tools, but it is largely complete for a simple getter.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by indicating that the single parameter is a 'slug or path', which is important context beyond the raw string type. However, it does not provide format details, examples, or clarify how path differs from slug.

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 ('Get'), a specific resource ('full recipe record'), and the key access method ('by slug or path'). It clearly distinguishes itself from sibling tools like recipes_list or recipes_search by indicating a direct lookup of a complete record, not a list or search result.

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

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

The description gives no explicit guidance about when to use this tool versus recipes_list or recipes_search. There are no alternatives mentioned, no exclusions, and no context about when direct slug/path retrieval is preferred over searching or listing.

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 carries full responsibility for disclosing behavior. It states only that the tool returns a plan; it does not mention whether the plan is generated dynamically, whether it depends on the provided IDs, whether it has side effects, requires authentication, or returns partial versus complete information. Minimal transparency 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 focused sentence with no filler. It is front-loaded with the primary action and resource. However, extreme brevity contributes to vagueness, so it earns a 4 rather than a 5.

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

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

With six optional parameters, no annotations, and many closely related sibling tools, the description is too thin to give an agent enough context to call the tool correctly. It does not explain what the readiness plan contains, how the parameters influence the result, or how this differs from other readiness and MCP-related packs. The presence of an output schema helps, but the description still lacks essential usage and selection context.

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

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

Schema description coverage is 0% and the description does not explain any of the six parameters (status, gate_id, risk_id, stage_id, control_id, buyer_evidence_id). The parameter names are somewhat suggestive but their roles as filters, inputs, or selection criteria are never clarified. The description offers no compensation for the schema's total lack of parameter documentation.

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

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

The description uses a specific verb ('Return') and identifies a distinct resource ('hosted MCP readiness plan for enterprise product rollout'). While it does not explicitly contrast with any sibling, the 'hosted MCP' qualifier and 'plan' resource help distinguish it from related readiness scorecards and risk packs. It is clear enough for an agent to know roughly what this tool produces.

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 choose this tool versus the many sibling readiness, risk, and pack tools. There are no exclusions, prerequisites, or alternative routing hints. An agent would have to infer usage entirely from the name and the generic description, which is insufficient given the large sibling set.

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 description carries the full burden of behavioral disclosure. It implies a read-only listing operation but says nothing about default limits, pagination behavior, how filters combine, whether results are sorted, or what transactions occur. This is thin for a 7-parameter list 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 one tight, front-loaded sentence with no redundancy. It could carry more information, but as far as concision and structure go, 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?

Given the large sibling namespace and 7 undocumented optional filters, the description does not give enough context for an agent to reliably choose it or construct a correct call. The output schema helps with return shape, but the selection and filtering semantics are left unexplained.

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

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

The input schema has 7 parameters with 0% description coverage, and the description only says 'metadata filtering' without explaining tags, agent, facets, section, severity, min_quality, or limit. Some names are self-explanatory, but facets and severity especially need semantics that neither the description nor schema provide.

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

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

The description clearly states the action ('List') and resource ('recipes'), and 'with optional metadata filtering' signals that this is a queryable list endpoint. It does not fully distinguish it from sibling tools like recipes_search or recipes_get, but the basic purpose 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?

No guidance is given about when to use this tool versus alternatives such as recipes_search, recipes_get, or recipes_playbooks_list. The phrase 'List recipes' implies enumeration, but there are no explicit conditions, exclusions, or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Heuristic matcher' hints at non-deterministic or best-effort matching, and 'suggests' implies a non-mutating action, but it does not disclose any side effects, authorization needs, rate limits, or the nature of the matching process.

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, so it is concise. However, one short sentence is too sparse for a tool with eight parameters and many sibling tools, leaving substantial coverage gaps.

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?

A return schema exists, so the description need not explain outputs, but it omits all parameter semantics, usage context, and behavioral caveats. For a heuristic matching tool with eight optional inputs and a large sibling set, this is not enough for an agent to confidently select and invoke it correctly.

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

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

Schema description coverage is 0% and the description mentions none of the eight parameters (cve, limit, facets, package, rule_id, ecosystem, min_quality). The description provides zero additional meaning to help an agent understand what each parameter controls or how to combine them.

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

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

The description states a specific action ('suggests best-fit recipes') and a clear target ('security finding'), so an agent can identify its core function. It does not explicitly contrast with sibling tools like recipes_cve_search or recipes_mcp_upstream_tools, so differentiation is partly left to inference.

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

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

There is no guidance on when to use this tool versus the many recipe-related siblings, nor any excluded cases or alternative suggestions. The phrase 'for a security finding' implies the general context but does not define when this matcher is preferable to direct search or retrieval 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 provided, so the description bears the full burden of behavioral disclosure. 'Return ... evidence' implies a read-like reporting operation, but it does not say whether state is modified, whether live assessment is performed, whether permissions or prerequisites apply, or what side effects could occur. This is insufficient for a tool with no annotation safety hints.

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

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

The description is one concise, front-loaded sentence with no fluff or repetition. It is easy to parse quickly. It sacrifices important detail, but that is better captued by completeness, not by length alone.

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 an output schema, the tool lacks guidance on when to use it, what the parameters mean, and what behavioral guarantees apply. For a tool with no annotations and multiple similar siblings, this description is too thin for an agent to reliably select and invoke it correctly.

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

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

Schema description coverage is 0%, and the description does not explain how 'decision', 'namespace', 'workflow_id', or 'connector_id' relate to authorization conformance, scope-drift, or token-boundary evidence. The parameter names offer weak inference, but the agent gets no concrete guidance on accepted values, filters, or required combinations.

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

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

The description clearly states a specific action ('Return') and a concrete resource ('MCP authorization conformance, scope-drift, and token-boundary evidence'). It also hints at differentiation from sibling tools like recipes_agentic_protocol_conformance_pack by focusing on authorization rather than general protocol conformance. However, it does not explicitly name any alternative or contrast with siblings.

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

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

There is no guidance on when this tool should be used versus the many sibling 'pack' tools, nor what disqualifies its use. The only implied usage is that an agent needing authorization conformance evidence might choose it, but no explicit conditions or exclusions 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 carries the burden of disclosing behavior. It clearly indicates a read-style retrieval operation and lists the content categories returned, which is useful. However, it does not state whether results are filtered by the optional parameters, whether the pack is generated dynamically, or any auth/rate-limit considerations.

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

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

The description is a single sentence that front-loads the action and lists the result types with no wasted words. It is concise, though the compactness comes at the cost of important operational 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?

While an output schema exists, the description still leaves critical gaps: it does not explain how the optional parameters shape the returned pack, when this intake pack is relevant, or how it differs from closely related MCP connector packs. For a tool with no annotations and no parameter documentation, this is not complete enough.

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 makes no mention of 'decision', 'namespace', or 'candidate_id'. The tool requires the description to compensate for the undocumented schema, but none of the parameters receive any added meaning or usage context.

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 ('Return') and a clear resource ('MCP connector intake decisions, risk findings, gaps, and promotion plans'), which conveys the tool's purpose. It does not explicitly contrast itself with sibling tools such as recipes_mcp_connector_trust_pack or recipes_mcp_risk_coverage_pack, so it falls short of full differentiation.

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

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

The description offers no guidance on when to use this tool versus the many sibling pack tools. It neither specifies the intended intake scenario nor namees alternatives or exclusions, leaving the agent to guess the decision boundary.

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 for behavioral disclosure. It implies a read operation through 'Return' but does not state filtering behavior, interaction of the three optional parameters, or whether the tool has side effects. This is thin for a tool with no annotation support.

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

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

The description is a single concise sentence with the action and primary output categories front-loaded. There is no filler, though 'and workflow namespace coverage' is slightly awkward and could be clearer.

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 presence of an output schema reduces the burden for describing return values, but the description still lacks parameter semantics, usage context, and behavioral details. For a tool with three optional filters and no annotations, an agent cannot confidently determine correct invocation 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?

The schema has 0% parameter description coverage and the tool description does not explain namespace, workflow_id, or connector_id. Their names give hints, but the description does not clarify whether they are independent filters, how they combine, or what an all-null call returns.

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

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

The description uses a clear verb, 'Return', and identifies a specific resource: MCP connector trust, with named output categories (tiers, controls, evidence, workflow namespace coverage). However, 'workflow namespace coverage' is ambiguous, and it does not distinguish this tool from many sibling recipes_* trust/risk/intake packs.

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

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

There is no guidance about when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or how to choose between this and similar tools like recipes_mcp_connector_intake_pack or recipes_mcp_risk_coverage_pack.

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, and it only states that the tool 'returns' evidence. It does not disclose whether evidence is computed or fetched, whether the call has side effects, whether authorization is needed, or what the evidence actually 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?

A single, grammatically clean declarative sentence with no wasted words and the key modality terms front-loaded. It is terse to the point of under-specification, but as a structural matter it is efficient and readable.

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?

Although an output schema exists and relieves the description of explaining return values, the definition still lacks parameter documentation (0% coverage), usage guidance, and behavioral disclosure. For a tool with 5 undocumented parameters sitting in a large family of similarly named recipes, this is far from 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% for all 5 parameters, and the description never mentions mode, decision, risk_tier, profile_id, or workflow_id. The parameter names are mildly suggestive, but the description does nothing to compensate for the total absence of schema documentation, leaving an agent to guess valid values and relationships.

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 ('Return') and names a resource ('MCP form-mode and URL-mode elicitation boundary evidence'), so it does state the tool's function. However, 'elicitation boundary evidence' is domain jargon, and the description does nothing to distinguish this from the many sibling boundary packs (e.g., recipes_context_egress_boundary_pack, recipes_mcp_stdio_launch_boundary_pack).

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

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

There is no guidance on when to use this tool versus any of the ~70 sibling recipe tools, including several other 'boundary_pack' tools. No context, conditions, or exclusions are provided anywhere in the 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only names the returned artifact and does not state whether the tool generates the policy, has side effects, requires configuration, or behaves differently based on workflow_id. The description is minimal but not contradictory.

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

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

One focused sentence with no filler; the core purpose is front-loaded and easy to parse. It is concise, though the brevity comes at the cost of leaving other dimensions under-specified.

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 optional parameter and an output schema, the description is serviceable but thin. It omits explanation of workflow_id semantics, selection criteria among dozens of sibling recipe tools, and what 'generated' entails in practice. More context is needed for reliable 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?

The single workflow_id parameter (nullable, default null) is not mentioned in the description, and schema description coverage is 0%. The agent cannot determine whether workflow_id scopes the generated policy or what passing null means, so the description adds no semantic value beyond the bare schema.

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

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

The description uses a specific verb ('Return') and names a concrete artifact ('MCP gateway policy'), with qualifiers 'scoped tool access and runtime controls' that clarify the policy's purpose. It is not a tautology, but it does not explicitly differentiate this tool from closely related siblings like recipes_mcp_authorization_conformance_pack or recipes_workflow_control_plane.

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 the many sibling recipe tools. There are no prerequisites, typical scenarios, or exclusion criteria, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations, the description carries the full burden, but it only says 'Return ... mapped to generated evidence.' It does not disclose whether evidence is generated on demand, how filters alter results, or what side effects may occur. 'Return' implies read-only, but little else is revealed.

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

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

The single sentence is economical and free of fluff, but it sacrifices substance for brevity. There is no organization separating purpose, usage, and parameter meaning, so the conciseness does not compensate for the omitted guidance.

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

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

For a tool with six optional parameters, no annotations, and 0% schema coverage, the description leaves too much undefined. The presence of an output schema reduces the need to explain return values, but the filtering semantics, meaning of 'risk coverage,' and relationship to the sibling packs remain unresolved.

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

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

Schema description coverage is 0%, and the description adds no meaning to any of the six parameters: status, risk_id, risk_tier, source_id, standard_id, and capability_id. The parameter names are mildly suggestive, but without enums, formats, or descriptions, an agent has insufficient information to construct meaningful calls.

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 ('Return') and names a concrete resource ('OWASP MCP and agentic-skill risk coverage') plus the output orientation ('mapped to generated evidence'). It identifies the tool's domain clearly, though it does not sharply differentiate it from the many sibling risk and coverage packs.

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 select this tool over siblings such as recipes_mcp_tool_risk_contract or recipes_agentic_assurance_pack. The six optional parameters are not connected to use cases, and there are no exclusions or alternative routing cues.

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 states a read-like outcome ('Return one... MCP server with... guidance') but does not explain what happens for unknown server_id values, whether this relies on network access, wait times, or any limitations around the 'publicly documented' condition.

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

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

The description is a single, front-loaded sentence with no filler. Every phrase contributes useful information: what is returned, its scope, and the included guidance.

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 one-parameter get operation with an output schema, the description covers the essential 'what' adequately but misses the 'how to choose server_id' context and any usage guidance relative to many similar sibling tools. It is minimally viable, not 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%, and the description does not explain server_id beyond implying it identifies a specific MCP server. The parameter name is intuitive, but the description adds no format, source, or lookup semantics, leaving the agent to infer how to populate it correctly.

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 ('Return') and the resource ('one publicly documented MCP server'), and it specifies what the result includes: 'official setup and safety guidance.' It is not fully distinguished from closely related siblings like recipes_mcp_servers_list or recipes_server_info, but the singular 'one' and the 'publicly documented' qualifier supply meaningful 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?

No guidance is provided about when to choose this tool over the many sibling tools, such as recipes_mcp_servers_list or recipes_get. The phrase 'publicly documented' hints at one selection criterion, but there is no explicit when-to-use, when-not-to-use, or alternative recommendation.

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 behavior-disclosure burden. It adds useful scoping by noting the catalog is 'bundled' and 'publicly documented,' implying a read-only search over a local catalog. But it does not disclose how search matching works, whether results are paginated, or what the availability parameter accepts, though nothing in the description is misleading.

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

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

The description is a single, tightly written sentence that front-loads the verb and resource without filler. Every word contributes to conveying the tool's 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?

Although an output schema exists, the description omits parameter semantics and any usage context that would help an agent decide when to call this tool. The bundled-catalog scope is useful, but with three undocumented parameters and many closely related siblings, the description is not sufficient for reliable invocation.

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

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

Schema description coverage is 0% and the description does not compensate for this gap. None of the three parameters (limit, query, availability) is explained beyond its JSON type and default; the meaning of the availability parameter and how the query is matched are entirely undefined, so an agent cannot reliably determine correct 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 states a specific action ('Search') and a clear resource ('bundled catalog of publicly documented MCP servers and ecosystems'), which makes the tool's purpose obvious. It is distinct from generic siblings like recipes_mcp_server_get, but it does not explicitly name or differentiate against siblings, so it falls just short of a 5.

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

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

The phrase 'bundled catalog' implies this tool is for searching the built-in/registered MCP server catalog, providing an implicit usage context. However, there is no explicit guidance about when to prefer this over related alternatives such as recipes_mcp_server_get, recipes_list, or recipes_upstream_servers, and no '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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only says 'Return' and does not explain data source, side effects, permissions, or how parameters affect the result.

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