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

The description discloses two meaningful behaviors: approvals are subject to tenant governance, and rejection is fail-safe. However, with no annotations provided, the description carries the full burden and does not explain side effects, permissions, idempotency, or what happens after approval or rejection.

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

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

The description is a single, front-loaded sentence with no filler. Every clause adds information: the action, the target, the governance constraint, and the fail-safe rejection behavior.

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

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

This is a mutation-oriented tool with four parameters, no annotations, and no output schema, so the description must carry significant weight. It explains the basic purpose and one policy nuance, but it omits parameter semantics, when to invoke it, and expected outcomes, leaving the agent under-informed.

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

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

Schema description coverage is 0%, and the description does not explain the roles of saga_id, node_id, reason, or approved. The approve/reject wording loosely maps to the 'approved' boolean, but the description adds almost no meaning beyond the schema's property names and types.

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

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

The description states a specific action ('Approve or reject') on a clear resource ('a workflow node'), which identifies the tool's core function. It doesn't explicitly differentiate from siblings like execute_saga_step, but the approval/rejection framing is sufficiently 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?

The description implies this tool is used to handle approval decisions on workflow nodes, but it gives no explicit guidance on when to choose it over related tools such as run_ready_steps or execute_saga_step. It does not mention prerequisites, alternatives, or exclusions.

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

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

The description adds only 'durable' and 'transactional' as behavioral traits, but with no annotations, it carries the full burden of transparency. It does not disclose return behavior, whether a saga ID is produced, idempotency, required permissions, or side effects of starting a workflow.

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

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

The description is one short sentence with no filler or repetition. 'Durable' and 'transactional' add meaningful context, and the key action is front-loaded.

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

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

The definition is too sparse given the lack of an output schema and annotations. It does not mention what the tool returns (likely a saga identifier) or how it fits into the broader saga lifecycle among many sibling tools. An agent could invoke it but would not know how to use the result or what to do next.

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

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

The description says nothing about the metadata parameter, and the input schema only provides the property name 'metadata' with no semantics. Since schema description coverage is 0%, the description was required to compensate, but it does not, leaving an agent without guidance on how to populate the optional metadata object.

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 ('Start') and a specific resource ('a durable transactional workflow'), which clearly identifies the tool's core purpose. The name 'begin_saga' plus the lifecycle siblings such as plan_saga_step, execute_saga_step, and commit_saga make the distinction obvious: this is the initiating 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?

The description implies that this tool should be used to start a durable workflow, but it does not explicitly say when to use it versus alternatives like plan_saga_step or execute_saga_step. It provides no exclusions, prerequisites, or sequencing guidance such as 'call this before planning steps.'

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

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

There are no annotations, so the description carries the full burden of explaining behavior. It indicates a persistent write operation but does not disclose whether an existing checkpoint is overwritten, whether the saga must already exist, whether data is optional, or what side effects occur.

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

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

The description is a single efficient sentence with the verb front-loaded. It contains no filler and communicates the core action and object quickly.

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

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

For a mutation tool with no annotations, no output schema, and minimal parameter documentation, one sentence is not enough. Missing context includes when checkpoints should be persisted, how naming works, overwrite behavior, and whether saga_id references an existing saga.

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

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

With 0% schema description coverage, the description must compensate. It adds meaning for 'name' (the checkpoint's name) and 'data' (operator/agent-provided checkpoint data), but it does not explain the saga_id parameter's role or the expected shape of the nested data object.

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, 'Persist', and names a distinct resource: a named workflow checkpoint plus operator/agent-provided data. This makes the tool's role clear and distinguishes it from the saga execution/rollback/commit siblings, though it does not explicitly contrast with them.

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

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

No guidance is given about when to use this tool versus alternatives such as begin_saga, execute_saga_step, commit_saga, or rollback_saga. The description states what the tool does but not the conditions under which an agent should call 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?

No annotations are provided, so the description must disclose behavioral traits. It states that the saga is 'committed' and that governance checks occur, but it does not explain side effects, irreversibility, permission requirements, failure behavior, or what happens to the saga after commit. This is a significant gap for a mutation-like operation.

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

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

The description is a single sentence with no filler words. It front-loads the core action and states a key precondition efficiently. It could add more useful detail without becoming verbose, but as written it is concise.

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

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

There is no output schema and no annotations, so the description bears full responsibility for explaining behavior and prerequisites. It mentions governance checks and completion state, but omits return values, side effects, and failure semantics. For a state-changing saga operation, this is incomplete.

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

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

Schema description coverage is 0%, and the description does not mention saga_id or explain how it is used. The single required parameter is only minimally documented by the schema itself. The description needs to compensate for the schema gap but 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 uses a specific verb and resource: 'Commit a completed saga.' This clearly identifies the action and lifecycle phase, distinguishing it from siblings like begin_saga, checkpoint_saga, or rollback_saga. It does not explicitly name an alternative, but the scope is reasonably clear.

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

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

The phrase 'after current tenant governance checks' implies a precondition and suggests usage is appropriate once those checks pass. However, it does not explicitly state when to use this tool versus alternatives such as checkpoint_saga or rollback_saga, leaving much of the routing 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?

With no annotations, the description must carry the full burden of disclosing side effects. It reveals that checks occur before execution, but it does not state whether execution is reversible, what happens if checks fail, whether it writes/commits, or what it returns—critical gaps for a tool whose name implies mutation.

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 padding. It is concise but under-specified for a three-parameter execution tool, so the brevity is not fully earned.

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 three required parameters, a nested object, no output schema, and many saga-related siblings, the description lacks information about return values, side effects, and how this call relates to plan/approve/retry/rollback steps. It is not complete enough for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It mentions 'action' only in passing and gives no meaning for saga_id, the action string, or the free-form input object; an agent cannot infer what values to supply.

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: immediately execute an action, and adds the qualifying context of governance/schema/action-policy checks. It is distinguishable from siblings like plan_saga_step or run_ready_steps by the 'immediately execute' phrasing, though it never names an alternative.

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 'after current governance, schema, and action-policy checks' implies the tool is the execution step used once checks are satisfied. However, there is no explicit when-to-use/when-not-to-use guidance and no reference to sibling tools such as plan_saga_step, approve_saga_step, or run_ready_steps.

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

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

With no annotations, the description carries the behavioral burden. 'Inspect' implies a read-only operation, and 'registered action contract' clarifies the target, but the description does not disclose return format, error behavior, or what happens when the id does not exist. It is not misleading but is minimally transparent.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying what the tool does and how to invoke it.

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 retrieval tool, the description is minimally sufficient, but it lacks details about version semantics (e.g., null meaning latest), output shape, or not-found behavior. With no output schema or annotations, a bit more context would make it fully complete.

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

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

Schema description coverage is 0%, so the description must add meaning beyond the raw schema. It does this by identifying 'action' as an id and 'version' as optional, which directly clarifies both parameters. It does not add format or default details, but the essential semantic mapping is provided.

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 ('Inspect') with a clear resource ('registered action contract') and distinguishes this single-item retrieval from sibling tools like list_actions. Including 'by id and optional version' makes the exact scope unambiguous.

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

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

The description implies usage for retrieving a specific action contract by id, but it does not explicitly name alternatives or state when not to use this tool. The guidance is adequate but relies on the agent inferring that list_actions would be used for listing multiple contracts.

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 behavioral burden. It does disclose two useful traits: audit events are append-only, and the response avoids exposing action inputs, results, or secret material. However, it does not explain ordering, pagination, event retention, or what fields are actually returned, leaving notable behavioral gaps.

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

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

The description is a single tight sentence with no filler. It front-loads the action and resource, then adds a valuable safety qualifier without wasting words.

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

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

The tool has three parameters, no annotations, no output schema, and many siblings. The description covers only the basic idea and redaction behavior, leaving out parameter usage, return shape, and when to prefer this over related audit or saga tools. It is not complete enough for confident autonomous invocation.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining saga_id, limit, or event_types. An agent gets no help understanding what event_types values are valid, why saga_id is required, or how limit affects retrieval.

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

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

The description clearly states the tool reads audit events and adds the important qualifier that they are append-only. It is specific about the resource and action, but it does not explicitly differentiate itself from the sibling verify_audit_chain, which also deals with audit 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 description gives no guidance on when to use this tool versus alternatives such as verify_audit_chain, get_saga_timeline, or list_actions. There is no mention of when it should or should not be used, making routing decisions left entirely to the agent.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states the operation is a read, but does not mention whether it requires special permissions, what happens for a nonexistent saga_id, how pagination via limit behaves, or whether results are ordered. The term 'durable' adds a little context but not enough.

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

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

The description is a single, front-loaded sentence that immediately conveys the operation type and object. Every word contributes meaning, and there is no redundant filler or repetition of the tool name.

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

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

The tool has no output schema, no annotations, 0% parameter description coverage, and many closely-related siblings. The one-sentence description is not sufficient to fully guide an agent on invocation semantics, parameter meaning, or expected results. This is a meaningful gap for a tool that reads governance decisions and safety overrides.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It implies saga_id identifies a tenant-owned saga, but it never names or explains saga_id or limit, nor does it describe the default/maximum behavior of limit. The schema only provides structural constraints, not semantic intent.

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 ('Read') with a clear resource ('durable governance decisions and safety overrides') and scopes it to 'one tenant-owned saga', which clearly differentiates it from sibling tools like get_policy_status or get_audit_events. An agent can understand what the tool returns and for which entity 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?

The description gives no guidance on when to choose this tool over alternatives. With 17 sibling tools, including get_policy_status and get_audit_events, the absence of any when-to-use or when-not-to-use guidance leaves the agent to infer the tool's role from its 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 burden of behavioral disclosure. 'Inspect' conveys a read-only operation and 'for the caller tenant' sets the scope, which is useful. However, it does not mention authorization requirements, side effects, or the impact of supplying tenant_id.

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 that front-loads the operation and lists the inspected attributes without wasted words. The structure is highly scannable for an agent.

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

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

The tool has no output schema, no annotations, and an undocumented optional parameter. The description tells what is inspected but omits tenant_id semantics, usage context, and any behavioral caveats, leaving the agent to guess for correct invocation.

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

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

There is one optional nullable tenant_id parameter with 0% schema description coverage, and the description never explains how to use it. It mentions 'caller tenant' but does not clarify whether tenant_id changes the target tenant, what null means, or whether cross-tenant inspection is possible.

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 ('Inspect') with a precise resource: the effective governance backend, revision, budgets, approval threshold, and rule ids. This clearly distinguishes it from sibling tools like get_policy_decisions or get_audit_events.

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

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

No guidance is given on when to use this tool versus alternatives such as get_policy_decisions. The description implies a status inspection use case, but it never states conditions, exclusions, or preferred alternatives.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The word 'Inspect' signals a read-only operation, and the enumerated facets clarify what can be viewed, but the description does not mention side effects, error behavior, or whether inspecting recovery state triggers any recovery computation.

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

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

The description is a single sentence with the verb and resource front-loaded. Every listed item is substantive, and there is no filler or redundant phrasing.

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 that no output schema is provided, the description compensates by listing the major return categories: saga, workflow DAG, checkpoints, action versions, results, approvals, and recovery state. It omits error cases and whether the response is a full dump or summary, but for a single-parameter inspect tool the coverage is strong.

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

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

The single parameter saga_id is self-explanatory from its name and title, and the description's 'Inspect saga' connects it to the target saga. The description does not add identifier format or lookup semantics, but with one simple string parameter, the schema and parameter name carry most of the meaning.

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

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

The description opens with the verb 'Inspect' and a specific resource ('saga'), then enumerates the state facets included: workflow DAG, checkpoints, action versions, results, approvals, and recovery state. This makes the tool's purpose clear and helps distinguish it from narrower siblings like get_action, though it does not explicitly name an alternative.

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

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

The description implies this is the comprehensive read/inspection tool for saga state, giving an agent a reason to use it when broad state is needed. However, it does not explicitly contrast with get_saga_timeline or get_action, nor does it state when not to use this tool.

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

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

With no annotations provided, the description carries the full burden. 'Inspect' implies a read-only operation and 'payload-safe' hints at behavioral handling of data, which adds some context beyond the schema. However, it does not explain what 'payload-safe' means, whether any state is modified, how pagination works, or what integrity status entails.

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 entire description is a single front-loaded sentence that communicates the primary purpose and the main content of the response. It is concise and avoids filler, though the term 'payload-safe' introduces some ambiguity that could be clarified without added length.

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, no output schema, and two parameters including a non-obvious limit, the description is too thin. It names what the timeline combines but does not describe return shape, pagination, parameter effects, or how this tool relates to closely named siblings. The agent would need to guess several important operational details.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining either parameter. 'saga_id' is inferable from the tool name and schema, but 'limit' is completely unexplained, including its default and maximum behavior. The description adds no meaning beyond the raw parameter names and types.

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

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

The description uses the specific verb 'Inspect' and names the resource ('saga timeline') along with the components it combines: steps, workflow nodes, audit evidence, and integrity status. This distinguishes it from sibling tools like get_saga or get_audit_events by signaling a merged view, though it does not explicitly name a sibling to differentiate against.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_audit_events, verify_audit_chain, or get_saga. There is no explicit context for when this combined timeline is appropriate or when it is not, leaving the agent to infer usage solely 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 present, so the description must disclose behavior on its own. 'List' implies a read-only operation, and the description enumerates what is returned, which is helpful. However, it does not mention authorization requirements, pagination, filtering behavior, or how 'active' is determined.

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

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

A single sentence that front-loads the verb and resource while compactly enumerating the returned facets. There is 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?

With no parameters, no output schema, and no annotations, the description does the necessary work by naming the six content types returned and signaling this is a listing operation. It is reasonably complete, though it could be stronger with a note on response shape or the meaning of 'active'.

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

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

The tool has zero parameters and the schema is empty, so there is no parameter semantic burden. The description adds useful context by enumerating the categories of data returned, which is the main information an agent needs.

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 'List' and names the resource: active action contracts, schemas, semantic effects, risk, hashes, and execution policies. This clearly identifies the tool's function and implies a broad inventory view that distinguishes it from singular tools like get_action, though it does not explicitly name a sibling.

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

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

The phrase 'active action contracts' gives implied context that this is for surveying currently active actions rather than retrieving a single action or checking policies. However, it provides no explicit when-to-use guidance or exclusions pointing to alternatives such as get_action or get_policy_status.

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

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

With no annotations, the description carries the full burden. It does disclose persistence, version pinning, and the possibility of governance adding an approval gate or rejecting the plan, which is useful. However, it omits permissions, return behavior, failure semantics, and reversibility.

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 that front-loads the verb and resource. Both clauses contribute distinct information, and there is no filler or repetition.

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

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

For a tool with no output schema and no annotations, one sentence is not enough. An agent cannot determine what response to expect, how 'reject the plan' manifests, how parameters map to behavior, or what prerequisites exist before calling 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?

The schema has six parameters with 0% description coverage, and the description names none of them. saga_id, action, input, depends_on, approval_required, and key are left entirely to schema titles and types, so the description adds no parameter-level meaning.

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

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

The description uses 'Persist' with 'workflow node' to state a specific action and resource, and the governance clause adds meaningful context. However, it does not explicitly distinguish this from siblings like execute_saga_step or approve_saga_step, so the differentiation is inferential rather than stated.

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 implies this is for the planning/persistence phase of a saga step rather than execution or approval, but it gives no explicit when-to-use or when-not-to-use guidance. No alternatives are named, and the conditions under which governance might reject the plan are left unclear.

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

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

The description reveals that the operation is a state transition subject to governance checks, which is a meaningful behavioral trait for a mutation tool. However, it does not disclose failure modes, side effects, idempotency, or what happens if governance checks fail. With no annotations, the burden is higher, and this short phrase is only partially sufficient.

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

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

The description is a single 13-word sentence with no filler. It front-loads the core action and condition, though it sacrifices helpful detail for brevity.

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

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

For a mutation tool with no annotations, no output schema, and three undocumented parameters, this description leaves too many gaps: parameter meanings, return value, error conditions, and the precise role of governance checks. It is enough to understand the basic intent but not to invoke the tool with confidence.

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

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

Schema description coverage is 0% and the description provides no explanation for saga_id, node_id, or force. The 'force' boolean is especially mysterious—it could bypass governance checks or force scheduling, but the text does not say. The agent cannot infer parameter semantics from this definition.

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

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

The description names the action ('Return ... to scheduling'), the target ('failed/rejected/blocked workflow node'), and the condition ('after current governance checks'). It clearly separates the tool from execute_saga_step and trigger_rollback by focusing on retrying blocked/failed nodes. It does not explicitly contrast it with approve_saga_step, but the core purpose is unambiguous.

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

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

It implies use for nodes in failed/rejected/blocked states that should be re-scheduled after governance checks. It does not specify alternatives or exclusion criteria, such as when to use run_ready_steps or execute_saga_step instead. The absence of explicit when-not guidance keeps this at the implied-usage level.

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 responsibility for disclosing behavior. It reveals that steps are compensated in reverse order, but it does not state side effects, idempotency, failure handling, whether compensation is asynchronous, or what happens when a step cannot be compensated.

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

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

The description is a single efficient sentence with no filler. The core action is front-loaded, and the second clause adds a useful distinction. It is concise, though somewhat under-specified for the information it needs to convey.

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

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

Despite having only one parameter and no output schema, the description is not complete enough. It omits failure behavior, return semantics, and any practical guidance about how compensation relates to rollback, which is essential for a saga-management tool with no annotations.

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 saga_id at all. The agent must rely entirely on the schema's minimal field title and minLength, with no guidance on where to obtain the saga_id or what format is expected.

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

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

The description states a specific action ('Compensate saga steps') with a clear scope ('in reverse order'), which goes beyond a mere restatement of the name. It also nudges differentiation from a rollback path, though it does not explicitly name a sibling tool.

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

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

The phrase 'rollback remains available as the safety path' hints at an alternative, but it does not specify when to use rollback_saga versus trigger_rollback or other saga tools. There is no explicit condition, prerequisite, or exclusion guiding tool selection.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal bounded wave execution and governance re-evaluation, but it omits crucial traits: whether execution mutates state, whether steps can be rolled back, how failures are handled, or whether execution is idempotent. Too much is left to inference for a tool that executes work.

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

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

The description is a single compact sentence and front-loads the primary action. However, phrases like 'current governance' and 'bounded dependency waves' are jargon-heavy and under-specified, so the brevity comes at the cost of clarity. It is concise but not optimally informative.

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

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

This is a non-trivial tool: it evaluates governance, executes DAG nodes, has multiple bounded execution parameters, and has no output schema or annotations. The description does not explain return behavior, error conditions, relationship to other saga tools, or side effects. It is insufficient for an agent to invoke the tool confidently and 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 compensate. It only hints at 'bounded' waves, which loosely maps to max_steps and max_parallel, and 'current governance' implies the saga_id context, but it never explicitly explains what each parameter means or how they interact. This is minimal compensation, not adequate parameter guidance.

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 clear action—re-evaluate governance and execute ready DAG nodes—and introduces distinctive concepts like bounded dependency waves that suggest a batch execution engine rather than a single-step executor. However, it does not explicitly distinguish itself from sibling execute_saga_step, so it stops short of full differentiation.

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

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

The description implies the tool is for executing ready nodes in a DAG, but it gives no explicit guidance about when to choose this over execute_saga_step, plan_saga_step, or related saga tools. There are no stated preconditions, exclusions, or alternative routing cues.

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

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

With no annotations, the description carries the full disclosure burden, but it only says compensation starts immediately. It does not state side effects on the saga, whether the operation is reversible/idempotent, whether prerequisites like a failed state exist, or whether it returns synchronously.

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 with no filler; the key trigger condition and action are front-loaded. Nothing needs to be cut.

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 mutating control operation with no annotations and no output schema, the description is too thin: it lacks state-transition behavior, return/acknowledgement semantics, and any guidance on the rollback_saga sibling. It is minimally usable but not complete.

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

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

Schema description coverage is 0%, so the description needed to explain that saga_id identifies the failed saga to compensate; it never mentions the parameter. The parameter name and title are mildly self-explanatory, but the description adds no parameter-level meaning.

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

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

The description states a specific action—'start compensation'—and a trigger condition ('after a client-detected failure'), so an agent knows the tool initiates a rollback. It is not a tautology, but it never distinguishes itself from the nearby sibling rollback_saga, 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?

The phrase 'after a client-detected failure' gives a clear context for when this tool is appropriate. It does not mention alternatives or exclusions, leaving the agent to infer when rollback_saga, retry_saga_step, or commit_saga would be preferable.

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

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

With no annotations, the description carries the full burden of disclosing behavior, but it only states the operation's purpose. It does not say whether the tool is read-only, what it returns on success or failure, whether it computes or just retrieves, or whether any side effects occur. 'Verify' implies inspection, but the actual behavioral contract is left unspecified.

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

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

The description is very short and front-loaded with the main verb, which is superficially concise. However, it under-specifies crucial details, so the brevity comes at the cost of usefulness; it has no structure beyond a single purpose statement.

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

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

The tool has three parameters, no annotations, no output schema, and many sibling audit tools, so a complete description would need to cover usage context, parameter meaning, and return behavior to be actionable. The provided one-liner leaves all of these gaps, making it inadequate for reliable agent selection and invocation.

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

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

The schema description coverage is 0%, and the description does not mention saga_id, limit, or event_types. It only implies the saga scope through the phrase 'per-saga,' leaving all three parameters—including the required saga_id and the filter semantics of event_types—undocumented at the description level.

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 ('Verify'), resource ('per-saga SHA-256 audit hash chain'), and scope ('per-saga'), so the core purpose is clear. It does not explicitly differentiate itself from sibling tools like get_audit_events, but 'verify' is distinct enough from 'get' that an agent can infer a verification/integrity-check role.

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 such as get_audit_events or get_saga_timeline. There are no context cues, exclusions, prerequisites, or examples, so an agent has no help selecting it over similar audit-related tools.

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