llm-kosh

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates a mutation ('applies') but does not disclose whether the action is reversible, what side effects occur on 'live memory', or whether permissions are required. The word 'directly' hints at an immediate effect but provides no detail about consequences or idempotency, leaving the agent unaware of the impact.

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 at one sentence, which is efficient in length. However, it is so minimal that it borders on restating the tool name ('applies an intake proposal' echoes 'apply_intake_proposal'), adding only 'to the live memory' as new information. While front-loaded and brief, it lacks the substance needed for a well-structured description.

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 a single parameter, but the description fails to explain any context: what an intake proposal batch is, how to obtain batch_id, what happens after application, or whether there are side effects. There is no output schema and no annotations to fill gaps. The description is wholly inadequate for an agent to correctly invoke the tool, despite the simple interface.

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 one parameter, batch_id, with no description beyond its type. The tool description does not explain what batch_id represents, how to obtain a valid value, or any constraints (e.g., format, source). Schema description coverage is 0%, so the description offers no compensatory guidance, leaving the agent to guess at the meaning of the parameter.

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

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

The description states a clear verb ('applies') and resource ('intake proposal batch to live memory'), which makes the tool's core purpose evident. However, it doesn't explicitly differentiate itself from sibling tools like trusted_memory_review or list_intake, relying on the verb 'directly applies' to imply it is the final execution step. The resource is specific enough to distinguish from other memory tools, but the lack of explicit contrast prevents a 5.

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

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

There is no guidance on when to use this tool versus alternatives. The description gives no context about prerequisites (e.g., that a proposal batch must exist), nor does it mention that this tool bypasses review or that it should be used after trusted_memory_review. An agent has no way to know if this is the right tool for its current task beyond the name itself.

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 must disclose behavior, but it only mentions 'verify and inspect' without stating whether the operation is read-only, what side effects occur, or what authorization entails. The word 'authorized' hints at permission requirements but provides no details on failures, outputs, or state changes.

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. However, it is under-specified for a tool with 9 parameters; while concise, it sacrifices necessary detail. The structure is acceptable but the content is too sparse.

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 (9 parameters, no output schema, no annotations), this description is grossly inadequate. An agent would not know what evidence_id refers to, what the other parameters control, or what a successful response looks like. The description does not cover the essential information needed to correctly invoke the tool.

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

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

Schema description coverage is 0% and there are 9 parameters. The description does not explain the meaning or purpose of any parameter, including the required evidence_id or the many optional ones like max_text, clearance, or metadata_only. The description fails to compensate for the lack of schema explanations.

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 provides a specific verb ('verify and inspect') and a resource ('authorized registered artifact'), but the scope of 'bounded region' is vague and doesn't differentiate from similar sibling tools like company_artifact_segment or company_artifact_snapshot. It's a clear one-liner but leaves the exact operation ambiguous.

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

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

There is no guidance on when to use this tool versus alternatives such as company_artifact_register, company_artifact_snapshot, or company_memory_search. No context is given for appropriate invocation 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 behavioral disclosure. It discloses that no byte copy occursainer, which is helpful, but it does not explain whether registration creates or updates a catalog entry, whether it rewrites existing registrations, what permissions are needed, or what the agent can expect as a result. These are significant behavioral gaps for a mutation-like operation.

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

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

The description is a single, tightly worded sentence that front-loads the core action and the most important constraint. No words are wasted, and every clause contributes useful 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?

The tool has five parameters, no output schema, and no annotations, yet the description is too sparse to be fully actionable. It does not explain return values, side effects, registration semantics, or how the optional parameters influence behavior. An agent could guess the primary input but would lack enough context to configure the call correctly.

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

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

The input schema has 0% description coverageebb, so the description must compensate for parameter meaning, but it does not. Only file_path can be loosely inferred from 'existing local artifact', while tenant_id, artifact_type, classification, and source_native_id are entirely unexplained. The description adds little value beyond the raw parameter names and defaults.

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 identifies the action: 'Register an existing local artifact by fingerprint'. It specifies the resource (local artifact), the mechanism (fingerprint), and a key behavioral constraint (without copying its bytes), which distinguishes it from tools like company_artifact_inspect or company_artifact_snapshot.

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

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

The description implies the intended use: registering an already-existing local artifact rather than uploading or copying it. However, it does not explicitly state when to prefer this tool over siblings like company_artifact_inspect, company_artifact_segment, or company_artifact_snapshot, nor does it mention any 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 provided, the description carries the full burden of behavioral disclosure. It does disclose that the tool persists data, which implies a write/mutation action, but it does not explain side effects, authorization needs, what happens to existing segments, or the meaning of 'native citations.'

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

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

The description is a single efficient sentence with no filler or repetition. It front-loads the primary action, though the phrase 'bounded derived segments with native citations' is compressed to the point of obscurity.

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

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

This is an 8-parameter tool with no annotations, no output schema, and no parameter explanations. A one-sentence description is far from sufficient for an agent to correctly construct arguments or understand the resulting behavior.

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

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

Schema description coverage is 0%, and the description mentions none of the eight parameters. Required evidence_id, max_text, clearance, groups_json, projects_json, and native_locator_json all go unexplained, so the agent has no semantic guidance beyond raw parameter names.

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

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

The description uses a specific verb-resource pair: 'Inspect an artifact and persist bounded derived segments with native citations.' It conveys the core action of inspecting an artifact and creating segments, but the term 'bounded derived segments' is jargon-heavy and the description does not explicitly differentiate from siblings like company_artifact_inspect or company_artifact_snapshot.

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

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

The description gives no guidance about when to use this tool versus alternatives. It neither names sibling tools nor states conditions, prerequisites, or exclusions. An agent would have to infer usage from the name and high-level action 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 must disclose behavior. It mentions 'immutable' and 'authorized', but doesn't explain side effects: does it create a snapshot record? Is it a write operation that changes system state? Does it require specific permissions? Does it fail if artifact not found? No mention of idempotency, reversibility, or what happens to existing snapshots.

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

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

The description is short and front-loaded with the primary action, but it's under-specified. It is one sentence with no fluff, but it doesn't earn its place because it lacks critical details. Conciseness without substance is not valuable.

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, 1 required, and no output schema, the description is incomplete. The agent doesn't know what the evidence_id refers to, what the clearance levels are, how to format groups_json/projects_json, or what the tool returns. Even though siblings provide context, the description alone is inadequate 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%, so the description carries full burden for parameter semantics flexibly. However, the description provides no information about any parameter except the concept of 'artifact' (which maps vaguely to evidence_id?). It doesn't explain evidence_id, clearance, tenant_id, groups_json, projects_json, principal_id, or their roles, especially the JSON string parameters.

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

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

The description 'Explicitly materialize an authorized artifact into immutable snapshot storage.' mentions verb 'materialize' and resource 'artifact' and destination 'snapshot storage', but it doesn't specify what 'materialize' means in operational terms (e.g., create a copy, freeze version). It doesn't distinguish from sibling tools like company_artifact_register or company_artifact_inspect; an agent wouldn't know when to use this vs. those without more context.

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 tool list includes many memory-related tools, but the description gives no conditions for use or exclusions. The phrase 'authorized artifact' implies some authorization context but doesn't explain how to ensure authorization or what steps precede.

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 not disclose whether these checks mutate state, require authorization, produce a report, or have side effects. 'Run checks' implies evaluation but leaves 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?

A single, compact sentence with no filler or repetitive wording. The action is front-loaded and the content is lean.

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 tool, the description is minimal but understandable. However, it does not explain what 'projection acceptance' means, what the checks verify, or what a successful invocation returns, leaving meaningful gaps given there is no 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, so there is no parameter documentation burden. The description adds context about what the empty-invocation tool does, which is sufficient.

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 a specific action ('Run ... checks') and names three distinct check areas: reference storage, citation, and projection acceptance. It is clear about what the tool does, though it does not explicitly differentiate it from siblings like company_brain_health.

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

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

There is no guidance about when this tool should be used, when it should not be used, or which sibling tool might be a better alternative. With many related company_brain tools nearby, an agent has no routing help.

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

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

With no annotations, the description carries the full burden of disclosing behavior. 'Validate' suggests a read-only check, but the description does not state whether it mutates anything, what it checks exactly, what it returns, or what happens if inconsistencies are found.

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

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

The description is a single, compact sentence with no filler. It places the core action ('Validate') and the subject ('canonical company-brain storage and projection consistency') upfront.

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 health-check tool, a one-line description is a minimum viable identification of purpose. However, key context is missing: what 'storage and projection consistency' means, what the tool outputs, and how it should be interpreted. No output schema exists to fill that gap.

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

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

The tool has zero parameters, so the input schema is complete by itself. The description does not need to explain parameter behavior, and it does not obscure anything. This meets the baseline for a parameterless tool.

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

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

The description uses a specific verb ('validate') and names a concrete resource and concern: canonical company-brain storage and projection consistency. This makes the tool's purpose reasonably clear, though it does not explicitly differentiate it from sibling tools like company_brain_evaluate or company_memory_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?

No guidance is provided about when to use this tool versus alternatives, when it is appropriate to run a health validation, or what conditions would prompt invocation. The description implies a diagnostic purpose but does not state 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?

Annotations are not provided, so the description carries the full burden. It mentions three key behaviors (structured, cited, token-budgeted) that are beyond the schema, which is valuable. However, it does not disclose any side effects, whether the tool reads or writes, how it sources citations, or if it performs expensive operations. The description is too terse to provide meaningful transparency, and the tool name suggests a compile operation but the description doesn't clarify if it persists or just returns output.

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

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

The description is extremely concise (one sentence), which is generally good. However, it is so terse that it sacrifices necessary detail. It is front-loaded with the main action, but the lack of any elaboration makes it under-specification rather than efficient conciseness. Every word earns its place, but more words are needed.

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 11 parameters, 0% schema coverage, no output schema, and no annotations, this description is grossly incomplete. An agent cannot determine what inputs are required, how they interact, what output format to expect, or what side effects occur. Tools like this typically need far more detail to be usable.

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

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

Schema description coverage is 0%, and the description does not explain any of the 11 parameters. The 'task' parameter is central but not described. The 'token_budget' parameter aligns with 'token-budgeted' in the description, but no specifics on how the budget is applied. For a tool with 11 parameters and 0% schema coverage, the description must compensate but does not.

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

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

The description states 'Compile structured, cited, token-budgeted context for an agent task,' which specifies a verb (compile) and a resource (context) with attributes (structured, cited, token-budgeted). However, it is quite generic and does not distinguish itself from siblings like 'company_session_understand' or 'get_project_context' which also compile context. It adds the concept of 'compiling' but lacks specificity about what kind of context or how it relates to the tool's parameters.

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 does not say when to use this tool vs alternatives. It does not mention that this is for preparing context before a task (the 'task' parameter), nor does it contrast with siblings like 'search_memory' for finding specific memories or 'get_project_context' for scope-specific context. There is no guidance on prerequisites, task types, or exclusions.

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

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

There are no annotations, so the description carries the behavioral burden. It does add some context by mentioning 'authorized' and by describing the return composition as ordered event and candidate provenance. However, it does not explicitly state read-only behavior, authorization failure behavior, rate limits, or what happens when the episode is not found.

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

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

The description is a single tightly written sentence with no filler. It front-loads the core operation and includes the most important distinguishing detail about provenance, earning 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 tool with six parameters, no annotations, no output schema, and zero schema description coverage, this description is far too thin. It fails to explain required versus optional parameters, default semantics, authorization expectations, or return structure beyond a brief phrase, so an agent cannot reliably invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it mentions no parameter details at all. It does not explain episode_id, clearance, tenant_id, groups_json, principal_id, or projects_json, leaving the agent without meaningful guidance for populating the six parameters.

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

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

The description clearly identifies a singular fetch operation ('Get one') on a specific resource ('authorized episode') and adds a distinctive outcome ('ordered event and candidate provenance'). This differentiates it from siblings like company_episodes_search, which implies searching rather than retrieving a single episode.

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 company_episodes_search or company_memory_get. The word 'one' implies a singular retrieval, but there is no explicit condition, prerequisite, or exclusion to help an agent choose this tool confidently.

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 implies a read-only search operation but does not explain access-control behavior, result ordering, pagination, filtering semantics, or what 'observed outcomes' means operationally. The word 'authorized' hints at permission gating but leaves it 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 a single sentence with a front-loaded verb and no filler. It is efficient and easily parsed, though the brevity comes at the cost of substantive guidance.

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

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

Given 8 undocumented parameters, no output schema, no annotations, and several sibling search tools, this one-sentence description is not enough to enable correct invocation. It lacks query semantics, result format expectations, and any relationship to related 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 schema has 8 parameters with 0% description coverage, and the tool description names none of them. It provides almost no semantic context for query, limit, clearance, tenant_id, groups_json, projects_json, or principal_id, leaving the agent to guess how these parameters affect the search.

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 specifies a clear verb ('Search') and a specific resource ('authorized goal-oriented work episodes and observed outcomes'), making its purpose understandable. It is distinguishable from company_episode_get, which targets a single episode, but it does not explicitly distinguish itself from other search siblings like search_memory or company_memory_search.

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

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

There is no guidance on when to use this tool versus alternatives such as search_memory, company_memory_search, or company_episode_get. The description states what it does but not when it is the right choice, what scope it covers, or what it intentionally excludes.

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 partially succeeds by signaling that access is authorization-gated and that the result includes evidence references and lifecycle information. However, it does not explicitly state that the operation is read-only, what happens for unauthorized access, or whether any side effects occur.

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

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

The description is one compact, front-loaded sentence with no redundant wording. It loses a point because it is so terse that it omits meaningful context about the parameters and authorization behavior, making it closer to minimal completeness than ideal 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?

The tool has six parameters, many related to authorization context, and no output schema. The description does not clarify how the authorization-related parameters behave, what 'authorized' means in practice, or what structure the evidence references and lifecycle take. More context is needed for an agent to call this correctly.

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

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

Schema description coverage is 0% and the description mentions none of the six parameters. It does not explain how memory_id, clearance, tenant_id, groups_json, principal_id, or projects_json affect the retrieval, leaving the agent to infer all parameter semantics from names and defaults.

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'), names the exact resource ('one authorized memory'), and adds scope beyond the tool name by specifying the returned content ('evidence references and lifecycle'). The word 'one' distinguishes it from sibling search/list tools such as company_memory_search and search_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?

The description implies a single-memory retrieval use case but provides no explicit guidance on when to choose it over related tools like search_memory, trusted_memory_recall, or get_project_context. It also does not state when this tool should not be used or what conditions must hold (e.g., authorization requirements).

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 discloses two meaningful behavioral traits: evidence is immutable and the resulting memory is non-authoritative/candidate. However, with no annotations, it omits side effects, permissions, whether the proposal enters a review workflow, and what the response contains.

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

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

The description is a single concise sentence and front-loads the core purpose. But it is so sparse that it sacrifices the structure and detail needed to support correct invocation of a 10-parameter tool.

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

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

For a tool with 10 parameters, no output schema, and no annotations, a one-sentence description is severely incomplete. The agent lacks guidance on how to construct a valid proposal, what counts as evidence, and what happens after the memory is proposed.

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

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

Schema description coverage is 0% and the description adds no parameter-level meaning. Ten parameters, including required fields like memory_type and evidence_content, are left completely unexplained, forcing the agent to guess allowed values and relationships.

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

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

The description names a specific action ('Create') and a clear resource ('immutable evidence and a non-authoritative candidate memory'). It hints at differentiation from authoritative/trusted memory tools, though it does not explicitly name a sibling or explain the proposal lifecycle.

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 'non-authoritative candidate' phrasing implies this is for proposing memory rather than finalizing trusted memory, but there is no explicit when-to-use/when-not-to-use guidance. An agent must infer the distinction from sibling tool names like trusted_memory_propose.

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. 'Create a candidate semantic memory' does convey a mutation-like action and the 'candidate' wording hints the memory may be provisional, but it does not disclose side effects, approval/review flow, permissions, or whether the memory is persisted immediately. This is a significant gap for a tool that likely creates state.

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

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

The single sentence is grammatically efficient and front-loaded with the core action. However, it is under-specified for a 14-parameter operation, and the conciseness comes at the cost of essential context such as evidence versus non-evidence flows or required parameter semantics. It is not tautological, but it is closer to under-specification than to well-rounded concision.

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

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

The tool is complex: 14 parameters, no annotations, no output schema, and no parameter descriptions. The one-sentence description leaves an agent without enough information to construct a valid call, understand the candidate memory lifecycle, or know how evidence_id relates to registered artifacts. This is far from complete.

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

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

Schema description coverage is 0%, and the description names none of the 14 parameters. It does not explain what evidence_id, memory_type, statement, title, or the defaulted fields mean, nor does it clarify which parameters are required in context. The description provides no value beyond the raw schema field names.

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

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

The description states a specific verb and resource: 'Create a candidate semantic memory' is clear, and the modifier 'citing an existing registered artifact' adds a meaningful scope. It is distinguishable from the sibling company_memory_propose by the evidence-citing precondition, though it does not explicitly name or contrast any sibling.

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

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

The description implies a precondition—that an existing registered artifact must be cited—but it gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives like company_memory_propose or trusted_memory_propose or explain what should happen when no artifact evidence is available.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It implies a state-changing operation ('transition') an unspecified authority check, but it does not state side effects, validation rules, required permissions, failure handling, or whether the transition is immediate or staged.

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 one-line description is technically terse, but this is under-specification, not genuine conciseness. It spends its only sentence on a generic claim and gives zero attention to parameters or operational context, so the structure fails to earn 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 a complex 8-parameter mutation tool with no annotations, no enums, and no output schema, this description is incomplete. Key aspects missing: what lifecycle states exist, what clearance/principal context is acceptable, what the governance flow does, and what the caller should expect upon completion.

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 has 0% description coverage and the description compensates by naming no parameters. With 8 params including to_lifecycle, reason, clearance, groups_json, and projects_json, an agent receives no insight into valid lifecycle values, how groups vs projects apply, or what distinguishes the defaulted principal 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 names a specific verb and resource ('Apply a lifecycle transition to an authorized memory'), so an agent can tell this tool mutates a memory's lifecycle state. However, it does not differentiate this from siblings such as trusted_memory_review or company_memory_propose, and the terms 'governed' and 'authorized' are left unexplained.

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

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

There is no guidance on when to use this tool versus the many sibling memory tools, nor any exclusion condition. The description never states what qualifies as 'authorized', what lifecycle transitions are valid, or how this relates to trusted_memory_review / company_memory_propose.

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 behavioral burden. It discloses 'permission-first' and 'hybrid' search behavior, but doesn't state whether the operation is read-only, what security/clearance requirements exist, how results are returned, or any other concrete behavioral details an agent needs.

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

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

One short sentence with no filler words; the qualifiers 'permission-first', 'hybrid', and 'atomic, evidence-backed' are efficiently packed. It is front-loaded and easy to parse, though the brevity stems from word count rather than structured presentation.

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 11 parameters, no output schema, and no annotations, this description is severely incomplete. It never mentions the required 'query' parameter, what 'permission-first' means operationally, the meaning of 'clearance'/'tenant_id', or the response shape. An agent would need much more context to invoke this tool correctly.

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

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

Schema description coverage is 0%, and the description mentions no parameters. All 11 parameters, including the required 'query', are left to the agent to infer from names like 'groups_json' and 'clearance'. The description adds no semantic value beyond the schema, so it fails to compensate for the absence 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 identifies a specific verb ('search'), resource ('company memory'), and includes distinctive qualifiers ('permission-first', 'hybrid', 'atomic, evidence-backed'). However, it does not distinguish this from sibling tools like 'search_memory' or 'trusted_memory_recall', leaving the agent to guess which search tool is which.

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 when-to-use guidance, exclusions, or alternatives. It merely implies a search use-case, and there is no indication of when a permission-first hybrid search is preferable to 'search_memory' or other sibling memory/recall 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 carries the full burden of behavioral disclosure. 'List' implies a read-only operation, and 'authorized' hints at access filtering, but the description says nothing about pagination, ordering, permission requirements, or return 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 sentence with no wasted words, which is concise. However, it is under-specified for a tool with 7 parameters and no other documentation, so brevity comes at the expense of necessary 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?

There is no output schema, no annotations, and zero parameter coverage, so the description is the only guidance available. 'List authorized normalized source sessions' is far too little for an agent to correctly construct a call or interpret results.

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

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

Schema description coverage is 0% and the description mentions none of the 7 parameters. The defaults such as 'clearance=restricted', 'tenant_id=local', and 'principal_id=local-user' are opaque, and the JSON string parameters are left completely unexplained.

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

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

The description uses a specific verb ('List') and identifies a resource ('authorized normalized source sessions'), making the core intent clear. However, it does not differentiate this tool from sibling tools like company_session_understand, and 'normalized source sessions' is somewhat jargon-heavy.

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

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

There is no guidance about when to use this tool versus alternatives such as company_session_understand or company_episodes_search. The description implies it is for listing sessions but provides no contextual cues, exclusions, or conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'Build' but does not disclose whether the operation persists data, whether dry_run avoids writes, whether existing data is replaced or merged, or what side effects an agent should expect.

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

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

The description is one sentence with no wasted words and front-loads the action and result. It is terse to the point of thinness, but it is still properly 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?

For an 11-parameter tool with no annotations, no output schema, and no parameter descriptions, this is not enough context. The description does not define what 'normalized' means, what the output structure looks like, whether calls are safe to repeat, or what the expected return behavior is.

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

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

Schema description coverage is 0%, and the single clause does not compensate for 11 parameters. 'JSONL evidence' only loosely maps to evidence_id/source_type; it gives no guidance for dry_run, clearance, tenant_id, max_events, groups_json, projects_json, or session_native_id.

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

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

The description names a specific action ('Build'), specific output objects ('normalized sessions, episodes, and cited candidates'), and a specific input ('JSONL evidence'). This is enough to separate it from list/search/propose siblings such as company_memory_propose_from_evidence and company_episodes_search.

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

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

'From JSONL evidence' implies the tool is intended for ingesting raw session/evidence data, so there is a light usage hint. There is no explicit statement of when to use this tool over sibling options, when not to use it, or required prerequisites.

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

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

With no annotations, the description carries full burden. It does mention that the tool 'includes private and sensitive information,' which is a useful behavioral warning. However, it omits other critical behaviors: side effects of creation, whether the pack persists, storage location, access controls, or if it can be retrieved later. The description hints at sensitivity but lacks depth.

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

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

The description is short (two sentences) and front-loads the primary purpose. It avoids fluff, but at the cost of omitting necessary details (especially about parameters and usage). The brevity is appropriate for a simple purpose, but for a tool with undocumented parameters, it sacrifices too much information.

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

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

This is a creation tool for a context pack with private/sensitive data, but there is no output schema or description of what it returns (e.g., an ID). The complement of siblings dealing with memory proposals, reviews, and searches suggests a larger workflow, but the description fails to surface prerequisites or follow-up steps. The tool is under-described for its role in the ecosystem.

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 provides no explanation for the 'query' parameter beyond what its name implies, nor does it explain the 'target' parameter's possible values (e.g., 'llm'). This is a significant gap: the agent must guess what a 'query' should contain and what 'target' options exist. The description should enumerate valid targets or clarify the query format.

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 action and core purpose: 'Creates a highly focused context pack for a specific task.' It clearly distinguishes itself as focused on a specific task, but does not explicitly contrast with sibling tools like 'get_project_context' or 'company_context_compile', leaving some ambiguity about its unique role. A 3 is appropriate—adequate but not particularly specific about what makes it distinct.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, limitations, or contexts (e.g., when a task is private vs. public, when to use company_context_compile instead). The absence of any usage guidance leaves the agent to infer, which is poor for correct 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 it only states the output format (structural map) without any details about side effects, data volume, performance, or what 'active concepts' means. No contradictions exist.

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

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

A single, clear sentence with no extraneous information. It is efficient and front-loaded with the verb and resource.

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 parameterless tool, it is reasonably complete, but it lacks detail on the structure's composition or how it relates to sibling tools. An agent might not know if this is the right tool without more guidance.

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

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

The tool has zero parameters, so the schema covers everything. The description adds meaning by clarifying the output scope, which is sufficient for a parameterless tool.

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

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

The description clearly states the tool returns a structural map, identifying the resource (knowledge base projects and active concepts). It is specific enough to distinguish from generic search/retrieval tools, though it does not explicitly differentiate from similar mapping tools like get_project_context.

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 search_memory or get_project_context. It lacks any indication of 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?

No annotations are provided, so the description must carry the full behavioral disclosure burden. It implies a read/check operation but does not state whether the verification has side effects, what status is returned, or whether it only reports already-computed state.

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

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

The description is a single sentence with no filler and is front-loaded with the action. It is concise, though slightly too terse to fully orient an agent about the tool's behavior.

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

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

Despite the simple zero-parameter shape, there is no output schema and no annotation context. The description names the object being verified but never explains what the agent will receive or how the daemon's status is expressed, leaving a meaningful gap.

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

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

The tool has zero parameters, so schema coverage is trivially complete and there is nothing for the description to add about arguments. The baseline of 4 applies because no parameter documentation 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 states a specific verb ('Verifies') and a specific resource ('the cryptographic ledger of the Cartridge'), giving the agent a concrete sense of what the tool does. However, it does not clearly differentiate from other verification-oriented siblings such as kosh_verify, and the phrasing doesn't strongly align with the 'daemon status' framing in the tool name.

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

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

There is no guidance about when to use this tool versus alternatives. The sibling list contains related tools, but the description gives no criteria for choosing get_daemon_status over them.

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

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

No annotations are provided, so the description carries the full burden. It states 'Fetches,' which suggests a read operation, but it does not disclose what 'all context' includes, whether 'active decisions' has a specific format, whether output is large or paginated, or any side-effect profile. The behavior remains underspecified.

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

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

The description is a single, tightly written sentence with no filler. The core action and target resource are front-loaded, and every word contributes to the 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?

The tool is simple (one required parameter, no output schema), but the description leaves the return payload opaque and does not guide selection among numerous sibling context tools. An agent could invoke it, but it would not know what to expect back or when this tool is the appropriate choice.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameter. It names 'project_name' implicitly via 'for a specific project' but adds no detail about format, examples, ambiguity, or what values are valid. The single parameter is self-explanatory by name, but the description does not enrich it.

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 ('Fetches') and names a clear resource ('all context and active decisions for a specific project'). It is not a tautology and gives an agent a basic idea of the tool's scope, though it does not explicitly distinguish it from sibling context tools like company_context_compile or search_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?

The description implies the tool is for retrieving project context, but it provides no explicit guidance on when to choose this tool over the many sibling context/memory tools, nor any exclusions or alternative routing. An agent is left to infer usage from the name and minimal description.

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

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

With no annotations, the description carries full responsibility. It discloses that the tool ingests into the cartridge, implying a state change, but does not explain side effects (e.g., overwrite behavior, reversibility, required permissions, or what happens to the source file). The behavioral detail is minimal.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently conveys the core action and lists example formats. 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?

The tool has no annotations, no output schema, and low schema coverage, so the description must be comprehensive. It omits the project parameter entirely, fails to describe return behavior or error conditions, and does not mention any prerequisites or side effects. For a tool that modifies state (ingestion), this is a significant gap.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly defines file_path as the local file to convert, but it never explains the 'project' parameter, which appears optional with a default. The description adds no meaning for project, leaving it ambiguous. This is insufficient for a 2-parameter tool.

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

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

The description clearly states a specific action (converts) and resource (local file), and lists supported formats. It distinguishes itself from siblings implicitly since no sibling performs file conversion or ingestion, but it does not explicitly name alternatives.

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

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

The description gives no guidance on when to use this tool versus other intake-related siblings like list_intake or apply_intake_proposal. It does not state prerequisites, such as file accessibility or cartridge context, nor 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 the full burden of disclosing safety and behavioral traits. The description does explicitly state 'read-only' and lists what it does not do (internet, mutation, export private context). However, it does not explain the meaning of the return fields (e.g., how contradictions are determined, what 'stability information' means) or whether the tool has side effects like noise. It is a read-only operation, but the description could be clearer on how the verification is performed or what the output format implies. The contradiction flag is false, but the lack of detail on behavioral specifics (e.g., whether it modifies any state in the analysis process) is a 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 concise and structured as a single paragraph, with the main purpose in the first sentence, followed by a list of what the output can include)Skip. The exclusions are listed in a separate sentence, which is efficient. It is front-loaded with the core purpose and then provides supporting details. No excessive fluff, but it could be slightly more broken down for skimmability; still, it's well-organized for the content provided.

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

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

The tool has no output schema, no annotations, and parameters are undocumented. The description provides an overview of the return fields (supporting facts, causal paths, etc.) but lacks detail on how the agent should interpret them, what 'abstention state' is, or how to handle the output. It also doesn't clarify the expected behavior of parameters like 'depth' or 'dialectic'. Given the complexity of temporal/causal verification, the description is insufficient for an agent to use the tool correctly without trial and error. The complexity is moderate, but the lack of parameter details and output schema 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?

Schema description coverage is 0%, meaning the description does not add any meaning to the parameters beyond their names. The description does not explain what 'depth', 'dialectic', or 'temporal_context' mean or how they affect the verification. The parameter names and defaults are present, but no additional context is given. This is a significant gap because with 4 parameters, the agent needs to understand what each does, especially 'dialectic' which is non-trivial. The description is completely silent, so it fails to compensate for the lack of schema hints.

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 that the tool verifies a question against local temporal/causal evidence)Skip. The verb 'Verify' and resource 'question against local temporal/causal evidence' are specific. It distinguishes itself from siblings by emphasizing local, temporal/causal, and read-only nature, which aligns with the sibling names like trusted_memory_recall and company_memory_search that likely focus on retrieval or proposal, not verification. However, it doesn't explicitly compare with siblings, so a 4 is warranted.

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

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

The description implies the tool is for verification, not for retrieving memories or proposing changes, as suggested by 'read-only' and the focus on evidence. It lists exclusions ('does not consult the internet, seed demo data, write or mutate memory...') which are useful boundary conditions confirming it is for read-only verification. However, it does not explicitly state when to use this tool versus a specific sibling like search_memory or reasoning_query, leaving the agent to infer from the generic description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates a list/read operation, but does not state whether status filtering affects results, whether results have ordering or pagination, or anything about output shape. The mention of 'pending' is a behavioral clue, but it is shallow.

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

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

The description is a single, efficient sentence with no filler and the core action is front-loaded. It is appropriately concise, though it sacrifices some useful detail.

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

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

For a simple tool with one optional parameter and no output schema, the description is minimally viable: calling it with no arguments should list pending intake items. However, the allowed status values, result format, and behavior when overriding the default are left undocumented, leaving gaps in 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?

Schema description coverage is 0%, so the description must compensate for the undocumented 'status' parameter. It mentions 'pending,' which matches the default value, but does not explain what other status values are allowed or how the parameter changes the result.

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

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

The description uses a specific verb ('Lists') and resource ('current items pending in the intake queue'), making the tool's function immediately clear. It is also distinguishable from sibling tools like intake_convert_file and apply_intake_proposal, which clearly do different work.

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

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

No guidance is given about when to use this tool versus alternatives, and no sibling tools or exclusions are mentioned. The intended context is only implied by the phrase 'current items pending,' which is not enough to clearly route an agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what it returns but does not indicate whether the operation is read-only, if it has side effects, requires special permissions, or handles errors. There is no mention of cost, rate limits, or what happens with invalid fact IDs.

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-loading the action and resource. Every word contributes to the purpose, and the return value summary is succinct and clear. No unnecessary elaboration exists.

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 parameter and no output schema, the description gives a high-level overview of the return values but does not define the meaning of 'stability score' or 'status'. It is adequate for invoking the tool, but an agent might need more context on how to interpret the results. The lack of usage guidance further limits 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 schema only defines 'fact_ids' as an array of strings, but the description clarifies that these are specific fact IDs to be processed. This adds meaningful context beyond the bare type definition, though it does not explain what constitutes a valid fact ID or any constraints on the list.

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 ('Run the Lyapunov critic'), the specific resource (list of fact IDs), and the output (stability score, status, per-dimension breakdown). This distinguishes it from sibling tools like reasoning_query or reasoning_explore, which serve different 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention when it is appropriate to invoke it, any prerequisites, or which sibling tools to prefer in other scenarios. The purpose is implied but not explicitly framed against other reasoning tools.

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

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

No annotations are provided, so the description carries the burden of explaining behavior. It does state that the tool enumerates paths and returns a 'fiber bundle,' which is useful, but it does not clarify whether the operation is read-only, how exhaustive 'all' may be, or any computational costs or caps. No annotation contradiction exists.

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 filler. Each sentence contributes useful information: what the tool does and what it returns.

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

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

For a tool with three parametersebab, no annotations, and no output schema, the description is under-specified. It doesn't explain what a 'fiber bundle' is in this domain, how max_hops affects the search, or what the output shape looks like, so an agent may struggle to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It only loosely indicates that from_fact_id and to_fact_id represent 'two known facts,' and it never mentions max_hops or its effect, leaving the agent without sufficient parameter-level guidance.

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

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

The description clearly states a specific action (enumerate) on a specific resource (causal paths between two facts), so an agent can understand the core purpose. It does not explicitly differentiate from siblings like reasoning_query or reasoning_critique, but the path-enumeration focus makes it reasonably distinct.

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

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

The phrase 'between two known facts' implies when to use it, but the description gives no explicit guidance on when to prefer this tool over sibling tools such as reasoning_query or reasoning_critique. No alternatives or exclusions 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?

With no annotations, the description carries the behavioral burden. It discloses that this is a write operation requiring --allow-write, characterizes the fact as bounded and atomic, gives the exact format for datetime and causal_edges, and states the return value (new fact_id). It does not cover failure modes or overwrite behavior, but it provides genuine behavioral context 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?

Four short sentences, each carrying necessary information: purpose, write/auth requirement, format constraints, and return value. There is no filler or redundancy, and the most important facts are 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 description covers required datetime fields, the causal_edges format, auth, and return, which makes a basic call possible. However, with no annotations and no output schema, it should also explain optional parameter behavior such as valid_until and confidence, and provide more detail on edge cases. It is 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?

Schema description coverage is 0%, so the description must add meaning to parameters. It does so for documented_at/valid_from (ISO 8601) and causal_edges (JSON array shape), but it leaves content, confidence, and valid_until semantics to inference. Partial compensation for a 6-parameter schema merits a middle 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 opens with a specific verb and resource: 'Add a bounded atomic fact to the Temporal Causal Reasoning Graph.' It clearly distinguishes this write/ingestion tool from read/query siblings like reasoning_query, reasoning_critique, and reasoning_explore. The title is null, but the description fully compensates.

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 write-operation statement and 'Add a bounded atomic fact' imply when to use the tool, and the required --allow-write flag gives a prerequisite. However, it does not explicitly contrast with alternatives or state when not to use it, so the guidance is 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?

With no annotations, the description carries the full burden. It discloses the default human-readable narrative output, the raw JSON alternative, and temporal_context format. However, it does not state whether the operation is read-only, what errors may occur, or what 'fiber bundle details' contain. Some behavioral clarity 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?

Three concise sentences deliver the essential purpose, default behavior, and a key parameter format. No filler or redundant phrasing. The front-loaded first sentence immediately establishes what the tool does.

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

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

For a tool with no output schema and no annotations, the description gives a reasonable baseline for basic invocation. It explains the main return modes and a parameter format, but omits depth semantics, output structure, and sibling differentiation. It is minimally viable but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for 'narrative' (defaults to true, raw JSON if false) and 'temporal_context' (ISO 8601 or Unix timestamp). It does not explain 'depth', although 'query' is self-explanatory. Partial compensation, not 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 identifies the verb ('Query') and the resource ('Temporal Causal Reasoning Graph'), making the tool's core purpose obvious. It does not explicitly differentiate from sibling tools like reasoning_explore, but the resource name is specific enough to avoid major confusion.

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 parameter-level guidance (narrative mode, temporal_context) but does not explain when to prefer this tool over siblings such as reasoning_explore or reasoning_ingest. No exclusions or alternative routing are mentioned, leaving tool selection largely to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Search', implying a read operation, but does not explain return format, pagination, semantic vs. non-semantic behavior, or any side effects. This is minimal and leaves many behavioral aspects undisclosed.

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

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

The description is a single, concise sentence with no wasted words, which is good. However, it is under-specified; it does not convey enough information to be considered appropriately sized for a tool with three parameters and no other documentation. It is concise but not sufficiently informative.

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

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

Given the absence of annotations, an output schema, and schema descriptions, the description is the only source of context. It fails to explain what the search returns, how results are ordered, how limit and use_semantic affect behavior, or any edge cases. This is critically incomplete for an agent to call the tool correctly.

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

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

Schema description coverage is 0%, and the description provides no explanation of the parameters (query, limit, use_semantic). The description does not compensate for the missing schema information, leaving the agent without any guidance on how to use these parameters effectively.

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

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

The description states a clear verb ('search') and a specific resource ('Cartridge Knowledge Base') with what it searches ('memories, decisions, and files'). This distinguishes it from generic search tools, but it does not explicitly differentiate from memory-related siblings like company_memory_search or trusted_memory_recall, which may also search similar content. Overall, the purpose is understandable but could be more precise.

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 its many siblings. It does not mention any conditions, alternatives, or exclusion criteria. An agent would have to infer usage from the name and context, which is insufficient given the large sibling list.

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

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

No annotations are provided, so the description carries the full burden. It discloses the critical non-obvious behavior: the receipt is queued and not applied immediately. But it omits other behavioral details such as validation, idempotency, or failure modes.

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 with the action and the essential caveat front-loaded. Every word earns its place; there is no filler or redundancy.

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

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

For a one-parameter tool with no output schema, the description explains the core lifecycle: submit, then review, then apply. Yet it does not mention how to verify submission success or check queue status, which would be useful given siblings like list_intake and apply_intake_proposal.

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 zero description coverage for the single parameter, so the description must compensate. It does so by identifying the expected format: 'a MEMORY_RECEIPT.md formatted string'. However, it does not define the structure or constraints of that format, leaving the agent to infer a spec.

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 ('Submits') and resource ('MEMORY_RECEIPT.md formatted string') with a clear destination ('intake queue'). It also distinguishes itself from apply-style tools by noting the receipt is not applied directly, though it does not explicitly name a sibling 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 statement 'Does not apply it directly; it must be reviewed and applied' implies this is the submission step before review/application. However, it does not explicitly state when to prefer this tool over siblings like trusted_memory_propose, trusted_memory_review, or apply_intake_proposal, nor does it provide any exclusions.

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

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

With no annotations, the description must carry behavioral context. 'List' implies a read-only operation, and 'unresolved authorized' adds a small amount of scoping context. However, it does not explain how authorization is determined, how limit/query affect behavior, or whether there are any side effects beyond reading.

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

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

The description is one short, front-loaded sentence with no filler; the verb and object appear immediately. It is concise, but it may be too terse given the number of parameters and lack of usage context, so it does not earn a 5.

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

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

For a tool with eight parameters, no output schema, and no annotations, this description is severely incomplete. It omits parameter semantics, result shape, filtering behavior, and any guidance on how authorization or tenant/project scoping impacts the list.

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

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

Schema description coverage is 0%, so the description must compensate for eight parameters, but it explains none of them. An agent cannot infer how limit, query, clearance, tenant_id, project_id, groups_json, principal_id, or projects_json affect the results.

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 a specific resource ('unresolved authorized Trusted Memory conflicts'), making the core operation clear. It is distinguishable from propose/review/recall siblings by its scoping to unresolved conflicts, though it does not explicitly name or differentiate a sibling.

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

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

The description provides no guidance on when to use this tool versus alternatives like trusted_memory_review, trusted_memory_recall, or trusted_memory_inbox. There are no exclusions, conditions, or example scenarios to help an agent choose this tool.

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

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

With no annotations, the description must carry behavioral disclosure; it does add that the result includes evidence and admission history. However, it does not explicitly state that this is read-only, how authorization is enforced, or what happens when the memory is not authorized.

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

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

The description is a single front-loaded sentence with no filler; every phrase contributes purpose or scope. It could have added more detail, but the structure itself is economical.

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 six-parameter tool with no output schema and no annotations, this one-liner is under-specified. It lacks parameter guidance, usage conditions, and behavioral constraints, so an agent would need to infer critical details.

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

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

Schema description coverage is 0%, and the description only implicitly covers memory_id via 'one authorized memory'. It does not explain clearance, tenant_id, groups_json, principal_id, or projects_json, all of which appear relevant to authorization context and are left to inference.

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

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

The description states a specific action ('Explain'), a specific resource ('one authorized memory'), and distinctive outputs ('evidence and admission history'). This makes it distinguishable from sibling tools like trusted_memory_recall or search_memory, which would not be expected to provide explanatory provenance.

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

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

No guidance is given on when to choose this tool over trusted_memory_recall, trusted_memory_conflicts, search_memory, or company_memory_get. The description does not state prerequisites, exclusions, or the type of query that should route here instead of to a sibling.

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

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

With no annotations, the description carries the behavioral burden. The verb 'List' clearly signals a read-only enumeration and the status scope is stated. Still, it does not disclose authorization needs, pagination/limit behavior, or what the returned items look like, which matters given there is no output schema.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It communicates the core action and scope efficiently, though its brevity does leave semantic gaps covered elsewhere.

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

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

Given 8 optional parameters, no output schema, no annotations, and many overlapping sibling tools, the description is too sparse to fully support correct invocation. An agent cannot tell how clearance, tenant/project, groups, or principal filters affect results, nor what the default call returns.

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

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

Schema description coverage is 0%, and none of the 8 parameters (limit, query, clearance, tenant_id, project_id, groups_json, principal_id, projects_json) are explained in the description. The status language ('candidate', 'quarantined', 'authorized') only loosely hints at filtering and does not map clearly to specific parameters.

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

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

The description uses a specific verb ('List'), a concrete resource ('Trusted Memory items'), and narrows the scope to candidate and quarantined statuses, which helps distinguish it from siblings like trusted_memory_recall or trusted_memory_search. It is not a 5 because 'authorized' is ambiguous and no sibling is explicitly named.

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

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

The phrase 'candidate and quarantined' implies this is the tool for enumerating pending or flagged Trusted Memory items, so the usage context is roughly inferable. However, there is no explicit when-to-use guidance, exclusions, or comparison to siblings such as trusted_memory_review, trusted_memory_conflicts, or list_intake.

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. It discloses that the operation requires MCP write capability, persists the proposal (side effect), and enforces a rule against self-labeling user_direct. It doesn't explain governance flow, review status, or return behavior, but it provides meaningful behavioral constraints 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?

Four short sentences, front-loaded with the core purpose and write requirement; the remaining sentences each add a distinct constraint or workflow note. 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 an 18-parameter tool with no annotations and no output schema, this description covers only the evidence_id edge case and write authorization. It omits governance semantics, required-field meanings, and what happens after proposal. It is not complete enough for correct invocation.

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

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

Schema coverage is 0%, so the description should explain the 18 parameters, but it only clarifies evidence_id (and the source-type implication). Required parameters memory_type, title, and statement are not explained, nor are clearance/classification, JSON fields, confidence, or tenant/project scoping. This is insufficient compensation for an undocumented schema.

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

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

States a concrete action ('Propose governed memory') with the resource and governance context. It is not a tautology and names the write-capability requirement. However, it doesn't distinguish trusted_memory_propose from sibling proposal tools such as company_memory_propose or trusted_memory_review.

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 operational guidance: if evidence_id is omitted, the memory is stored as an agent_observation, and agents cannot self-label user_direct; it instructs to register evidence first when a stronger source type is needed. This is clear context for when to supply evidence_id, but it never states when to prefer this tool over sibling alternatives.

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

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

With no annotations, the description must carry the full behavioral disclosure burden. It adds only a vague governance claim ('admission and lifecycle policy enforced') and does not explain what that means operationally, whether the operation is read-only, how failures are surfaced, or what response shape to expect.

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

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

The description is a single short sentence with no wasted words, but it is under-specified. The phrasing 'admission and lifecycle policy enforced' is jargon that adds ambiguity rather than meaningful structure.

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

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

For a tool with 11 policy-related parameters, no annotations, and no output schema, the description is severely incomplete. It provides no information about query semantics, parameter roles, return values, or governance behavior, so an agent cannot reliably invoke it correctly.

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

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

Schema description coverage is 0% and the description mentions none of the 11 parameters. Parameters such as 'clearance', 'tenant_id', 'principal_id', 'memory_types_json', and 'groups_json' are completely unexplained, leaving an agent unable to infer their meaning from either description or 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 ('Recall') and identifies a resource ('governed memory'), so an agent can tell this is a retrieval/query operation. However, it does not distinguish itself from sibling tools like search_memory or company_memory_search, both of which also imply memory retrieval.

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

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

No guidance is given about when to use this tool versus alternatives. The phrase 'governed memory' hints at a policy-aware context, but there are no explicit conditions, exclusions, or named alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses the requirement for mutate capability (a permission trait) and that conflict resolution is explicit, but it fails to describe what actually happens on approval, quarantine, reject, or supersede—whether actions are reversible, what side effects occur, or what the response looks like. This is insufficient 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 extremely concise at two sentences, with no fluff. The main verbs are front-loaded, and the prerequisite is clearly stated. The second sentence adds nuance but could be clearer; overall it is efficient 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 tool with 9 parameters, no output schema, and no annotations, this description is drastically incomplete. It does not explain the meaning of action, clearance, tenant_id, groups_json, supersede_ids_json, or any other parameter. An agent cannot confidently invoke this tool based on the description alone.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It does not mention any of the nine parameters, including critical ones like action (no enum values defined), reason, memory_id, or supersede_ids_json. The agent receives no guidance on valid values or parameter roles.

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 set (approve, quarantine, reject, supersede) applied to 'governed memory', which clearly identifies the tool's core function. It distinguishes from siblings like trusted_memory_propose or trusted_memory_recall, but does not explicitly name alternatives, leaving some differentiation to inference.

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

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

The description mentions requiring the MCP mutate capability, which implies a prerequisite, and notes that conflict resolution is never inferred, hinting this is for explicit conflict handling. However, it does not clearly state when to use this tool versus alternatives like trusted_memory_conflicts or trusted_memory_recall, nor provide exclusions.

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