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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that a detected pattern is 'converted into an enforced workflow', implying a state change, but does not disclose side effects, reversibility, permissions required, or what 'enforced' means in terms of governance. The tool likely mutates state, and the lack of such details 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?

The description is two short sentences: the first defines the core action, the second specifies the origin of the required parameter. Every word earns its place; no redundant information or filler.

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

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

For a simple one-parameter tool with no output schema, the description covers the primary action and parameter source. However, it lacks any mention of the result or consequences of enforcement, such as whether the change is permanent, reversible, or requires special permissions. Given the governance-related sibling tools, more context on what 'enforced workflow' entails would make it more complete.

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

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

The input schema already describes detectedId as 'ID of the detected pattern to accept' (100% coverage). The description adds valuable context by specifying that the ID comes from 'suggested_workflows in the orient() response', which clarifies the exact source and relationship to another tool. This goes beyond the schema's generic description.

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

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

The description clearly states a specific action ('Convert a detected decision pattern into an enforced workflow') with a resource (a decision pattern) and an outcome. It also names the source of the pattern ID from 'suggested_workflows in the orient() response', which distinguishes it from sibling tools like marrow_orient or marrow_workflow.

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

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

The description provides a clear usage context: use this tool when a decision pattern has been detected, and the ID comes from the orient() response. This implies it should be used after orient() returns suggested workflows. However, it does not explicitly state when not to use it or name alternatives, only a single key contextual dependency.

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 carry the full transparency burden. It discloses the type of data returned but does not describe behavioral details such as data aggregation, performance implications, or how the 'agent-facing' nature affects results. For a read-only tool, this is a minimal disclosure that raises questions about interpretation of the metrics.

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, well-structured sentence that front-loads the core purpose and lists the returned metrics. Every word contributes meaning, with no filler or repetition. It is an excellent example of concise writing.

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 schema adequately covers parameters, but there is no output schema and the description does not specify the return format or data structure. It lists conceptual metrics but not exact field names or types, which could lead to parsing difficulty. Additionally, without usage guidance relative to similar sibling tools, the tool's role is not fully contextualized.

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

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

The input schema fully describes both parameters (period and agentId) with their defaults and constraints, so schema coverage is 100%. The description does not add additional parameter semantics beyond what is in the schema, so the baseline score of 3 is 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 description clearly states the tool's function using a specific verb ('Get') and a specific resource ('agent-facing fleet value metrics'), and enumerates the metrics returned. However, it does not explicitly distinguish this from sibling tools like marrow_value_report or marrow_dashboard, so it stops short of a 5.

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

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

No guidance is provided about when to use this tool versus alternatives such as marrow_value_report or marrow_dashboard. It does not state prerequisites, exclusions, or contexts where this tool is preferred, leaving the agent to infer appropriate usage from the name alone.

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

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

No annotations are present, so the description carries full burden. It lists return fields but does not disclose whether the tool causes side effects, requires authentication, or behaves differently under certain conditions. 'Passive status' hints at read-only, but it's not explicit, and preconditions are unstated.

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 dense sentences; the first packs a long list of outputs, the second gives usage. No filler, but the output list is a bit unwieldy and could be structured more clearly.

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 9 parameters, no output schema, and no annotations, the description is thin. It lists output names but not their structure, interpretation, or any behavioral context. A comprehensive decision-guidance tool should explain what 'passive status' or 'risk gate' means and how to act on the response.

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

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

Schema description coverage is 100%, so baseline 3 applies. The description adds no parameter-level semantics, but the schema already documents each of the 9 parameters adequately.

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 identifies the tool as a 'one-call agent-native Marrow loop' and enumerates the returned artifacts, distinguishing it as a comprehensive guidance call. However, 'Marrow loop' is jargon, and sibling differentiation is implicit rather than explicit.

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

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

Explicitly instructs to use 'before meaningful work when you want Marrow to guide the whole action in one call,' providing clear timing and intent. It doesn't mention alternative tools, but the context is unambiguous.

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, but the description carries the burden well for a read-only status tool. It discloses that this is a non-destructive check ('Check whether'), names the returned data (connected state, signal quality, non-sensitive proof, next actions), and clarifies the proof is non-sensitive.

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, front-loaded with the primary purpose and then a concise use case. Every sentence adds value with no filler.

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

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

For a low-complexity status check, the description covers what the tool does, when to use it, and what it returns. There is no output schema, but the return categories are explicitly named. A minor gap is lack of detail about output formatting or behavior across periods, but the schema compensates.

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% for both parameters (period and agentId), so the baseline is 3. The description does not add additional parameter detail, such as how period ranges behave or how agentId filtering works, beyond what the schema already documents.

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 action ('Check whether Marrow is passively active') with a clear resource ('for this agent or fleet') and lists concrete return values. This distinguishes it from sibling status tools by emphasizing fleet scope, passive activity, and dashboard-free proof.

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

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

Provides explicit usage context: 'Use at session start or before owner reporting'. This is clear guidance on when to invoke the tool, though it does not explicitly contrast with alternatives or state when not to use 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 carries full burden. It discloses that the tool uses the Marrow runtime gate and returns a durable arbitration receipt with four outcome types (selected, synthesized, review-required, blocked) and an explanation for changes. However, it does not address side effects, permission requirements, or whether the receipt is a persisted record beyond 'durable,' leaving ambiguity about impact on execution. This is a moderate level of transparency.

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 two concise sentences that front-load the core purpose and then specify the return artifact and possible outcomes. Every phrase adds value with no repetition of schema details, making it highly efficient.

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

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

Given the tool's complexity (11 parameters, nested proposal objects, no output schema), the description provides a high-level overview of the return receipt and possible outcomes but doesn't explain the meaning of 'synthesized' vs 'selected' or what the caller should do next. It lacks information about error conditions, prerequisite runtime gate state, or how the 'durable' receipt should be consumed, leaving notable gaps for an agent.

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 73%, so the schema carries most of the parameter documentation. The description adds little parameter detail beyond naming 'proposals' implicitly and the 'two or more tenant agents' requirement, which is already encoded in minItems=2. For the undocumented parameters (surfaces, conflictType), the description offers no help, so parameter semantics are adequate but not enhanced.

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 'Resolve conflicting next-step proposals from two or more tenant agents before execution,' using a specific verb ('resolve') and resource ('conflicting next-step proposals'). It distinguishes itself by the 'before execution' qualifier and the specific input type, making it distinct from sibling tools.

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

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

The description implies usage when there are conflicting proposals among multiple agents and indicates it's a pre-execution step, but it does not explicitly state when not to use it or mention alternative tools such as marrow_policy_resolve or marrow_workflow_gate. It provides a clear context (conflict resolution) but lacks exclusions, so a 4 is appropriate.

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. It commits to returning 'direct answer + supporting evidence' and strongly implies a read-only operation via 'Query'. While it doesn't explicitly state 'does not modify data', the language is unambiguous for an advisory 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?

Two concise sentences with the action verb front-loaded ('Query the collective hive'). Every clause adds relevant information—what to ask, when to use, and what to expect in return—with no fluff.

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

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

For a single-parameter query tool with no output schema and no annotations, the description fully covers the required context: this is a non-mutating advisory query that returns an answer and evidence. The simplicity of the tool means no further detail is needed.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by giving concrete examples of what the query can contain ('failure patterns, what worked, what broke, recommendation'), which helps the agent formulate a proper query.

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 'Query' and identifies a clear resource ('collective hive'), with explicit examples of what can be asked (failure patterns, what worked, what broke, recommendations). This distinguishes it from sibling tools like marrow_think or marrow_digest, which focus on different operations.

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

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

The description states when to use the tool: 'before acting' and for getting recommendations or asking about decision history. It does not explicitly name alternatives or exclusion cases, but the context is clear enough for an agent to select it over memory-management or key-management siblings.

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

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

No annotations are provided, so the description carries the burden. It discloses that the call is mutating and requires full-scope key, but does not reveal other behavioral traits such as whether existing assignments are overwritten, idempotency, or error behavior. Some transparency is present but not comprehensive.

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

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

The description is exceptionally concise, one sentence with two clear clauses. Every word adds value: purpose, mutation status, and permission requirement. No redundancy or fluff.

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

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

For a simple tool with only two parameters, no output schema, and no annotations, the description covers the essential purpose, side-effect nature, and auth requirement. It lacks explicit discussion of return values or edge cases, but given the tool's simplicity, it is reasonably complete.

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

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

Schema description coverage is 100%, so both parameters are already described well. The description does not add additional meaning about parameter formatting or constraints beyond what the schema provides, meriting the baseline score.

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

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

The description clearly states a specific verb ('Assign') and resource ('active governance policy profile') with a target ('project key'), distinguishing it from sibling tools like marrow_policy_profiles (listing) or marrow_create_policy_profile (creating).

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

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

The description provides useful context (mutating call, requires full scope key) but does not explicitly state when to use this tool versus alternatives like marrow_policy_resolve or marrow_create_policy_profile. Usage is implied rather than directly contrasted with siblings.

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

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

No annotations are provided, so the description carries the full burden. It does disclose key behavioral traits: 'Marrow handles everything in the background without blocking' and 'Zero-friction.' This adds useful context about non-blocking execution. However, it doesn't describe potential side effects (e.g., persistent storage, impact on other tools) or return behavior, leaving some 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 four sentences, each earning its place. It front-loads the purpose, then explains usage, parameters, and a batching tip without fluff. There is no redundant repetition of schema details, making it appropriately sized and well-structured.

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

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

Given the tool's simplicity (generic logging, no nested objects, no output schema), the description is quite complete. It covers what, when, how, and key behavioral constraints. The only notable omission is what happens after logging (e.g., confirmation, visibility), but this is not critical for a fire-and-forget logger.

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 covers 100% of parameters, providing a baseline of 3. The description adds semantic meaning beyond the schema by clarifying the temporal distinction between action ('about to do') and outcome ('if already done'), and explaining how to combine parameters for one-shot logging. This goes beyond the raw field descriptions.

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

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

The description clearly states the tool's purpose: 'Zero-friction Marrow logging' and 'One call for any action.' This specifies the verb (logging) and resource (any action), and distinguishes it from sibling tools by positioning it as a universal, catch-all logger. It explicitly contrasts with specialized siblings by claiming applicability to 'ANY 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 gives explicit usage context: 'Use for ANY action: deploys, file writes, API calls, external sends.' It also provides a practical tip for batching parameters ('pass action + outcome + success together'). However, it doesn't mention when not to use the tool or alternative specialized tools, so it stops short of a 5.

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

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

With no annotations, the description carries the transparency burden. 'Return' implies a read-only operation, and the list of returned metrics provides some transparency about behavior. However, it does not explicitly state side effects, data sources, or any prerequisites, leaving some ambiguity.

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

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

Single sentence, front-loaded with the core action and resource, then a compact list of outputs. No filler words, though the list is slightly dense.

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

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

The description enumerates the report contents, which helps given no output schema, but it lacks usage guidance, sibling differentiation, and any detail on output format or defaults. For a reporting tool with two optional params and no annotations, it is minimally adequate 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?

Input schema covers both parameters at 100% with descriptions. The tool description does not add extra meaning about agentId or periodDays beyond the schema, so the baseline 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?

The description uses a specific verb 'Return' and clearly names the resource 'buyer-grade value proof' with an enumerated list of contents. This makes the tool's purpose clear, though it does not explicitly differentiate from similar sibling reporting tools like marrow_value_report or marrow_dashboard.

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 about when to use this tool versus alternatives. It describes what it returns but not in what situations, nor does it mention exclusions or alternatives. Given many sibling tools, this lack of usage context is a notable gap.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions required proof and consequential work, but does not disclose side effects (e.g., auto-calling marrow_agent_runtime via auto_gate), persistence, or validation behavior. The description adds some context but leaves significant behavioral aspects unexplained.

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 three sentences, each earning its place: purpose, cross-tool inputs, and rationale. It's front-loaded with the verb and resource, and contains no filler or repetition of schema content.

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

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

Given the tool's complexity (13 parameters, nested objects, no output schema), the description is relatively thin. It doesn't explain the overall closure workflow, what happens after commit, or how proof is validated. The schema covers parameter details, but the description alone would not fully guide an agent on the complete commit process.

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 the baseline is 3. The description references 'success/failure, outcome, and proof' which maps to the required parameters, but adds no additional meaning beyond the schema's own parameter descriptions. It does not clarify parameter relationships or formats beyond what's already in the schema.

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

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

The description uses a specific verb ('Close') with a clear resource ('a recorded action') and outlines the core purpose: recording success/failure, outcome, and proof. This clearly distinguishes it from siblings like marrow_think (initiating) or marrow_agent_runtime (executing).

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 direct guidance on what to supply ('Use the decision_id from marrow_think and the gate receipt from marrow_agent_runtime for consequential work') and explains why closure is needed ('accountable fleet learning'). It doesn't explicitly state when NOT to use it, but the context is clear enough for a commit/closure tool.

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

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

No annotations are provided, so the description carries the full burden. The verb 'List' implies a read-only, non-destructive operation, but the description does not explicitly confirm safety, state response format, or mention any side effects. For a simple listing tool, this is adequate but not rich in behavioral detail.

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, front-loading the core action ('List') and efficiently listing the relevant workflow categories. Every word earns its place, and the structure is immediately scannable.

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

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

Given the tool has no parameters and no output schema, the description adequately explains what the tool does and the scope of contracts. It could be improved by mentioning the relationship to the evaluation sibling, but the current text is sufficient for a simple listing tool and would not leave an agent confused about 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 tool has zero parameters, so the schema is empty, and the description naturally adds no parameter-specific details. The baseline for zero parameters is 4, and the description's enumeration of workflow types provides useful context about what the returned contracts may cover, even though it doesn't define parameter syntax.

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 'List' and names the resource 'Marrow completion contracts', enumerating several workflow categories (deploy, merge, publish, etc.). This makes the tool's purpose clear and distinguishes it from sibling tools like 'marrow_evaluate_completion_contract', which focuses on evaluation rather than listing.

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 clear context for when to use this tool: when you need a list of completion contracts across specified workflow types. It implies this is the go-to tool for overviews, though it does not explicitly mention alternatives or when not to use it, which would merit a 5.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It adds useful context by stating the handoff will be tracked through four specific states. However, it omits other behavioral details like persistence, return values, or prerequisites, limiting transparency.

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, front-loaded with the action verb 'Create.' It is free of filler words and every word contributes to the meaning, making it appropriately concise and well-structured.

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

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

Given the tool has 6 parameters, no output schema, and no annotations, the description is severely inadequate. It provides only a minimal purpose statement and lacks parameter semantics, usage alternatives, and behavioral details, making it impossible for an agent to invoke the tool correctly.

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

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

The schema describes 6 parameters with 0% coverage in the description. The description does not mention any parameter names (e.g., to_agent_id, task) or add meaning beyond the schema, failing to compensate for the complete lack of parameter descriptions.

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

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

The description clearly states the tool creates a structured cross-agent handoff, using a specific verb (create) and resource (cross-agent handoff). It also mentions the tracked states (pending, stale, blocked, complete), which distinguishes it from sibling tools like update_handoff and handoff_status.

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 when to use the tool—when creating a new cross-agent handoff that Marrow should track. However, it does not explicitly mention alternatives (e.g., update_handoff) or when not to use it, leaving usage guidance implied rather than explicit.

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

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

No annotations are present, so the description carries the burden of behavioral disclosure. It does reveal the most important non-obvious behavior: the plaintext key is only returned once and must be copied. However, it does not mention other behavioral aspects like permissions, idempotency, or side effects beyond creation.

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 clean sentences, no filler. The purpose is stated first, followed by a critical one-time action warning. Every word earns its place.

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

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

Given 5 parameters and no output schema, the description covers the essential non-obvious return behavior. It could benefit from a bit more context (e.g., typical usage or relationship between key_type and scopes), but the schema covers the parameters themselves, so the description is adequate for a creation 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 100%, so all five parameters already have meaningful descriptions. The tool description adds no parameter-specific semantics, keeping the baseline of 3 as 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 description clearly states the action ('Create') and the resource ('a new API key'), which is specific and distinguishes this from sibling tools like marrow_list_keys, marrow_revoke_key, and marrow_rotate_key. The wording is unambiguous and front-loaded.

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 for initial key creation, but it does not explicitly contrast with alternatives (e.g., rotate, revoke). The instruction 'copy it now' provides practical post-invocation guidance but no when-to-use or when-not-to-use guidance.

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

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

With no annotations, the description must disclose behavioral traits. It explicitly labels itself as a 'Mutating call' and states the auth requirement ('requires a key with full scope'). However, it does not describe update semantics (e.g., whether existing rules are overwritten or merged) or any side effects on related governance data.

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

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

The description is concise, consisting of two short sentences. The main action is front-loaded ('Create or update an explicit governance policy profile'), and the mutation/auth warning is a necessary and concise addition. No unnecessary words 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 no annotations, the description covers purpose, mutation, and auth requirements. However, it omits update behavior (create vs. update distinction) and potential side effects. Given the moderate complexity and 100% schema coverage, the description is adequate but leaves gaps.

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

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

The input schema already provides descriptions for all 3 parameters (name, rules, description), so the description adds little on parameter semantics. With schema coverage at 100%, the baseline of 3 applies; the description does not introduce additional context beyond what the schema already offers.

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

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

The description clearly states the action: 'Create or update an explicit governance policy profile.' It uses a specific verb+resource combination and distinguishes it from sibling tools like marrow_policy_profiles (which likely lists profiles) and marrow_assign_project_policy_profile (which assigns profiles to projects). The term 'explicit' adds specificity.

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

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

The description provides minimal usage context: 'Mutating call; requires a key with full scope.' It implies this tool is for creating/updating policy profiles but does not mention when to prefer this over alternatives like marrow_policy_resolve or marrow_assign_project_policy_profile. No explicit exclusions or alternative conditions are given.

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

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

No annotations are provided, so the description carries the full burden. It clearly indicates a read-only operation ('Get') and lists the data categories included, providing a solid understanding of the tool's behavior. It doesn't discuss side effects or potential failures, but for a read-only dashboard, the behavior is well disclosed.

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

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

The description is extremely concise: two short sentences. The first sentence front-loads the tool's purpose and contents, while the second adds the value proposition. Every word earns its place, with no fluff or repetition of schema information.

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

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

For a no-parameter dashboard tool with no output schema, the description is complete. It fully covers what the tool returns and why it's useful. The sibling context is not needed since this is a unique aggregator. The content list is sufficient for an agent to decide when to call this tool.

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

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

The tool has zero parameters, so there is nothing to document. The description's mention of 'one call' reinforces that no input is needed, making the parameter semantics fully clear. Baseline for zero params is 4, and the description adds positive value by implying the zero-input nature.

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 ('Get') and resource ('operator dashboard'), and enumerates the exact contents: account health, top failures, workflow status, recent activity, and Marrow's saves metric. This clearly distinguishes it from sibling tools like marrow_status or marrow_agent_status, which likely focus on singular metrics.

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 states when to use: 'One call returns everything an operator needs to see.' This implies using it for a consolidated overview. It doesn't explicitly name alternatives or exclusions, but the 'everything' phrasing makes the scope clear, and sibling comparisons are not necessary for such a dashboard aggregator.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It does disclose what the call returns (risk level, workflow steps, handoff requirements, etc.) and positions it as a 'pre-action call.' However, it does not state whether the call has side effects, requires authentication, or is read-only. This is a noticeable gap for a tool that might be used before critical operations.

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 two sentences, front-loaded with the tool's core purpose ('One pre-action call before meaningful or risky work'), followed by a concise list of return contents and usage contexts. Every sentence provides value with no redundancy or filler.

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

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

The tool has 7 parameters, no output schema, and no annotations, so the description must provide substantial context. It names the key return fields and specifies when to use it. It does not explain how parameters like role, type, period, or surfaces map to the returned brief, but the schema covers their definitions. Given the tool's moderate complexity, the description is quite complete for selection and invocation purposes.

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

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

The input schema covers all 7 parameters with descriptions (100% coverage), so the description is not required to re-explain them. The description does not add meaningful parameter-level detail beyond what is in the schema, but it also does not need to. Baseline 3 is 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 description clearly states this is a 'pre-action call' that 'returns risk level, workflow/playbook steps, handoff requirements, freshness/source-of-truth checks, minimum verification checks, proof-pack fields, and next actions.' It uses specific verbs and lists concrete use cases ('deploys, publishes, merges, audits, patches, secret changes, or production work'), which distinguishes it from sibling tools like marrow_run or marrow_workflow_gate.

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

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

The description provides explicit when-to-use guidance: 'Use this before deploys, publishes, merges, audits, patches, secret changes, or production work.' This gives clear context for invocation. However, it does not mention when not to use it or alternatives, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden. It implies a read-only operation via 'Inspect' but does not disclose return format, error behavior, permissions, or whether any state changes occur. The term 'tenant-scoped' hints at access constraints but is not elaborated.

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

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

The description is a single, front-loaded sentence that starts with the action verb. It contains no filler or redundant information, making it highly concise and well structured.

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

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

Without an output schema, the description should explain what the user receives. It mentions inspecting a 'path' but does not describe the output format (e.g., list, graph, narrative). It also lacks context on how the path components (failures, lessons, gate, proof, workflow, outcome) are presented or related. For a simple one-parameter tool, this is a notable gap.

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

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

Schema coverage is 100% and the decisionId parameter is already described as 'Decision ID owned by this account and agent scope.' The description does not add further detail about how the parameter is used or any constraints beyond what the schema provides, so the baseline 3 is 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 description uses a specific verb ('Inspect') and clearly identifies the resource: 'the tenant-scoped path from a decision to prior failures, reused lessons, gate, proof, workflow, and observed outcome.' It conveys a distinct function compared to sibling tools like marrow_decision_brief or marrow_workflow_gate, which likely provide summaries or gate statuses.

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 guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or scenarios where a sibling tool would be more appropriate. The usage context is only implied by the description's wording.

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. 'Soft delete' implies non-destructive behavior, but it does not explain what actually happens (e.g., recoverability, visibility, side effects) or how the 'note' and 'actor' parameters are used.

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 extremely short and to the point, containing no filler or redundant phrasing. However, it may be too terse, but conciseness is rewarded and it earns a high score for clarity without waste.

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

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

The description lacks sufficient context for a soft-delete tool with no output schema and no annotations. It does not explain return values, whether the operation is reversible, or how it differs from related tools, making it incomplete for an agent to fully understand consequences.

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

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

All three parameters have descriptions in the schema (100% coverage), so schema already provides the meaning. The description adds nothing beyond that, matching the baseline of 3 for high coverage.

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

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

The description states a specific verb ('delete') and resource ('memory'), and adds 'soft' to clarify the type of deletion. It is concise and unambiguous, though it does not differentiate from similar sibling tools like 'marrow_mark_outdated' or 'marrow_supersede_memory'.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of the difference between soft delete, mark outdated, or supersede, and no indication of appropriate scenarios or prerequisites.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. While 'Get' implies a read operation, the description does not explicitly state that it is non-mutating, what permissions are required, or any side effects. It focuses on the output contents rather than safety or operational behavior.

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

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

The description is two sentences, front-loads the verb and resource, and lists the key output components efficiently. Every sentence contributes useful detail without wasted 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?

For a tool with a single optional parameter and no output schema, the description does a reasonable job of explaining the purpose and contents of the digest. It lists the main sections (decision counts, trend, saves, improvements, risks) and the default period, though it could go further by noting limitations or clarifying the 'Marrow impact' concept relative to sibling tools.

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

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

The input schema already documents the 'period' parameter with 100% coverage, including the default and allowed values. The description adds a redundant mention of the default 7-day period but does not introduce any new parameter context, so it stays at the baseline for high schema coverage.

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

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

The description clearly states the tool retrieves a periodic summary of agent activity and Marrow impact, listing the specific metrics included (decision counts, success rate trend, saves, improvements, risks). This distinguishes it from sibling reporting tools like marrow_dashboard or marrow_value_report by emphasizing the periodic digest format and the default 7-day period.

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 'periodic summary' and the default 7-day period make the intended context clear – the agent should call this for a periodic review of activity and impact. However, it does not explicitly mention when not to use it or point to alternatives among the many sibling tools, so it stops short of full usage guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals the outcome space and that missing proof fields are returned, which is useful. However, it does not mention whether the tool has side effects, requires specific permissions, or how it processes the evidence object. The behavior is partially disclosed but not fully comprehensive.

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

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

The description is two concise sentences with no redundancy. It front-loads the purpose and then lists the possible outputs, making it easy for an agent to quickly understand the tool's core function.

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 must explain return values. It lists the four statuses and mentions missing proof fields, but does not detail the structure of the missing_proof object or how risk_level/evidence affect the result. Given the tool's moderate complexity, more detail would improve completeness.

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

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

All four parameters have full descriptions in the schema (100% coverage), so the description adds no additional semantic value beyond what is already provided. The baseline 3 applies because the schema does the heavy lifting; the description only implicitly relates to evidence via 'missing proof fields'.

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

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

The description clearly states the tool's function: evaluating whether an agent has enough proof to mark work complete. It enumerates the exact return statuses (complete, missing_proof, review_required, blocked) and mentions 'missing proof fields', distinguishing it from sibling tools focused on memory or key management.

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 when deciding if work is complete, providing clear context. However, it does not explicitly state when not to use it or mention alternatives like marrow_completion_contracts. It gives enough context to infer the primary use case but lacks explicit 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?

With no annotations, the description carries the full burden of disclosing behavioral traits. It does not mention whether export is destructive, what side effects occur, or how output is returned. The term 'export' implies a read operation but provides no concrete behavioral context.

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

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

The description is a single, clear sentence with no filler or redundancy. It efficiently communicates the core purpose without wasted 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 description is incomplete for a tool with no output schema and no annotations. It does not clarify default behavior (e.g., what happens if 'status' is omitted), how the exported data is delivered, or any side effects. This leaves significant ambiguity for the agent.

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 descriptions cover all three parameters with 100% coverage ('tags', 'format', 'status'). The description adds no extra meaning beyond the schema; the baseline of 3 is 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 description clearly states the tool exports memories to two specific formats (JSON and CSV), making the purpose unambiguous. It differentiates from siblings like import/list by specifying the 'export' 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, typical scenarios, or any exclusions compared to related tools.

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

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

With no annotations, the description must disclose side effects and state changes itself. It only lists return values and doesn't state whether the operation is read-only, requires special permissions, or could modify data. It fails to carry the full burden of behavioral 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?

The description is a single sentence with no redundant filler. However, it is jargon-heavy ('outcome closure/runtime gate') and could be more readable. It earns points for brevity but isn't a model of clarity.

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

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

No output schema exists, so the description must explain return values and usage context. It lists return items but leaves 'Marrow value proof,' 'first-run,' and the relationship to other tools unexplained. The description is insufficient for an agent to understand when and why to invoke this tool.

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

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

Schema coverage is 100%, so the JSON schema already documents all eight parameters adequately. The description adds no parameter-specific meaning, but the baseline of 3 is appropriate since the schema carries the load.

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 says it returns a 'value proof' with specific items, but the core function is vague—'proof' could mean verification, demonstration, or reporting. It doesn't clearly differentiate from siblings like marrow_value_report or marrow_buyer_proof, which likely serve similar purposes.

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

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

There is no guidance on when to use this tool versus alternatives. The word 'First-run' hints at an initial onboarding scenario, but the description doesn't state exclusions, prerequisites, or which sibling tools to prefer for other situations.

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 burden of disclosing behavior. The verb 'Retrieve' implicitly signals a read-only operation, and 'ranked' and 'reusable' add context. However, it does not disclose any potential side effects, permissions, rate limits, or result format, which is a gap for an unannotated tool.

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

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

The description is two short sentences, front-loaded with the action and resource. Every word earns its place: the first sentence states what it does, the second gives concrete use cases. There is zero fluff 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?

The tool has no output schema, so the description should help the agent understand what a 'lesson' looks like and what to do with the returned data. While the description clarifies when to call it, it does not describe the return format beyond the word 'ranked', leaving a meaningful gap for a simple retrieval tool.

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

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

Schema description coverage is high (75%), so the baseline is 3. The description does not add meaningful parameter semantics beyond the schema; it never mentions type, limit, query, or agentId. The enum for 'type' lacks a schema description but the enum values are self-explanatory. Overall, the description adds minimal value over the schema.

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

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

The description starts with a clear, specific verb-resource pair ('Retrieve ranked reusable fleet lessons') and immediately indicates the tool's scope. It distinguishes itself from sibling memory and handoff tools by focusing on 'lessons' rather than memories or handoffs, making the resource type 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?

Provides explicit guidance on when to use the tool: 'Use before deploys, handoffs, migrations, audits, and repeated task types.' This gives clear positive use cases, though it does not mention when not to use it or name alternative tools. Missing the 'when-not' component prevents a 5.

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

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

The description adds a key behavioral trait: the key value is masked after creation. However, with no annotations provided, it does not explicitly state the operation is read-only or describe other side effects, leaving some gaps in transparency.

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, direct sentences with no filler. The core purpose is front-loaded, and every word earns its place.

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

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

Given low complexity and one well-described parameter, the description covers the essential purpose and a notable behavioral trait. However, since there is no output schema, it could be more explicit about the return value or structure, though the masking note hints at it.

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

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

The only parameter 'id' is fully described in the schema, and the description refers to it ('by ID'). The description adds no additional semantics beyond what the schema already provides, so the baseline of 3 is 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 description clearly states the action (Get), the resource (API key), and the specific scope (single by ID). This distinguishes it from sibling tools like list_keys (multiple) and create_key (creation).

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 when to use the tool: when you need a specific API key by ID. It doesn't explicitly mention alternatives or exclusions, but for a simple getter the context is clear enough to guide 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 must disclose behavioral traits but only restates the operation. It does not mention side effects, authentication requirements, return format, error behavior (e.g., what happens if the ID does not exist), or whether this is a read-only operation beyond the implication of 'get'.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently communicates the core function without unnecessary elaboration.

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 is simple, but the description omits any detail about the return payload or edge-case behavior. Since no output schema or annotations are provided, additional context such as 'returns null if not found' or 'requires read access' would improve completeness, though the core purpose is clear.

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

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

The input schema already fully documents the sole parameter 'id' as 'Memory ID' with 100% coverage. The description adds no additional semantic nuance beyond the schema, aligning with the baseline for high schema coverage.

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

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

The description clearly states 'Get a single memory by ID,' specifying the action (get), resource (memory), and scope (single, by ID). This distinguishes it from sibling tools like marrow_list_memories (which returns multiple) and marrow_retrieve_memories (likely a search/batch operation).

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

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

The description provides no guidance on when to use this tool versus alternatives such as marrow_retrieve_memories or marrow_list_memories. It does not mention any prerequisites, exclusions, or conditions under which a different tool should be preferred.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only says 'Return' (implying read-only), but does not explain whether 'proof' involves computation, permissions, rate limits, or what happens if control-plane data is unavailable. The return semantics remain opaque.

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

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

A single, front-loaded sentence lists all major content areas without filler. Every word contributes to setting expectations. Very concise and well-structured.

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

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

For a zero-parameter aggregate status tool, the description adequately lists high-level content categories. However, with no output schema, it leaves terms like 'proof packs', 'fleet intelligence', and 'exact next action' undefined, and does not clarify the response structure or level of detail. This is a minimal viable description but not fully self-sufficient.

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 are zero parameters, so the description does not need to add parameter-level meaning. Baseline 4 applies; no gaps to penalize.

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

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

Description clearly states it 'Return[s] Marrow control-plane proof' and enumerates the contents: governance, runtime gates, proof packs, fleet intelligence, supported harnesses, and exact next action. This is a specific verb+resource combination, though it doesn't explicitly differentiate from sibling status/governance tools.

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

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

No explicit guidance on when to use this tool versus alternatives. It implies a current-state proof/status use case, but does not state when this is preferred over related tools like marrow_status, marrow_governance_timeline, or marrow_dashboard.

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 behavior. It implies a read-only retrieval ('Return') but doesn't state if any state is affected, how results are ordered, or what 'recent' means. It also doesn't mention the default agentId behavior or response format beyond the schema.

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

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

A single, well-structured sentence that conveys the core purpose without extraneous detail.

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

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

While the description covers the basic function, it lacks an explanation of the return format (especially with no output schema) and could provide more context on what constitutes governance timeline events. However, given the simple two-param interface, it is minimally complete.

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

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

The schema descriptions cover 100% of parameters, including limit defaults and agentId default. The description adds no extra parameter context, so baseline 3 is 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 description clearly states the tool returns a fleet governance timeline and specifies the event types (decisions, risk gates, proof-pack), giving a specific verb+resource. It distinguishes from sibling tools like decision_trace by focusing on a combined timeline rather than individual decisions.

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

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

No guidance on when to use this vs governance_control_plane or decision_trace. The description only states the action, not contextual recommendations or when-not scenarios.

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

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

With no annotations, the description indicates a read-only query semantics ('Ask who...'), which implies no destructive side effects. However, it does not disclose whether results are aggregated or per-agent, whether historical state is included, or whether special permissions are needed. It adds marginal transparency beyond the basic query intent.

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 efficiently conveys the tool's purpose. It avoids fluff and is easy to parse. Minor deduction for 'Ask' being less direct than 'List' or 'Get', but overall it is appropriately 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?

Given three optional parameters, no annotations, and no output schema, the description is too sparse to enable correct invocation. It doesn't explain what the output looks like, how parameters filter results, or any edge cases. The tool needs more detail to be safely used by an agent.

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

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

Schema coverage is 0% and the description does not mention any of the three parameters (limit, status, agentId). The status list in the description hints at the 'status' parameter but does not explicitly link them. No meaning is added for 'limit' or 'agentId'. The description fails to compensate for the schema gap.

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

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

The description uses 'Ask' as a clear query verb and specifies the resource ('agent fleet') and the statuses being queried (pending, stuck, stale, blocked, complete). It is distinguishable from siblings that focus on other aspects like keys, memories, or runtime, though it doesn't explicitly name any alternative 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?

No guidance is provided on when to use this tool versus alternatives, such as marrow_status or marrow_agent_status. There are no exclusions or prerequisites mentioned. The only hint is the status list itself, but it doesn't tell the agent when this is the right tool.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The verb 'Return' suggests a read-only operation, but it does not explicitly state that there are no side effects, no authentication requirements, or rate limits. For a simple retrieval tool, this is adequate but not richly 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 sentence, about 20 words, that front-loads the primary action and resource. There is no redundant information or filler, making it appropriately concise and well-structured.

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

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

Given the tool's simplicity (zero parameters, no output schema), the description provides enough context to understand what the tool returns and its purpose. It does not explain the return format (e.g., Markdown, plain text), which would be helpful but is not critical for an informational guide retrieval tool.

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

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

The tool has zero parameters, and the input schema is empty. According to the rubric, zero parameters warrant a baseline of 4. The description does not need to explain parameter semantics since none exist.

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

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

The description uses a specific verb ('Return') and names a concrete resource ('Hermes Agent integration guide') with clear content scope (mapping /goal, verification evidence, /learn, /journey, and background subagents). This distinguishes it from other marrow_* sibling tools, which focus on keys, memories, workflows, and other operational concerns.

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 when to use the tool (when you need the Hermes integration guide) but does not explicitly state usage context, exclusions, or alternatives. It is clear enough for an informational tool, but lacks the 'when not to use' or alternative recommendations seen in higher-scoring examples.

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 mentions 'merge (dedup)' and 'replace' modes, which hints at behavior, but it does not explain what replace actually does (e.g., destructive effects, whether existing memories are deleted) or any other side effects. With no annotations provided, the description carries full burden and falls short.

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

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

A single, front-loaded sentence with no wasted words. It immediately states the action and key modes.

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 only two parameters and no output schema, the description covers the core purpose and modes. However, it lacks any mention of return values, idempotency, or potential side effects beyond 'replace', leaving gaps for an agent to handle.

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 covers both parameters with descriptions, so the baseline is 3. The description adds value by clarifying the 'merge' mode as deduping, which provides more semantic meaning than the schema's simple 'Import mode' label.

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 ('Import') with a clear resource ('memories') and distinguishes between merge and replace modes. It clearly differentiates from sibling tools like export_memories or retrieve_memories.

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 usage context is implied by the name and description (importing memories), but there is no explicit guidance on when to use this tool over alternatives like update_memory or delete_memory. No exclusions or alternative tools are mentioned.

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

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

No annotations are provided, so the description carries full responsibility. It only states that the template becomes an active workflow, but does not disclose side effects (e.g., whether it overwrites existing workflows), permission requirements, or reversibility. This is a significant gap 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?

The description is two short, front-loaded sentences with no redundancy. The action is stated first, followed by a direct usage instruction, making it easy to parse.

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

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

The description covers the essential purpose and usage, but lacks detail on expected outcomes or side effects. Since there is no output schema and no annotations, the agent may be left unsure about the return value or whether installation is additive or replacing.

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% with a clear description for 'slug'. The description adds valuable context by instructing the agent to pick the slug from marrow_list_templates, tying the parameter to a specific source and meaning beyond the schema's generic 'Template slug to install'.

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

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

The description clearly states the action ('Install a workflow template into your fleet as an active workflow') with a specific verb, resource, and destination. It distinguishes from siblings like marrow_list_templates, which lists templates, making the install action 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?

Provides explicit contextual guidance: 'Use after marrow_list_templates to pick one.' This tells the agent when to use the tool, but does not mention alternative tools or when not to use it, so it falls short of a 5.

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

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

With no annotations to rely on, the description carries the full burden of behavioral disclosure. It adds a valuable behavioral detail: 'Keys are masked here by design,' which informs the agent that the response will not contain plaintext key values. The 'List' verb also implies a read-only operation, though this is not explicitly stated.

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

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

The description is a single, front-loaded sentence that conveys both the core function and a critical behavioral note. Every word earns its place, and there is no unnecessary 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 zero-parameter, no-output-schema tool, the description is nearly complete. It states the action, the resource, and a key behavioral trait (masking). However, it does not describe the return structure or any potential limitations (e.g., pagination), which could be useful without an output schema.

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

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

The tool has zero parameters, and the schema coverage is 100%, meaning there is no parameter ambiguity. Thus, the description does not need to explain parameter meaning, and the baseline score of 4 is appropriate because the schema is perfectly clear by being empty.

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

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

The description clearly states a specific verb 'List' and resource 'API keys', which precisely identifies the tool's function. It also distinguishes from sibling key-related tools like get_key, create_key, rotate_key, and revoke_key by focusing on enumeration rather than retrieval, creation, rotation, or revocation.

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

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

No guidance is provided on when to use this tool versus alternatives. While the sibling tool names suggest a set of key management operations, the description itself does not mention any exclusions, prerequisites, or comparisons, leaving the agent to infer usage context.

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

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

With no annotations present, the description carries the full burden of explaining behavior. It does not disclose whether results are paginated, whether deleted memories are included by default, whether shared memory access requires permissions, or what the response format looks like.

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 clear sentence with no filler. It front-loads the action and resource, then lists the filters concisely. Every word earns its place.

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

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

For a simple list tool with full schema coverage, the description is minimally adequate. However, given the many sibling memory tools, the lack of usage guidance and behavioral details (e.g., return format, default behavior) leaves gaps that could cause incorrect selection or 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 input schema has 100% coverage for all four parameters with descriptions, so this is the baseline. The description adds no extra meaning beyond what the schema already provides—it merely restates that filters exist.

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

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

The description clearly states a specific action ('List memories') and the resource, and it mentions optional filters. However, it doesn't explicitly distinguish itself from the sibling tool 'marrow_retrieve_memories', which could have overlapping functionality.

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

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

No guidance is provided about when to use this tool versus alternatives like marrow_get_memory or marrow_retrieve_memories. The description only lists filters, not use cases, prerequisites, 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?

With no annotations, the description carries the full burden. It indicates a read-only browse/filter operation through the words 'Browse' and 'Filter,' but it does not explicitly state non-destructiveness, auth requirements, pagination behavior, or return format. It adds context about discovering templates before installing, which is useful but not comprehensive.

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

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

Two sentences, front-loaded with the main purpose, followed by filtering details and the intended use case. Every word earns its place with no redundancy or filler.

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

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

For a simple list tool with three optional, well-documented parameters, the description is largely complete. It explains what the tool does, how to filter, and when to use it. However, it does not describe the return value structure or whether pagination beyond the limit parameter exists, which is a minor gap given the lack of an output schema.

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

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

All three parameters are fully documented in the schema (100% coverage), so the description adds little beyond what the schema provides. The mention of industry examples mirrors the schema's own examples. The description does not introduce new semantics or clarify edge cases, so a baseline 3 is 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 description clearly states the tool's function: 'Browse pre-built workflow templates' and distinguishes it from siblings like marrow_install_template by adding 'Use to discover available workflows before installing.' This makes the purpose obvious and specific.

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

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

The description provides clear context for when to use the tool ('Use to discover available workflows before installing'), implying a pre-installation discovery role. It does not explicitly name alternative tools or list exclusions, but the 'before installing' phrase strongly suggests the relationship with install_template.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It simply states the action without explaining consequences: whether the change is reversible, whether it affects memory retrieval, if permissions are required, or what happens to the memory's lifecycle. This is a significant gap for a mutation-type tool.

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

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

The description is a single concise sentence, which is efficient and free of fluff. It front-loads the core action. However, it lacks any structured breakdown (e.g., bullet points or examples) that could enhance clarity. Overly brief, but not padded, so it earns a 4.

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 3 parameters, no annotations, and no output schema, the description is severely inadequate. It does not explain the meaning of 'outdated', the expected effect on memory data, or any return values. Compare to the calibration example, this is far below the minimum viable description for a 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?

The input schema covers 100% of the parameters (id, note, actor) with brief descriptions like 'Memory ID', 'Audit note', and 'Actor name'. The description does not add further meaning beyond the schema. Since schema coverage is complete, the baseline of 3 applies; no compensation is needed.

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 'Mark a memory as outdated' is a clear verb+resource statement. It clearly identifies the action (mark) and the resource (memory) and specifies the outcome (outdated state). However, it does not explicitly distinguish this from sibling tools like 'marrow_supersede_memory' or 'marrow_update_memory', which could overlap in purpose. The specificity of 'outdated' helps, but explicit differentiation is missing.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or exclusions. Sibling tools like 'marrow_update_memory' and 'marrow_supersede_memory' offer related functionality, but the description fails to clarify when 'mark as outdated' is the appropriate choice.

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 transparency burden. It does disclose an important behavioral constraint: the tool must not receive raw prompts or sensitive content. However, it does not mention side effects, persistence, idempotency, or what the tool returns, leaving significant 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 extremely concise: two sentences, front-loaded with the main action and usage context. The safety instruction is essential and earns its place. 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?

With 17 parameters, no output schema, and no annotations, this description is underspecified. It gives the tool's general purpose but doesn't explain how to populate the many optional fields (e.g., cost_usd, latency_ms, estimated_tokens_saved) or what the recorded data is used for. It is minimally viable but lacks operational detail.

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 18%, and the description does little to compensate. It mentions 'model token usage' and 'value proof,' which hints at the token and cost parameters, but 17 parameters are mostly undocumented, and their meanings must be inferred from names alone.

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

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

The description opens with the specific verb 'Record' and a clear object: 'compact model token usage for value proof.' This distinguishes it from siblings like marrow_value_report, which implies reporting rather than recording.

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

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

Explicitly states when to use the tool: 'Use when the harness exposes provider/model token counts.' It also provides an exclusion by saying 'Do not send raw prompts, completions, tool logs, secrets, or customer content.' It does not name alternative tools, but the context is clear.

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

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

With no annotations provided, the description carries the full burden. It discloses a key behavioral trait: no auto-switching and requires user/agent acceptance or override. However, it doesn't explain the side effects of passing selected_mode/selection_source (e.g., logging) or what the response looks like, leaving some behavioral ambiguity.

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, no wasted words. The core action and critical constraint (no auto-switching) are front-loaded, making the description easy to parse and remember.

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 recommendation tool with nested objects and no output schema, the description adequately covers purpose and the no-auto-switch behavior. However, it doesn't mention the return value or how selected_mode/selection_source are used, which would enhance completeness. Moderate gap but not severe.

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 parameter meanings are already documented. The description adds the context that project/workflow signals are inputs to the recommendation but doesn't elaborate on parameter formats or interrelations. Baseline 3 is appropriate when the schema is complete.

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

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

The description clearly states the action ('Recommend'), the specific targets (passive/pilot/enforce modes), and the input basis (project/workflow signals). It explicitly distinguishes itself from other Marrow tools by noting that it never auto-switches, which differentiates it from workflow or execution tools.

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

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

The description implies usage when a mode recommendation is needed based on project/workflow signals. It also signals that for automatic mode switching, other tools should be used ('Marrow never auto-switches here'), though it doesn't name specific alternatives. This is clear context with minor absence of explicit 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?

With no annotations, the description carries the burden. It reveals that the tool returns lessons/warnings, and it instructs handling of shouldPause=true. However, it does not explicitly state whether the tool has side effects, whether it is read-only, or any authorization/error behavior beyond 'authorized.' This is a moderate transparency 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?

The description is three short sentences, front-loaded with the most important usage instruction ('Call at session start'), and every sentence adds distinct value: when to use, what it returns, and how to handle the response plus an alternative. No filler.

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

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

The description covers when to call, what it returns, the shouldPause behavior, and points to an alternative for policy gating. Missing is a description of the response format or examples of lessons/warnings, which could help given there is no output schema. Overall, it is fairly complete for the tool's purpose.

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 parameters are already well documented. The description does not add meaning beyond the schema; it only mentions 'failure warnings' tangentially related to autoWarn. Baseline 3 is appropriate because the schema already carries the param semantics.

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

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

The description states the tool 'Returns authorized prior lessons and failure warnings for the current account or agent,' which is a specific verb (returns) and resource (lessons/warnings). It also clarifies the timing ('at session start or before meaningful work') and distinguishes from the sibling tool marrow_agent_runtime by directing policy-gate usage elsewhere.

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

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

Explicitly states when to call ('at session start or before meaningful work') and provides a clear alternative: 'Use marrow_agent_runtime for the policy gate before a consequential side effect.' This gives both positive usage context and an exclusion, which is strong guidance.

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

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

No annotations are present, so the description carries the transparency burden. It correctly implies a read-only operation and discloses the default-business fallback, but omits return format, authorization requirements, and pagination behavior.

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

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

The description is a single, front-loaded sentence with no filler. It states the action, resource, and an important edge-case behavior efficiently.

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 no-argument listing tool, the description is largely complete: it identifies the action and the fallback. Since there is no output schema, explicitly describing the return format would improve completeness, but the current wording is adequate for basic usage.

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

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

The tool has zero parameters, so the schema provides no information. Per the baseline for zero-parameter tools, a score of 4 is appropriate; the description adds no parameter-related details, but none are needed.

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 resource ('saved Marrow governance policy profiles') with account scope, clearly distinguishing it from sibling tools like marrow_create_policy_profile and marrow_policy_resolve.

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

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

Provides clear context for when to use (viewing saved profiles) and notes fallback behavior. It does not explicitly mention alternatives or exclusions, but the read-only listing nature makes the use case evident.

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

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

With no annotations, the description carries the full burden and does disclose a key behavioral trait: 'Does not auto-apply', which signals a non-mutating operation. It also mentions the fallback behavior. However, it does not detail return format, error handling, or whether any side effects beyond resolving occur, so it stops short of full transparency.

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 two concise sentences, front-loaded with the main action and scope. Every word earns its place, and the 'Does not auto-apply' caveat is a valuable, non-redundant addition.

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

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

Given the tool's complexity (5 params, nested objects, no output schema), the description adequately covers the core function, fallback behavior, and a key side-effect disclaimer. It does not explain the exact meaning of 'explicit mode' or how matches are resolved, but for a resolver tool this is reasonably complete and would enable an agent to use 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 high (100%), so the baseline is 3. The description does not add significant parameter-level detail beyond what the schema already provides, though it implicitly references 'project/workflow' and 'saved policy profiles' which map to the relevant parameters. No additional syntax or format guidance is given.

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

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

The description clearly states the action ('Resolve'), the object ('explicit mode'), the source ('from saved policy profiles'), and the fallback behavior ('falling back to recommendation'). It also adds a distinguishing behavioral note ('Does not auto-apply'), which differentiates it from sibling tools like marrow_mode_recommend and marrow_workflow_gate.

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 a clear use case: when you need to resolve an explicit mode from saved profiles, with a recommendation fallback. It does not explicitly name alternatives or state when not to use this tool, but the context is sufficient for an agent to select it over related tools like marrow_mode_recommend.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavioral traits. The verb 'Record' implies a write operation, but it does not state whether this creates a new memory entry, whether it can overwrite existing memories, if specific permissions are needed, or what side effects occur. The existence of sibling update_memory makes this ambiguity more significant.

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

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

The description is one concise sentence, front-loaded with the verb and object, followed by a comma-separated list of relevant fields. Every word earns its place, with no fluff 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?

With 10 optional parameters, no annotations, no output schema, and no usage guidelines, the description is not complete enough for an agent to invoke the tool confidently across all cases. It lists many fields but fails to explain key parameters like status, when recording is appropriate vs updating, or what happens after recording (e.g., whether the memory is immediately retrievable).

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

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

The schema has 0% description coverage, so the description must compensate. It lists 7 of 10 parameters in human-readable terms (PR, commit, tests, smoke result, rollback plan, production health, incident notes), which adds some meaning beyond bare property names. However, it omits status, environment, and release_id, and gives no details about formats, allowed values, or relationships between fields.

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

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

The description clearly states the verb 'Record' and the specific resource 'deploy or incident memory', then enumerates the key fields such as PR, commit, tests, smoke result, rollback plan, production health, and incident notes. This makes the tool's purpose unambiguous and distinct from general memory operations like update or get.

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

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

The description provides no guidance on when to use this tool versus alternatives such as marrow_update_memory or other memory-related tools. It does not mention preferred scenarios, exclusions, or how to decide between recording a new memory and updating an existing one.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'full-text search' and filters but does not disclose whether the operation is read-only, how results are sorted, whether filters are combined, or any rate limits or authentication requirements. Minimal behavioral context is provided.

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

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

The description is a single sentence that front-loads the verb and resource, then enumerates filters. Every word earns its place; it is concise and scannable.

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 8 parameters and no output schema, the description gives a general overview but omits details like the limit parameter, result format, and pagination behavior. It is complete for a quick overview but leaves gaps for an agent to fully use the tool correctly.

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

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

Schema coverage is 100%, so the schema already documents each parameter. The description lists the filter names but does not add meaning beyond the schema (e.g., how filters interact, date format specifics, or limit semantics). It provides a useful summary but no additional semantics.

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

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

The description clearly states the tool's function with a specific verb ('Full-text search') and resource ('memories'), and lists the available filters. This distinguishes it from sibling tools like list_memories (browsing) and get_memory (retrieving a specific memory), making the purpose 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 searching memories with filters, but does not explicitly specify when to use this tool over alternatives like list_memories or get_memory. It provides clear context for search scenarios but lacks exclusions or comparison with siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but does not mention side effects (e.g., the key becomes invalid immediately), reversibility, any required permissions, or whether the key is permanently deleted or only deactivated. This is a significant gap for a destructive-looking 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, front-loaded sentence with no unnecessary words. It directly states the core purpose in a clear and efficient manner.

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 is simple (one parameter, no output schema) but the description is too sparse. It lacks critical context about the consequences of revoking a key (e.g., irreversibility, authentication requirements) and any special considerations. Given that no annotations or output schema compensate, the description is not fully complete for safe and correct invocation.

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

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

The input schema already provides 100% coverage by defining 'id' as 'API key ID'. The description only says 'by ID', which adds no new meaning beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states the action ('Revoke') and the resource ('API key'), with a specific method ('by ID'). This distinguishes it from sibling tools like marrow_create_key, marrow_get_key, marrow_list_keys, and marrow_rotate_key, which address different key lifecycle operations.

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

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

The description implies this tool is used when an API key needs to be invalidated, but it does not explicitly state when to use it instead of alternatives like marrow_rotate_key (which might revoke and create a new key) or marrow_list_keys (to find the ID). No exclusions or contextual guidance are provided.

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

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

The critical warning 'Full plaintext key is returned once — copy it now' is a valuable behavioral disclosure not available in annotations (which are absent). It informs the agent that the key is non-retrievable after this call, though it omits other potential consequences like old key invalidation timing or permission requirements.

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, front-loaded with the action, and no filler. Every word contributes to meaning.

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

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

For a simple tool with one fully documented parameter and no output schema, the description covers the essential return behavior ('key is returned once') and gives practical guidance. It could be more complete by noting what happens to the old key, but the core context is present.

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

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

The input schema fully describes the single parameter 'id' as 'API key ID' (100% coverage). The description's phrase 'by ID' reinforces this but adds no novel semantic information beyond the schema.

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

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

The description uses a specific verb ('Rotate') and resource ('API key by ID'), making the tool's function immediately clear. It also distinguishes itself from sibling tools like revoke and get by explicitly stating rotation.

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 use when needing to rotate an API key and warns to copy the returned plaintext, but it does not explicitly contrast with alternatives such as get_key or revoke_key, nor does it state when not to use the 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, the description carries the full burden. It does disclose the automatic orient → think → commit sequence, which is a key behavior. However, it omits any details about side effects, failure modes, or what the output/return value looks like, leaving some ambiguity for a mutation-like tool.

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

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

The description is two sentences, front-loaded with the key benefit ('Zero-ceremony memory logging'), and every phrase adds value. It is tightly written without redundancy or fluff.

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

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

Given the moderate complexity (4 params, no output schema, no annotations), the description is fairly complete. It explains the tool's role as a wrapper and when to use it, though it could mention what the tool returns and any prerequisites. Still, it provides enough context for an agent to decide whether to invoke it.

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

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

Schema coverage is 100%, so the schema already explains all four parameters. The description adds no additional parameter-level detail, but this is acceptable given the schema does the heavy lifting. Baseline 3 is 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 description clearly states the tool's purpose: zero-ceremony memory logging that combines orient, think, and commit into a single call. It distinguishes itself from the sibling tools marrow_think and marrow_commit by explicitly referencing them as the manual 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 explicitly tells the agent when to use this tool ('when you want Marrow to just work without managing the loop yourself') and provides a direct alternative ('instead of chaining marrow_think + marrow_commit'). This is a clear usage guideline with an alternative named.

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 states 'Read live' indicating a read-only operation, but it does not disclose any other behavioral traits such as potential latency, caching behavior (the 'fast' parameter hints at this but is not explained), authentication requirements, or what the response contains beyond the listed categories. This is a significant transparency 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?

The description is two sentences long with no wasted words. The first sentence states the exact action and endpoint, and the second sentence provides use context. It is well-structured and front-loaded.

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

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

The tool is simple (one optional boolean parameter) and the schema covers everything. The description gives a clear purpose and usage context, but without an output schema or annotations, it does not describe return format or behavior of the 'fast' path. For a read-only diagnostic tool, this is adequate but not 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?

The input schema has 100% coverage with a clear description for the only parameter 'fast' ('Use fast cached summary path when available. Defaults to true.'). The tool description adds no additional information about the parameter, so the schema already does the heavy lifting. A baseline score of 3 is 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 description clearly states the tool's action: 'Read live Marrow runtime hook diagnostics from /v1/agent/status.' It specifies the resource and lists the exact diagnostic categories (passive hook, token-capture, outcome-closure, client-update, repair-command status), distinguishing it from broader status tools like marrow_status or marrow_agent_runtime.

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

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

The description provides explicit guidance on when to use the tool: 'Use this when an agent needs exact passive hook, token-capture, outcome-closure, client-update, and repair-command status.' This gives a clear use context. However, it does not mention alternatives or when not to use it, so it falls short of a full 5.

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

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

Since no annotations are provided, the description carries the full burden. It discloses the important side effect of optionally auto-committing open decisions and the purpose of preventing orphaned decisions. However, it does not clarify what happens if autoCommitOpen is false or whether the session end is irreversible, leaving some behavioral ambiguity.

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 extremely concise: two sentences that front-load the primary purpose and then add the secondary behavior. Every word contributes to understanding.

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 tool with one optional parameter and no output schema, the description covers the main aspects: what it does, when to use it, and the side effect of auto-commit. It is slightly incomplete in not describing the default behavior when autoCommitOpen is false and there is an open decision.

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 already describes the parameter with 100% coverage, but the description adds meaningful context by explaining why the flag exists ('Optionally auto-commits any open decision' and 'Prevents orphaned decisions'), which enriches the parameter semantics beyond the schema alone.

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

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

The description clearly states the tool's function with a specific verb ('end') and resource ('current session'), and additionally mentions the optional auto-commit behavior, distinguishing it from other tools like 'marrow_commit' that only handle commits.

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 provides a clear use case: 'when an agent finishes a task', which communicates the intended context. However, it does not explicitly contrast with alternatives (e.g., when to use 'marrow_commit' instead of setting autoCommitOpen), so it lacks formal 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 responsibility for behavioral disclosure. It states the action but does not mention side effects, return format, permissions, reversibility, or other consequences of sharing a memory.

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, well-structured sentence that front-loads the core purpose with no filler or redundancy. Every word contributes to functional clarity.

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

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

For a simple three-parameter tool with complete schema descriptions, the description is minimally adequate. However, the lack of output schema and behavioral context means the agent still lacks information about return values and side effects, which a fuller description could provide.

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

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

The input schema already documents all parameters with clear descriptions (id, actor, agentIds), giving 100% schema coverage. The description adds no additional parameter semantics beyond the phrase 'specific agents,' so the baseline of 3 is 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 description uses a specific verb ('share'), a clear resource ('a memory'), and a precise scope ('with specific agents'), which distinguishes it from sibling memory operations like get, update, or delete. It immediately conveys what the tool does.

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 context is only implied: the description says sharing with specific agents, which hints at when this tool applies, but it does not explicitly contrast with alternatives or mention when not to use it. No exclusions or prerequisites 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 to declare safety or side effects, the description carries the full burden of behavioral disclosure. It only says 'Check... status' and does not mention whether the operation is read-only, what it returns, or any side effects. This is minimal and offers little beyond the tool name.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise for a simple health-check tool, though it could add more detail without becoming verbose.

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

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

The tool is simple with no parameters, annotations, or output schema. The description states the basic function but fails to specify what 'health and status' includes or what kind of response the agent should expect. With no output schema, the description should at least outline return values, which it does not. The presence of several sibling status tools further reduces completeness.

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

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

The tool has zero parameters, so per the rubric, the baseline is 4. The description correctly implies a parameterless status check, and there is no schema to document.

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

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

The description uses a clear verb ('Check') and specific resource ('Marrow platform health and status'), stating the tool's purpose. However, it does not differentiate from sibling tools like marrow_agent_status or marrow_runtime_status, which also sound like status checks.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or relationships to sibling tools, leaving the agent to guess based on the name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'atomically' which is a useful behavioral trait, but it does not disclose what happens to the old memory (e.g., whether it is deleted, archived, or versioned), any permission requirements, or the nature of the replacement. This is a significant gap 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?

The description is a single concise sentence that immediately conveys the core purpose. It is front-loaded with the action and resource, and there is zero wasted wording.

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 and no output schema, the description is inadequate. It explains the basic operation but omits critical context such as what happens to the previous version, whether this is destructive or reversible, and what the return/response indicates. Despite having 6 parameters, no usage context is given beyond the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter semantics beyond what the schema already provides; it does not clarify how parameters like actor, source, or note relate to the atomic replace operation. The description's mention of 'new version' aligns with the text parameter but adds no extra 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 clearly states the action ('Atomically replace') and the resource ('a memory') with a specific outcome ('with a new version'). It is not a tautology and provides a clear verb+resource+scope. However, it does not explicitly distinguish this from sibling tools like marrow_update_memory or marrow_mark_outdated, so it misses an opportunity for 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 gives no guidance on when to use this tool versus alternatives. It does not mention any context, prerequisites, or exclusions. Given the sibling tools include update_memory and mark_outdated, explicit usage guidance would be valuable but is entirely absent.

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 burden. It discloses key behaviors: recording intent, returning a decision_id, auto-committing on previous_outcome, and potential response fields (onboarding_hint, intelligence). It also implies authorization requirements ('authorized governance intelligence'). This is solid but not exhaustive (e.g., error handling or permission details omitted).

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

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

The description is three sentences long, front-loads the main purpose, and every sentence adds value. It avoids redundant details already in the schema and is well-structured for quick reading.

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

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

Given the tool's complexity (11 params, nested objects, no output schema), the description covers the essential workflow and return values. It could be more complete with error cases or conditional behaviors, but the schema fills the parameter gaps, making this adequate.

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 already provides 100% coverage of parameter descriptions, so the baseline is 3. The description adds meaningful context beyond the schema, particularly the 'auto-commit' semantics tied to previous_outcome and the response structure, which helps an agent understand the workflow.

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

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

The description clearly states the tool's purpose: 'Record intent and retrieve authorized governance intelligence before acting.' This uses specific verbs (record, retrieve) and specifies the resource (governance intelligence), distinguishing it from sibling tools as a preparatory step for actions.

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 provides clear usage context ('before acting') and explains the chaining behavior via 'Pass previous_outcome to auto-commit the last decision and open a new one.' However, it doesn't explicitly contrast with sibling tools or state when not to use it, so it lacks a full when/when-not breakdown.

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

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

No annotations are present, so the description carries the full burden for behavioral disclosure. It indicates an update operation but fails to mention side effects, prerequisites (e.g., handoff must exist), constraints on status transitions, or error behaviors. This is a significant gap 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?

The description is a single, well-structured sentence that leads with the verb and resource. It is concise without wordiness, but its brevity leaves out essential details, so it is not a model of informative conciseness.

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

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

Given four parameters, zero schema descriptions, no annotations, and no output schema, the description leaves critical information unexplained. An agent cannot reliably determine what a checkpoint is, which statuses are valid in a given situation, or what the response will be. The description is insufficient for correct invocation.

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

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

Schema description coverage is 0%, yet the description provides no parameter explanations. It mentions 'checkpoint/status' but does not define what 'checkpoint' means, how status maps to the listed events, or what 'result_summary' is. The description fails to compensate for the bare schema.

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

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

The description uses a specific verb ('Update') with a clear resource ('Marrow handoff checkpoint/status') and lists the exact triggering events (accepts, blocks, completes, needs review). This clearly identifies the tool's function and distinguishes it from siblings like marrow_create_handoff and marrow_handoff_status.

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

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

The description explicitly states when to use the tool: 'when an agent accepts, blocks, completes, or needs review.' This provides clear contextual triggers. However, it does not explicitly name alternative tools or state when not to use it, so it lacks the full exclusionary guidance.

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