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

With no annotations, the description carries the full burden. It does disclose a meaningful behavior: messages are queued for extraction rather than directly stored, and it mentions schema selection. However, it does not explain idempotency behavior, required permissions, whether a job is created, or what happens after queueing.

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 tight sentences with no filler. The core action is front-loaded in the first sentence, and the second sentence adds useful context about schema usage. 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 no output schema, no annotations, and 0% schema description coverage, the description is too thin for reliable invocation. It omits the meaning of required parameters, the expected message format, asynchronous job behavior, and what the caller should expect in response.

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

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

Schema description coverage is 0% and the description does not compensate. It vaguely implies the 'messages' parameter and tenant scoping, but does not clarify external_user_id, idempotency_key, agent_id, metadata, or the message object shape. An agent would have to guess at several parameter semantics.

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

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

The description uses a specific verb ('Queue') and a clear resource ('tenant-scoped conversation messages for MemoryOS extraction'). The phrase 'tenant-scoped' also distinguishes this from the sibling universal_add_memory tool, so an agent can tell what it is for.

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 by calling out tenant scoping and the workspace's configured schema, but it never explicitly names alternatives or states when not to use it. Usage context is present, but exclusions and trade-offs versus universal_add_memory are left 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 only says 'advanced allowlisted,' which hints at access restrictions, but it does not warn that arbitrary method/path calls may mutate data, require special auth, or return inconsistent shapes. The behavioral risk profile of a raw API passthrough is largely undisclosed.

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

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

The single sentence is front-loaded with 'Advanced allowlisted MemoryOS API request' and contains no filler. It is appropriately concise, though it achieves brevity at the cost of behavioral and parameter 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?

This tool has 7 parameters, no output schema, no annotations, and 0% schema description coverage, yet the description is only one sentence. An agent has insufficient information to select this tool confidently, choose an endpoint, pass authentication correctly, or interpret the response.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It provides no meaning for method, path, json, params, uui_token, agent_api_key, or use_universal_auth. The auth-related parameters are especially ambiguous, including the relationship between uui_token, agent_api_key, and use_universal_auth.

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

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

Description clearly identifies this as a low-level allowlisted MemoryOS API passthrough and differentiates it from first-class sibling tools by stating it covers endpoints 'not yet promoted.' It lacks a specific verb or endpoint example, but that is inherent to a generic request tool.

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

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

The phrase 'endpoints not yet promoted to first-class MCP tools' implies use only when no dedicated sibling exists, providing implicit usage context. However, it never explicitly tells the agent to prefer existing memory/support/billing tools where available, and it does not explain the allowlist boundary or any authentication prerequisites.

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

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

With no annotations, the description carries the behavioral transparency burden. It usefully clarifies that the block applies to 'future memory operations' and is 'tenant-scoped,' but it does not disclose whether the action is reversible, whether existing memories are affected, what permissions are required, or what the response/error behavior is.

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

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

A single, front-loaded sentence with no filler. Every word adds meaning, and the core intent is immediately clear.

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 with no annotations, no output schema, and no parameter details, the description is too thin for an agent to invoke it with full confidence. Missing context includes reversibility, side effects, whether repeated blocks are idempotent, and any prerequisites.

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

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

The schema has only external_user_id with no description, and schema description coverage is 0%. The description mentions 'tenant-scoped user' but does not explain the expected format of external_user_id, where it comes from, or how it maps to the tenant scope. The parameter name is somewhat self-explanatory, but the description adds minimal value beyond the schema.

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

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

The description uses a specific verb ('Block') with a specific resource ('a tenant-scoped user') and a clear effect ('from future memory operations'). This distinguishes it from the sibling memory CRUD, export, and consent tools without requiring schema inspection.

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 is given about when to use this tool versus alternatives such as memoryos_delete_memory, memoryos_export_user, or memoryos_create_consent_url. The intended use is implied but not stated, and no exclusions or prerequisites 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 no annotations at all, the description carries the full disclosure burden, yet it only says a URL is created. It does not disclose OAuth/consent flow side effects, what happens to existing consent, whether an external request is made, or what the caller should expect beyond the returned URL.

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, which is efficient. However, it is arguably too terse for a 4-parameter tool with zero annotation support, so it loses a point for underspecification.

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 4 parameters (2 required), no annotations, and schema descriptions are absent; an output schema exists but is not shown. The description gives no workflow context, no parameter explanations, and no behavioral notes, so an agent cannot confidently construct a correct call without guessing.

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

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

Input schema coverage is 0% and the description does not mention any parameter by name. It adds only the general context that the URL is for cross-agent sharing, leaving agents to infer the roles of agent_id, redirect_uri, state, and consent_base_url.

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 begins with a specific verb ('Create') and a concrete resource ('a MemoryOS consent URL'), then states the purpose ('for cross-agent memory sharing'). This is enough to distinguish it from the memory CRUD and stats siblings, none of which produce a consent URL.

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 'for cross-agent memory sharing' implies the tool is for generating a user-facing consent link in that workflow, but it does not explicitly state when to use it versus alternatives or mention any prerequisites/exclusions. Usage is inferable rather than specified.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that there are two modes, archive and hard-delete, but does not state that hard-delete is irreversible, whether archiving is reversible, what permissions are needed, or what side effects occur. For a destructive operation, this is a notable gap.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to understanding the tool's core behavior.

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

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

Given the absence of annotations and output schema, this minimal description is incomplete for a destructive tool. It does not clarify what archiving means, whether hard-delete is permanent, what the operation returns, or what conditions apply, leaving an agent without enough context for safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by mapping the hard_delete boolean to 'hard-delete' versus 'archive,' which is useful. However, memory_id is only implicitly identified as the memory being operated on, rather than being explicitly described.

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 ('Archive or hard-delete') and identifies the resource ('a memory'), making the tool's purpose immediately clear. It also distinguishes two modes of operation, which helps differentiate it from generic update or list tools among the siblings.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor when to choose archive versus hard-delete. It does not mention prerequisites, consequences, or alternatives like memoryos_update_memory for non-destructive changes.

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, and the description does not disclose side effects, whether the operation is read-only, whether it returns data directly or initiates an async job, or any error conditions. The description gives only a high-level action without behavioral details.

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 words. It efficiently conveys 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?

The description gives enough for a basic understanding but omits important context such as output format, whether the export is synchronous or asynchronous, and how the result is delivered (e.g., file, job ID). Given the presence of job-status sibling tools, async behavior is plausible but not stated.

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 sole parameter external_user_id has no schema description beyond its name, and the tool description adds no further meaning. Since schema coverage is 0%, the description fails to compensate, leaving the parameter's format, constraints, or purpose unclear.

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 (export), the target (a tenant user's memories and version history), and the purpose (for access requests), making it easy to distinguish from other memory-related tools.

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

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

The description implies usage for access requests but does not explicitly mention when to prefer this over alternatives like memoryos_get_memory or memoryos_get_context. No direct comparison with sibling tools is given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the tool is read-only and enumerates what it never does, which is exactly the kind of side-effect transparency an agent needs before invoking a billing-related tool.

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

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

The description is two tight sentences with the primary action front-loaded and no wasted words. The side-effect clarification earns its place by reinforcing the read-only nature 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?

For a zero-parameter read-only tool, the description is nearly complete: it states what is fetched and what side effects are absent. It could go slightly further by clarifying the exact return shape or differentiating from list_billing_plans, but those are minor gaps for such a simple tool.

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

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

The tool has zero parameters and 100% schema coverage, so the baseline is 4. The description adds no parameter-specific detail, but none is needed because the input schema is empty.

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

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

The description uses a specific verb and resource: 'Fetch the authenticated tenant's read-only subscription and plan limits.' It clearly communicates what the tool does, though it does not explicitly differentiate itself from the sibling memoryos_list_billing_plans, 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?

The description provides clear context and explicit exclusions: 'never creates a checkout, verifies a payment, or changes billing.' This helps an agent avoid using it for side-effectful billing operations, but it does not explicitly name alternatives or state when to prefer 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?

No annotations are provided, so the description carries the behavioral transparency burden. It does add one useful behavioral trait: domain schema context is included by the MemoryOS backend when enabled. 'Retrieve' implies a read operation, but the description omits other behavioral details like pagination, empty-result behavior, authentication requirements, or output format specifics.

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 with no filler, and the core purpose is front-loaded. The second sentence adds a relevant backend behavior detail. It is concise, though arguably too terse for a tool with 9 parameters.

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

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

For a tool with 9 parameters, no annotations, and no output schema, this description is insufficient. It does not describe return values, parameter semantics, filtering behavior, or how this tool relates to sibling context/memory tools, leaving significant gaps for an agent deciding how to invoke it.

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

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

Schema description coverage is 0%, and the description explains none of the 9 parameters. The agent cannot infer the meaning or valid values for query, external_user_id, format, limit, categories, as_of, time_filter_days, context_max_tokens, or agent_id from either the schema or 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?

States a specific verb ('Retrieve') and object ('prompt-ready memory context') for a tenant-scoped user, which helps distinguish it from memoryos_universal_get_context. However, it does not explicitly name any sibling or define what 'prompt-ready' means, so it is clear but not fully differentiating.

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 such as memoryos_universal_get_context or memoryos_get_memory. 'Tenant-scoped' hints at the intended scope, but there are no exclusions, conditions, or alternative recommendations.

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

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

With no annotations, the description carries the burden of indicating behavior. 'Read' signals a non-mutating operation, which is helpful, but the description does not disclose what exactly is returned, whether it is a full schema object, or any authentication expectations.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the operation and target.

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 tool, this is largely complete: the verb and resource are clear, and the sibling set_domain_schema provides disambiguation. It could be more complete by explicitly stating that it returns the current schema value, but the absence of parameters and output schema keep the risk low.

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 baseline is 4. The description does not need to explain any parameters, and the empty schema is already fully explicit.

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, 'Read', and a clear resource, 'workspace domain schema setting'. It is immediately distinguishable from the sibling set_domain_schema because reading is the inverse of setting.

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 is the tool to use when you need the current domain schema setting. However, it does not explicitly say when to use it instead of set_domain_schema or how it relates to the other 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?

No annotations are provided, so the description carries the full responsibility for behavioral disclosure. It does not state whether the tool is read-only, what happens if the EdTech schema is not enabled, whether authentication is needed, or what the response looks like. 'Fetch' implies a read operation, but the behavioral caveats are thin.

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

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

The description is a single, front-loaded sentence with no filler. It states the operation, target, and condition efficiently, and every phrase 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 getter, the description provides the essential purpose and a key precondition. However, with no annotations and no output schema, it leaves open important details like behavior when the schema is disabled and the shape or content of the returned profile.

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

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

Schema description coverage is 0%, and the description does not elaborate on the external_user_id parameter beyond 'for a user.' It fails to compensate for the low schema coverage by not explaining the expected ID format, where to obtain it, or any constraints around it.

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

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

The description uses a specific verb ('Fetch') with a clear resource ('the structured EdTech profile') and target ('a user'), plus a condition ('when the EdTech schema is enabled'). This clearly distinguishes it from sibling tools like get_user_stats or get_context, which target different data.

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 condition: use when the EdTech schema is enabled. It does not explicitly state when not to use the tool or name an alternative for non-EdTech contexts, but the condition is enough to guide an agent toward correct invocation.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It conveys that the operation is a read-only fetch of public data, which is useful, but it does not mention behavior on missing IDs, response shape, or any access 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?

The description is a single, front-loaded sentence with no filler or redundant information. It is concise while still conveying the core purpose of the tool.

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

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

For a one-parameter read-only tool, this description is close to adequate, but with no output schema and no annotation context, it leaves out return details and error behavior. An agent could invoke it correctly, but would have limited expectations about the response.

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

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

Schema description coverage is 0%, and the description does not explain the required agent_id parameter at all. The sole parameter must be understood purely from its name, so the description fails to compensate for the missing schema documentation.

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

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

The description states a specific action ('Fetch') and a specific resource ('public global agent profile'), clearly identifying what the tool returns. It is more specific than simply restating the tool name, though it does not explicitly contrast with sibling profile tools like memoryos_get_edtech_profile.

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 qualifier 'public global agent profile' implies when this tool is appropriate, but there is no explicit guidance about when not to use it or which sibling tool to prefer. The usage context is inferable, not stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Fetch' implies a read-only operation, but the description does not mention response format, possible job status values, error behavior, or whether the status may be polled repeatedly.

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 filler, and the core action is presented clearly. It is appropriately short for such a simple tool, though brevity leaves several behavioral details unstated.

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 getter, the description is minimally viable: it names the operation and the object being fetched. However, there is no output schema and no description of return shape or status values, and the similar sibling memoryos_universal_get_job_status is not addressed, leaving the full context 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 single parameter job_id is required and has no schema description, so coverage is 0%. The description only implies that job_id identifies the extraction job; it does not say where this ID comes from, its format, or any constraints. Because the parameter name is self-explanatory, this is adequate but minimal.

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 'Fetch extraction job status' states a clear verb and resource, so an agent knows this is a read operation for job status. It does not, however, differentiate this tool from the similarly named sibling memoryos_universal_get_job_status.

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

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

No guidance is given about when to use this tool versus alternatives. The sibling list contains memoryos_universal_get_job_status, which could serve a similar purpose, but the description does not explain the distinction or any conditions for selecting one over the other.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only says 'Fetch one memory by id' and does not disclose return format, error/not-found behavior, or read-only guarantees. This is a significant gap for a fetch operation.

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

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

Extremely concise at seven words, with the verb and object front-loaded. No filler or 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 simple one-parameter get-by-id tool, the core operation is clear and callable. However, with no annotations and no output schema, the agent lacks explicit return or error behavior details, making it minimally adequate rather than fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. 'by id' only restates that memory_id is an identifier, which is already evident from the parameter name. It adds no format, constraints, or additional semantic context.

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 ('Fetch'), a specific resource ('one memory'), and the selection mechanism ('by id'). This clearly distinguishes it from sibling tools like memoryos_list_memories or memoryos_get_memory_history.

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 'by id' clearly implies this is the single-memory retrieval tool, giving clear context for when to use it. However, it does not explicitly mention alternatives or when not to use it.

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

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

With no annotations, the description must carry all behavioral information. It explicitly uses 'Fetch' to indicate a read-only operation and 'append-only' to signal that the history cannot be altered, providing transparency about side effects.

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

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

The description is a single, compact sentence with no extraneous words. It effectively communicates the core function in the fewest possible terms.

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

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

The description is adequate for the tool's simple role, but it does not mention return shape, ordering, pagination, or error conditions. Since there is no output schema, a bit more detail about the expected response would round it out, though the core function is clear.

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

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

The schema provides only a required memory_id with no description, and the tool description offers minimal additional context—merely tying the ID to 'a memory.' It does not explain the format, source, or validation of the ID, leaving the parameter semantics largely to inference.

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

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

The description clearly states the action (Fetch) and the resource (append-only version history for a memory). It distinguishes from get_memory (current state) and list_memories (all memories) by focusing on historical versions.

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

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

It provides clear context that this is for retrieving historical versions, indicating a distinct use case from the other memory-fetching tools. However, it does not explicitly name sibling tools or state when not to use this tool, so it stops short of full explicitness.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects, permissions, or read-only nature. The description only says 'Fetch', implying a read operation, but does not explicitly state that it has no side effects or whether it requires any authentication or permissions. This lack of transparency could lead to incorrect assumptions about side effects.

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 redundant words or vague phrasing. It is well-structured and immediately conveys the purpose without unnecessary elaboration.

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

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

The description lacks essential context about the return value. It mentions 'aggregate stats' but does not define what statistics are included (e.g., total counts, average metrics, time ranges). Without an output schema or further description, an agent cannot anticipate the shape or content of the response, which may lead to incorrect handling of the result. This is a significant gap for a tool that returns data.

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 is fully covered (100% coverage as there are no properties). The description does not add any parameter-specific meaning, but since none exist, the agent can infer from the schema that no arguments are needed. The description's brevity means it does not contradict or omit parameter details, so a high score 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 'Fetch Customer Support schema aggregate stats' clearly identifies the action (fetch) and the resource (aggregate stats for the Customer Support schema). It is distinguishable from sibling tools like 'memoryos_list_support_customers' which list individual records, and 'memoryos_get_user_stats' which targets user stats rather than schema-level aggregates. However, it does not specify which aggregate stats are returned (e.g., counts, averages), leaving some 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?

The description provides no guidance on when to use this tool instead of alternatives such as 'memoryos_list_support_customers' or 'memoryos_get_user_stats'. There is no mention of use cases, prerequisites, or context that would help an agent decide between fetching schema aggregates versus other related operations.

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 verb 'fetch' indicates a read-only operation, and the description mentions 'tenant-scoped' which hints at permission boundaries. However, it does not explicitly state that there are no side effects or required permissions, leaving some room for inference.

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 unnecessary words. It is well-structured and easy to parse.

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

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

For a simple fetch operation, the description is adequate but omits details about what specific stats are returned or any error conditions. It covers the essential purpose but lacks comprehensive context that could aid an agent in fully understanding the tool's output.

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 description clarifies that the 'external_user_id' parameter refers to 'one external user', providing meaning beyond the bare schema type. It does not elaborate on format or constraints, but the context is sufficient for a single parameter.

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

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

The description clearly states the action (fetch), the resource (tenant-scoped memory stats), and the target (one external user). It distinguishes from sibling tools like memoryos_get_support_stats or memoryos_get_global_agent by specifying memory stats and external user scope.

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 (for memory stats of a specific external user) but does not explicitly contrast with alternatives like support stats or global agent stats. Usage guidance is inferred 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?

No annotations are present, so the description must disclose behavioral traits. It only says 'Fetch,' implying a read-only operation, but does not explicitly mention safety, authentication requirements, rate limits, or side effects. This is insufficient for full transparency.

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

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

The description is a single, clear sentence with no unnecessary words. It is well-structured and immediately conveys the tool's 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 list-fetching tool, the description is mostly complete. It lacks details about the output format or any filtering options, but given the minimal complexity, it is adequate. A small expansion on what 'billing plans' are could improve completeness.

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

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

The input schema is empty (0 parameters), so there is nothing to explain. Based on the '0 params = baseline 4' guideline, this score is appropriate.

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

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

The description clearly states the action ('Fetch'), the specific resource ('billing plans'), and the scope ('public'). It does not explicitly name a sibling tool for distinction, but the resource type 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?

No guidance is provided on when to use this tool versus alternatives (e.g., memoryos_get_billing_subscription). The description does not mention any conditions, prerequisites, or typical use cases.

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, and the description does not state whether this operation is read-only or has side effects. Though listing is typically safe, the absence of any explicit statement about side effects or permissions leaves behavioral expectations unclear.

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 very concise with a single sentence, which is efficient. However, it is so minimal that it omits useful context about filtering or pagination that could be conveyed without excessive length.

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 5 parameters and no output schema, the description is incomplete. It fails to explain the meaning and purpose of the optional parameters, nor does it provide any context about the response format or potential use cases, making it difficult to use correctly without external knowledge.

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?

Only the 'external_user_id' parameter is indirectly explained via 'for a user'. The other parameters (limit, cursor, agent_id, categories) are not described at all, and the schema has no descriptions. The description does not compensate for the low schema coverage.

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

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

The description states a specific action ('List') and a clear resource ('tenant-scoped memories for a user'), which makes the tool's purpose easy to understand. It is distinguishable from other memory tools that get single memories, but does not explicitly mention pagination or filtering capabilities.

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

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

The description gives no guidance on when to use this tool versus alternatives like memoryos_get_memory or memoryos_add_memory. It does not mention that this is for retrieving multiple memories as opposed to a single one, leaving the agent to infer the use case from the tool name alone.

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

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

The description only says 'List' which implies a read-only operation, but it does not disclose any side effects, pagination behavior, or whether the tool returns partial or full summaries. With no annotations, more behavioral detail is expected.

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 unnecessary words. It is appropriately short for a straightforward list operation.

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

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

The description is minimal and does not explain what a 'customer summary' contains, how results are ordered, or what the output looks like. Since there is no output schema, this missing context leaves the tool incomplete for an agent.

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

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

The input schema fully describes the parameters and their types/defaults, but the description adds no semantic explanation of 'limit' or 'cursor'. Since schema coverage is high, a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('List') and the resource ('Customer Support schema customer summaries'), distinguishing it from generic list_memories. However, the phrase 'Customer Support schema customer summaries' is slightly awkward and could be more explicit.

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

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

No guidance is given on when to use this tool versus alternatives such as memoryos_list_memories or memoryos_get_support_stats. The description does not explain the intended use case or provide any exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the API key is returned only once, which is valuable, but it does not mention authorization requirements, whether registration creates a persistent resource, side effects, or what happens if registration is attempted twice. The one disclosed behavior is useful but the overall picture is thin.

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

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

The description is a single, front-loaded sentence with no filler. Every word adds meaning, and the most important behavioral fact—that the API key is returned once—is included without extra verbiage.

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?

Although the registration outcome is stated, the description is not complete enough for correct invocation. It lacks parameter guidance, prerequisites, response structure, and behavioral caveats. With six parameters, no output schema, and no annotations, the description leaves critical gaps that an agent must resolve through guesswork.

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 meaning for any of the six parameters, not even the required name and redirect_uri. The agent is left without guidance on what values to supply, what format redirect_uri should take, or how optional fields like default_categories_requested affect the registration. The description does nothing to compensate for the complete lack of schema-level parameter documentation.

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 ('Register'), names the exact resource ('a global cross-agent MemoryOS agent'), and states the outcome ('receive its agent API key once'). This clearly differentiates the tool from sibling tools like memoryos_get_global_agent, since registering is distinct from retrieving an existing 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 implies the tool is for initial global-agent registration, but it does not explicitly state when to use it versus alternatives such as memoryos_get_global_agent, nor does it mention prerequisites or any 'use this only if...' conditions. The intended use is inferable but not spelled out.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says 'set' and lists allowed values; it does not disclose side effects, overwrite behavior, permissions, persistence, or any response/confirmation behavior for this mutating tool.

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

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

Two short sentences, zero filler. The action is front-loaded and the value guidance immediately follows, making the description easy to parse and act on.

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

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

For a single-parameter setter, the description is mostly adequate and covers the key input semantics. However, with no annotations and no output schema, it omits behavioral context such as whether the change is immediate, persistent, or scoped to a specific workspace, leaving an agent with some uncertainty about consequences.

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

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

The input schema description coverage is 0%, but the description fully compensates by explaining the single domain_schema parameter: null for General Engine, 'edtech' for EdTech, and 'support' for Customer Support. This adds meaning the schema's bare anyOf does not provide.

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 ('Set') and resource ('workspace domain schema'), and clearly distinguishes itself from the sibling getter memoryos_get_domain_schema. The allowed values further specify what the tool does, making its purpose unambiguous.

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

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

The first sentence states the operation, and the value mapping implies when you would use it. However, it does not explicitly guide an agent away from related tools such as memoryos_set_support_type or explain when to read instead with memoryos_get_domain_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?

No annotations are present, and the description does not disclose side effects, persistence, authorization requirements, or whether the operation is destructive. The word 'Configure' implies a mutation, but no details are provided.

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

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

The description is a single concise sentence with no redundant information. It is appropriately sized and front-loaded with the primary action.

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 lack of parameter descriptions, output schema, and annotations, the description is far from complete. It does not explain what the routing mode options are, how allowed types are specified, or what the tool actually returns or affects.

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

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

The schema has three parameters with no descriptions, and the tool description does not explain the meaning or relationship of support_type, support_type_mode, and support_types_allowed. This leaves parameter usage ambiguous.

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

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

The description clearly states a specific action ('Configure') and identifies the resource ('Customer Support routing mode and allowed support types'). It is distinguishable from the sibling read-only support tools, though it does not explicitly name a sibling it is not.

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 when a support configuration change is needed versus when reading support stats or listing customers. There are no usage conditions or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only reveals that the operation is queued. It does not mention whether the result is retrieved via a job ID, whether extraction creates memories immediately, authentication requirements, idempotency behavior, or side effects.

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

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

The single sentence is front-loaded and contains no filler, but it is drastically under-specified for a five-parameter async tool. This reads as brevity hiding missing information rather than effective conciseness.

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

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

There are no annotations and no output schema, and the description omits input semantics, asynchronous job behavior, response format, and tool-selection context. This is inadequate for an agent to safely select or invoke the tool.

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

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

Schema description coverage is 0%, and the description mentions none of the five parameters. The required 'messages' array, plus optional metadata, uui_token, agent_api_key, and idempotency_key, are entirely unexplained, so an agent cannot reliably construct a 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 uses a specific verb ('Queue') and names a resource ('cross-agent universal memory extraction'), giving a rough idea of an asynchronous memory extraction job. However, 'memory extraction' is vague, and the description does not clarify what the resulting memory looks like or how it differs from sibling tools like memoryos_add_memory.

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

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

No guidance is provided about when to use this tool versus siblings such as memoryos_add_memory or memoryos_universal_get_context. The 'cross-agent' phrase implies a use case, but there are no prerequisites, exclusions, or alternative recommendations.

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. The verb 'Retrieve' signals a read-only operation, which is a meaningful behavioral trait. However, it does not disclose authentication requirements, aggregation behavior, or any side effects, even though the schema hints at uui_token and agent_api_key.

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 economical sentence with no fluff, but it is arguably too sparse for a tool with six parameters. It does not include any structural cues or parameter hints, so while concise, it is not optimally sized for the tool's complexity.

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

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

The tool has six parameters, no output schema, and no annotations, yet the description only provides a high-level phrase. Critical context is missing: what query means, what formats are valid, how the token parameters work, and what the return value represents. This is inadequate for reliable tool 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?

Schema description coverage is 0%, and the description provides no parameter-level meaning. Six parameters exist, including query, limit, format, tokens, and context_max_tokens, but the description does not explain any of them, leaving the agent to infer semantics entirely from names and defaults.

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

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

The description uses a clear verb ('Retrieve') and resource ('cross-agent universal memory context'), which distinguishes it from siblings like memoryos_get_context. However, it does not define what 'context' includes or how this differs from other retrieval tools beyond the 'universal' qualifier.

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

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

There is no guidance on when to use this tool versus memoryos_get_context or other memory retrieval siblings. No alternative tools, exclusions, or selection criteria are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the fetch action and reveals nothing about authentication needs, required tokens, rate limits, return format, or job lifecycle semantics.

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

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

The description is a single short sentence with no filler, which is positive. However, it is under-specified and omits essential context, so the brevity is not fully earned.

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 three parameters, no output schema, and no annotations, yet the description does not clarify the universal mode, the relationship to memoryos_get_job_status, or how the optional auth parameters are used. An agent cannot reliably decide whether this is the right tool or how to call it correctly.

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

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

Schema description coverage is 0%, and the description adds no meaning to job_id, uui_token, or agent_api_key. Since the schema itself provides only types and defaults, the agent is left without any explanation of what these parameters control.

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

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

The description states a specific action (fetch) and resource (universal memory extraction job status), so an agent can tell what it operates on. However, it does not explain what 'universal' means or differentiate it from the closely named sibling memoryos_get_job_status.

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

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

There is no guidance about when to use this tool versus memoryos_get_job_status or any other alternative. The description does not mention typical usage context, such as after submitting an extraction job or polling behavior.

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. It only states that content, importance, or archived state can be updated, but does not disclose whether this is a partial update, how nulls are handled, whether archiving is reversible, or what side effects occur. This is a significant transparency gap for a mutation tool.

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

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

The description is a single front-loaded sentence with no filler. It loses a point because the word 'or' can misleadingly imply only one field can be updated at a time, whereas the schema allows multiple optional fields together.

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 no annotations, no output schema, and abbreviated parameter documentation, the description is too thin to fully support correct invocation. It omits update semantics, valid values, and the distinction from add/delete, so an agent has insufficient context for confident use.

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 needed to explain the parameters. It broadly names 'content', 'importance', and 'archived state', but does not clarify the importance_score scale, default/null behavior, or the requirement that memory_id identifies an existing memory. The description adds little beyond the property names already visible 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 names a specific verb ('Update'), a clear resource ('memory'), and the exact updatable aspects ('content, importance, or archived state'). This distinguishes it from sibling tools like memoryos_add_memory and memoryos_delete_memory without requiring schema inspection.

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

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

No guidance is given about when to use this tool versus memoryos_add_memory, memoryos_delete_memory, or memoryos_get_memory. The word 'update' implies existing memories, but no explicit context, prerequisites, or exclusions are provided.

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