Synapse Layer — Trust Infrastructure for AI Agents

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

The description discloses that this is a 'public method' and implies a read-only operation (checking). However, with no annotations provided, the description carries the full burden. It does not mention potential error behavior, return format, or whether the tool makes network calls, leaving some ambiguity.

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

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

The description is a single, concise sentence that leads with the verb 'Check' and follows with the specific objects. It is efficient and contains no unnecessary words, earning a top score for conciseness and 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?

The tool is simple with no input schema, but there is no output schema either. The description does not mention what the tool returns, which is a gap for an agent needing to interpret results. While the name and description imply a health status, the lack of return information makes it incomplete.

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

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

The tool has zero parameters, so the description adds no parameter-specific information, which is acceptable. The baseline for 0 params is 4, and the description correctly does not attempt to explain nonexistent 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 states the action 'Check' and specifies the exact targets: service availability, engine version, and storage health. This makes it distinct from sibling tools like recall or save_memory, which are clearly different in purpose.

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 simply states what the tool does without any context about typical use cases, prerequisites, or exclusions. For a health check tool, the usage might be implicit, but explicit guidance is absent.

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

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

With no annotations provided, the description carries the full burden. It discloses that the default returns redacted metadata, that full retrieval requires a reason and is audit-logged under MEMORY_EXPORT_GOVERNANCE_V1, and that failure occurs without the reason. This gives valuable context about safety, governance, and side effects beyond a simple 'initialize'.

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

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

The description is two sentences, front-loaded with the primary purpose, then concise details on the detail parameter and governance. Every clause adds value, and no redundant or extraneous information is present.

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 explains the return behavior (redacted metadata vs plaintext) well, which is important since no output schema exists. It covers the key conditions for full content and the audit requirement. It doesn't specify the structure of the returned metadata or potential side effects like overwriting existing contexts, but these are not critical for a simple initialization tool.

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

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

Schema description coverage is 100% for both parameters, so baseline is 3. The description essentially restates the schema's content (default detail, reason requirement, 10–200 chars, governance policy, failure code -32602) without adding new meaning. It does not compensate beyond what the schema already provides, so no higher score is warranted.

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

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

The description uses the specific verb 'Initialize' and names the resource 'persistent memory context', clearly stating what the tool does. It also mentions returning redacted metadata by default and optional full plaintext retrieval. However, it does not explicitly distinguish from sibling tools like save_memory or recall_memory, only implicitly via the concept of a session 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 implies usage by explaining when to use default summary vs. full detail with a reason, including the governance policy. But it provides no explicit guidance on when to choose this tool over alternatives such as save_memory, recall_memory, or list_memories. The conditional parameter usage is clear, but tool-selection guidance is missing.

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 mentions 'pagination and governance limits' but does not disclose whether the operation is read-only, what a typical response looks like, or any side effects. This is minimal information for a tool with no annotation support.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It clearly states the action and key qualifiers ('pagination' and 'governance limits') without 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?

The tool has no output schema, and the description does not clarify what 'memory metadata' includes or how governance limits affect results. While the schema explains parameters well, the description leaves room for ambiguity about return values and error behavior, making it 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?

The input schema already provides 100% coverage with detailed parameter descriptions, including the limit cap and scope behavior. The description adds no parameter-specific details, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'List memory metadata'. It is clear and distinguishes from sibling tools by focusing on metadata rather than content, though 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?

No explicit guidance on when to use this tool versus alternatives. The description implies listing behavior but does not contrast with sibling tools like 'search' or 'recall', nor does it state when this tool is preferred.

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

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

With no annotations, the description carries full burden but only discloses that it adjusts trust scoring. It omits key side effects such as how the feedback modifies scores, whether it is idempotent, whether repeated feedback is allowed, and any permissions/auth requirements. 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 a single, front-loaded sentence with no redundant information. It efficiently communicates the core action and target without wasted words.

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

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

The tool is simple (3 parameters, no output schema), and the schema fully documents parameters, but the behavioral impact on trust scoring is vague. The description does not explain how signals affect trust, what happens after submission, or any constraints, leaving moderate 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?

The schema covers all parameters with descriptions, including the enum values for signal. The tool description adds no additional parameter context beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool's action: 'Submit feedback to adjust trust scoring for stored memories.' It uses a specific verb ('submit feedback') and resource ('trust scoring'), distinguishing it from sibling tools like save_memory or recall.

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 does not state when to use this tool versus alternatives, nor does it provide any context for when feedback should be submitted. It only explains the purpose, leaving the agent without guidance on selecting this tool from the memory-related siblings.

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

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

With no annotations, the description bears the full burden of behavioral disclosure. It does not explain token consumption, side effects, validation, or whether this operation mutates state. 'Continuity controls' is vague and fails to reveal potential destructive or state-changing 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 fluff. It is front-loaded and every word earns its place, making it highly concise and well-structured.

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

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

Given moderate complexity (3 parameters, no output schema, no annotations), the description is too minimal. It fails to explain the handover token's origin, consumption behavior, or return value, leaving critical operational context uncovered.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no additional parameter semantics beyond hinting at 'continuity controls', which does not meaningfully map to the token/reason parameters. Baseline 3 is appropriate.

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

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

The description 'Transfer contextual state between agents with continuity controls' uses a specific verb (transfer) and resource (contextual state), clearly distinguishing it from memory-related sibling tools. It succinctly captures the core purpose without ambiguity.

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

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

No guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, exclusions, or contrast with sibling tools like save_memory or recall. The phrase 'continuity controls' hints at a use case but provides no actionable directive.

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 adds some behavioral context with 'governance filters and sanitization', suggesting rules and cleaning, but does not disclose side effects, permissions, or whether the operation is read-only or writes data. This is more transparent than a bare 'process' but still incomplete.

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

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

The description is a single sentence that is front-loaded with the verb and object, contains no fluff, and conveys the core purpose and key nuances efficiently. 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?

There is no output schema and no mention of return format, success/error behavior, or what happens when no candidates are found. For a tool with four parameters (one required) and no output schema, the description is too thin to fully prepare an agent for invocation and interpretation of 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?

The input schema provides 100% coverage with clear descriptions for all four parameters, so the description itself does not need to add parameter details. Baseline of 3 applies because the schema already documents parameter semantics sufficiently.

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 concrete action — 'Extract candidate memories from free-form text' — and adds detail ('governance filters and sanitization') that clearly differentiates it from sibling tools like recall or save_memory. The verb is specific and the resource is unambiguous.

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

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

The description implies the tool is for processing free-form text into memory candidates, but it does not explicitly state when to use it versus alternatives, nor does it mention exclusions or prerequisites. Sibling tools exist but are not referenced, leaving usage guidance to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose governance requirements ('requires reason (10–200 chars)') and rate limits ('20/min'), which are useful. However, it does not mention return format, error behavior (beyond the -32602 for reason), or whether results are ordered or filtered. This is adequate but not rich.

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: the first states the core function and routing methods, the second covers governance and rate limits. Every word earns its place, with no fluff or repetition of schema content.

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

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

Given the tool has 6 parameters and no output schema or annotations, the description is somewhat sparse. It covers the basic purpose and key constraints (reason, rate limit), but does not explain expected output format, pagination, or how to construct effective queries. The schema covers parameters well, but the description could benefit from a brief note on return behavior or use cases.

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

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

The schema covers 100% of parameters with detailed descriptions, so the baseline is 3. The description itself does not add extra parameter semantics beyond stating the reason requirement, which is already in the schema. It provides no additional context that would make the parameters clearer or more actionable.

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

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

The description clearly states the tool's function: 'Retrieve relevant persisted memory using semantic, temporal, priority, or hybrid routing.' This provides a specific verb ('retrieve'), a resource ('persisted memory'), and a method (routing modes). However, it does not distinguish itself from the sibling tool 'recall_memory', which likely has a similar purpose, so it loses a point for lacking sibling differentiation.

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

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

The description offers no guidance on when to use this tool versus alternatives like 'search' or 'recall_memory'. It mentions governance and rate limits but doesn't explain appropriate contexts, exclusions, or prerequisites. The mode parameter descriptions in the schema help but are not part of the description 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the basic action and alias, but does not mention safety, side effects, required parameters, or scope behavior. The fail-closed scope semantics and mandatory 'reason' field are disclosed only in the schema, not the description.

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, using just two short sentences. Every word contributes, with the alias note being useful context.

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

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

The tool is moderately complex with 6 parameters and no output schema, yet the description provides no information about return values, pagination, or behavior beyond the basic recall action. The schema compensates for parameter details, but the description lacks usage context and output expectations.

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

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

The schema provides thorough descriptions for all 6 parameters (100% coverage), so the description does not need to add parameter details. It does not mention any parameters, but the schema's rich definitions suffice; baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Recall persisted memory by query.' It also identifies it as an alias of 'recall', which distinguishes it from sibling tools by clarifying it is essentially the same operation.

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

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

The description offers no guidance on when to use this tool versus alternatives. It merely notes it is an alias of 'recall', but does not explain when one should be preferred over the other or when to use other memory tools like 'list_memories', 'save_memory', or 'search'.

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

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

No annotations are present, so the description carries full responsibility for disclosing behavior. It only mentions saving to a persistent store, without addressing idempotency, overwrite semantics, required permissions, or return behavior. The alias note is indirect and does not replace explicit behavioral transparency.

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

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

The description consists of two short, to-the-point sentences. The purpose is front-loaded, and the alias note adds useful cross-reference without unnecessary 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 three well-documented parameters and no output schema, the description covers the essential operation. However, it lacks information about the return value and does not fully disambiguate from overlapping siblings like store_memory, leaving some gaps in contextual 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 100%, with all three parameters (tags, content, agent_id) having descriptive text. The tool description adds no additional parameter context, so the baseline of 3 applies.

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

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

The description clearly states 'Save a memory entry to the persistent store' with a specific verb and resource. It also mentions being an alias of save_to_synapse, which adds clarity, but it does not differentiate from the sibling store_memory, so it loses the full sibling distinction.

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

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

The only usage guidance is 'Alias of save_to_synapse,' which implies equivalence but gives no explicit instructions on when to use this tool versus the sibling store_memory or others. There are no exclusions or alternative scenarios provided.

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

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

With no annotations, the description carries the transparency burden. It discloses meaningful behavioral traits (encryption, sanitization, deduplication) but remains vague about side effects, error handling, or specific sanitization/dedup 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, front-loaded with the primary action ('Persist memory') followed by key differentiators. Every word earns its place and there is no 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?

Despite a complete schema, the tool has 6 parameters and no annotations, yet the description is brief. It lacks guidance on when to use this tool versus similar siblings, and omits return behavior or deduplication semantics, leaving the context thin for a non-trivial memory operation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-specific context beyond what the schema already provides, making it sufficient but not enhanced.

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

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

The description clearly states the tool persists memory, with specific differentiators of encryption at rest, sanitization, and deduplication controls. This distinguishes it from sibling tools like save_memory and store_memory, which likely lack these specialized features.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or scenarios where other memory tools should be preferred.

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

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

With no annotations, the description carries the transparency burden. It discloses that results contain plaintext, governance reason is required, and the default agent scope is fail-closed. This is significant behavioral context beyond a simple 'searches memories' statement.

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

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

Two sentences, front-loaded with purpose and immediately adding governance context. No filler or redundancy; every sentence earns its place.

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

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

Given 5 parameters, no output schema, and no annotations, the description covers purpose, scope semantics, and governance. It does not describe the return format or pagination, but the schema covers parameter details and the core behavior is clear. Overall adequate for the complexity.

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

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

Schema description coverage is 100% and every parameter is clearly explained in the schema. The tool description mostly repeats the reason requirement and scope behavior already present in the schema, adding little new meaning beyond framing the search as full-text.

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

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

The description uses a specific verb ('Search') and resource ('persisted memory') and adds 'across agent scopes using full-text matching', which distinguishes it from sibling tools like list_memories or recall that imply listing or retrieval by other means. It clearly defines the tool's function.

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

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

The description provides clear context: the tool searches persisted memory across scopes and requires a reason due to plaintext content. It implies when to use it (full-text search with governance) but does not explicitly mention alternatives or when not to use it compared to siblings.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It does not mention authentication requirements (though documented in the schema), side effects, or return format. The verb 'return' implies read-only but not explicitly.

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, focused sentence with no redundant phrases. It is front-loaded and efficiently communicates the core purpose.

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 report tool, the description is minimally adequate. The schema covers parameters, but with no output schema and no annotations, the description could add more context about the report's structure or authentication requirements. Overall, it is sufficient but leaves room for improvement.

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

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

The input schema fully documents both parameters (admin_token and window_hours, including defaults and meanings). The description adds no extra parameter information, so the baseline score of 3 for high schema coverage applies.

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

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

The description clearly states the tool returns uptime and SLO metrics for the MCP service, using a specific verb ('Return') and resource. However, it does not explicitly distinguish itself from the sibling health_check tool, though the resource type differs.

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 usage guidance is provided. The description only states what the tool does, without any indication of when to use it versus alternatives like health_check or memory tools.

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

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

With no annotations, the description must convey behavioral details. It only says 'store' and mentions 'trust scoring' without explaining what that entails, whether it's a safe operation, or what side effects occur. This leaves the agent uncertain about the tool's 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 concise sentence with no wasted words. However, it's under-specified—terms like 'trust scoring' are left unexplained, making the brevity less helpful than it could be.

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

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

The tool is simple, but without an output schema, the description should at least indicate what the tool returns or how it handles existing memories. It doesn't, and it doesn't distinguish itself from the many sibling memory tools, making it incomplete for selection and invocation.

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

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

The schema covers all parameters with descriptions, giving a baseline of 3. The tool description doesn't add parameter semantics beyond the schema; 'metadata' might map to tags, but 'trust scoring' isn't tied to any parameter, and the description doesn't discuss parameter usage or examples.

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 action ('Store') on a resource ('structured memory') and adds distinguishing features ('metadata and trust scoring'), but it doesn't explicitly differentiate this from sibling tools like 'save_memory' or 'save_to_synapse'.

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 usage guidance is provided. The description doesn't indicate when to use this tool over alternatives, and there's no mention of exclusions or complementary tools.

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