Penfield Memory

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

Annotations already declare readOnlyHint and openWorldHint. The description adds significant context: it returns a briefing with persona, voice, custom instructions, and boundaries, and emphasizes the need to call it every new conversation.

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 front-loaded with an imperative instruction, uses formatting (emojis, example) for clarity. It is slightly verbose but every sentence provides necessary context.

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

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

For a zero-parameter tool with an output schema, the description is complete. It covers purpose, usage, and return content comprehensively.

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?

No parameters exist, so baseline is 4. The description adds value by detailing the structure of the return briefing, which complements the output 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 explicitly states that the tool loads personality configuration and user preferences, and must be called first. The verb 'awaken' is clearly defined as initialization.

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 'CALL THIS TOOL FIRST IN EVERY NEW CONVERSATION' and explains why, providing strong when-to-use guidance. No alternatives needed as it's the primary initialization tool.

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

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

Annotations indicate write operation (readOnlyHint=false). Description adds context: creates links, returns success/IDs. Does not contradict annotations, but could mention if connections are reversible or list any side effects like overwriting.

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?

Moderately long but well-structured with headings, bulleted categories, workflow steps, and example. Every section adds value; no redundancy. Could be slightly shorter but earns its 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?

With output schema existing, description covers all needed: parameter details, relationship semantics, usage guidance. No gaps remain for an agent to misuse 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 has 0% description coverage, but description compensates fully: explains from_memory/to_memory as source/target, lists all relationship types with meanings, gives strength range and default (0.5) despite schema default null. This is thorough.

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

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

The description clearly states the tool connects memories to build knowledge graphs, and distinguishes from 'store' by recommending immediate use after storing. The extensive relationship taxonomy and workflow make the 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?

Provides explicit timing ('After using store'), a structured workflow with questions, and an example. It implicitly advises against connecting unrelated memories by emphasizing relevance through relationship categories.

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 destructiveHint: true. Description adds value by stating that it also removes the associated memory record, providing behavioral context beyond the annotation.

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?

Very concise, clear sections for description, args, and returns. No redundant information; every sentence is essential.

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?

Single parameter is well-explained, output schema exists (implied), annotations cover destructiveness, and description fully describes the effect (permanent removal of artifact and memory record). Complete for a delete 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?

Input schema has no description for the path parameter (0% coverage). The description's Args section adds the meaning 'Full path of the artifact to delete', which compensates for the schema gap.

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 states the tool deletes artifacts from storage, explicitly mentions permanent removal of both the artifact and its associated memory record, which distinguishes it from sibling tools like save_artifact or retrieve_artifact.

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 versus alternatives such as update or soft-delete. The destructive nature is implied but not directly contrasted with other 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 annotations already indicate destructiveHint=true, and the description confirms it by stating 'Deletes'. The description adds no further behavioral context beyond what annotations suggest, such as specifics about what gets destroyed 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 description is well-structured with a brief main sentence followed by Args, Returns, and Examples sections. It is relatively concise, though including the ctx parameter adds a small amount of noise.

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 two simple parameters and the existence of an output schema, the description covers the essential aspects. It explains both parameters, provides a return format, and includes an example. Minor gaps remain in usage guidelines.

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 no descriptions for parameters (coverage 0%), so the description must compensate. It does so by explaining that 'from_memory' is the source UUID and 'to_memory' is the target UUID, and provides an example showing placeholder values.

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

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

The description clearly states the tool's purpose with the verb 'Remove' and the resource 'connection between memories'. It explicitly says it 'Deletes the relationship between two memories', making it distinct from the sibling tool 'connect'.

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

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

The description does not explicitly state when to use this tool versus alternatives. While the sibling 'connect' implies this is for removal, no direct guidance is provided about prerequisites, conditions, or when to prefer 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?

Annotations declare readOnlyHint and openWorldHint, but the description adds behavioral details: traversal depth limits (max 10), return format (dict with paths_found, max_depth_reached, paths), and an example. 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 well-structured with Args, Returns, and Examples sections. It is clear and not overly long, though some redundancy exists (e.g., repeating types in Examples).

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 presence of output schema and annotations, the description covers behavior, parameters, and return basics adequately. However, it lacks details on relationship_types format or how paths are structured, slightly limiting 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?

With 0% schema description coverage, the description fully explains each parameter: start_memory (UUID), max_depth (default 3, max 10), relationship_types (optional filter), and ctx (automatically provided). This adds significant meaning 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 clearly states the tool's purpose: 'Explore connections from a memory. Traverses the knowledge graph to find related concepts.' It distinguishes itself from sibling tools like 'search' and 'recall' by specifying graph traversal.

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

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

The description does not explicitly state when to use this tool versus alternatives. It provides examples but no guidance on context or exclusions, leaving usage 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?

Annotations already declare readOnlyHint=true. Description adds that it returns a single memory with citation support (id, title, url, text fields), and explains the tool's purpose beyond 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?

Well-structured with clear sections: purpose, rationale, args, returns. Slightly lengthy but every sentence is informative. Could be more concise.

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

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

For a simple read-only tool with one parameter and an output schema, the description covers purpose, usage context, return fields, and rationale. Complete and sufficient.

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 one parameter (id) with 0% schema description coverage. Description adds 'Memory UUID to fetch', which clarifies the expected input beyond the raw schema type. Good but minimal additional 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?

The description clearly states the tool fetches a memory by ID, distinguishes it from native alternatives like recall, and specifies its role for ChatGPT Connector compatibility.

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 states when to use (ChatGPT Deep Research requirement) and when not to (native MCP clients should use recall or API endpoint). Provides clear alternatives.

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

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

Annotations declare readOnlyHint and openWorldHint. The description adds behavioral context: non-recursive listing and separation of folders/files. 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 concise, well-structured with a summary, parameter docs, return type, and examples. Every sentence adds value without redundancy.

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

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

The description includes a clear return format and examples, compensating for the output schema not being provided. It covers the tool's functionality sufficiently for a list operation.

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

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

With 0% schema description coverage, the description compensates by explaining both parameters: path_prefix as default '/' and name_pattern as optional case-insensitive filter. This adds meaning beyond the schema's type and default.

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

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

The description clearly states the tool lists artifacts in a directory and returns immediate contents non-recursively, separating folders and files. This specific verb and resource distinction differentiates it from sibling tools like explore or search.

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

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

While the description implies usage for listing directory contents and shows examples, it does not explicitly state when to use this tool over siblings like explore or search. The purpose is clear but lacks explicit when-not-to-use guidance.

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?

Consistent with readOnlyHint and openWorldHint annotations. Adds details on pagination, filtering, and default behavior beyond 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?

Well-structured with purpose statement, args documentation, return description, and examples. No wasted words; efficient and front-loaded.

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

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

Covers all necessary aspects: input parameters, return value (Dict with contexts), and examples. Output schema is present but not fully detailed in description; still adequate.

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 has 0% description coverage, but the description thoroughly explains each parameter: limit (default 20, max 100), offset, name_pattern (case-insensitive substring), include_descriptions (default False). Adds significant value.

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?

Clearly states the tool lists available context checkpoints for multi-agent workflows. Distinct from sibling tools like save_context and restore_context.

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

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

Provides usage context (multi-agent workflows) and examples with filtering. Lacks explicit guidance on when to prefer this tool over alternatives like list_artifacts.

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 indicate read-only, open-world. Description adds significant behavioral details: hybrid search method, filter options, default and max limit, date format, include_inactive flag, and document chunk context. No contradictions.

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?

Well-structured with title, args list, returns, examples, and notes. Front-loaded purpose. Some redundancy with schema but informative. Could be slightly more concise.

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

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

Comprehensive coverage: all 7 parameters explained, return format detailed, examples provided, and special notes about document context. Given annotations and output schema, no gaps remain.

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 thoroughly explains each parameter with examples, including OR logic for tags, date format, limit defaults, and the include_inactive flag. Adds meaning beyond schema names.

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

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

The description clearly states the tool recalls information using hybrid search, specifying resources like memories and documents. However, it does not differentiate from the sibling tool 'search', which may have similar 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?

Examples show when to use the tool, but no explicit guidance on when not to use it or alternatives. Implied usage from examples, but lacks exclusions or comparisons with siblings.

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

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

The description goes beyond annotations by disclosing experimental status and a missing feature ('Importance weighting in results not yet implemented'). It also explains the default exclusion of document chunks. The annotations already indicate read-only and open-world behavior, but the description adds valuable context about limitations.

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 well-structured with sections for overview, experimental warning, args, returns, and examples. While it is relatively long, every sentence adds value. It could be slightly more concise by removing the redundant 'Args:' label, but overall it is efficient.

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

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

Given the output schema exists, the description adequately describes the return value as a dict with 'top memories, active topics, patterns, insights, and any saved contexts'. It covers all parameters with examples, and the experimental note adds necessary caveats. It is complete for a tool of this 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?

Despite 0% schema description coverage, the description thoroughly explains all four parameters: time_window (with valid values), include_documents (boolean, default false), and start_date/end_date (ISO 8601 format with examples). It also shows usage in examples, fully compensating for the missing schema descriptions.

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

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

The description clearly states the tool's purpose: 'Reflect on recent thoughts and patterns' and 'Analyzes recent activity to identify patterns, topics, and insights.' It specifies the resource (user memories and optionally document chunks) and the action (analysis), distinguishing it from sibling tools like 'recall' or 'search' which focus on retrieval.

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

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

The description provides explicit usage context: 'Useful for understanding what have I been thinking about?' It explains default behavior and how to include documents with the 'include_documents' parameter. While it doesn't explicitly state when not to use the tool or list alternatives, the context and examples give clear guidance.

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

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

The description discloses that the tool is read-only (no mutations) and provides a cognitive briefing, which aligns with the readOnlyHint annotation. It adds details about the briefing content, memory limit, and the 'awakening' case, going beyond the annotations. No contradictions are present.

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 quite long with a detailed example, but it is well-structured with bullet points and clear sections. It could be more concise, but the length is justified by the need to explain the briefing format and special cases. The main purpose is front-loaded.

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

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

Given the tool's complexity (2 parameters, output schema), the description covers all aspects: input parameters, special cases, return values, and the nature of the briefing. It is complete and leaves no major gaps.

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

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

The description adds significant meaning to both parameters: 'name' is described with valid values (context name, UUID, 'awakening'), and 'limit' is given a default and purpose (max memories). This compensates fully for the 0% schema description 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 clearly states the tool resumes work from a saved cognitive context, providing a narrative briefing. It distinguishes from sibling tools like 'save_context' and 'awaken' by specifying that it restores previous context, and handles a special case 'awakening' for personality, which is differentiated from the sibling 'awaken'.

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

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

The description explains when to use the tool: to continue work from a saved context. It provides a detailed example and mentions the special case for personality loading. It does not explicitly state when not to use it, but the context is clear enough, and it implicitly differentiates from siblings like 'list_contexts' and 'save_context'.

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

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

Annotations already declare readOnlyHint=true, aligning with the description's 'Retrieve' verb. The description adds return type details (content or error) and an example, but does not disclose additional behavioral traits like auth or limits. With good annotations, the bar is lower, and the description adds marginal value.

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

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

The description is concise with a one-line summary, a brief detail line, and structured Args/Returns/Examples sections. Every sentence adds value 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 simple one-parameter tool with an output schema, the description covers the purpose, parameter usage, and return format. The example confirms typical behavior. No gaps remain for effective 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 Args section provides clear meaning for the 'path' parameter, including a full path description and an example. Since schema description coverage is 0%, the description fully compensates by giving concrete usage guidance.

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

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

The description clearly states the tool retrieves an artifact from storage, using specific verbs like 'Retrieve' and 'Fetches content'. It distinguishes itself from siblings such as 'delete_artifact' and 'list_artifacts' by its unique function.

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

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

The description does not provide guidance on when to use this tool versus alternatives. It lacks explicit context or references to siblings, leaving the agent without decision support.

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 indicate it's not read-only (readOnlyHint=false), and description confirms it's a write operation that stores and indexes content. However, it does not disclose whether files are overwritten, error handling, or required permissions, which could be valuable.

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?

Description is concise and well-structured: a single-sentence purpose, followed by clear args, returns, and examples. Every sentence adds value, no fluff.

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 purpose, args, returns, and examples. With an output schema present, the return format is already documented. Lacks details on size limits or allowed file types, but overall sufficient for a save operation.

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

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

Schema has 0% coverage, but description fully compensates by explaining the 'content' param as file content and 'path' as full path including filename with examples. This adds essential meaning beyond the raw 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?

Description clearly states the tool saves artifacts (user-created content like diagrams, notes, code) to storage, and indexes them for search. It distinguishes from siblings like retrieve_artifact and delete_artifact by focusing on creation/saving.

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

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

Provides clear context that it saves content to organized file structures, but lacks explicit guidance on when to use this tool versus alternatives like 'store' or 'save_context'. No 'when not to use' or conditions 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?

Discloses beyond annotations: explains hybrid search on description, memory attachment behavior, reference resolution reporting, and return values. Annotations already indicate write operation and open world, but description adds significant behavioral context.

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

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

Well-structured with clear sections (purpose, reference syntax, returns). Some redundancy (e.g., repeated mention of hybrid search) but overall efficient.

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?

Comprehensive for a complex handoff tool: covers purpose, reference resolution, error reporting, and points to external resources. Output schema exists, but description still adds value.

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?

Despite 0% schema coverage, the description contains a detailed Args section explaining both parameters, including valid usage of memory references and default values. Fully compensates for missing schema descriptions.

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

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

The description clearly states it saves a cognitive checkpoint for handoff, with a specific verb ('save'), resource ('context'), and purpose. It distinguishes from siblings like 'restore_context'.

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

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

Explicitly states when to use (handoff to another agent or future self) and provides guidelines for memory references (UUIDs vs phrases). Mentions a separate prompt for full hygiene guide, but lacks explicit when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds that the tool returns results with citation support (id, title, url, text) and shares identical hybrid-search semantics with recall. No contradictions, and it adds value beyond annotations by detailing return fields.

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 front-loaded with purpose, then explains context, then return format, then parameters. While not overly long, it includes necessary explanations. Could be slightly more concise, but the structure is logical.

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

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

Given the tool's simplicity and presence of output schema and annotations, the description covers purpose, usage guidance, return fields, and parameters. It lacks details on pagination or default behavior when limit is exceeded, but overall provides sufficient context for an AI 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?

Schema description coverage is 0%, so the description should add meaning. However, it mostly restates schema defaults and titles for `query` and `limit`. For `include_inactive`, it adds 'superseded/contradicted memories', which is helpful. The description also lists a `ctx` parameter not present in the schema, causing confusion. Overall minimal added value.

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

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

The description clearly states the tool searches for memories. It distinguishes from sibling `recall` by noting `recall` is preferred for native MCP clients, and explains this tool exists for ChatGPT Connector compat. The verb 'search' and resource 'memories' are specific.

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 explicitly says when to use this tool: for ChatGPT Connector compat, and advises native MCP clients to prefer `recall`. This provides clear usage context and direct alternatives.

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

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

The description discloses behavioral traits such as auto-detected memory types, experimental fields (importance, confidence), and the emphasis on building knowledge graphs. Annotations indicate readOnlyHint false (write operation) and openWorldHint true, which the description aligns with. The description adds value by explaining the importance of connections and experimental nature of some parameters.

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 front-loaded with the primary purpose and then expands into extensive sections including memory types, what to include, examples, and connection phrases. While comprehensive, it is verbose and could be more concise. The structure is logical but contains redundancies and excessive detail that may detract from quick understanding.

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 complexity of a memory storage tool, the description covers a wide range of aspects: memory types, required content elements, examples for different scenarios, experimental fields, and connection strategies. The output schema is referenced but its details are not provided, which is acceptable. The description is sufficiently complete for an AI agent to use effectively.

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

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

The input schema has 0% description coverage, relying entirely on the description for parameter meaning. The description provides a brief 'Args' section that lists parameters but adds minimal semantics beyond the schema's titles and types. For example, it notes that 'importance' is experimental, but does not explain format or validation rules. The content parameter is not detailed beyond stating it should be detailed.

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

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

The description clearly states the tool's purpose: 'Store important information from your work' with emphasis on writing detailed, complete thoughts. It distinguishes from siblings like 'recall' and 'search' by focusing on creation of rich memory entries. The verb 'store' is specific and the resource is the knowledge base.

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 extensive guidance on when to use the tool, including memory types, required content elements, and connection strategies. It explicitly instructs to use the 'connect' tool for linking items. However, it does not explicitly state when NOT to use this tool or compare with alternatives like 'save_context' or 'save_artifact'.

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 indicate readOnlyHint=false and openWorldHint=true, so the description correctly adds that it modifies an existing memory, requires a UUID, and replaces tags (not merges). This adds context beyond 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 well-structured with a one-liner purpose, then Args, Returns, and Examples. It is slightly verbose but every sentence adds value. The main purpose is front-loaded.

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

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

The description covers usage, parameters, return format, and examples. Given the moderate complexity (4 params, no enums) and presence of an output schema, it is nearly complete but could mention error cases or 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?

With 0% schema description coverage, the description provides detailed explanations for all 4 parameters (memory_id, content, importance, tags) including types, optionality, and behavior (e.g., 'replaces existing tags'). This fully compensates for the schema gap.

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 'Update an existing memory' with specific properties (content, importance, tags), using a specific verb and resource. It distinguishes from siblings like 'store' (create) and 'recall' (read) by focusing on mutation.

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

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

The description explains required vs optional parameters but does not provide explicit guidance on when to use this tool versus alternatives (e.g., 'store' for creation) or when not to use it. Examples show usage but lack context for decision-making.

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