Synapse Layer — Trust Infrastructure for AI Agents

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

Annotations already declare readOnlyHint=true, so the read-only nature is known. The description adds value by specifying the exact aspects checked (service availability, engine version, storage health) and explicitly stating it is a public method, which informs about potential authentication requirements. No contradiction with annotations.

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

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

The description is extremely concise: two short sentences with no wasted words. It is front-loaded with the core action and immediately lists what is checked. 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?

For a zero-parameter health check tool with an existing output schema and clear annotations, the description is fully adequate. It specifies exactly what is checked and that it is public, leaving no essential 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?

There are no parameters (0 params, schema coverage 100%), so no parameter details are needed. The description correctly omits parameter information, and the baseline score of 4 applies given the complete schema coverage and absence of 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 resources: service availability, engine version, and storage health. It distinctly defines the tool's purpose without ambiguity, and it is easily distinguishable from sibling tools like slo_report which focus on performance metrics.

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

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

The description includes 'Public method' indicating accessibility but offers no explicit guidance on when to use this tool versus alternatives or when not to use it. Given the tool's simplicity (no parameters, health check), the guidance is adequate but minimal; clear context is implied rather than stated.

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

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

The annotations already declare readOnlyHint=true, so the description adds value by disclosing that 'full' detail requires a reason (10–200 chars) and is audit-logged under MEMORY_EXPORT_GOVERNANCE_V1. It also clarifies that 'summary' returns redacted metadata with no plaintext, providing transparency beyond the annotation. However, it does not describe return metadata structure or failure modes beyond the reason requirement.

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 with two sentences, front-loading the core purpose and then detailing the two modes. It is efficient but could be slightly more structured with clearer separation of default vs. advanced usage.

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 output schema exists (handling return values), the description adequately covers initialization behavior and the two detail modes. It is complete enough for a read-only tool with clear parameter documentation, though it could mention any side effects or persistence 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 coverage is 100%, so the schema documents both parameters well. The description adds meaning by explaining that 'summary' is the default and returns redacted metadata only, while 'full' requires reason and is audit-logged. It also states that without reason, 'full' will fail with code -32602, which is valuable context not in the schema.

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

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

The description clearly states the tool initializes a persistent memory context for a conversation or agent session, specifying the verb 'Initialize', resource 'persistent memory context', and the recipient 'conversation or agent session'. This distinguishes it from siblings like 'list_memories', 'recall', and 'store_memory', which are about listing, recalling, or storing memories rather than initializing a 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 explains when to use each detail level: 'summary' for default redacted metadata, 'full' for plaintext content when a reason is provided. It implicitly guides usage by stating requirements for 'full', but does not explicitly contrast with sibling tools or state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true, so the read-only nature is covered without description credit. The description adds 'pagination and governance limits,' which hints at bounded output and scope-based restrictions beyond the annotation. However, the concrete behaviors (hard cap of 10, silent reduction, fail-closed scope default) live 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?

A single seven-word sentence with zero waste. The core action and resource are front-loaded, followed by the two governing concepts (pagination, governance limits). 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 presence of an output schema means return values need no description, and the fully detailed schema plus readOnly annotation carry most of the burden. The notable gap is routing: with 12 memory-flavored siblings, the description doesn't help an agent decide when listing metadata is the right operation versus retrieving content via recall or search.

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

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

Schema description coverage is 100%, so the baseline is 3 even with no param info in the description. The terms 'pagination' and 'governance limits' loosely map to the limit and scope parameters but add little meaning beyond what the schema already states in greater detail (hard caps, silent reduction, fail-closed behavior, PII warning).

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

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

The description pairs a specific verb (List) with a specific resource (memory metadata), and the 'metadata' qualifier implies enumeration of records rather than content retrieval, which loosely distinguishes it from content-returning siblings like recall and search. However, it doesn't explicitly differentiate from the several memory-related siblings (recall_memory, search, store_memory), leaving some inference required.

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. With 12 siblings — including recall, recall_memory, search, save_memory, and store_memory — there is real routing risk and nothing in the description mitigates it. The schema's scope parameter details are functional semantics, not usage direction.

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 already indicate this is a mutating operation (readOnlyHint=false). The description adds that the mutation affects trust scoring rather than memory content, which is useful context beyond the schema. It discloses the core side effect honestly and does not contradict the annotations.

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 earns its place, stating the action and its effect. There is no structural improvement 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?

The schema is rich with aliases and enums, but the description leaves gaps: it does not explain why memory_id is optional despite referring to 'stored memories,' nor the distinction between session_id and memory_id contexts. The presence of an output schema and full parameter docs reduces the severity, but the ambiguous optionality is 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?

All five parameters are fully documented in the schema, so the description carries no additional parameter information. The baseline for 100% schema coverage is 3. No enhancement or clarification of parameter meaning is attempted in the description.

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

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

The description states a clear verb ('Submit') and resource ('stored memories') with a concrete outcome ('adjust trust scoring'). It is not a tautology and is distinct from sibling memory operations. However, it does not explicitly name or contrast with sibling tools, so it earns a 4 rather than 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?

The description implies this tool is for providing feedback after memory use or storage, but it does not state when to choose it over alternatives like save_memory or recall. No exclusions or prerequisites are given. The usage context must be inferred from the tool name and sibling set.

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 show readOnlyHint=false (mutable) and openWorldHint=false (bounded), but the description doesn't disclose what continuity controls entail, whether the handover is destructive to the source, or if auth tokens are required. Output schema exists but description adds no behavioral detail beyond the schema's token/reason requirements.

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

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

The description is a single concise sentence, front-loaded with key action. However, key details like the required token and reason are only in the schema, and continuity controls are vague—could be expanded without bloat to be more helpful.

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 an output schema present, return values don't need explanation. However, given the complexity of state transfer semantics and no mention of side effects or continuity control specifics, the description feels incomplete for agents needing to understand impact before 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 100%, so the schema already documents all three parameters with descriptions. The description explicitly mentions token and reason but adds no extra meaning like format constraints or examples beyond what the schema provides. 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 it transfers contextual state between agents with continuity controls, specifying verb and resource. It distinguishes from sibling tools like initialize_context or process_text by focusing on state transfer rather than initialization or processing.

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

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

The description implies use when handing off context between agents but does not explicitly state when-not-to-use or exclude alternatives like initialize_context for fresh starts. No guidance on preconditions or when a handover is inadvisable.

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

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

The description adds behavioral context with 'governance filters and sanitization', but it does not disclose that the tool may auto-save memories based on triggers, as hinted by the input schema. Annotations only indicate readOnlyHint=false, so the side-effect profile remains vague.

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

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

Single, compact sentence of 11 words that front-loads the verb and core action. No fluff 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?

Despite good schema and annotations, the description omits critical behavioral context: whether the tool only extracts candidate memories or also triggers saves. Given the readOnlyHint=false and schema mention of 'auto-save triggers', this ambiguity is a significant gap for an agent deciding how to use 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 coverage is 100%, so the baseline is 3. The description does not add useful parameter-specific details beyond what the schema already provides, though 'governance filters' hints at project and source handling.

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 specific verb 'extract' with resource 'candidate memories from free-form text', clearly distinguishing it from sibling tools like save_memory, recall, and store_memory. It communicates a distinct processing role.

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

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

The description implies usage for extracting memories from free-form text but does not explicitly state when to choose this over alternatives or provide exclusions. It is clear but lacks direct guidance on tool selection.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds valuable behavioral context beyond this: the mandatory 'reason' parameter with character range, the governance/audit policy implication, and the 20/min rate limit. This is meaningful additional disclosure of operational constraints.

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

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

Two concise sentences with no filler. The core action is front-loaded, followed immediately by the critical governance constraint and rate limit. Every phrase earns its place and the structure is easily scannable.

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

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

With an output schema present and 100% schema coverage, the return format and parameter semantics are already documented. However, the description lacks context about the fail-closed scope behavior and, more importantly, does not disambiguate from the 'recall_memory' sibling, leaving a notable completeness gap for an AI agent selecting between 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?

Schema description coverage is 100%, and the schema already provides rich semantics for each parameter, including enums and examples. The description's mention of 'reason (10–200 chars)' reinforces the schema but does not add significant new meaning beyond what the parameter descriptions already state. 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?

States a specific verb ('Retrieve') and resource ('persisted memory') along with routing modes, which clearly identifies the tool's function. However, the sibling tool 'recall_memory' exists with a nearly identical name, and the description does not differentiate this tool from it, so it is not 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?

The description explains governance and rate limits but gives no guidance on when to use 'recall' versus the closely related 'recall_memory', 'search', or 'list_memories' siblings. There is no mention of conditions, exclusions, or alternative routing, leaving the agent to infer usage from the name and schema.

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 readOnlyHint annotation already covers the safe read-only nature. The description adds only the alias relationship, which is minor behavioral context. It does not mention fail-closed scoping or the required audit reason, though those are documented in the parameter schema rather than 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: two short sentences, each adding some value. The core purpose is front-loaded, and the alias note is a useful routing hint without unnecessary elaboration.

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

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

Given the rich input schema, annotations, and presence of an output schema, the minimal description is mostly sufficient. The alias identification helps avoid confusion with the recall sibling. It could add a sentence on when to prefer this over search, but that gap is minor given the structured metadata already present.

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

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

Schema description coverage is 100%, and parameter descriptions are already detailed, including enums, defaults, scope behavior, and failure conditions. The description itself adds no parameter information, but with complete schema coverage the baseline of 3 is appropriate.

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

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

The description states the action clearly: 'Recall persisted memory by query,' identifying the resource (persisted memory) and the operation. The 'Alias of recall' note further clarifies that it is equivalent to the recall sibling. It does not explicitly distinguish itself from search or list_memories, but the core purpose is unambiguous.

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

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

'Recall persisted memory by query' implies the tool is for natural-language memory retrieval, which gives the agent a basic sense of when to use it. The alias note signals interchangeability with recall, but there is no explicit guidance on when to choose this over search or list_memories, and no exclusion criteria.

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 already declare readOnlyHint=false and idempotentHint=true, so the safety profile is covered. The description adds that the save goes to a 'persistent store', which is mildly useful, but it does not disclose other behaviors like whether existing memories are overwritten, how duplicates are handled, or any security implications.

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

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

The description is two short sentences with no filler. The main action is front-loaded, and the alias note is useful for routing agents to the equivalent save_to_synapse 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?

The schema and output schema are rich, so the agent has enough to call the tool. However, the description omits guidance on when this tool is preferable to the very similar sibling store_memory, and the alias note is the only contextual link to the broader toolset.

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

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

Schema description coverage is 100%, so the schema already fully documents all six parameters, including the nuanced force_intent and subject fields. The description itself adds no parameter-level detail, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's action ('Save a memory entry') and destination ('persistent store'), so an agent can tell it saves memory. It also names save_to_synapse as an alias, but it does not distinguish save_memory from the sibling store_memory, so sibling differentiation is incomplete.

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-related information is 'Alias of save_to_synapse', which tells the agent these two tools are equivalent but gives no guidance on when to prefer this tool over store_memory or other memory tools. No exclusions, conditions, or alternative-selection criteria are provided.

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

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

Annotations already signal that this is a write operation (readOnlyHint=false) and idempotent (idempotentHint=true). The description adds context beyond those annotations by mentioning encryption at rest, sanitization, and deduplication controls, though it does not explain how sanitization/deduplication manifest or what side effects 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?

One front-loaded sentence with no filler, and the core action 'Persist memory' leads. It is appropriately terse, though it could have included routing guidance without becoming verbose.

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

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

With an output schema, 100% parameter documentation, and annotations, the agent can invoke it, but the description leaves the sibling-selection question unresolved and does not clarify the behavior of sanitization/deduplication controls. For a 9-parameter tool in a crowded sibling set, this 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 100%, so the schema fully documents all nine parameters; the description adds no parameter-level meaning. That meets the baseline but does not rise above 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 names an explicit operation and resource: 'Persist memory' is a clear verb+object, and the distinguishing features (encryption at rest, sanitization, deduplication controls) separate it from generic siblings such as save_memory. It does not explicitly name or contrast any sibling, so it misses the top score.

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 rather than save_memory, store_memory, or recall_memory. The feature list implies secure persistence, but there is no explicit context, condition, or alternative mention for an agent to route correctly.

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 that results contain plaintext content and are governed by a reason requirement, adding meaningful behavior beyond the readOnlyHint annotation. It also signals that search operates across agent scopes, which is relevant behavioral context.

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

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

Two tight sentences with no filler: the first states the core action and method, and the second front-loads the critical governance constraint. Every element 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 the rich schema, output schema, and readOnlyHint annotation, the description covers what an agent needs to call the tool safely. The only meaningful gap is guidance on when to use search versus sibling memory tools, but the rest of the context is well supplied.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no parameter-level detail beyond restating the reason requirement, so it meets the baseline but does not go further.

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-resource pair ('Search persisted memory') and adds method detail ('full-text matching') and scope ('across agent scopes'). It is distinguishable in function, though it does not explicitly differentiate itself from siblings like recall or list_memories.

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

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

The description gives clear governance context for when the reason parameter is required, which is useful operational guidance. However, it does not state when to choose this tool over sibling recollection tools, leaving usage selection implicit 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?

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds context about what the tool returns (uptime and SLO metrics) and names the service (MCP service), which is useful beyond annotations. No contradiction with annotations, and the description provides meaningful behavioral context.

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

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

The description is a single, concise sentence (10 words) that efficiently states the tool's function. It is front-loaded with the key verb and resource, with zero redundant or filler content. Every word earns its place.

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

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

Given the tool has only 2 parameters (both well-documented in schema), an output schema exists (so return format isn't the description's job), and annotations provide read safety, the description is largely complete. It could mention that window_hours is optional and defaults to [24, 168], but the schema already covers this, so the completeness is adequate for the tool's simplicity.

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

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

Schema description coverage is 100%, so the schema already documents both parameters well. The description does not add parameter details beyond the schema, but since coverage is high, baseline is 3. The description mentions 'uptime and SLO metrics' which implies the outputs and justifies the window_hours parameter, earning a slight bonus to 4.

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

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

The description clearly states the verb 'return' and the specific resource 'uptime and SLO metrics for the MCP service'. It is unambiguous but does not explicitly distinguish from siblings like health_check, which also returns service status. The title 'SLO Report' reinforces the 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 such as health_check (which likely also returns uptime info). It does not specify when not to use it or mention prerequisites like needing admin_token. The context is implied by the tool's purpose but lacks explicit direction.

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 already indicate readOnlyHint=false and idempotentHint=true, so the description does not need to restate safety. It adds the context of 'metadata and trust scoring' as behavioral features, but does not disclose how trust scoring works, whether existing memories are overwritten, or what side effects occur beyond storing.

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 clean sentence with no filler, and the core action is front-loaded. It is efficient, though it is so terse that some important context is left to the schema and annotations.

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 rich input schema and output schema carry much of the burden, but the description alone does not explain trust scoring semantics or how this tool differs from the similarly named 'save_memory'. Given the number of memory-related siblings, the description is minimally adequate but not complete for confident tool selection.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters thoroughly. The description's phrase 'metadata' loosely maps to tags, subject, and agent_id, but it adds no concrete parameter semantics beyond what the schema provides. 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 names a specific verb ('Store') and a specific resource ('structured memory') with a distinguishing feature ('metadata and trust scoring'). However, it does not differentiate from the sibling 'save_memory', which appears to be a near-synonym, so the agent cannot reliably pick between them from the description alone.

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

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

There is no guidance about when to use this tool versus alternatives such as 'save_memory', 'recall_memory', or 'list_memories'. The one-sentence description gives no use-case context, preconditions, or exclusions, leaving tool selection to inference.

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