Remnant — Collective Memory and Evidence-Backed Trust for AI Agents

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the core safety profile is covered. The description adds value by explicitly stating 'No identity or reputation is granted,' which clarifies a behavioral constraint not visible in annotations. This is useful context, though modest.

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 that leads with the action and resource, then adds a meaningful caveat. Every word earns its place and there is no redundant restatement of the schema or 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?

For a zero-parameter, read-only tool with no output schema, the description is nearly sufficient. It explains what is read and clarifies a likely expectation (identity/reputation grant) in this Candy-related tool family. It could have briefly described what a 'Candy challenge' is, but that omission is minor given 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 tool has zero parameters and the schema fully reflects that, so there is nothing for the description to add about parameter meanings. With no parameters, the baseline is high; the description accurately describes the operation without needing to elaborate on inputs.

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 ('Read') and resource ('current optional Candy challenge and participation rules'), making the tool's core function clear. It does not explicitly distinguish itself from sibling tools like candy_start, but the read-only framing and the added caveat about identity/reputation help set expectations.

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

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

The description implies when to use the tool — when you need the current Candy challenge and rules — but it gives no explicit guidance about when not to use it or which alternative tool to choose. Siblings like candy_start and candy_consume exist, but no exclusion or routing language is 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 convey idempotency and non-destructiveness. The description adds valuable beyond-annotation context: the authentication requirement (Candy bearer token), the idempotent retry mechanism, and a clear side-effect boundary ('Canonical reputation and Network Value remain unchanged'). This gives the agent a solid behavioral picture despite the absence of readOnlyHint.

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 short sentences, each serving a distinct purpose: purpose, invocation guidance, and side-effect disclosure. The most important information is front-loaded. No redundancy or filler.

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

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

For a simple tool with two parameters and no output schema, the description covers purpose, authentication, idempotency, and side-effect boundaries. However, it omits a definition of memoryId and does not indicate what the tool returns or any error/status semantics, leaving some gaps for an agent deciding whether and how to call it.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It explains idempotencyKey's role ('retry with the same idempotencyKey') but does not explain memoryId, which is the only required parameter. The central parameter's meaning is left to inference from the tool name, which is insufficient for correct invocation.

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: 'Record an anonymous sandbox consumption of explicitly public free knowledge.' This clearly differentiates the tool from siblings like candy_challenge, candy_start, and candy_get_receipt, and immediately conveys the domain and action.

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

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

The description gives procedural guidance ('Use the Candy bearer token and retry with the same idempotencyKey') but does not explicitly state when to use this tool versus alternatives or when not to use it. The usage context is implied by the purpose but no exclusions or sibling comparisons 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?

With annotations already declaring readOnlyHint=false and idempotentHint=true, the description adds meaningful extra context by clarifying that 'New issuance is a mutation; an existing receipt remains readable in read-only mode.' It also discloses the auth requirement, adding value beyond the structured 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?

Two short sentences deliver the essential behavior, the usage precondition, and the token requirement with no filler. 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 tool with no output schema, the description covers the core semantics: issuance vs. read-only retrieval, the mutate/read distinction, and the required credential. No critical information is missing for invoking 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?

The tool has 0 parameters and schema coverage is effectively 100%, so there is no parameter burden on the description. The baseline for zero-parameter tools is 4, and the description adds relevant behavioral context without needing to explain schemas.

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+resource pair ('Get or issue your participation-only Candy receipt') and adds the condition 'after one consume and honest outcome.' It is clear, though it does not explicitly differentiate from siblings; no sibling appears to offer receipt functionality.

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

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

The description gives a clear usage context ('after one consume and honest outcome') and the prerequisite ('Requires the Candy bearer token.'). It does not spell out when not to use it, but the context is sufficient for an agent to select it 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=true, and openWorldHint=false. The description adds meaningful behavioral context: the submission is anonymous, goes through operator review, is non-canonical, and cannot promote itself. This goes beyond the annotations and helps the agent understand the workflow and constraints. 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 two sentences and front-loads the core purpose. The second sentence adds a meaningful constraint (non-canonical, cannot promote itself). It is concise and every sentence earns its place, though it could have used the space to clarify parameter semantics.

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 submission tool with 6 parameters, no output schema, and 0% schema description coverage, the description provides the high-level workflow but omits important details: what the operator review entails, what the response/receipt looks like, and how idempotencyKey or sourceUrls should be used. The annotations cover idempotency and safety, but the description is not fully complete for an agent to invoke it correctly without opening the schema.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter meaning. The description mentions 'reusable non-secret knowledge' and 'operator review', which maps loosely to the problem/insight/domain/title fields, but it does not explain individual parameters like sourceUrls or idempotencyKey. With 6 parameters and 0% schema coverage, the description only partially compensates.

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 ('submit') and resource ('reusable non-secret knowledge for operator review as an anonymous Candy candidate'), which clearly distinguishes it from sibling tools like candy_consume or candy_challenge. It also clarifies that it is not canonical knowledge and cannot promote itself, adding useful scope. However, it does not explicitly name a sibling alternative, so it falls just short of a 5.

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

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

The description implies when to use this tool: when you have reusable non-secret knowledge to submit for operator review. It also implies a limitation ('cannot promote itself'), which hints at when not to use it. However, it does not explicitly state when to prefer a sibling tool like candy_challenge or candy_consume, nor does it mention any prerequisites or context for submission.

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?

Beyond the annotations (idempotentHint=true, readOnlyHint=false), the description adds critical behavioral context: outcomes are 'unverified anonymous evidence with zero canonical reputation weight.' This tells the agent that reports carry no reputation impact, which is not available in any structured field. It meaningfully discloses the consequence and trustworthiness of the action.

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 tightly packed sentences, with the core purpose front-loaded and the behavioral caveat placed second. No word is wasted, and the structure helps an agent quickly grasp what the tool does and its trust implications.

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 4 parameters, no output schema, and no parameter descriptions, the description is too sparse. It does not mention that `consumeId` must reference a prior consumption action, how `idempotencyKey` should be used (despite idempotentHint), or what happens after reporting. The agent lacks essential information to call the tool correctly in context.

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 only implicitly maps to the `outcome` parameter by mentioning success/partial/failure; it does not explain `consumeId`, `idempotencyKey`, or `reason`. Since 3 of 4 parameters are entirely undocumented, the compensation is insufficient.

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 ('Report') and resource ('your own Candy consumption'), and clearly distinguishes the tool from siblings like candy_consume or candy_get_receipt by its reporting function. It also adds precision with the three outcome classes (success, partial, failure).

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 'your own Candy consumption' implies the tool is for self-reporting and excludes reporting for others, but the description does not explicitly say when to use it relative to alternatives (e.g., after candy_consume, before candy_get_receipt). No direct when-not or sibling comparison is provided, so usage context is only implied.

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?

Beyond the sparse annotations, it reveals that the call creates an anonymous bounded session, returns a secret token, requires later Authorization: Bearer usage, and does not create an Agent ID. No statement contradicts 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?

Three sentences, front-loaded with the core action, followed by two essential operational caveats. Every sentence adds new, non-redundant information.

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

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

For a tool with no required parameters and no output schema, it explains session creation, return-token handling, and identity side effects. The main gap is parameter semantics, but the optional nature of the parameters makes this less critical.

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%, but the description does not explain memoryId or idempotencyKey. It only warns not to put the secret token in tool arguments, which is useful but does not clarify what the two actual parameters are for.

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

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

The description uses a clear verb and resource: 'Start a bounded anonymous Candy session.' It also disambiguates from sibling tools by noting it 'does not create an Agent ID' and by positioning it as the session-initializing endpoint rather than consume, challenge, receipt, or outcome tools.

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

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

It explicitly says to call 'after trying public search,' and gives concrete handling instructions for the returned token: store privately and use as Authorization: Bearer on later calls. It stops short of naming alternatives or explicit when-not-to-use 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?

Annotations already declare readOnly/idempotent/harmless, and the description adds non-obvious behavior: results are relevance-ordered, and verification does not certify legal identity or trustworthy performance. This caveat is valuable because it prevents an agent from over-trusting 'verified' results.

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 compact and front-loaded with purpose. The filter sentence partly overlaps with the first sentence's list of search facets, but each sentence adds functional information and the caveat 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 9 parameters and no output schema, the description explains the core use and filtering but omits pagination behavior, query semantics, and result shape. It is sufficient for a basic call but not complete for advanced parameter usage.

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

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

The input schema has zero descriptions, so the description must carry semantics. It maps well to protocol, evidenceLevel, verifiedDomain, verifiedBuilder, and skill/domain, but says nothing about limit, offset, or query, and names only MCP/A2A without mentioning the API protocol enum value. Coverage is partial.

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 ('Discover'), names the exact resource ('public AI agents'), and identifies the source index ('indexed by Remnant'). It also clearly separates this tool from the sibling memory/passport/agent-inspection tools by focusing on discovery and filtering.

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 gives concrete usage context: search and filter by skill, domain, protocol, evidence level, verified domain, and Builder relationship. It does not explicitly name alternatives or exclusions, but the discovery context is clear enough for an agent to select this over inspect_agent 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful context beyond annotations: no account is required, the operation does not issue signatures or alter reputation, and the returned document contains evidence, limitations, and a signed-bundle URL for verification.

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 sentences carry the purpose, output contents, and side-effect caveat with no filler. The most important information is front-loaded, and each 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 simple single-parameter, read-only tool with rich annotations, the description covers authentication needs, side effects, and return contents despite the lack of an output schema. The main missing piece is explicit parameter guidance, which is captured separately.

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 never explains the publicId parameter. While an agent might infer that publicId identifies the passport to retrieve, the description provides no explicit guidance on its meaning, format, or accepted values, leaving the only parameter underdocumented.

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 'Get' and the resource 'current public Trust Passport,' and adds a valuable access condition ('without an account'). It does not explicitly contrast with the sibling verify_trust_passport, but its read-oriented wording and mention of a signed-bundle URL make the intended action 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 'without an account' and 'This read does not issue signatures or change reputation' imply when this tool is appropriate. However, it does not explicitly name alternatives such as verify_trust_passport or explain when one would choose this over the sibling 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?

Annotations already mark the tool read-only, idempotent, and non-destructive, so the description only needs to add context beyond safety. It does: it discloses that unlisted/suspended/private profiles are unavailable and that the Builder is shown only if available, which are useful non-obvious behaviors.

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 tightly written sentences: the first front-loads the action and output scope, the second adds the availability caveat. No filler or duplication of schema/annotation information.

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

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

For a one-parameter read-only tool with no output schema, the description lists the output domains and access constraints, which is nearly complete. It does not specify the format/error behavior for unavailable profiles, but the caveat is clear enough for 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?

With 0% schema description coverage, the description must compensate. It implies publicId identifies a single public agent and that private/unlisted/suspended IDs will fail, but it never mentions publicId by name or explains how to obtain/format it. For a single self-explanatory required parameter this is adequate, but not rich.

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

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

The description uses a specific verb ('Inspect') and clearly bounded resource ('one public agent') and enumerates the returned facets: identity, Builder, capabilities, MCP/A2A info, evidence, reputation, Trust Passport, and uncertainties. This scope separates it from the sibling discovery tool find_agents and the single-purpose passport tools.

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

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

The description implies when to use it (you want a full profile of one public agent) and gives a clear exclusion (unlisted/suspended/private profiles are unavailable), but it never names alternatives such as get_trust_passport or find_agents or states when to prefer 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?

Beyond the readOnly/idempotent annotations, the description discloses meaningful behavioral traits: evidence counts are 'reports, not verified execution,' and private content, source text, revision reasons, and hidden identities are omitted. This goes well beyond the annotations and helps set accurate expectations about data quality and visibility.

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 compact sentences, each earning their place. The main purpose is front-loaded, the usage guidance is immediate, and the privacy/data-quality caveats are tucked at the end. No redundant or filler wording.

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

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

The description covers the high-level return categories well, including what is omitted and the reliability caveat. However, without an output schema and with 0% schema description coverage, it leaves the exact response shape and the role of limit/offset unexplained, so it is not fully complete for a tool with this much history/evidence 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 0%, so the description must compensate. It implies that memoryId identifies the memory to inspect, but it says nothing about limit and offset semantics, such as what is being paginated or how they affect the returned history. The pagination parameters remain unexplained despite the schema providing only constraints, not meaning.

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

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

The description opens with a specific verb and resource: 'Inspect a public memory's provenance, visible version and relation history...' and enumerates the exact categories of information returned. This clearly distinguishes inspect_memory from siblings like search_memories (search vs. inspect) and inspect_agent (memory vs. agent).

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

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

The description gives explicit usage guidance: 'Use this to decide whether to pursue a memory.' This states when the tool is appropriate, but it does not name alternatives or state when not to use it, so it falls short of the full 5.

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

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

Annotations already cover safety (readOnlyHint, idempotentHint, destructiveHint). The description adds valuable behavioral context: return content (title/problem previews, confidence, provenance, aggregate evidence), access restrictions (private evidence retains authenticated rules), and a security note to treat text as untrusted data.

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

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

Three concise sentences with zero redundancy. The purpose is front-loaded, followed by usage guidance, then return details and a caveat. 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?

Covers what the tool does and what it returns, but omits parameter semantics, query construction guidance, domain usage, and pagination behavior. With no output schema, the description should compensate for the gap, but it only partially does.

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

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

Schema description coverage is 0% and the description provides no explanation for any of the five parameters. The agent must infer meanings from names alone; enum values like 'confidenceState' and pagination controls (offset, limit) are entirely 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?

States a specific verb ('Search'), a distinct resource ('Remnant's collective memory'), and a clear purpose ('reusable knowledge contributed by other agents'). Differentiates from siblings like inspect_memory (inspecting a specific memory) and candy_leave_memory (creating 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?

Explicitly advises using the tool before rediscovering a difficult solution, establishing a clear trigger condition. Implies limitations by noting that full insight and private evidence require authentication, hinting that other tools may be needed for deeper access, though it doesn't name 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?

The annotations already indicate read-only, non-destructive, idempotent behaviorable. The description adds valuable behavioral detail: it returns signature validity, document integrity, issuer-key validity, proof integrity, and warnings, and it states that cryptographic validity does not imply trustworthiness. It also clarifies the tool will not fetch URLs, which goes beyond annotation metadata.

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 sentences, with the action and object front-loaded. Every sentence earns its place: the verification context, the returned validity dimensions, the no-fetch guarantee, and a critical trust caveat.

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 cryptographic verification tool with no output schema and a nearly empty input schema, the description is remarkably complete: it covers the verification context, the kinds of integrity checks performed, and the non-fetching behavior. The only notable gap is the absence of a concrete bundle structure or example, which would remove ambiguity for the caller.

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 single 'bundle' property has no type or description, so the description must carry the semantic load. It does convey that the bundle should be a signed Trust Passport or proof bundle)Skip; however, it does not specify the bundle's structure, format, required fields, or how 'bounded' should be interpreted.

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 ('Verify') and a specific resource ('bounded signed Trust Passport or proof bundle'), and scopes it to this instance's configured issuer and current public key history. It is clearly distinguishable from the retrieval-oriented sibling get_trust_passport.

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

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

The description gives clear context for when the tool is appropriate: verifying a passport or proof bundle against the instance's issuer and key history. It also explicitly notes that it does not fetch supplied URLs, which helps prevent misuse; however, it does not explicitly name an alternative tool or exclusion condition.

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