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

No annotations are supplied, so the description carries the full disclosure burden. It does usefully signal that this writes persisted state while preserving rules and baseline, and the schema's confirm field implies a write gate, but the description never mentions that confirm requirement, what happens on a dry run, or what 'refreshed Guard state' 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 tightly written sentence with the scope constraint front-loaded and no filler. Every clause (refresh, persisted facts, no rule/contract/baseline change) carries distinct information.

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

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

This is a state-mutating tool with no annotations, no output schema, and half its parameters undocumented. The description omits the confirm-before-write flow, what the refresh result looks like, and whether the operation is reversible or incremental, leaving meaningful gaps for a no-annotation mutation 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 only 50%: root and confirm are documented in the schema, while no_wait and wait_ms have no descriptions anywhere. The description adds no parameter-level meaning at all, so the two undocumented timing parameters remain opaque to the agent.

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

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

The description names a specific verb (refresh) and resource (persisted project facts and snapshots) and clarifies the scope boundary by excluding rules, contracts, and baseline changes. That exclusion implicitly separates it from sibling mutation tools like codapult_guard_propose and codapult_guard_init, though it never names any of 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 conveys the negative case (it does not modify rules, contracts, or baseline) but never states the positive trigger, such as 'use when Guard state is stale or after external changes.' With 13 sibling tools, an agent has no explicit routing cue to prefer this over codapult_guard_check, codapult_guard_verify, or codapult_guard_context.

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

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

No annotations are provided, so the description carries the full burden. It does disclose two meaningful behaviors — baseline suppression is bypassed and contracts are validated — which is real beyond-schema value, but it omits whether the audit is read-only, whether it writes reports, cost/runtime expectations, and permission needs.

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 zero filler, front-loading the action and then the two behavioral qualifiers that actually differentiate the 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?

For a one-optional-param, no-output-schema tool the description covers what it does and two notable behavior traits, which is close to sufficient. The main remaining gap is routing guidance against the many guard siblings; return-value details are less critical since there is no output schema to lean on, though a hint would help.

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

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

Schema description coverage is 100% and the single `root` parameter already documents "Project path or workspace root." The description adds nothing about the parameter, but per the coverage rule the schema baseline of 3 applies.

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

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

States a specific verb and resource ("Run a full Guard audit") plus two distinguishing modifiers: ignoring baseline suppression and validating contracts. It does not explicitly contrast with close siblings like codapult_guard_check, codapult_guard_verify, or codapult_guard_analyze, so an agent must infer the difference from the modifiers 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?

"Full" audit and "ignoring baseline suppression" imply this is the exhaustive, un-suppressed variant, but the description never states when to pick it over codapult_guard_check or codapult_guard_verify, nor any prerequisites such as an initialized workspace.

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 does not meet it. It never says whether the check is read-only or records state, what 'new' means (relative to a baseline? prior runs?), what permissions/paths are needed, or how results are shaped beyond the phrase 'structured new violations'.

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 brevity here shades into under-specification rather than crispness.

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

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

With no annotations, no output schema, an undocumented parameter, and a dense sibling family, the definition leaves an agent guessing about prerequisites, side effects, and the semantics of 'new'. It is not sufficient for correct invocation in this tool family.

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

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

Schema coverage is only 50%: 'root' is documented but 'changed_only' has no description, and the tool description does not compensate by explaining that it scopes the scan to changed files. It adds no meaning beyond the schema text.

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 ('Check') and resource ('project architecture rules') plus a distinctive output nuance ('structured new violations'), so an agent knows this is a rules-evaluation tool rather than a governance/waiver management tool. It does not explicitly name how it differs from close siblings like codapult_guard_verify or codapult_guard_analyze, which keeps it below 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 guidance on when to call this versus the 13 sibling guard tools (verify, analyze, audit, review, impact), several of which sound near-identical. No prerequisites (e.g., whether codapult_guard_init must run first) or exclusions are stated.

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

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

With no annotations, the description carries the full burden; it does disclose that the tool reads a persisted snapshot by default and can rediscover the working tree, plus that it functions before init. It does not clarify whether on-demand discovery writes/persists a snapshot (a possible side effect), nor anything about cost, caching, or failure modes when no project is found.

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

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

Two short sentences, zero filler, with the core capability front-loaded and the pre-init capability as a secondary clause. Everything present earns its place.

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

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

There is no output schema and no annotations, so the description is the only source of behavioral detail; it covers what is read and the pre-init case but omits return structure, any write/persist side effects of discovery, and error behavior. Adequate to start, but not complete for an agent deciding whether calling it is safe or expensive.

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

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

Schema coverage is 100% and both parameters are documented in-schema, so the baseline is 3. The description only echoes the refresh behavior (rediscover vs persisted snapshot) without adding format, cost, or default-related nuance beyond the schema's own 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 (read) and concrete resources (project model, architecture insights, local rules) scoped to Codapult Guard. It is clear what comes back, though it doesn't explicitly contrast itself with close siblings like guard_analyze or guard_explain, which also surface project understanding.

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?

"Works before init by discovering the project on demand" gives one useful usage condition (callable pre-init, no prior setup). However there is no guidance on when to prefer this over siblings such as guard_init (which presumably persists context) or guard_analyze, leaving selection largely 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 behavioral burden and does not meet it: it does not say whether the operation is read-only, whether it requires an initialized workspace or specific permissions, or what happens when the id is unknown. It hints at return content ('evidence and applicable scope') but nothing about failure modes or cost.

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

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

A single sentence with no filler, and the verb/resource leads. Its brevity is a virtue structurally, though it borders on under-specification rather than crispness.

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

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

With no annotations, no output schema, and half the parameters undocumented, a one-sentence description leaves too much unknown for an agent to call this confidently in a crowded sibling namespace. At minimum it should state the read-only nature and how it differs from guard_context/guard_audit.

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

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

Schema coverage is 50%: 'root' is documented in the schema while 'id' has no description. The phrase 'a Guard rule or contract' does implicitly map 'id' to a rule/contract identifier, which adds modest value, but no format, prefix, or lookup guidance is given.

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

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

The description pairs a specific verb ('Explain') with a specific resource ('a Guard rule or contract') and adds what the answer contains (evidence and applicable scope). That is clear on its own, but it never distinguishes this tool from close siblings like codapult_guard_context, codapult_guard_audit, or codapult_guard_analyze.

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 reach for this tool versus the thirteen sibling guard tools, nor any prerequisites (e.g., whether the project must be initialized or a rule must already exist). The agent must infer usage entirely from the name.

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

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

With no annotations, the description carries the full burden. It does disclose an important behavioral trait beyond the schema: the output is declared metadata only and does not establish identity or cryptographic signatures, which sets the right expectations about result trustworthiness. It omits whether the operation is read-only, whether it can fail on missing config, and what the report 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?

Two sentences, front-loaded with the audited scope and closed with the key caveat. Every clause carries information and nothing is repeated from the schema or title.

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

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

For a tool with no annotations and no output schema, the description should say more about the shape of the report (sections, pass/fail verdicts) so an agent knows what it will receive. The trust caveat is valuable, but return-value expectations remain underspecified.

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

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

There is a single optional parameter ('root') whose schema description already covers it at 100%, so the schema does the work. The description never mentions the root or what happens when it is omitted, but the high coverage makes baseline 3 appropriate.

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

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

The verb 'Audit' is paired with a specific scope (proposal/approval provenance, policy bindings, verification reachability), which is more than a restatement of the title. However, the sibling list contains both codapult_guard_audit and codapult_guard_verify/codapult_guard_check, and nothing in the description explains how 'governance' audit differs from plain audit. An agent cannot reliably choose between them from this text 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 preconditions, and no named alternative. The second sentence is a scope disclaimer about what the results mean, not an instruction about when to pick this tool over codapult_guard_audit or codapult_guard_verify.

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 whether this is read-only or mutating, whether it requires a prior codapult_guard_init/discovery pass, whether it touches the filesystem, or what the response contains. For an analysis tool with zero annotation coverage, that 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 well-formed sentence with the action front-loaded and no filler. It earns its space, though brevity here comes partly at the cost of the missing usage and behavioral information rather than from efficiency alone.

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

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

With no output schema, no annotations, and a required parameter undocumented in both schema and description, the definition is under-specified. An agent cannot tell what 'impact' looks like in the response — affected routes, capabilities, contracts? — or whether this is a safe repeated 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 coverage is 50%: 'root' is documented in the schema but the required 'files' array has no description at all. The description mentions 'one or more changed files' but does not say whether paths are absolute, repo-relative, or workspace-relative to root — the one ambiguity an agent would most need resolved.

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 ('Explain') and resource ('project impact of changed files'), and enumerates the evidence sources it draws on (dependency graph, routes, capabilities, contracts). This is clearly distinct from siblings like init or proposal_decide, though it does not distinguish itself from codapult_guard_analyze or codapult_guard_check, which likely occupy adjacent territory.

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

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

No explicit when-to-use guidance, no exclusions, and no alternatives named despite 13 sibling tools in the same guard family. The phrase 'using the discovered dependency graph' hints that discovery/init must have run first, but this prerequisite is implied rather than stated.

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

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

With no annotations, the description must carry behavioral burden; it does disclose two useful traits (confirmation required, existing state protected by default). It omits what artifacts are written, where, and whether non-force re-runs are idempotent or fail.

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 safety trait comes early. Brevity is appropriate, though it verges on under-specification for a 5-parameter init 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?

No annotations, no output schema, and two parameters (no_wait, wait_ms) are unexplained anywhere. For an initializing write tool the description leaves the agent without enough to call it correctly or anticipate results.

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

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

Schema coverage is 60% and the description adds no detail on any parameter: no_wait and wait_ms are undocumented in both schema and description, and 'explicit confirmation' only restates the existing confirm field 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 ('Create') and resource ('Guard artifacts'), plus a scope trait that separates it from verification/review siblings. However, 'Guard artifacts' is unexplained jargon, so an agent still doesn't know concretely what gets written.

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 phrasing 'after explicit confirmation' and 'existing baselines are protected by default' implies initialization is a guarded, deliberate step, but no alternatives are named and no explicit condition selects this tool over codapult_guard_propose or codapult_guard_next_action.

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. The 'without modifying project files' clause is a useful safety signal, but nothing is said about whether it reads or writes guard state, how the 'bounded' constraint is enforced, or what form the returned action takes.

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

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

One sentence, front-loaded with the verb and result. Nothing is padded, though the terseness crosses into underspecification rather than efficiency.

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

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

There is no output schema, so the description should explain what a 'bounded action' contains and how the agent should consume it. The nature of the return value is left entirely undefined, which is a real gap for a tool whose whole purpose is producing a next-step payload.

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?

Single optional `root` parameter is fully described in the schema (100% coverage), so the schema already does the work. The description adds nothing about path semantics or defaults, which is the expected baseline for full coverage.

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

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

Names a specific verb ('Return') and object ('next bounded action for an AI coding-agent loop'), and adds a non-mutation qualifier. However, 'bounded action' is unexplained jargon, and it doesn't distinguish itself from siblings like codapult_guard_propose or codapult_guard_check, which plausibly also return guidance.

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 indication of when this tool should be chosen over codapult_guard_propose, codapult_guard_check, codapult_guard_verify, or the other nine siblings. The agent must guess at the loop-step position this tool occupies.

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. It discloses one important constraint (stale proposals cannot be activated), but omits state-change effects, the need for confirmation before changing Guard state, reversibility, and error behavior for a mutation 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 tightly written sentence with the core action and the key staleness constraint front-loaded. No filler or redundancy.

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

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

For a mutation tool with four parameters, no annotations, and no output schema, the description is too thin. It leaves out confirmation requirements, state-change semantics, permission expectations, and what happens after approval or rejection.

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

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

Schema description coverage is only 50%, so the description should compensate. It implies that ids refer to proposals and that decision is approve/reject, but it says nothing about the confirm parameter, root scoping, or the format of ids beyond what the schema already conveys.

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

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

The description states a clear verb pair (approve/reject) and resource (current evidence-backed proposals), and adds a validity constraint (stale proposals cannot be activated). It does not explicitly differentiate itself from siblings like codapult_guard_propose or codapult_guard_review, but the scope is specific enough for an agent to identify the action.

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: this tool applies decisions to current proposals, and stale ones are excluded. However, the description never states when to use this tool versus alternatives such as review, verify, or propose, nor does it list prerequisites like confirmation.

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

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

With no annotations, the description carries the full burden. It discloses one genuinely important behavioral trait – proposals are never activated automatically, so this is non-destructive – but says nothing about what 'evidence-based' means, whether the tool reads the repository, whether persist triggers filesystem writes, or whether it requires review by proposal_decide.

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

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

Two sentences, front-loaded with the purpose and followed by the key safety constraint; no filler. It is arguably too terse for a tool with no annotations, but every sentence present earns its place.

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

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

For a 3-parameter governance tool with no annotations and no output schema, and 13 closely related siblings, the description is far too thin. It omits prerequisites, what evidence is generated, the role of persist/confirm in the workflow, and how output proposals are consumed by proposal_decide.

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

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

Schema description coverage is 100%, so root, confirm and persist are already documented, including the dependency that confirm is required when persist is true. The description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource: 'Generate evidence-based rule and contract proposals for an AI agent.' That is clear and identifiable, but the description never distinguishes it from the numerous sibling governance tools (proposal_decide, verify, analyze, check) that also touch rules and proposals.

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

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

There is no when-to-use or when-not-to-use guidance. It never says whether to call this before proposal_decide, whether init must run first, or what prerequisites (e.g., project root, evidence sources) exist. Only the implicit reading of the name suggests its place in the workflow.

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 says the packet is 'bounded' (consistent with the max_diff_chars cap) but never says whether the call is read-only, whether it writes a packet to disk, whether it invokes a model, whether it requires an initialized guard state, or what happens on a dirty/empty diff.

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 dense with undefined domain jargon ('project model', 'contracts', 'deterministic findings'), but nothing is redundant.

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

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

For a 5-parameter tool with no output schema, no annotations, and 40% schema coverage, the description should say what the packet looks like when returned (structured object? file path? text blob?) and how it feeds the reviewer. That return-shape information is entirely absent.

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

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

Schema coverage is only 40%, so the description must compensate: 'current diff' loosely points at base/max_diff_chars and 'project model' at root, and 'bounded' hints at the size cap. The 'requirement', 'changed_only', and all defaults/bounds remain unexplained, so the compensation is partial.

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 ('Prepare') and artifact ('bounded semantic-review packet') plus an enumeration of its contents, so an agent knows what it produces. It never distinguishes itself from close siblings such as codapult_guard_context, codapult_guard_analyze, or codapult_guard_check, which likely also assemble diff/model data.

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 only usage hint is the trailing phrase 'for an AI reviewer,' which vaguely implies a preparatory workflow step. There is no statement of when to call this versus the 13 sibling guard tools, no prerequisites (e.g. must guard_init have run first), and no exclusions.

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

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

No annotations are provided, so the description carries the full burden. It reveals only that several checks are aggregated into one gate; it says nothing about whether builds mutate the workspace, whether the call is read-only, what a failure returns, timeouts, or how policy_base/fail_on_policy_change alter 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 front-loaded sentence with zero filler; the action and scope come first. It is as concise as a one-line description can be.

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

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

For a 10-parameter tool with no annotations and no output schema, one sentence is insufficient. Critical context is missing: what 'architecture regression checks' entail, whether the gate is read-only or modifies artifacts, and what the result/failure surface looks like.

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

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

Schema description coverage is only 60%, leaving strict, iteration, requirement, and changed_only undocumented. The description mentions checks and build but adds no meaning to any of the 10 parameters, so it 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 ('Run') and concrete resources (project checks, production build, architecture regression checks) framed as a single verification gate. An agent can tell what the tool does, but it is not distinguished from the many sibling guard tools, notably codapult_guard_check, which likely overlaps.

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 'as one verification gate' hints at a use case, but there is no explicit when-to-use, when-not-to-use, or routing to alternatives such as guard_check or guard_audit. With 14 sibling tools, this omission forces the agent to guess.

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

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

With no annotations, the description carries full behavioral burden, yet it never states that add/remove/renew are mutations, that confirm=true is required, whether removal is reversible, or what approval/authorization is needed. 'Time-bounded' and 'project-approved' hint at expiry and approval semantics, which is the only real 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 and the core resource stated immediately. It is arguably too terse for a 9-parameter mutation tool, but nothing in it is wasted or buried.

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

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

For a 9-parameter tool with zero annotations, no output schema, and 11% schema coverage, one sentence is not enough. The agent cannot tell what a list result contains, what happens on remove, or how confirm and expires_at interact with the action enum.

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 11% (only 'root' documented) across 9 parameters, so the description must compensate and largely fails. 'Time-bounded' loosely maps to expires_at and 'project-approved' to root/owner, but action, confirm, reason, id, fingerprint, and issue get no explanation at all.

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 resource (time-bounded, project-approved exceptions) and the verb set (list and manage), and it usefully glosses the tool name 'waivers' as exceptions to active Guard findings. It does not, however, distinguish this from close siblings like codapult_guard_governance or codapult_guard_review, leaving the agent to infer boundaries.

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

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

There is no guidance on when to use this tool versus the many sibling Guard tools, and no mention of the list/add/remove/renew action modes or which mode a given request implies. No prerequisites, exclusions, or workflow position are stated.

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