Security Recipes

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. 'Return' implies a read operation, but there is no disclosure of authentication needs, rate limits, side effects, or data sensitivity. It adds minimal behavioral context beyond implying 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 wasted words. It is appropriately concise, though its brevity leaves important semantic gaps that are captured under 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?

An output schema exists, so return values need not be explained. However, with no annotations, three undocumented parameters, and no usage guidance, the description is substantially incomplete for helping an agent select and invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description does not mention any of the three parameters (decision, risk_tier, profile_id) or their expected values. The parameter names alone provide some hint, but the description adds no meaning 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 clear verb ('Return') and names the resources: A2A Agent Card intake profiles, trust controls, and sample decisions. It distinguishes the tool from generic siblings by mentioning A2A Agent Card trust content, but it does not explicitly differentiate it from similar trust/agentic 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?

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. Usage must be inferred entirely from the name and resource list.

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

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

No annotations are provided, so the description must carry the full behavioral burden, but it only states the return purpose. It does not disclose whether the operation is read-only, whether authentication is required, how filters behave, or what the scores represent 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 single sentence is front-loaded and contains no filler, but it is under-specified rather than concise. For a tool with four undocumented parameters and no annotations, the extreme brevity leaves important invocation details unaddressed.

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 does not compensate for absent annotations, 0% parameter documentation, or the dense sibling landscape. It gives only a high-level purpose, so an agent would struggle to know how to filter, when to call it, or what the scores 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% for four parameters, and the description does not mention or explain any of them. An agent receives no meaning for decision, risk_tier, workflow_id, or minimum_residual_score beyond their names in the schema.

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

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

The description states a specific verb ('Return') and resource ('capability-based residual risk scores for agentic workflows'), so the basic purpose is clear. However, it does not distinguish this tool from sibling risk-scoring tools such as recipes_agentic_aivss_risk_scoring_pack or recipes_mcp_risk_coverage_pack, leaving ambiguity about which risk register is appropriate.

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

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

There is no explicit guidance on when to use this tool versus its many risk-related siblings. The phrase 'for agentic workflows' implies a context but gives no conditions, prerequisites, or alternatives to help an agent choose correctly.

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. 'Return' weakly implies a read, but nothing is said about authorization needs, scoping, pagination, or whether the optional filters narrow or widen the result. For a zero-annotation tool this leaves the agent guessing about how the call behaves.

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

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

A single front-loaded sentence with no filler or repetition. It is tight, but at this level of under-specification the brevity reflects a lack of content rather than disciplined editing.

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 values need not be explained. Still, with no annotations, no usage context, and four undocumented optional parameters, the description is not sufficient for an agent to invoke this tool correctly rather than a neighboring pack.

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 four parameters (decision, protocol, profile_id, workflow_id). The description only incidentally echoes 'protocol' and 'workflow' in its output noun list, giving no meaning, format, or expected values for any parameter — decision and profile_id are entirely unaddressed.

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 verb ('Return') and a set of resources (handoff boundary profiles, protocol controls, workflow maps), so the general shape of the output is inferable. However, the terminology is opaque jargon and there is no differentiation from near-identical siblings such as recipes_agent_memory_boundary_pack, recipes_context_egress_boundary_pack, or recipes_agentic_protocol_conformance_pack, so an agent cannot confidently choose this tool over 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?

The description offers no when-to-use guidance, no prerequisites, and no alternatives. With roughly sixty sibling 'pack' tools sharing this naming pattern, the absence of any routing signal is a real selection hazard rather than a minor omission.

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' weakly implies a read, but the description says nothing about side effects, permissions, rate limits, or whether the optional filters constrain the result set. Since an output schema exists, return-value shape is partly covered, but behavior beyond that is undocumented.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though arguably too terse relative to the tool's complexity and four unexplained parameters.

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 values need not be described, but for a tool with four optional filtering parameters at 0% schema coverage and no annotations, the description should at minimum explain what the pack is and how the filters scope it. As written, an agent cannot confidently invoke it.

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

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

All four parameters (decision, risk_tier, workflow_id, action_class_id) have 0% schema description coverage, and the description mentions none of them. There is no indication of what these filters mean, their expected string formats, or how combining them affects the returned pack, so the parameter layer is entirely opaque.

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 concrete verb ('Return') and lists specific resources (action classes, workflow action envelopes, runtime policy, evidence), which is more informative than a tautology. However, it never says what the tool actually does operationally — assemble a report, fetch configuration, or generate a bundle — and dozens of sibling 'recipes_*_pack' tools use near-identical framing, so it does little to distinguish itself.

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

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

There is no when-to-use guidance, no description of which scenarios call for this pack versus siblings like recipes_agentic_assurance_pack or recipes_agentic_control_plane_blueprint, and no prerequisites. The agent is left to infer applicability purely from the resource nouns in the sentence.

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' implies a read-style operation, but there is no information about side effects, permissions, rate limits, authentication needs, or whether the result is cached or live. The description adds no behavioral context beyond the basic output categories.

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 sized for a concise tool summary, though the phrase 'hosted MCP wedges' is opaque and undercuts clarity.

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

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

Given five undocumented parameters, no annotations, and a dense sibling ecosystem, the description is far too sparse to guide correct invocation. The presence of an output schema means return values need not be explained, but parameter filtering behavior, selection criteria, and behavioral constraints 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?

The schema has 5 parameters with 0% description coverage, and the description does not explain any of them. Terms like 'owner', 'severity', 'scenario_id', 'minimum_score', and 'runtime_default_decision' are left entirely undefined. For a five-parameter tool with no schema documentation, this is a severe gap.

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

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

The description states a verb ('Return') and a set of resources (AIVSS-aligned agentic risk scores, SLAs, evidence, hosted MCP wedges), so it is more than a tautology. However, 'hosted MCP wedges' is vague jargon and the definition does not distinguish this tool from any of the many sibling risk/scoring/assurance tools. It provides a general sense of purpose without a precise boundary.

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, when-not-to-use, or alternative-tool guidance. The description does not say when an agent should select this pack over the many sibling risk, assurance, or scoring tools. It simply states what is returned.

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, and it discloses almost nothing: not whether the call is read-only, whether results are cached or generated on demand, how filtering behaves when optional params are omitted, or any auth/rate considerations. The single verb 'Return' is the only behavioral signal.

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 short sentence with no filler, which is good, but it is under-specified rather than concise — the brevity stems from missing content rather than from tight editing. Front-loaded verb+resource is fine.

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 excuses the description from explaining return values, but for a five-parameter, zero-coverage, annotation-free tool the description is far too thin. Nothing tells an agent how to use the filters or what the call guarantees.

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 five optional parameters (app_id, decision, risk_tier, buyer_stage, minimum_score), so the description must compensate and does not. Parameter names are somewhat self-descriptive, but the description adds no meaning about filtering semantics, allowed values, or how the numeric threshold interacts with the others.

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

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

The description states a general verb ('Return') and resource ('agentic app launch-review profiles and decisions'), which hints at a read operation over launch-review records. However, it does not distinguish this pack from the many similarly named sibling packs (intake, approval receipt, assurance, readiness scorecard), so an agent cannot tell when this one is the right choice. Minimum viable but 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 when-to-use guidance, no prerequisites, and no named alternative among the ~60 sibling tools. The word 'generated' hints the profiles are pre-produced rather than computed on demand, but this is not made explicit as a selection criterion.

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

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

No annotations are provided, so the description carries full disclosure burden, yet it says nothing about read-only vs. mutating behavior, permissions, side effects, or rate limits. 'Return' weakly implies a read, but no guarantees are stated.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though the extreme terseness contributes to gaps elsewhere rather than to conciseness itself.

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, return values need not be explained, but a 5-parameter, 0%-covered, annotation-free tool needs far more: parameter meaning, usage context, and behavioral guarantees are all absent.

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

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

All 5 parameters have 0% schema description coverage and the description does not mention any of them. Terms like 'scope-bound' hint at filtering but never map to decision, risk_tier, workflow_id, action_class, or approval_profile_id.

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 names specific artifacts (approval receipt profiles, workflow requirements, evidence). It does not distinguish this tool from the many sibling '..._pack' tools, 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?

There is no indication of when to use this tool, what prerequisites exist, or which sibling tools (e.g., run_receipt_pack, assurance_pack) are alternatives. Only a bare output statement is given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read ('Return') but discloses nothing about auth requirements, scoping behavior when control_id/workflow_id are omitted, result size, or how the three artifact types relate. The terse noun list leaves behavior 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, front-loaded sentence with no padding, which is efficient. However, it is a noun-list fragment rather than a structured statement, and its brevity borders on under-specification for a tool with two undocumented inputs.

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 detail is rightly omitted. But with no annotations, 0% parameter coverage, and no routing guidance among many near-identical siblings, the description is not sufficient for an agent to select or call this tool confidently.

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

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

Two optional parameters exist at 0% schema description coverage, and the description never mentions control_id or workflow_id. It gives no indication of what values these IDs are, whether both are needed, or what happens when they are null. This falls well short of compensating for the documentation 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 verb 'Return' plus a bundle of three nouns ('enterprise assurance controls', 'workflow evidence', 'AI/Agent BOM seed') loosely conveys the resource but not a specific one. Against ~60 sibling 'recipes_agentic_*_pack' tools (including recipes_agentic_system_bom), it gives no basis for distinguishing this pack from adjacent ones. Purpose is implied rather than defined.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the many similar pack tools. The agent is left to infer invocation context entirely from the noun list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose read-only status, permission requirements, rate limits, or any mutation/side-effect profile; only the word 'Return' weakly implies a read 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 single sentence is front-loaded and free of fluff. It is efficient, though extremely sparse for a tool with five filter parameters and no annotation coverage.

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 values need not be explained. However, with five undocumented optional filters, no annotations, and no usage context, the definition is not complete enough to guide 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?

The schema has five optional parameters with 0% description coverage, and the description mentions none of them. It adds no meaning about status, control_id, scenario_id, buyer_view_id, or impact_domain, so the parameters remain entirely opaque.

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 severe-risk annex. It does not, however, distinguish this annex from the many sibling risk, incident, scoring, and assurance packs, so an agent cannot easily tell when this is the right artifact 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?

There is no when-to-use guidance, no exclusions, and no named alternatives. The description only says what is returned, leaving the agent to infer usage context 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?

No annotations are provided, so the description carries the full burden. It implies a read ('Return') but does not state whether the operation is read-only, what permissions are needed, whether results are cached/refreshed, or what filtering does. It adds only marketing-style framing ('acquisition-ready') rather than behavioral facts.

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 short, front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is partly under-specification rather than disciplined 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?

An output schema exists so return values needn't be explained, but with no annotations and three undocumented filter parameters at 0% coverage, the definition leaves too much to inference. It does not say how the optional filters interact or what the blueprint contains at a glance.

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?

Three filter parameters (status, layer_id, question_id) have 0% schema description coverage and are never mentioned in the description, so the agent cannot tell what values are valid or what each filter scopes. Parameter names are loosely inferable, but nothing compensates for the coverage 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?

States a specific verb ('Return') and a named resource ('agentic control plane architecture and buyer evidence map'), so an agent understands what comes back. However it offers no differentiation from the many sibling 'recipes_agentic_*' packs (assurance_pack, posture_snapshot, system_bom), leaving the reader unsure why this one is distinct.

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 of when to use this tool, when not to, or which sibling to prefer instead. The phrase 'acquisition-ready' hints at a diligence/buyer context but never says so explicitly as a usage condition.

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 disclosure burden. 'Return' implies a read, but nothing states whether this requires authorization, pagination behavior, freshness of the data, or whether results are filtered/scoped by the optional params.

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 tight sentence with the key scope ('expiring') front-loaded and zero filler. It is efficient, though brevity here reflects under-specification as much as discipline.

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-format explanation is not required, but with six undocumented filter parameters, no annotations, and no usage context, the definition is not complete enough for an agent to invoke it correctly or confidently.

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

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

All six parameters (namespace, risk_tier, access_mode, identity_id, workflow_id, entitlement_id) have 0% schema description coverage and no enums, and the description mentions none of them. The agent has no way to know what each filter accepts or means, which is a severe gap for a 6-param tool.

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

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

The description states a specific verb ('Return') and concrete resources ('expiring agent entitlement leases, access reviews, and scope evidence'), which is more than a restatement of the name. However, it does not differentiate from the many sibling 'pack' tools (e.g. agent_identity_ledger, access-review-adjacent packs), so an agent cannot tell which pack to pick without reading all 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 statement of when to use this tool, when not to, or which alternative to choose. With 50+ similarly named sibling packs, the absence of routing guidance leaves the agent to guess based on the name alone.

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

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

With no annotations, the description carries the full behavioral burden. "Risk-ranked" hints at ordering semantics, but it says nothing about how ranking is computed, whether results are bounded/paginated, what permissions are required, or how the four facets relate. For an 8-parameter analytical tool this is thin.

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

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

A single front-loaded sentence with zero filler, which is structurally clean. It earns the score on brevity, though the brevity comes partly from under-specification rather than tight editing.

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 values need not be described. However, with no annotations, 0% schema coverage across 8 parameters, and no usage context, the definition leaves an agent unable to determine what the filters do 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?

Schema description coverage is 0%, so all 8 parameters (node_id, path_id, decision, namespace, identity_id, workflow_id, minimum_score, path_class_id) are undocumented in both schema and description. Phrases like "identities" and "MCP tools" only vaguely gesture at filterable facets and explain none of the actual parameter names or value formats.

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

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

States a specific verb ("Return") and a concrete resource ("risk-ranked agentic exposure paths"), with a scope spanning context, identities, MCP tools, and evidence. It is clear on its own, but gives no signal distinguishing it from the many other agentic risk/analysis siblings such as recipes_agentic_posture_snapshot or recipes_agentic_threat_radar.

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

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

No when-to-use guidance, no prerequisites, and no named alternatives despite a sibling set dense with overlapping agentic-risk tools. The single sentence describes output only; an agent has no basis for choosing this over neighboring graph/score 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 carries the full behavioral burden. It implies a read ('Return') but says nothing about permissions, whether inputs are required, how filtering behaves, or what the evidence payload contains. It discloses the output categories but no behavioral traits.

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

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

A single front-loaded sentence with no wasted words, which is structurally clean. But at one line for a four-parameter pack tool, the brevity reads as under-specification rather than disciplined 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?

An output schema exists, so return-format explanation is not required. Still, for a tool with four undocumented optional parameters and zero annotations, the description omits everything an agent would need to invoke it correctly: usage context, filter semantics, and any behavioral expectations.

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

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

The tool has four parameters (decision, severity, workflow_id, incident_class_id) with 0% schema description coverage, and the description mentions none of them. It adds no meaning about what these optional filters do or how they narrow the returned pack, leaving every parameter undocumented in both the schema and 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?

States a specific verb ('Return') and enumerates the resource contents: incident response classes, phases, workflow matrix, and evidence. This is clearly more than a tautology and tells the agent what the pack yields. However, it offers no differentiation from the many near-identical 'recipes_agentic_*_pack' siblings, so the agent cannot tell why it should pick this pack over, say, the soc_detection_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 at all about when to use this tool, when not to, or which sibling to prefer. The description is purely a content inventory with no context-setting. An agent must infer usage purely from the tool 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about mutability, permissions, or side effects. The verb 'Return' weakly implies a read operation, but the description never confirms it, nor does it explain how the six filters interact or what happens when none are supplied.

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

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

A single well-formed sentence with no waste and no redundancy. But the brevity comes at the cost of under-specification rather than disciplined conciseness, so it earns only a middling score.

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

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

An output schema exists, so return values need not be described, but for a 6-parameter filtering tool with zero annotation and zero schema-description coverage, the definition leaves the agent unable to construct a meaningful call or predict the result set.

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?

Six parameters with 0% schema description coverage and no enum values, and the description adds no parameter meaning whatsoever. Nothing explains what status, class_id, decision, probe_id, workflow_id, or minimum_score filter on or how they combine.

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 verb ('Return') and a resource ('measurement probes') with a scope qualifier ('agentic workflow traceability and readiness'). However, 'measurement probes' is jargon that is not defined, and the description does nothing to distinguish this tool from near-neighbors like recipes_agentic_readiness_scorecard, recipes_agentic_telemetry_contract, or recipes_agentic_posture_snapshot.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of any alternative sibling in a list of ~70 related recipes tools. The agent must guess whether this is the right tool for a probe/measurement need.

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 disclosure burden, and it discloses almost nothing: not whether this is a read-only lookup or a compute/generate operation, not the cost or latency, not whether the snapshot is cached or regenerated, and not whether the optional filters are ANDed together. The word "generated" hints at computation but is never resolved.

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

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

A single front-loaded sentence with no filler or redundancy. It is compact, though its brevity reflects under-specification rather than disciplined 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?

An output schema exists, so return values need not be described, but everything else is missing: five undocumented filters at 0% coverage, no annotations, and no differentiation from a large family of near-identically named agentic posture/risk tools. As written, an agent could not confidently choose or parameterize this call.

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

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

Schema description coverage is 0% and the description mentions no parameter at all, leaving finding_id, workflow_id, minimum_score, risk_factor_id, and posture_decision entirely undefined in both places. For a five-filter tool, an agent has no way to know what values are valid (e.g., allowed posture_decision strings) or whether filters combine.

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 verb and resource ("Return the ... enterprise posture snapshot") and scopes it to agentic AI and MCP operations, so it is not a tautology. But "posture snapshot" is unexplained jargon, and against ~65 sibling recipes_* tools it gives no basis for distinguishing this artifact from recipes_agentic_readiness_scorecard, recipes_agentic_assurance_pack, or recipes_agentic_risk_* 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 statement of when to call this tool, what preconditions exist (e.g., whether a snapshot must be generated first, given the sibling recipes_refresh), or which alternative artifacts to use instead. The only usage signal is the phrase "generated ... snapshot," which implies prior generation but never says so.

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. "Return" implies a read, but the description never states permissions, whether anything is mutated, rate limits, or what the evidence output 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 front-loaded sentence with no filler sentences. It loses a point only because the jargon-dense phrasing ("buyer-ready drift controls") adds words without adding meaning.

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

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

An output schema exists, so return-value explanation is not required, but with four undocumented parameters and no annotations, the description is far too thin for an agent to invoke this correctly or route to it over its many 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 four parameters (check_id, decision, source_id, protocol_id), and the description mentions none of them. The description provides no compensating meaning for what these identifiers select or how they interact.

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 verb ("Return") and a resource ("MCP/A2A protocol conformance evidence"), which is more than a tautology, but "buyer-ready drift controls" is marketing jargon rather than a concrete deliverable. It gives no basis to distinguish it from close siblings like recipes_mcp_authorization_conformance_pack or recipes_mcp_tool_surface_drift_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 when-to-use guidance, no prerequisites, and no mention of alternatives among the ~60 sibling "pack" tools. The agent is left to infer selection from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the return vocabulary. It does not state whether the operation is read-only or generative, whether a missing workflow_id yields all workflows or an error, whether minimum_score filters results, or what the scorecard 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 front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is closer to under-specification than to disciplined concision.

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 values needn't be described, but that is the only thing excused. With zero annotation coverage, 0% parameter documentation, and no workflow/prerequisite context, the definition leaves an agent unable to invoke this 3-parameter tool confidently.

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

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

Schema description coverage is 0% for three parameters. The words "scale, pilot, gate, or block" loosely map to the `decision` filter and "minimum_score" is plausibly the threshold referenced by those labels, but `workflow_id` is never explained and no type/format/allowed values are given. The description adds only marginal meaning over 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?

"Return generated scale, pilot, gate, or block decisions for agentic workflows" names a verb (return), a resource (decisions/scorecard), and enumerates the decision values. However, it never clarifies whether the tool computes these decisions or merely retrieves stored ones, and against ~70 sibling "recipes_*" packs (posture_snapshot, quality_report, assurance_pack) an agent cannot tell when this one applies.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance. The description gives a bare capability statement with no indication of the precondition for calling it (e.g., does a workflow_id need to exist first, is this the entry point or a follow-up read?).

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

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

No annotations are provided, so the description carries the full burden. 'Return' weakly implies a read operation, but the description does not disclose whether drills are generated or fetched, whether results are deterministic, how large the output is, or any auth/scoping constraints. For a tool with zero annotation coverage this is a significant gap.

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

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

A single efficient sentence with the verb and resource front-loaded and no filler. It is well-sized, though its brevity is partly under-specification rather than disciplined trimming.

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 values need not be explained. However, with no annotations, no parameter documentation, and an ambiguous relationship to a very close sibling (red_team_replay_harness), the description is too thin for an agent to select and invoke this tool confidently.

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

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

Three parameters (scenario_id, workflow_id, attack_family) have 0% schema description coverage and no elaboration in the description. The words 'remediation workflows' and 'adversarial drills' only loosely gesture at workflow_id and attack_family, leaving scenario_id and the relationship between the three filters unexplained.

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

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

States a specific verb ('Return') and resource ('adversarial drills') with a domain scoping ('agentic remediation workflows and MCP controls'). It is clear what the tool produces, but it does not differentiate itself from the near-identical sibling recipes_agentic_red_team_replay_harness or the other red-team-adjacent packs like recipes_agentic_threat_radar.

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

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

There is no when-to-use guidance, no condition that selects this tool over the replay harness or threat radar siblings, and no stated prerequisites. The agent must infer usage entirely from the tool name and the crowded sibling list.

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

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

No annotations exist, so the description carries the full behavioral burden. 'Return' implies a read operation, but it says nothing about whether results are static fixtures or generated, whether filtering combines across the five optional parameters, or whether authentication or drill state is required to get meaningful output.

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 compact sentence with the returned artifacts front-loaded and no filler. It is efficiently structured, though its brevity is achieved partly by omitting necessary detail rather than by disciplined editing.

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 description is not required, but the tool has five undocumented filter parameters, zero annotations, and no usage context. For a five-parameter retrieval harness, the definition leaves the agent without enough to invoke it correctly or interpret what the filters do.

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?

Five parameters (severity, replay_id, scenario_id, workflow_id, attack_family) all have 0% schema description coverage, no enums, and nullable defaults, yet the description mentions none of them or how they filter the returned fixtures. This is the same failure mode as the LOW calibration case and leaves every parameter's meaning to guesswork.

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 three concrete artifacts (replay fixtures, expected decisions, evidence gates) scoped to red-team drills, which an agent can distinguish from the similarly named recipes_agentic_red_team_drill_pack. It is clear but stops short of explicitly differentiating itself from that 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?

There is no when-to-use, when-not-to-use, or prerequisite guidance. The obvious alternative, recipes_agentic_red_team_drill_pack, is never mentioned, so an agent has no basis for choosing between them.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It clarifies only that templates are returned rather than persisted receipts, but says nothing about read-only vs. mutating behavior, side effects, auth/permission requirements, or idempotency. For a tool with zero annotation coverage this is a significant gap.

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

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

A single front-loaded sentence with no filler; the category list earns its place by scoping the returned templates. It is efficient, though the terseness comes at the cost of omitting any operational 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 return values need not be explained, but the definition still leaves the agent without usage context, parameter meaning, or behavioral profile for a three-parameter tool. Given zero annotations and zero schema description coverage, the description is too thin to support confident 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% across three parameters (receipt_id, workflow_id, minimum_score), and the description does not mention any of them or explain filtering/scoring semantics. The enumerated categories (identity, context, tools, etc.) describe output content, not the input parameters, so the description fails to compensate for the coverage 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?

States a specific verb ('Return') and resource ('agent run receipt templates') and enumerates the receipt categories covered (identity, context, tools, egress, approval, evidence). It is clearly distinct from a generic template tool, though it does not explicitly differentiate itself from the closely related sibling recipes_agentic_approval_receipt_pack despite both touching 'approval' receipts.

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

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

No guidance on when to invoke this tool versus alternatives, nor any preconditions or context for its use. The agent must infer from the name alone that this is a template/artifact generator for agent run receipts.

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-style generation of detections, but discloses nothing about filtering behavior, whether output is deterministic, size, or any auth/rate constraints. Only marginal value beyond the name.

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

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

A single front-loaded sentence with zero filler. It is efficient, though arguably too terse for a tool with five undocumented parameters and a large sibling surface.

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-format explanation is not required. However, with five undocumented params, no annotations, and no usage guidance, the description is not sufficient for an agent to invoke this 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?

Five parameters (rule_id, decision, severity, event_class, workflow_id) with 0% schema coverage and no descriptions. The description never explains what these control or whether they filter the returned detections, so the schema-side gap is left uncompensated.

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+resource: "Return SIEM-ready detections for agentic AI and MCP telemetry." An agent can tell this is a detection-content pack, distinct from siblings like threat_radar or telemetry_contract. It stops short of explicitly naming or contrasting a sibling, so it earns 4 rather than 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?

There is no when-to-use, when-not-to-use, or alternative routing guidance. Against a dense pack of ~70 sibling "recipes_*" tools (incident_response_pack, threat_radar, telemetry_contract), the agent gets no signal for choosing this one.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the implied read: no permissions or auth requirements, no statement of whether freshness/drift records are persisted or merely computed, no rate or scope limits. "Return ... evidence" hints at a read operation but that is inference, not disclosure.

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

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

A single front-loaded sentence with no filler, which is structurally fine. But given seven optional parameters and no output guidance, the brevity reads as under-specification rather than economy.

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 values need not be described. Still, with seven undocumented parameters, zero annotations, and no usage routing, the definition leaves an agent without enough information to invoke the tool correctly or predict its behavior.

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

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

Schema description coverage is 0% across seven parameters (decision, source_id, freshness_class, publisher_family, watched_source_id, source_class_family, primary_watchlist_id), and the description explains none of them. The phrase "source-freshness" weakly gestures at freshness_class/source_id but gives no meaning, format, or filtering semantics for the remaining parameters.

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

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

The description names a verb ("Return") and a resource ("source-freshness and standards-drift evidence") scoped to SecurityRecipes, so the general purpose is discernible. However, it never distinguishes this watch from near-identical siblings such as recipes_agentic_standards_crosswalk, recipes_agentic_threat_radar, or recipes_mcp_tool_surface_drift_pack, and "evidence" 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 statement of when to use this tool, when not to, or which sibling it replaces. An agent has no basis for choosing it over the many other agentic evidence/assessment tools in the same family.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only retrieval ('Return'), but says nothing about whether the five filter parameters are combined with AND or OR, what happens when none are supplied (does it return everything?), pagination, or result size — all material for a catalog-style lookup 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?

A single front-loaded sentence with no filler, and the resource is stated before the qualifier. It is efficient, though its brevity reflects under-specification that is penalized in other dimensions rather than verbosity problems here.

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

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

An output schema exists, so return-format explanation is correctly omitted. However, with no annotations, no schema descriptions, and five undocumented filter parameters, the definition leaves the agent without enough information to invoke the tool correctly or predict its filtering behavior.

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

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

Schema description coverage is 0% for five optional parameters (status, source_id, control_id, standard_id, capability_id), and the description mentions none of them. The parameter names are somewhat self-explanatory, but there is no indication of accepted values or filter interaction, so the description does not compensate for the coverage 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?

States a concrete verb ('Return') and a specific resource ('standards-to-evidence mappings') scoped to three named domains (agentic AI, MCP, prompt-injection guidance). The purpose is clear on its own, but nothing distinguishes it from the many similarly named agentic/secure-context sibling packs (e.g. recipes_agentic_control_plane_blueprint, recipes_secure_context_evidence_contract).

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

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

There is no guidance on when to call this tool versus its many siblings, no prerequisites, and no stated alternative for the reverse lookup (evidence-to-standards). The agent must infer usage entirely from the name and description.

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

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

No annotations are provided, so the description carries the full behavioral burden. "Return" weakly implies a read-only operation, but the description says nothing about permissions, scoping behavior, whether filters are conjunctive, or what happens when no filters are supplied — all undefined given four optional parameters.

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

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

A single front-loaded sentence with no filler. It is efficient, though terse enough that it could have spent a few more words on filtering and sibling differentiation at little cost.

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 values need not be described, but the description still omits critical context: no annotations covering safety/mutation semantics, no explanation of the four undocumented filter parameters, and no differentiation from the many related agentic-* tools.

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

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

Schema description coverage is 0% and none of the four parameters (namespace, agent_class, workflow_id, component_type) are explained in the description. The listed entity types loosely hint at filter dimensions, but there is no indication of how each parameter narrows the BOM or how they combine.

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 ("Return") and resource ("Agentic System BOM") and enumerates the covered entity types (workflows, agents, identities, MCP tools, evidence), which gives the agent a concrete picture of scope. However, it never differentiates itself from closely-named siblings like recipes_agentic_exposure_graph or recipes_agentic_posture_snapshot, and "BOM" remains domain jargon.

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

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

There is no when-to-use guidance, no stated preconditions, and no mention of alternative tools despite a large set of overlapping agentic-* siblings. The agent must infer usage purely from the name and description.

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

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

No annotations are provided, so the description must carry the full behavioral burden. 'Return' implies a read, but it says nothing about auth/permission requirements, whether filters change the returned contract, rate 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?

A single, front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is achieved partly by omitting information the tool 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?

An output schema exists, so return values need not be explained, but the definition still leaves five undocumented filter parameters, no usage context, and no behavioral disclosure for a domain-heavy contract tool with many near-identical 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?

All five parameters (check_id, decision, workflow_id, signal_class_id, required_attribute) have 0% schema description coverage and zero documentation. The description adds no meaning for any of them, leaving the agent unable to know what a valid value or the effect of each filter is.

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 a named resource ('OpenTelemetry-aligned agentic telemetry and redaction contract'), which is more than a tautology. It does not, however, distinguish itself from the many sibling '*_contract' and '*_pack' tools, so an agent still has to infer which contract to pick.

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 of when to call this tool, when not to, or which sibling alternatives exist. The description is purely declarative about what is returned and offers no routing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the return payload. It does not say whether the call is read-only, how 'current' freshness is determined, whether results are cached, paginated, or how scores/priorities are ranked.

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

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

A single front-loaded sentence with zero filler; the core action and resource appear immediately. It is efficient, though its brevity reflects under-specification rather than disciplined trimming.

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 explanation is not required, but a five-parameter filter tool with zero parameter documentation and no annotations needs far more than one sentence. The agent lacks the information needed to call it correctly or to route to the right sibling.

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 five parameters (horizon, priority, signal_id, capability_id, minimum_score), so the description must compensate and largely does not. 'Threat signals' and 'product priorities' hint weakly at signal_id and priority, but the accepted formats for horizon, capability_id, and minimum_score are entirely undocumented anywhere.

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 ('source-backed agentic AI threat signals and product priorities'), which is more informative than a bare name restatement. However, it does not differentiate itself from the many closely-named siblings such as recipes_agentic_exposure_graph, recipes_agentic_posture_snapshot, or recipes_agentic_source_freshness_watch, so an agent cannot tell from the text alone which of these to pick.

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 of when to use this tool, when not to, or which sibling to prefer for adjacent needs (e.g. freshness monitoring vs. risk registers). The agent is left to infer usage purely from the tool 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?

No annotations are provided, so the description carries the full behavioral burden. It does not state that this is a read-only lookup, what the ledger returns, whether results are scoped per-tenant, or how the optional filters interact - none of the context a caller needs is disclosed.

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?

It is a single short sentence with no waste, but it is under-specified rather than concise - the brevity comes from omitting essential information, not from tight writing. Nothing is front-loaded beyond a bare domain list.

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

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

An output schema exists, so return-value detail is not strictly required. But for a 3-parameter tool with 0% schema coverage and no annotations, the description should at minimum explain the filters and the read-only nature of the call; neither is present, leaving the definition inadequate.

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 nothing about agent_class, identity_id, or workflow_id. The word 'identity' loosely gestures at identity_id, but there is no explanation of what values these filters accept, whether they combine, or what omitting them 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 has a verb ('Return') and names the domains covered (non-human identity, delegation, scope, audit contracts), which loosely distinguishes it from siblings like recipes_agent_capability_risk_register. However, 'contracts' is undefined and it never says what form the ledger takes or what 'return' produces, so an agent cannot confidently tell its exact scope from the sibling cluster.

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 of when to use this tool, when not to, or which sibling to prefer for adjacent questions (e.g. delegation vs. handoff boundary or capability risk). The domain nouns imply a topical fit at best; no explicit routing guidance is given.

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

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

With no annotations provided, the description carries the full behavioral burden and mostly fails. 'Return' implies a read, but nothing states whether the four optional inputs act as filters, whether results are scoped by them, or what happens when they 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?

A single front-loaded sentence with no filler. It is efficient, though it could spend a few more words mapping the four inputs to behavior without becoming bloated.

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

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

An output schema exists, so return values need not be described, but the invocation side is unaddressed: four optional, nullable parameters with 0% coverage and no annotations leave the agent guessing how to call it meaningfully.

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

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

Schema description coverage is 0% and the description never explains the four parameters (decision, persistent, workflow_id, memory_class_id). The listed return concepts loosely echo two of them, but there is no mapping and no indication of whether these are filters, selectors, or overrides.

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 (Return) and a concrete resource (agent memory classes, workflow profiles, TTLs, persistence decisions). The purpose is legible, but it does nothing to distinguish itself from the surrounding boundary-pack siblings, so an agent cannot tell why it would pick this over recipes_agent_handoff_boundary_pack without opening the schema.

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

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

There is no when-to-use guidance, no prerequisites, and no naming of alternatives among the ~60 sibling tools. The agent is left to infer context entirely from the title and resource list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read ('Return'), but says nothing about permissions required, whether filtering is scoped, rate limits, or what 'decisions' contain. For a supply-chain/security tool with a rich risk surface, this is a substantial gap.

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

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

A single, front-loaded sentence with no filler. It is efficient, though efficiency here partly reflects under-specification rather than disciplined editing.

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 explanation is not required. But with zero annotations, 0% parameter coverage on five params, and no usage context, the definition is not complete enough for an agent to call it confidently among so many similar peers.

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?

Five parameters (decision, platform, skill_id, risk_tier, minimum_score) with 0% schema description coverage, and the description mentions none of them. It does not explain what values decision/risk_tier/platform accept or how minimum_score filters results, leaving every parameter undocumented in both schema and prose.

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

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

The description states a verb and a resource domain ('Return agent skill provenance, permission, isolation, and supply-chain decisions'), so the general purpose is inferable. However, 'decisions' is vague about what is actually returned, and nothing distinguishes it from close siblings like recipes_agent_trust_fabric_pack or recipes_mcp_connector_trust_pack. Adequate but not sibling-differentiating.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternative. With 60+ sibling 'pack' tools in this family, an agent gets no help deciding when this one applies versus the trust-fabric or connector-trust packs.

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' implies a read operation, but there is no explicit read-only statement, no information about authentication, pagination, filtering behavior, or the effect of omitting parameters.

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 front-loaded with the verb and contains no filler, which is efficient. It is slightly too sparse for a tool with four parameters and no annotations, but it avoids unnecessary repetition.

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

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

An output schema exists, so return shape need not be described. However, with no annotations, 0% schema description coverage, and four parameters, the description is not complete enough to guide an agent on filtering or invocation beyond a minimal notion of the returned content.

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

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

Schema description coverage is 0% and there are four optional parameters. The description mentions 'dimensions' and 'workflow tiers', which loosely correspond to dimension_id and trust_tier, but it does not explain what status, trust_tier, workflow_id, or dimension_id actually filter or control.

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 the resource contents: Agent Trust Fabric dimensions, workflow tiers, source evidence, and buyer proof. However, it does not distinguish this tool from the many sibling recipes_* pack tools, several of which also return trust or assurance 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?

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no explanation of how the optional filters should be applied. The description only states what is returned.

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. "Return" implies a read-only retrieval, but nothing confirms read-only semantics, whether the optional filters narrow or widen the result set, whether results are paginated, or how large a response 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?

A single front-loaded sentence with no filler or repetition; the resource enumeration is efficient. It is terse to the point of under-specification, but that is a completeness problem rather than verbosity.

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 values need not be explained. However, with no annotations, 0% parameter coverage, and no usage routing against a dense sibling set of boundary packs, the description leaves an agent without enough to select or correctly filter 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% across four optional filter parameters (decision, risk_tier, task_profile_id, workspace_class_id), and the description mentions none of them. The parameter names are reasonably self-describing, but with zero coverage the description should have compensated and does not.

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

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

States a specific verb ("Return") plus a concrete resource set (workspace classes, task profiles, controls, evidence) that identifies it as a read/retrieval tool distinct from sibling packs like recipes_agent_handoff_boundary_pack. It never explains what the pack is for or why a browser-agent boundary differs from the other boundary packs, so sibling differentiation rests on the name alone.

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

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

There is no when-to-use guidance, no when-not-to-use, and no named alternative among the ~20 sibling boundary/agentic packs. An agent cannot tell from the description which situation calls for this pack versus recipes_agent_handoff_boundary_pack or recipes_context_egress_boundary_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. 'Return' weakly implies a read-only lookup, but the description discloses nothing about permissions, scoping, whether the four optional filters are ANDed, or behavior when no filters are supplied. For a tool with zero annotation coverage this is thin, though the existing output schema covers the return shape.

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

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

A single front-loaded sentence with no filler and no redundancy. It is appropriately sized, though brevity here is partly a symptom of under-specification rather than disciplined editing.

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 values needn't be described, but with four undocumented optional parameters and no annotations, the definition leaves the agent without enough to invoke the tool confidently or know what distinguishes it from sibling boundary 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% across four parameters, so the description must compensate and does not. It loosely echoes 'data classes' and 'destination classes' which hint at data_class/destination_class, but source_id and workflow_id are never explained, nor is the meaning of combining 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?

States a specific verb ('Return') and enumerates the artifacts returned (context egress data classes, destination classes, workflow boundary policy), which is clear enough for an agent to know what comes back. However, it does not distinguish this tool from boundary-themed siblings like recipes_agent_handoff_boundary_pack or recipes_agent_memory_boundary_pack, so the agent must guess which boundary pack applies.

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

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

There is no when-to-use guidance, no conditions that select this tool over the many sibling '*_boundary_pack' tools, and no prerequisites stated. The agent gets a description of contents but no trigger for calling it.

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

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

With no annotations at all, the description carries the full burden and does not meet it: it never states that this is a non-mutating read, whether results are paginated or capped, what a 'decision' outcome means, or what happens when no sources are registered. Only the word 'Return' hints at read-only behavior, which is a weak inference rather than a disclosure.

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

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

A single efficient sentence with the resource front-loaded and no filler. It is appropriately sized, though its brevity comes at the cost of the missing detail noted 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?

An output schema exists, so return values need not be described, but the query surface is not covered: six optional parameters with implicit defaults and no documented filter/limit behavior leaves the agent unable to construct a correct invocation. For a parameterized findings tool with zero annotations and zero schema coverage, this is under-specified.

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

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

Six parameters with 0% schema description coverage, and the description explains none of them. The critical filters (rule_id, decision, severity, source_id, actionable_only) and the limit default are left entirely unspecified, so the agent cannot know valid values or filtering semantics — exactly the compensation gap the description should fill.

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 clear verb ('Return') and a specific resource ('context-poisoning scan results for registered secure-context sources'), so the agent knows it is a read of scan findings scoped to secure-context sources. However, it does not distinguish itself from the many adjacent siblings (e.g. recipes_secure_context_trust_pack, recipes_secure_context_eval_pack, recipes_agentic_source_freshness_watch), leaving the agent to guess among overlapping '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 on when to use this versus any alternative, no prerequisites (what counts as a 'registered' source), and no exclusions. The agent must infer the usage context entirely from the name and the phrase 'registered secure-context sources'.

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, and it discloses essentially nothing: not whether the tool reads a pre-generated artifact or computes one, not whether it has side effects, auth requirements, or how the parameter filters affect the result. The only minor credit is the word 'generated,' hinting the profile is a pre-existing artifact.

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?

It is a single front-loaded sentence with no wasted words, which is structurally clean. But the brevity reflects under-specification rather than disciplined concision for a tool with five inputs and a rich sibling surface.

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 values need not be described. Still, for a 5-parameter tool with no annotations and no usage guidance, the description leaves the agent unable to determine what inputs do or when to call it, which is a substantial completeness 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?

All five parameters (decision, sector_id, control_id, buyer_view_id, readiness_status) have 0% schema description coverage and the description adds no meaning about them whatsoever. It does not say whether they are filters, whether supplying them narrows or selects the profile, or whether they are required for meaningful output. With five undocumented params the description must compensate and does not.

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

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

The description names a specific verb ('Return') and a specific resource ('critical-infrastructure secure-context profile'), so the basic purpose is parseable. However, it offers no differentiation from the ~70 sibling 'recipes_*_pack' tools, and 'generated' begs the question of what generates it. It is adequate but thin.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance anywhere in the description. Given the dense sibling list (e.g. recipes_secure_context_trust_pack, recipes_secure_context_evidence_contract), an agent has no signal for choosing this tool over neighbors.

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 does disclose that the returned scope is limited to Medium/High/Critical severities and includes provenance. However, it says nothing about permissions, freshness guarantees, or response size/caching for what is evidently a static metadata endpoint; the low inherent risk of a zero-arg read keeps this from being worse.

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 naming the verb, resource, and returned fields with zero filler. Nothing is padded and nothing unrelated is included.

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 values need not be explained, and the description still previews the four content areas (scope, coverage, provenance, counts). For a simple zero-param info tool the definition is essentially complete, missing only an explicit pointer to the sibling CVE tools.

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

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

The tool takes zero parameters, so per the baseline there is nothing for the description to disambiguate. The severity-scoping language adds context about the implicit filter the catalog applies, which is a small bonus over an empty schema.

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

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

States a specific verb ('Return') plus the resource ('CVE catalog') and enumerates exactly what the payload contains: scope, coverage, provenance, and counts. The severity framing (Medium/High/Critical) further narrows the scope, making it distinguishable from recipes_cve_get and recipes_cve_search, though it never names 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?

Usage is implied rather than stated: 'catalog info' reads as a metadata/about call to be used alongside the per-CVE get and search tools, but the description gives no explicit when-to-use, when-not-to-use, or alternative tool names. An agent can infer the role but is not guided.

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

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

With no annotations, the description carries the disclosure burden itself. It usefully characterizes the output as 'bounded' evidence plus a change plan, hinting at scope limits, but says nothing about read-only behavior, data freshness/source, auth needs, or rate limits. The 'Get' verb implies a safe read, but this is inference rather than stated behavior.

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

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

A single dense sentence with no filler. The required scope qualifier ('one exact CVE') and the payoff (change plan) are both front-loaded, so an agent can triage the tool at a glance.

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 values need not be re-explained, and the description still summarizes the payload. For a one-parameter read tool the coverage is nearly sufficient; the only meaningful gap is routing guidance against the other CVE-related siblings.

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

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

Schema description coverage is 0% for the single 'cve' parameter. The description compensates partially by signaling that the value must be one exact CVE identifier (not a range or keyword), which adds real meaning over the bare schema, but it does not specify accepted formats such as CVE-YYYY-NNNN.

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 ('Get') and a tightly scoped resource ('one exact CVE'), then enumerates what is produced: evidence, recipe authority, and a bounded change plan. The word 'one exact' implicitly separates it from a multi-result sibling like recipes_cve_search, though no sibling is named explicitly.

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

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

Usage is only implied. 'One exact CVE' suggests this is a single-item lookup rather than a search, but the description never states when to prefer it over recipes_cve_search, recipes_cve_catalog_info, or recipes_match_finding, nor does it give 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 behavioral burden. It implies a read-only search but says nothing about pagination, result caps (the limit default of 20 contradicts 'search every'), rate limits, or what an empty/partial result means. For a 5-param tool with zero annotation coverage this is thin.

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

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

A single efficient sentence with the core capability front-loaded and the alternative appended. Nothing is padded, though the brevity is partly achieved by omitting needed detail rather than by pruning.

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 explanation is rightly omitted, but the definition leaves four of five filters unexplained, provides no annotation substitutes, and its 'every CVE' claim sits awkwardly against a default limit of 20. It is not complete enough for an agent to invoke the filters correctly.

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

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

Schema description coverage is 0%, so the description must explain the parameters and largely does not. 'Medium/High/Critical' loosely gestures at the severity filter, but query syntax, kev_only, limit, and published_year are completely undocumented anywhere.

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 (Search) and resource (CVE) with a scope qualifier (in-scope Medium/High/Critical). It also names the sibling recipes_cve_get and positions itself as the summary view, which lets an agent distinguish it from that tool without opening a schema.

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 routes the agent to recipes_cve_get when full details are needed, which is a genuine alternative hint. However, it never states when to use this search versus recipes_cve_catalog_info, nor any preconditions or exclusions, so usage is only partially implied.

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

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

No annotations are provided, so the description carries the full behavioral burden. "Return" weakly implies a read-only fetch, but the description discloses nothing about permissions, whether the result is static or computed, or how the returned motion relates to the filter parameters. For a tool with zero annotation coverage this is a meaningful gap.

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

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

It is a single front-loaded sentence with no filler, which is structurally clean. But the brevity is achieved by omission rather than precision — the sentence is too thin to orient an agent calling a 7-parameter tool.

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

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

An output schema exists so return values needn't be spelled out, but with 7 undocumented parameters, no annotations, and no usage context, the description leaves the agent without enough to invoke the tool correctly. It fails to carry the burden the structured fields don't cover.

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?

Seven optional parameters (status, risk_id, phase_id, wedge_id, metric_id, segment_id, question_id) exist at 0% schema description coverage, and the description explains none of them. The agent cannot tell whether these are filters, selectors, or scoping identifiers, nor what values are valid.

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 verb ("Return") and a resource ("design partner pilot motion"), so the general shape is clear. However, "pilot motion" is abstract jargon that doesn't tell an agent what data actually comes back, and nothing distinguishes this pack from near-identical siblings like recipes_secure_context_customer_proof_pack or recipes_hosted_mcp_readiness_pack, both of which also touch buyer proof and hosted MCP validation.

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 guidance, no when-not-to-use, and no named alternative among the many sibling packs. An agent has no basis for choosing this tool over the dozens of other recipes_* packs beyond guessing from the title.

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. 'Return' implies a read, but nothing explains whether the export is pre-bundled server-side, how the optional filters interact, whether results are truncated, or what permissions are needed. The word 'bundled' hints at aggregation but is not elaborated.

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

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

A single front-loaded sentence with no filler. It is appropriately short, though that brevity is partly the result of under-specification rather than disciplined editing.

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 values need not be re-explained. But with five undocumented parameters, no annotations, and no usage routing against a dense field of sibling trust/diligence tools, the definition leaves too much for the agent to infer before calling.

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?

Five optional parameters (status, pack_id, category, section_id, question_id) have 0% schema description coverage, and the description adds no meaning about any of them. It never explains the filter hierarchy or whether the parameters narrow the bundle or select a sub-section, leaving five undocumented knobs.

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 ('Return') and resource ('bundled enterprise trust-center export') with a stated audience ('buyer and platform diligence'). However, it does not distinguish itself from nearby siblings such as recipes_secure_context_buyer_diligence_brief or 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 explicit when-to-use guidance, no prerequisites, and no named alternative. The phrase 'for buyer and platform diligence' implies a context but does not tell the agent when this tool should be selected over the many adjacent 'pack' and 'diligence' siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only implies a read operation and that a full record is returned; it does not disclose permissions, rate limits, error behavior, or what happens if the identifier is not found.

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

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

A single front-loaded sentence with no wasted words. The core action and lookup key are presented immediately.

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

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

For a simple single-parameter read tool with an output schema, the description is minimally adequate. It omits routing guidance against the many sibling list/search/get tools and does not clarify identifier format, which leaves meaningful gaps for an agent selecting among dozens of recipes_* tools.

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

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

Schema description coverage is 0% for the single required parameter. The description says 'slug or path', which largely repeats the parameter name slug_or_path and adds no format examples, validation rules, or path syntax to compensate for the schema gap.

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

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

The description names a specific verb (Get) and resource (full recipe record) and specifies the lookup key (slug or path). It implicitly distinguishes direct lookup from list/search siblings, but does not explicitly differentiate itself from recipes_list or recipes_search.

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 'by slug or path' implies the tool is used when an identifier is known, which is useful usage context. However, it gives no explicit when-to-use guidance against alternatives like recipes_list or recipes_search, nor any exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Return' implies a read, but it doesn't disclose whether this computes/generates a plan versus retrieving a stored one, what auth or tenant scope is needed, or what happens with the six optional ID filters. This is a significant gap 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?

A single front-loaded sentence with no padding, which is structurally clean. But it is under-specified rather than genuinely concise — the brevity comes at the cost of all usage and parameter context.

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

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

An output schema exists, so return-value explanation is not required. But with six undocumented optional parameters, no annotations, and no usage guidance, the definition leaves an agent unable to invoke this correctly against its many similar 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?

Six optional parameters (status, gate_id, risk_id, stage_id, control_id, buyer_evidence_id) with 0% schema description coverage and zero mention in the description. An agent cannot tell whether these filter, scope, or select the returned plan, nor what entity each ID refers to.

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 the hosted MCP readiness plan'), which is clearer than a tautology. However, the crowded sibling set contains many near-identical readiness/risk/trust pack tools (e.g. recipes_agentic_readiness_scorecard, recipes_mcp_risk_coverage_pack), and nothing here distinguishes this one from them or clarifies what 'hosted MCP readiness' actually covers.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives among the dozens of sibling packs. The phrase 'for enterprise product rollout' is a context hint but not an actionable usage rule.

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, yet it says nothing about pagination or how 'limit' defaults, result ordering, or whether filtering is conjunctive. It also doesn't disclose auth or rate-limit characteristics. Given zero annotation coverage for a 7-parameter listing tool, this is a thin disclosure.

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

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

A single front-loaded sentence with no filler, which is structurally clean. It is arguably underspecified rather than wasteful, so the terse form costs a little clarity without bloating.

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 7-parameter, zero-required, zero-coverage listing tool with no annotations, the description omits nearly everything an agent needs to call it correctly. The presence of an output schema means return values needn't be described, but filter semantics, limit behavior, and sibling routing are all 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%, so all seven parameters (tags, agent, limit, facets, section, severity, min_quality) are undocumented anywhere. The phrase 'metadata filtering' gestures at the filter family but gives no semantics for any individual parameter or how they combine.

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 ('List recipes') plus a scope qualifier ('optional metadata filtering'), so the basic operation is clear. However, it does nothing to distinguish itself from siblings like recipes_search or recipes_get, which a listing tool must do since an agent choosing between them has no signal here.

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

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

No guidance on when to use this versus recipes_search (query-based retrieval) or recipes_get (single-item lookup). There are also no prerequisites or exclusions, so the agent must infer the routing 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?

No annotations provided, so the description carries the full burden. It hints at read-only/non-deterministic behavior via 'heuristic matcher' and 'suggests', but omits auth requirements, rate limits, side effects, or output characteristics.

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

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

One concise sentence, front-loaded with the tool's action. No wasted words, though it could include more specific guidance without becoming verbose.

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

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

Tool has 8 parameters, 0 required, 0% schema coverage, no annotations, and a complex heuristic matching purpose. Output schema exists, so return values needn't be described, but the description omits all input semantics and usage 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% across 8 optional parameters (cve, package, rule_id, keywords, ecosystem, facets, min_quality, limit), and the description mentions none of them. It adds no meaning beyond parameter names.

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

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

The description states a specific matching action ('suggests best-fit recipes') and target ('security finding'), so an agent can tell it is a matcher. However, it does not differentiate from sibling tools like recipes_cve_search or recipes_playbook_plan, and 'security finding' is 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?

No when-to-use guidance, no alternatives, no prerequisites. The description does not say when to choose this over recipes_cve_* or recipes_search.

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 safe read ('Return ... evidence') but never states read-only semantics, required authorization/scopes, whether the call reaches upstream connectors, or any rate/limit behavior. Only a bare output summary is given.

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?

It is a single front-loaded sentence with no filler, so it is efficient. It is arguably under-specified rather than concise, but it wastes no words.

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

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

An output schema exists, so return format need not be explained. But with zero annotation coverage, four entirely undocumented parameters, and no sibling differentiation, the definition is too thin for an agent to invoke the tool correctly or know when it 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?

All four parameters (decision, namespace, workflow_id, connector_id) are undocumented in the schema (0% coverage), and the description mentions none of them. An agent cannot infer what these optional filters do or how to scope the call, so the description fails to compensate for the coverage 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 names a specific verb ('Return') and a fairly specific resource ('MCP authorization conformance, scope-drift, and token-boundary evidence'), so an agent understands the artifact produced. However, it does not differentiate itself from adjacent sibling packs such as recipes_agentic_protocol_conformance_pack or recipes_mcp_tool_surface_drift_pack, which overlap in the conformance/evidence space.

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 invoke this pack versus the many other conformance/drift/risk packs, and no stated preconditions or exclusions. The single sentence is purely descriptive of output, leaving usage entirely to inference.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it says nothing about whether the tool is read-only, whether it mutates state, what auth it requires, or what triggers it. "Return" weakly implies a read, but that is inference, not disclosure.

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

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

A single front-loaded sentence with no padding, so it is structurally clean. But its brevity reflects under-specification rather than disciplined conciseness, so it earns only the minimum-viable score.

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

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

The presence of an output schema relieves the description of explaining return values, but with zero annotations, 0% parameter coverage, and three ambiguous optional parameters, the description leaves far too much unresolved for an agent to invoke this tool confidently.

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

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

Schema description coverage is 0% across three parameters (decision, namespace, candidate_id), and the description never references any of them. An agent cannot tell whether these are filters, selectors, or write targets, so the description fails to compensate for the documentation 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 names a verb ("Return") and enumerates the artifact types produced (decisions, risk findings, gaps, promotion plans), which is more specific than a tautology. However, it does not distinguish this tool from the many near-identical siblings such as recipes_mcp_connector_trust_pack, recipes_mcp_risk_coverage_pack, or recipes_agentic_app_intake_pack, and "intake pack" remains jargon an agent cannot map to a distinct operation.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. With a sibling list containing several overlapping MCP connector packs, the absence of routing guidance is a real gap rather than a minor omission.

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. 'Return' weakly implies a read-only report, but there is no disclosure of permissions, rate limits, side effects, or what scope the returned trust data covers.

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

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

The definition is a single front-loaded sentence with no filler. It is appropriately terse, though its brevity contributes to under-specification rather than being a structural flaw in itself.

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 is present, so return values need not be explained. However, with three undocumented input parameters, no annotations, and no usage guidance, the description is not complete enough for an agent to know how to scope or 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?

All three parameters (namespace, workflow_id, connector_id) have 0% schema description coverage, and the description does not explain what any of them filter or control. The phrase 'workflow namespace coverage' is output-oriented and does not compensate for the missing parameter semantics.

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

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

The description states a verb (Return) and a resource (MCP connector trust tiers, controls, evidence, workflow namespace coverage), but the purpose remains vague because the listed concepts are broad jargon and the tool is not differentiated from similar sibling trust packs such as recipes_mcp_connector_intake_pack or recipes_mcp_risk_coverage_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 description offers no when-to-use guidance, no prerequisites, and no alternatives among the many sibling trust/connector tools. An agent must infer usage entirely from the tool name and one-sentence summary.

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-style retrieval ('Return ... evidence') but never confirms it is read-only, does not describe permission requirements, filtering behavior, or whether results are deterministic versus environment-dependent.

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 tight sentence with the verb leading and no filler. It is appropriately sized, though its brevity reflects under-specification rather than disciplined editing.

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 values need not be explained. But with no annotations, 5 undocumented optional parameters, and no indication of what 'evidence' comprises or how inputs scope it, the description leaves the agent without enough to invoke the tool confidently.

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

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

Schema description coverage is 0% across 5 parameters. The description only loosely gestures at the 'mode' parameter via 'form-mode and URL-mode'; it adds nothing for decision, risk_tier, profile_id, or workflow_id, leaving their semantics entirely opaque.

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 verb ('Return') and a resource ('MCP form-mode and URL-mode elicitation boundary evidence'), which is more specific than the bare name. However, it does not differentiate this pack from the dozens of sibling '*_pack' recipes, and 'boundary evidence' is jargon that an agent cannot map to a concrete artifact.

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, when-not-to-use, or alternative guidance is given. The agent cannot tell when this pack is preferable to recipes_agent_handoff_boundary_pack, recipes_context_egress_boundary_pack, or other boundary packs.

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, and it discloses almost nothing: it does not say whether the tool generates or merely retrieves a policy, whether it requires authorization, whether it is read-only or has side effects, or how errors/empty results behave.

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 efficient sentence with the resource front-loaded and no filler. It is appropriately short, though its brevity reflects under-specification rather than economy of well-chosen 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?

An output schema exists, so return values need not be described. But with no annotations, no parameter documentation, and no usage context, the definition is too thin for an agent to confidently select or call this tool among its many 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% for the single parameter workflow_id, so the schema provides no meaning and the description supplies none either. It is unclear whether workflow_id scopes the policy, is optional context, or what null implies.

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 verb ('Return') and a resource ('generated MCP gateway policy for scoped tool access and runtime controls'), which is more than a tautology. However, it is ambiguous whether this generates a policy or merely fetches one, and it does nothing to distinguish itself from near-identical siblings such as recipes_mcp_tool_risk_contract or recipes_agentic_control_plane_blueprint.

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

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

There is no guidance on when to call this tool, what precondition triggers it, or which sibling to use instead. With dozens of closely related MCP/agentic policy recipes available, the absence of any routing guidance leaves the agent guessing.

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, but 'Return' implies a read-only, side-effect-free operation and an output schema exists to describe results. The description says nothing about filtering behavior, defaults, or pagination, but it is 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 front-loaded sentence with no filler or redundancy — appropriately sized, though the brevity comes at the cost of the missing detail noted 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?

The output schema covers return values, so those need not be described, but six undocumented filter parameters, no usage guidance, and no annotations leave the definition substantially incomplete for invoking the tool correctly.

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

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

All six filter parameters (status, risk_id, risk_tier, source_id, standard_id, capability_id) have 0% schema description coverage and no enums, and the description explains none of them. It does not compensate for the coverage gap at all, leaving the agent to guess each filter's meaning and valid values.

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 a clearly named resource (OWASP MCP and agentic-skill risk coverage mapped to generated evidence), which is much more informative than a generic 'pack' label. However, it offers no differentiation from the many sibling '*_pack' tools such as recipes_agentic_assurance_pack or recipes_agentic_standards_crosswalk, so an agent cannot easily tell which pack to choose.

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 of when to use this tool, when not to, or which sibling it substitutes for. With dozens of near-identically named risk/assurance packs, the absence of routing guidance is a real gap.

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

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

With no annotations, the description carries the full disclosure burden. It usefully reveals that the returned record is 'publicly documented' and carries 'official setup and safety guidance', which scopes the content, but says nothing about what happens when server_id is unknown or whether the call is cached/read-only.

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 tight sentence with the resource and payload described up front and zero 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?

An output schema exists, so return values need no explanation, and the description at least characterizes the payload. However, for a required lookup key at 0% schema coverage, the absence of any server_id semantics leaves an operational 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?

Schema description coverage is 0% for the single required server_id parameter, so the description must compensate and does not. It never states whether server_id is a slug, UUID, or name, or any format/validity constraint.

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 and resource: return one documented MCP server, along with its setup and safety guidance. The word 'one' implicitly distinguishes it from the plural list sibling (recipes_mcp_servers_list), though that sibling is never named.

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

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

Usage is only implied by the singular 'one' versus the sibling list tool; there is no explicit statement of when to fetch a single server versus listing or searching. No prerequisites, lookup-key guidance, or error behavior 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 behavioral burden. It hints that the catalog is 'bundled' and 'publicly documented' (i.e., not live/dynamic), which is modest useful context, but it says nothing about pagination behavior, default ordering, rate limits, or result size limits. For a search tool with zero annotation coverage this is a significant gap.

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

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

A single tight sentence with the key resource front-loaded and zero filler. It is appropriately sized, though it omits content that would earn its place (usage routing, parameter meaning).

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

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

An output schema exists, so return values needn't be described, and the core purpose is conveyed. But for a three-parameter search tool with no annotations and no parameter documentation, the definition leaves selection ambiguity against sibling tools and the semantics of its own inputs unaddressed. Adequate only in the most minimal sense.

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 tool has three parameters (limit, query, availability) that are entirely undocumented in the schema. The description mentions no parameter semantics at all — not what 'query' matches on, not what values 'availability' accepts, not how 'limit' behaves. With low coverage the description must compensate, and it does not.

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

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

States a specific verb ('Search') and resource ('bundled catalog of publicly documented MCP servers and ecosystems'), which is clearer than a bare name restatement. It does not, however, distinguish this list/search tool from nearby siblings such as recipes_mcp_server_get or recipes_mcp_upstream_servers, leaving the agent to infer the difference. Clear purpose, no sibling differentiation.

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

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

The description offers no guidance on when to use this tool versus alternatives. With siblings like recipes_mcp_server_get (detail lookup) and recipes_mcp_upstream_servers (live upstream) present, an agent gets no signal about which to pick. Nothing is stated about the bundled/static nature being the differentiator.

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