Hipocampo MCP

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

No annotations are present, so the description carries full responsibility for behavioral disclosure. It only states that a directory is added to the watch list but does not mention side effects, idempotency, duplicate handling, permission requirements, or whether reindexing starts immediately.

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 efficient sentence with no filler. The core action and purpose are front-loaded and every word contributes meaning.

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 this is a simple one-parameter tool with an output schema, the description is adequate for basic invocation. However, with no annotations, it lacks details about behavioral side effects and edge cases such as duplicate directories or invalid paths.

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 clarifies that 'path' refers to a directory, which adds meaning beyond the raw schema, but it does not specify path format, existence requirements, or whether relative/absolute paths are accepted.

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

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

The description states a specific verb ('Agrega') and resource ('directorio al watch list') and explains the purpose ('para auto-reindexación'). It clearly differentiates this from siblings like remove_watch_dir and list_watch_dirs.

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 adding directories to be watched for auto-reindexing, but it does not explicitly state when to prefer it over similar siblings or mention any exclusions. The use case is inferable but not explicitly guided.

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 behavioral burden and performs well: it discloses API cost for the LLM method, the fact that extractive is fast with no cost, the default method behavior, and return statistics. It does not explicitly state whether the operation is read-only or describe rate limits, but its behavior is substantially transparent.

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 and front-loaded: purpose, method options, usage context, argument list, and return summary. Every sentence adds useful information, and no filler or repetition is present.

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

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

Given six parameters, zero annotations, and no schema descriptions, the description covers all required invocation details: query semantics, k constraints, method choices, token budgeting, metadata option, and output contents. Agents can correctly select and call the tool without needing external context.

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

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

Schema description coverage is 0%, but the description compensates fully by explaining every parameter, including defaults, max value for k, the meaning of target_token = -1, and budget_ratio as a scale factor. This is exactly the semantic detail an agent needs beyond the bare schema titles.

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 ('compress') and resource ('retrieved memories from Hipocampo'), and clarifies the hybrid approach. It clearly distinguishes this tool from sibling tools like search_hipocampo, which retrieve without compressing.

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 to use this tool BEFORE sending context to another LLM to reduce prompt size, and gives method-selection guidance for technical/code versus generic content. It does not explicitly state when to prefer a sibling tool like search_hipocampo, but the context is clear enough.

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

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

No annotations are present, so the description carries the burden of behavioral disclosure. It does disclose that memories are promoted and content may be compressed, and it explains dry_run behavior, but it does not clarify how optional compression is triggered given there is no compression parameter, nor whether the operation is reversible.

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

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

The description is compact, front-loaded with a clear summary, and uses a clean Args section. The only minor issue is the phrase 'opcionalmente comprimiendo su contenido,' which introduces behavior not backed by any parameter, creating slight ambiguity.

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

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

With an output schema present, return-value detail is not required, and the two parameters are well documented. The main gaps are the missing explanation of how the optional compression is controlled and the lack of explicit side-effect or reversibility information, though these are not fatal for basic 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 fully compensates by explaining both parameters: min_age_days is the minimum age in days and dry_run previews the consolidation. It adds meaningful semantics beyond the schema's titles 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 states a specific verb ('migra') and resource ('memorias episódicas' -> 'semánticas'), and it explains the exact consolidation algorithm. It is clearly distinguishable from siblings like compress_hipocampo and decay_hipocampo by the described operation.

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

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

The behavior implies a maintenance use case—consolidating old episodic memories—but the description gives no explicit when-to-use or when-not-to-use guidance. It does not name alternatives or exclusions, leaving the agent to infer when this tool should be selected.

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 and does provide real behavioral insight: it reveals the embedding-based mechanism, the negation-probe prompt, and the exact distance-comparison criterion ('Si la distancia... → señal de contradicción'). It does not explicitly state that no mutation occurs, but 'Detecta' implies a read-only analysis.

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 definition is compact and front-loaded: one purpose sentence, one algorithm sentence, one condition sentence, and one parameter definition. Every sentence earns its place; there is no filler or repetition.

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 tool with an output schema, the description covers the core calling details and algorithm, which is largely complete. However, it lacks usage context and exclusions, and it never explicitly states side effects or read-only behavior; given the absence of annotations, this leaves a small but real gap.

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

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

Schema description coverage is 0%, so the description must compensate. The 'Args' section adds semantic meaning to memory_id beyond the bare integer schema: it defines it as the numeric ID of the memory in memoria_vectorial. This is sufficient for the 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 opens with 'Detecta contradicciones semánticas de una memoria existente', a specific verb and resource that clearly identifies the tool's function. This purpose is unique among the sibling tools, none of which mention semantic contradiction detection, so an agent can distinguish it without ambiguity.

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

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

The description explains what the tool does and how ('Usa negation-probe embedding...') but never states when to prefer it over alternatives such as review_automatica or when not to use it. There is no explicit exclusion or decision rule.

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 available, the description carries the full burden and does so thoroughly: link decay uses a 90-day half-life, links below 0.01 are deleted, episodic memories are archived to memory_historica, and excluded categories are enumerated. It also explicitly warns that dry_run=False executes changes.

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 a one-line summary, then uses clearly labeled sections for ENLACES, MEMORIAS, Protecciones, Args, and Returns. Every section earns its place and the bulleted protections are easy to scan.

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 behavior, safety protections, dry-run semantics, and the return report, making it largely complete for invocation. A minor ambiguity remains in the phrase 'sin acceso ni protección a memoria_historica,' and min_age_days is expressly described for memories but not for links.

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 compensates by defining both parameters: dry_run as read-only by default versus executing changes, and min_age_days as the minimum candidate age in days. The defaults already exist in the schema, but the semantic meaning is added here.

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 concrete operation ('Aplica decaimiento temporal') on specific resources: graph links and old memories. It goes further with distinct sub-behaviors for ENLACES and MEMORIAS, making its purpose unmistakable even among many hipocampo 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?

No guidance is given about when to prefer decay_hipocampo over related maintenance tools such as consolidate_hipocampo, compress_hipocampo, or hipocampo_maintenance. The protection list is a safety rule, not an explicit usage decision or alternative-routing instruction.

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?

It explicitly warns that the operation is irreversible and that the memory cannot be recovered or appear in future searches. This is a clear disclosure of the destructive side effect, fulfilling the burden since no annotations exist.

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 brief purpose statement, an irreversibility warning, and a structured Args/Returns section. No superfluous content is present.

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

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

While it gives sufficient info for a delete operation, it doesn't mention possible errors (e.g., ID not found) or the exact format of confirmation. In the context of many sibling tools, it could have added a note on when deletion is appropriate, but the core is covered.

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 explains the 'id' parameter as the numeric ID of the memory to delete, adding meaning beyond the schema's type and required status. It clarifies what the ID refers to, making the parameter semantics fully transparent.

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 deletes a memory from the Hippocampus by ID, using the verb 'Elimina'. It is distinct from sibling tools like search or update, and the name and description 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?

The description does not explicitly compare with alternatives such as update_hipocampo or search_hipocampo, nor does it provide conditional guidance on when to choose this tool. The irreversibility warning is useful but does not serve as a usage directive.

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

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

No annotations are provided, so the description carries the full burden. It explains the operation, defaults, and return format, and the verb 'explora' implies a read-only action. However, it does not explicitly state that no mutations occur, nor does it mention error behavior or limits beyond max_nodes.

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 and well-structured, with a one-sentence overview followed by clear parameter details. Every sentence contributes useful information, and there is no redundant or filler content.

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

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

The description covers the tool's purpose, all parameters, and the return format (ASCII tree). It is sufficiently complete for a tool with simple integer parameters, though it could mention edge cases such as depth=0 or behavior when node_id is not found.

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

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

Schema coverage is 0%, but the description fully compensates by explaining each parameter: node_id as the root memory ID with a special 0 value for a general view, depth with default and maximum, and max_nodes with default. This adds meaningful semantic detail beyond the plain integer 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 explores the memory graph from a root node, with a specific return format (ASCII tree). It is distinguishable from sibling search/query tools by emphasizing graph traversal and the general view when node_id is 0, though it does not explicitly name alternatives.

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

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

There is no explicit guidance on when to use this tool versus sibling tools like search_hipocampo or path_hipocampo. The description explains the parameters and special behavior for node_id=0, but does not provide usage context or selection criteria.

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

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

Since no annotations are provided, the description carries the transparency burden. It explicitly lists mutating actions (restart, create tables, configure), which discloses the nature of the tool, though it does not mention potential side effects like downtime or the need for elevated permissions.

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 brief purpose statement, a clear list of repair actions, and a simple return description. Every sentence contributes meaning without 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?

The description mentions a return value but only as 'Reporte de reparaciones ejecutadas', which is vague. Since there is no output schema, more detail about the report format or content would improve completeness. The list of repairs is helpful, but the return specification is thin.

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 parameters, so there is nothing to explain. The description adds no irrelevant parameter info, and the score reflects that nothing is missing.

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 as automatically repairing detected system issues, with specific repair actions listed (restart PostgreSQL, create missing tables, configure NVIDIA_API_KEY). It is distinct from sibling tools like health checks or maintenance routines.

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

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

The description implies use when problems are detected, but it does not explicitly contrast with alternative tools or state when not to use it. Sibling tools like 'hipocampo_health' and 'hipocampo_maintenance' exist, so clearer usage guidance would be beneficial.

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 and it does disclose real mechanics: what each tier means (embedding present, embedding=NULL, content moved to memoria_historica) and that automatica/semantica/critico/enlazadas items are exempt. Missing are the consequences of actually executing tiering — reversibility, scope of changes per run, or the restoration path (e.g., via restaurar_historica) — which matters for a 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?

Compact and well-structured: purpose in the first line, then scannable bullet-point tiers, then exemptions, then the parameter. Every sentence earns its place, and the most decision-relevant info (dry_run behavior) is clearly separated under Args.

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 thoroughly covers the tiering mechanics and fully documents the only parameter, and an output schema exists so return values need no explanation. It falls short on operational context: when to run this versus the maintenance/tune/compress siblings, and what happens after execution (permanence, undo path). For a tool that mutates data, that context is important.

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, and it fully explains the single parameter: dry_run=True means analysis only, False executes tiering. This conveys exactly the semantic distinction the schema cannot. The only minor gap is what 'ejecuta tiering' entails in terms of affected items or confirmation output.

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 first line states a specific verb+resource ('Gestiona el presupuesto de memoria') and the description elaborates the three-tier model (HOT/WARM/COLD) with concrete storage mechanics, making the tool's function unmistakable. It is topically distinct from most siblings, but it never names or contrasts a sibling, so differentiation is implicit rather than 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?

The description implies a safe invocation pattern — dry_run defaults to analysis-only, and False executes tiering — which is genuine how-to-call guidance. However, it never states when to choose this tool over the many overlapping hipocampo maintenance siblings (maintenance, tune, compress, decay), nor any exclusions or 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 provided, the description carries the full transparency burden. It thoroughly discloses behavior: dry_run=True is read-only and safe, dry_run=False is destructive and irreversible, originals are deleted after compression, and the operation is idempotent. This gives the agent a complete mental model of side effects and safety.

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-organized with clear sections (behavior, alternative, recommendation, args, returns), but it contains some redundancy. For instance, the dry_run behavior is explained both in the second paragraph and again in the Args section, and the irreversibility is repeated. This makes it slightly longer than necessary, though not confusing.

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 simple tool (one optional parameter, no required args, output schema present), the description covers all essential context: purpose, usage vs. alternatives, side effects, parameter semantics, and return value contents. Nothing an agent needs to invoke this correctly is missing.

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?

Although the schema provides zero description coverage, the tool description fully explains the only parameter dry_run: 'If True (default), only shows what would be compressed. If False, executes the compression (irreversible).' This adds complete semantic meaning beyond the bare boolean type and default 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's function: 'Compress old memories using logarithmic checkpointing.' It also distinguishes itself from hipocampo_maintenance, specifying that this tool is for one-off execution or preview, which clarifies its unique role among 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?

Explicit guidance is provided on when to use this tool versus alternatives: 'To run checkpoint as part of the full maintenance cycle, use hipocampo_maintenance (step 3 of the cycle). This tool is for one-off execution or preview.' It also recommends a periodic usage frequency (weekly or monthly), giving clear operational 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?

With no annotations provided, the description carries the full burden, and it does so clearly: merge=False is read-only and safe, merge=True is destructive and irreversible. It also defines what counts as a duplicate and what the report contains, giving the agent a solid behavioral model.

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 and front-loaded with the core purpose and safety warning. It is slightly repetitive, restating the merge=False safety behavior in both the main text and the Args section, but every major piece of information is present and easy to scan.

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 a single boolean parameter and an output schema, the description covers all necessary context: purpose, safety modes, duplicate definition, report contents, and the sibling alternative. Nothing essential is missing for an agent to invoke 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%, so the description must compensate, and it fully does. The Args section explains the only parameter, merge, with both its default behavior and the destructive alternative, leaving no ambiguity about how to set 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 opens with a clear verb and resource: 'Detecta y opcionalmente fusiona duplicados en las tablas de memoria.' It distinguishes itself from the related sibling hipocampo_maintenance by explicitly stating that this tool is for ad-hoc use or preview before merge, while maintenance runs dedup as step 2 of a cycle.

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?

Usage guidance is explicit and actionable: run with merge=False to preview first, use merge=True only when intending an irreversible consolidation. It also names hipocampo_maintenance as the alternative for full-cycle dedup, which helps an agent decide between siblings.

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

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

With no annotations, the description carries the full behavioral burden, yet it only states what it verifies and that it returns a 'Reporte formateado'. 'Verifica' implies a diagnostic, non-destructive operation, but the description never explicitly states it is read-only, whether the NVIDIA API check may be slow or fail, or whether it only reports rather than repairs — a meaningful ambiguity given the sibling hipocampo_auto_repair.

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 tight and front-loaded: a purpose line, a verification list, and a return note in under 25 words. The 'Returns:' line is slightly redundant given an output schema exists, but every other sentence earns its place and the structure is 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 0-parameter, low-complexity tool with an output schema, the description covers what it does, what it checks, and what it returns. Clear gaps remain: it never clarifies that the operation is non-destructive, and it does not position itself against relevant siblings like hipocampo_stats or hipocampo_auto_repair, which an agent needs when selecting among diagnostic tools.

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

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

The tool has zero parameters and an empty input schema, so the baseline 4 applies — parameter semantics are trivially satisfied and the description needs no parameter documentation. No additional meaning is required.

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 leads with a specific verb and resource — 'Ejecuta un health check completo del sistema Hipocampo' — and enumerates the exact verification scope: PostgreSQL, NVIDIA API, tablas, espacio en disco, extensiones. The function is clearly stated and practically distinguishable from maintenance/repair siblings, though it never explicitly names 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 listed verifications (PostgreSQL, NVIDIA API, tables, disk, extensions) imply the tool is for checking system integrity, but there is no explicit when-to-use, when-not-to-use, or alternative routing. Given 36 sibling tools such as hipocampo_stats, hipocampo_maintenance, and hipocampo_auto_repair, the description offers no guidance for choosing among related diagnostics.

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 burden and does well: it discloses mutating/destructive behaviors including merging duplicates, compressing old memories, and purging access logs older than 30 days. It also flags sibling tools as destructive, helping the agent understand the broader risk landscape. It could be even more explicit about the destructive nature of the purge/checkpoint steps in this tool itself, but the listed actions already convey this.

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 tight numbered list with no filler. The main purpose is front-loaded, each step earns its place, and the caveat about destructive sibling tools is succinctly appended.

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-argument orchestration tool, the description is complete: it lists all phases, names excluded/related tools, and states the return value ('Reporte consolidado del mantenimiento'). An agent can invoke it correctly with no further information.

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 schema fully covers parameter semantics (100% coverage). The description appropriately focuses on behavior rather than inputs; no additional parameter explanation is needed.

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

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

The description opens with a specific verb+resource statement: 'Ejecuta el ciclo completo de mantenimiento.' It then details the five concrete phases, making it unmistakable what the tool does and how it differs from more granular siblings like hipocampo_health, hipocampo_dedup, and hipocampo_tune.

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

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

The description gives clear usage context: run this for a full maintenance cycle, while hipocampo_budget and decay_hipocampo are executed manually or via separate cron because they are destructive and require a prior dry run. It does not explicitly contrast against every individual sibling, but the scope distinction is strong.

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 communicate that the tool analyzes performance metrics and returns a report with recommendations, implying a read-only analytical operation. However, it never explicitly states that no data is modified, nor does it disclose any operational costs, permissions, or potential impacts beyond returning a report.

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

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

The description is compact, front-loaded with the main action, and clearly organized with a 'Returns' line. Every sentence adds value, covering what the tool does, what it analyzes, and what it produces, without unnecessary filler.

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

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

Given the tool has no parameters and an output schema is present, the description covers the essential context: the metrics analyzed and the nature of the returned report. It is slightly incomplete in not framing the tool's role relative to other Hipocampo diagnostics or explicitly stating it is non-destructive, but overall it is sufficient for a zero-parameter stats 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, so the description does not need to explain parameter meaning. The baseline for parameter-less tools is 4, and the description appropriately focuses on the tool's behavior rather than inputs.

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

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

The description clearly states the tool 'Muestra estadísticas de rendimiento del sistema Hipocampo' and enumerates the specific metrics analyzed: query latency, methods used, average scores, and optimization recommendations. This distinguishes it from sibling tools focused on health, maintenance, or search, giving an agent a concrete sense of the resource and purpose.

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

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

The usage context is implied rather than explicit: it is a stats/reporting tool for performance analysis and optimization recommendations. However, it does not state when to prefer this over sibling tools like hipocampo_health, profile_hipocampo, or hipocampo_budget, nor does it provide exclusions or 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?

With no annotations present, the description fully carries the behavioral burden. It explicitly discloses that the tool is destructive, modifies thresholds and weights irreversibly, is idempotent with convergent results, and should be used with caution. This is exactly the kind of context an agent needs before invoking a 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?

The description is well-structured and front-loaded: purpose first, then behavioral warnings, then alternatives, then usage conditions, and finally return value. Every sentence adds relevant information; nothing is wasted.

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 complete for a destructive, parameterless tool without annotations. It covers purpose, side effects, idempotency, recommended conditions, alternatives, and expected return output. An agent has all the information needed to decide whether and when to invoke this 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, so the input schema provides nothing to clarify. The description appropriately focuses on behavior and return value rather than parameter details. The 0-parameter baseline of 4 applies because no additional parameter semantics are necessary.

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 ('Ajusta automáticamente los thresholds y pesos del SSC') based on accumulated performance metrics. It also distinguishes itself from related tools by explicitly naming hipocampo_stats and hipocampo_maintenance, so an agent can tell them apart without opening schemas.

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

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

The description gives explicit when-to-use and when-not-to-use guidance: run only after at least 100 recorded queries, and avoid if the system is functioning correctly. It also names alternatives for read-only stats (hipocampo_stats) and the full maintenance cycle (hipocampo_maintenance).

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 correctly carries the full disclosure burden. It reveals substantial non-obvious behavior: file type filtering, chunking into semantic memories with embeddings, incremental indexing by mtime on the second run, and force semantics. The mtime incremental behavior is exactly the kind of trait an agent can't infer from the schema. It stops short of stating side effects (whether re-indexing replaces or duplicates existing memories), which keeps it from a 5.

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, scan scope, process, incremental behavior, Args, and Returns. The content is front-loaded with the core purpose. The file type list is somewhat long but earns its place since it defines scan scope precisely; no sentence is wasted.

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 2 optional parameters and an existing output schema, the description covers the essentials: input semantics, behavior, and a Returns note ('Estadísticas de la indexación'). No annotations exist, so it also carries safety disclosure for a mutation-style tool, which it does adequately by describing what gets stored. The lack of sibling differentiation and undocumented re-index side effects are the only notable 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?

Schema description coverage is 0%, so the description fully compensates: it explains project_path is an absolute path that falls back to the current directory when empty, and clarifies force re-indexes everything regardless of changes. Both parameters gain real meaning beyond the bare type/default declarations in the input 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 opens with a specific verb and resource: 'Indexa archivos de código fuente de un proyecto en Hipocampo (RAG)'. It further enumerates the exact file types scanned (PHP, JS, TS, Python, SQL, HTML, CSS, JSON, YAML), distinguishing it clearly from siblings like search_hipocampo, watch_hipocampo, and reindex_now without needing to open their schemas.

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?

Usage context is implied through the behavioral details — initial indexing, incremental mtime-based re-runs, and force re-indexing — but no alternative tools are ever named. With 30+ siblings including reindex_now, an explicit 'use X instead when...' note would materially help routing; its absence leaves the agent to infer when this tool is the right choice.

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 burden and does it reasonably well: it states the creation side effect, common relation_type values, weight bounds/defaults, and a return confirmation. It does not disclose edge-case behavior such as duplicate links or missing IDs, but the primary mutation is clear.

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

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

The description is compact and well structured: one summary sentence, an Args block with each parameter on its own line, and a Returns line. It is front-loaded and every line earns its place.

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

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

The description covers the required parameters, optional defaults, and the return confirmation, which is enough to invoke the tool for a simple link operation. It would be stronger with an example or error behavior, but the core invocation context is not missing.

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

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

Schema coverage is 0%, and the description compensates by explaining all four parameters: source_id/target_id roles, relation_type values with default, and weight range/default. However, it claims source_id can be a string for memory_items while the schema declares integer, making the added guidance not fully consistent.

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 opening sentence 'Crea un enlace entre dos recuerdos en el grafo de memoria' names a specific verb, resource, and context. The action is clearly distinct from sibling tools such as unlink_hipocampo, so an agent can understand what the tool does without extra inference.

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 how to link memories but gives no guidance on when to choose this tool over alternatives. It does not mention the inverse relation with unlink_hipocampo or any preconditions such as the memories existing. Usage context is entirely left to the agent.

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 accurately conveys a read-only listing operation, but it does not explicitly state that it makes no changes or how the configured directories are sourced; the output schema presumably covers the return shape.

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

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

The description is a single, tightly written sentence that front-loads the action and object. Every word contributes to the meaning, and there is no redundant or filler content.

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

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

For a no-parameter listing tool with an output schema, the description is largely adequate. However, the sibling set contains several watch-related tools such as list_watches and watch_hipocampo, and the definition does not disambiguate when list_watch_dirs is the appropriate choice.

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 there is no parameter ambiguity to resolve. With an empty properties schema and 100% schema coverage, the description does not need to add parameter-level meaning, and the baseline of 4 applies.

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

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

The description states the verb 'Lista' and the specific resource 'directorios configurados para auto-reindexación', making the tool's function clear. It is distinguishable from similar siblings like list_watches by the auto-reindexation scope, though it does not explicitly name or contrast that sibling.

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 list_watches, add_watch_dir, remove_watch_dir, or watch_hipocampo. The phrase 'para auto-reindexación' implies a context, but there is no direct when-to-use or when-not-to-use statement.

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 usefully discloses the return contents (ID, pattern, URL), but it never states whether the operation is read-only, side-effect-free, or requires any auth. An agent must infer the safety profile from the word 'list'.

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 with zero filler. The purpose is front-loaded, and the Returns line earns its place by specifying the exact fields an agent should expect (ID, patrón, URL).

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 listing tool with an output schema present (per context signals), the description covers purpose and return value and is largely complete. The only genuine gap is lack of sibling differentiation, which is already penalized under 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 tool has zero parameters and an empty schema, so the baseline is 4. There is nothing for the description to add beyond the schema; it correctly describes the operation rather than parameters, and there is no parameter documentation gap to compensate for.

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

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

States a specific verb and resource: 'Lista todos los webhooks registrados' (Lists all registered webhooks), and adds the return shape (ID, patrón, URL). It is reasonably distinguishable from the look-alike sibling list_watch_dirs via the 'webhooks' resource, though the description never explicitly differentiates them and mixes terminology ('webhooks' vs 'watches').

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

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

No guidance on when to use this tool versus alternatives, and no exclusions or prerequisites. With a sibling set of 36 tools including the similarly named list_watch_dirs, an agent is left to infer selection criteria from the name and one-liner 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?

With no annotations, the description carries the full behavioral burden. It adds useful context beyond the schema: max_depth is capped at 10 (a constraint absent from the schema) and the return value is a node sequence. However, it does not disclose what happens when no path exists within max_depth, error behavior, or whether the operation is strictly read-only.

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

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

One purpose sentence followed by compact Args/Returns sections. Zero filler, purpose front-loaded, and the parameter documentation is structured and scannable. The Spanish phrasing matches the domain naming (hipocampo) and every line 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 3-parameter tool with an output schema, the description covers the purpose, every parameter, and the return shape. The one clear gap is the no-path-found outcome (empty sequence, null, or error), which is a realistic scenario for a shortest-path tool and is left unspecified.

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 — and it does completely. from_id and to_id are explained as memory IDs (recuerdo origen/destino), and max_depth gets both its meaning ('Profundidad máxima de búsqueda'), its default (5), and a max constraint (10) that the schema omits.

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

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

The description states a specific verb and resource: 'Encuentra el camino más corto entre dos recuerdos en el grafo de memoria' (finds the shortest path between two memories in the memory graph). This clearly distinguishes it from siblings like search_hipocampo (retrieval), graph_hipocampo (whole-graph operations), and link_hipocampo (edge creation).

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 pairwise framing ('entre dos recuerdos') implies the use case — determining connectivity between two specific memories — but the description never explicitly says when to prefer this tool over search_hipocampo, graph_hipocampo, or quick_hipocampo_search, nor does it state when not to use it. Usage must be inferred from the stated behavior rather than explicitly guided.

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 the burden of explaining side effects. It mentions extracting and returning but does not clarify if it modifies state, has side effects, or is read-only. This leaves some ambiguity.

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

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

The description is concise, well-structured with separate Args and Returns sections, and every sentence contributes to understanding the tool's purpose and usage. 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?

The return value is described as a compressed summary with relevant memories, which is sufficient for many use cases. However, no output schema is provided, and the description does not mention error handling or edge cases, leaving a small gap.

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

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

Both parameters are well explained: project_path is described as an absolute path with a fallback to the current working directory, and k is described with its default and max value. This adds meaningful detail 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?

States exactly what the tool does: pre-loads context by extracting relevant memories and returning a compressed summary. It also differentiates from sibling search tools by specifying the use case of restoring working context for a known project.

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 says when to use it ('when starting work on a known project'), but does not explicitly mention when not to use it or contrast with alternatives like search_hipocampo. Still, the guidance is clear enough for most agents.

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 behavioral burden. It clearly indicates that the tool persists a memory item, specifies the data domain, and states the return value (confirmation with assigned ID). It does not discuss side effects like overwrite or idempotency, but for a simple low-risk create operation this is reasonably transparent.

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

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

The description is compact and well-structured: purpose and differentiation first, then clean Args and Returns sections. Every sentence contributes useful information, with no redundant filler.

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

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

For a simple tool with one required parameter and an output schema, the description is complete. It tells the agent what the tool does, when to use it, what each parameter means, and what the return will be, so no critical calling information is missing.

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 documents all three parameters with type guidance, optionality, and useful examples for summary and categories. This adds substantial meaning beyond the bare 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 states a specific action ('Guarda un dato de perfil personal'), identifies the resource (Hipocampo memory_items), and explicitly differentiates itself from the sibling save_hipocampo. An agent can immediately understand this tool is for personal-profile memory, not technical vector 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?

The description names the main alternative (save_hipocampo) and explains the decisive distinction: this tool stores personal data in memory_items while save_hipocampo stores technical data in memoria_vectorial. This gives the agent a clear selection rule.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states it is read-only, has no side effects, and produces identical behavior and output to search_hipocampo. This is strong behavioral disclosure for a presumably safe search tool. It does not detail pagination or error behavior, but the alias's identical-to-search_hipocampo promise covers that expectation.

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 clear sections: purpose, read-only guarantee, alias relation, usage guidance, parameters, and return format. Every sentence adds value. Minor redundancy exists with the alias statement being repeated, but the text remains compact and scannable.

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

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

For a simple alias with 2 params, 1 required, and an output schema, the description fully covers what an agent needs: behavior, safety, parameters, return format, and usage guidance. The output schema exists, so return values need not be detailed further. The only minor gap is a precise definition of session_id semantics beyond 'filters results', but the alias relationship to search_hipocampo mitigates this.

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 explains query as natural-language search text with concrete examples, and session_id as an optional filter to a specific session. It could add more detail on session_id semantics, but the parameter meaning is clear and goes beyond the bare 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 identifies this as a quick alias for search_hipocampo with read-only search behavior. It states the verb ('Búsqueda rápida') and resource ('Hipocampo'), and distinguishes it from the canonical sibling by noting it is an alias for shorter client names. However, a fully standalone definition would explain what the search does even if read without knowledge of search_hipocampo.

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 alias: when the MCP client prefers shorter tool names, and directs users to search_hipocampo for the descriptive name. This gives clear alternatives and selection criteria, fully satisfying the dimension.

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 hay anotaciones, así que la descripción es la única fuente de comportamiento. 'Fuerza reindexación inmediata' y '(o todos los watch)' comunican que la operación es forzosa, inmediata y puede abarcar todos los watch, pero no se mencionan efectos secundarios, coste o si requiere permisos específicos.

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?

Una sola frase sin palabras de relleno. La información principal (acción forzosa, inmediatez, alcance directorio/todos los watch) está al frente y cada elemento aporta.

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?

Para una herramienta de un solo parámetro opcional con output schema, la descripción es casi suficiente a nivel de invocación: define qué reindexa y el alcance. Falta aclarar si el directorio debe ser un watch existente, qué ocurre con una ruta inválida, y no hay guía de uso frente a herramientas hermanas.

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?

Con 0% de cobertura en el schema, la descripción compensa en parte: indica que la operación se aplica a un directorio y que, en lugar de un directorio concreto, puede aplicarse a todos los watch, lo que da sentido al path opcional y a su default vacío. No relaciona explícitamente el nombre del parámetro 'path' con ese directorio.

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?

La descripción usa un verbo concreto ('Fuerza reindexación inmediata') y un recurso específico ('un directorio (o todos los watch)'), por lo que un agente entiende la acción y el alcance. No diferencia explícitamente de herramientas hermanas como hipocampo_maintenance o index_project, por eso no alcanza el 5.

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

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

No indica cuándo usar esta herramienta frente a las alternativas hermanas, ni excluye casos de uso. Solo se puede inferir que el caso de uso es una reindexación inmediata, pero no hay mención de condiciones, prerrequisitos ni cuándo no usarla.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says the directory is removed from the watch list; it does not mention whether the operation is persistent, idempotent, or what happens if the path is not currently watched.

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 short sentence conveys the core action with no filler or repetition. The essential information is front-loaded 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 one-parameter tool with an output schema, the description is mostly complete: the agent knows what action to take and what parameter to provide. It would benefit from a little more behavioral context, but the simplicity of the tool keeps the gap small.

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 clarifies that 'path' refers to a directory in the watch list, but it does not specify path format, absolute vs relative, or behavior for invalid paths. This is minimal but non-redundant 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 states a specific verb ('Elimina'), a clear resource ('directorio del watch list'), and is immediately distinguishable from sibling tools like add_watch_dir and list_watch_dirs. There is no ambiguity about what the tool does.

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 intended use is implied: use this when a directory should no longer be watched. However, the description provides no explicit guidance on when to prefer it over alternatives such as unwatch_hipocampo, nor does it mention prerequisites or edge 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?

With no annotations, the description carries the behavioral burden. It usefully discloses that the embedding is reconstructed automatically and that the memory is returned to the HOT tier. However, it does not clarify whether the source memory is moved, copied, or deleted from memoria_historica, which is a significant side-effect 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 compact and front-loaded: the action and resource flow appear first, followed by key behavioral details, then the parameter explanation. No sentence is wasted.

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, has one parameter, and an output schema exists, so return values need no explanation. Still, the description omits side effects, prerequisites, and conditions for use, leaving the operational context partially 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?

Schema coverage is 0%, so the description must compensate. It does: 'historica_id' is defined as 'ID de la memoria en memoria_historica', giving meaning beyond the bare integer type in the input schema. This is sufficient for a single required 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 states a specific verb ('Restaura'), a clear resource flow ('desde memoria_historica a memoria_vectorial'), and the observable outcome ('La memoria vuelve al tier HOT'). This clearly distinguishes it from sibling tools like delete_hipocampo or consolidate_hipocampo.

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 the many sibling hipocampo tools. It does not state prerequisites, exclusions, or alternatives, so an agent must infer the appropriate context from the operation 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?

Al no haber anotaciones, la descripción asume toda la carga de transparencia y lo hace bien. Revela que la degradación es reversible en cuanto a que no borra reglas, que solo pierden inmunidad de compresión, y especifica la condición review_count=0. Esto permite al agente anticipar efectos secundarios sin ambigüedad.

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?

La descripción está bien estructurada: una frase introductoria, contexto breve, explicación del modo dry_run, argumentos y retorno. Cada sección aporta información necesaria y no hay relleno ni repetición innecesaria del esquema.

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?

Para una herramienta con dos parámetros opcionales y un esquema de salida presente, la descripción cubre todo lo necesario: qué hace, cuándo aplica, qué condiciones activan la degradación, qué ocurre con cada valor de dry_run y qué devuelve. No faltan detalles relevantes para invocarla correctamente.

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?

La cobertura del esquema es 0%, pero la descripción compensa completamente. Explica que max_age_days define la edad máxima sin revisión para considerar degradación y que dry_run controla si la acción es solo informativa o ejecuta la degradación. Añade significado real más allá de los títulos y defaults del esquema.

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?

La descripción usa un verbo específico ('Revisa'), indica el recurso exacto ('reglas automatica sin revisión') y añade el alcance temporal ('últimos N días'). Deja claro que la herramienta identifica y potencialmente degrada reglas, distinguiéndola de las demás herramientas del ecosistema.

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?

Explica el contexto de uso: las reglas automatica son permanentes por diseño y solo se degradan si no han sido útiles tras max_age_days. Además, diferencia claramente entre dry_run=True (solo lista candidatos) y dry_run=False (degradación real), orientando al agente sobre cuándo usar cada modo.

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 exist, so the description must carry the safety/behavior burden. It does disclose conditional logic: if original IDs still exist it reports no rollback needed, otherwise attempts restoration. But it does not reveal side effects (e.g., whether current state is overwritten), failure behavior if the snapshot is missing, or any destructive consequences.

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 short, well-structured with Args/Returns, and front-loads the main action. Every sentence contributes to understanding the flow; no filler or repetition beyond minor redundancy in 'previamente'.

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 tool with an output schema present, the description provides enough invocation context: what the ID is, what the tool checks, and what it returns. It could add failure-mode or impact details, but the missing output schema details are not necessary to call the tool.

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

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

Schema coverage is 0%, so the Args section is critical. It defines snapshot_id as 'ID del snapshot [CHECKPOINT SNAPSHOT] guardado', clarifying that the ID refers to a previously saved checkpoint rather than a generic integer. The body reinforces how the ID is used ('Busca el snapshot por ID').

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 action and resource ('Revierte un checkpoint usando el snapshot guardado') and explains the operation flow. However, it never distinguishes itself from similar sibling tools like 'restaurar_historica' or 'hipocampo_checkpoint', so an agent must infer the exact boundary.

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 call this tool vs alternatives. It describes mechanics (look up snapshot, compare IDs, restore if needed) but omits preconditions, exclusions, or a when-not-to-use note. The intended use is only implied by the name and first sentence.

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 exist, so the description carries the full behavioral disclosure burden — and it excels. It reveals asynchronous background embedding ('_finalize_save_bg'), the transient WARM tier state with embedding=NULL until backfill, retrievability-by-text during that window, blocking trigram dedup versus non-blocking semantic dedup (>0.9 logs only), auto-link behavior (>0.75 threshold), and the critico flag's lifetime protection semantics. This is rich operational detail an agent needs to predict 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 long but information-dense and well-organized: a front-loaded behavioral summary precedes a structured Args block with per-parameter detail. Nearly every sentence earns its place given the 0% schema coverage and the tool's genuine complexity. Minor trimmable details like the internal function name '_finalize_save_bg' and the 'Returns' line (redundant with the output schema) keep it from a 5.

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 high-complexity tool (9 params, async behavior, dedup logic, retention tiers, side-effectful auto-linking), the description covers parameters, behavioral states, side effects, duplicate handling, and returns. Small gaps remain: error conditions are unspecified, memory_type lists only 'valores comunes' without stating whether other values are accepted, and there is no guidance on content-length limits. These are minor against an otherwise thorough definition.

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% — the schema provides only parameter titles with no descriptions. The description fully compensates by documenting all 9 parameters with defaults, semantics, and concrete examples: memory_type values ('event', 'decision', 'profile'), code examples ('documentacion', 'bugfix'), categories, nivel hierarchy, and force/critico behavior. Every parameter an agent needs to understand is explained with actionable detail.

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 opening line 'Guarda un recuerdo en el Hipocampo (memoria_vectorial)' names a specific verb (save/insert) and a specific resource (a memory into the vector store). The description goes further to refine purpose by delineating the exact write semantics: immediate, non-blocking insert with background embedding. Against a sibling set containing update_hipocampo, delete_hipocampo, link_hipocampo, and search_hipocampo, this is unmistakably the primary create/insert 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 description provides clear context about when a save will or won't happen: 'Si ya existe un recuerdo casi idéntico (trigram), se advierte y se omite el guardado a menos que force=True' tells the agent the call may be a no-op and how to override it. However, it never explicitly names alternatives for adjacent use cases (e.g., when to call update_hipocampo for modifying an existing memory instead, or search_hipocampo for retrieval). Context is clear but exclusions and alternative routing are absent.

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

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

No annotations are provided, so the description carries the full burden. It discloses read-like behavior and output content, but does not mention side effects, permissions, or rate limits, which would be expected without 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 and well-structured with clear Args and Returns sections, containing no redundant or irrelevant 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?

The tool description is self-contained for a search operation, covering purpose, parameters, and return content. With an output schema present, the return explanation is sufficient, though a brief example or mention of result count could make it slightly more 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?

Although the schema properties lack descriptions, the Args section fully explains each parameter: query is natural language, k has default and max values, and language has a default meaning. This adds complete semantic meaning beyond the bare 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 action ('Busca código fuente indexado') and resource (Hipocampo RAG), and explicitly distinguishes it from search_hipocampo by filtering code_snippet memories and returning real code fragments with file locations.

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?

Directly compares to search_hipocampo and explains the filtering difference, making it clear when this tool should be preferred for code-specific searches, though it does not explicitly mention 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 carries the full burden and delivers: it declares read-only with no side effects, no rate limits, hybrid semantic+lexical search mechanics, session scoping, and the no-results behavior. This fully discloses the safety and behavioral profile an agent needs before invoking.

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 front-loaded safety and scope statements, followed by organized Args/Returns sections. Slight redundancy in the triple-phrased read-only statement ('solo lectura — no modifica datos, no tiene efectos secundarios'), but every section 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?

Complete for a search tool: covers what it searches, safety profile, rate limits, session filtering, parameter constraints, return format, and empty-result behavior. The alias relationship to quick_hipocampo_search removes ambiguity within the large sibling set.

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 fully compensates for the bare schema. It adds the 500-character max constraint, natural-language semantics, concrete examples for query, and the filtering effect of session_id — all absent from the structured definition.

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 and resource: searches the Hipocampo memory with hybrid semantic+lexical search over memoria_vectorial and memory_items. It clearly differentiates from sibling quick_hipocampo_search by positioning itself as the full descriptive-name version while noting the alias is identical.

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 names the alternative quick_hipocampo_search and describes session_id filtering behavior for scoped searches. However, the routing condition ('when the short name is preferred') is about naming preference rather than functional differentiation, and it gives no when-not-to-use guidance relative to non-search siblings like search_code.

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 states 'Cambia' (changes) and specifies a return of 'Confirmación del cambio', which discloses that this is a mutating operation. However, it does not mention potential side effects, error conditions, or whether the operation is idempotent. Since no annotations are provided, the description carries the full burden and could be more explicit.

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 and well-structured, with clear sections for the levels and parameters. It avoids unnecessary detail while still providing essential 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?

The description includes a 'Returns' section, which gives expected output, and explains the level values in a way that informs the user about the tool's effect. It does not cover error handling or edge cases, but for a simple setter, it provides sufficient context for an agent to invoke it correctly.

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

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

The description elaborates on both parameters: 'id' is defined as the memory ID, and 'nivel' is given three explicit allowed values with their meanings. This adds value beyond the raw schema, which only specifies types (integer and string). It lacks details on validation or whether IDs must exist, but covers the key 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 verb 'Cambia' and resource 'nivel jerárquico de un recuerdo' clearly indicate the tool's function of setting a memory's hierarchical level. It is distinct from sibling tools like compress_hipocampo or consolidate_hipocampo, though it does not explicitly contrast with them.

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 the purpose and the meaning of the level values, but it does not provide explicit guidance on when to choose this tool over similar siblings like compress_hipocampo or consolidate_hipocampo. The user must infer the appropriate context from the level descriptions.

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 burden of behavioral disclosure. It clearly states that this is a deletion operation and notes that it returns a deletion confirmation. It does not mention irreversibility, whether the linked nodes are preserved, or any authorization requirements — gaps that matter for a destructive tool with zero annotation coverage.

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

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

The description is compact and well-structured: a one-sentence purpose, an Args list, and a Returns line. Every part earns its place, and the primary action is front-loaded. No filler or redundant 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 covers all four parameters and the return type, and the usage fallback logic is reasonably complete. However, it leaves ambiguity about whether relation_type is truly optional when identifying by source+target (which could affect uniqueness), and it does not state the side-effect scope — specifically whether deleting a link leaves the associated nodes intact. For a destructive tool with no annotations, this is a meaningful gap.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explains the role of each parameter and the precedence relationship: id takes priority, and source_id/target_id/relation_type are the fallback keys when id is absent. This adds real meaning beyond the bare schema properties.

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

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

The description opens with a specific verb and resource: 'Elimina un enlace del grafo de memoria' (deletes a link from the memory graph). This clearly distinguishes the operation from broader tools like delete_hipocampo or graph_hipocampo, though it does not explicitly name those 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 Args section provides conditional routing logic: use 'id' if known; otherwise delete by source_id + target_id + relation_type, with target_id marked as required when id is absent. This tells an agent how to select between two invocation patterns. It does not, however, explain when to choose unlink_hipocampo over delete_hipocampo or other 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 present, so the description carries the burden of behavioral disclosure. It clearly indicates a destructive action ('Elimina') and states the success return ('Confirmación de eliminación'), but it does not describe error behavior, irreversibility, or side effects such as the webhook no longer receiving events.

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

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

The description is compact and well-structured with short Args/Returns sections. The core behavior is front-loaded and every sentence adds necessary information 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 deletion tool with an output schema present, the description covers the essential invocation details: the required ID, the action, and the return value. It loses a point for not situating the tool among related watch-management siblings or describing possible error outcomes.

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 compensates by defining id as 'ID del watch a eliminar.' This sufficiently clarifies the single integer parameter, though it does not explain how to obtain the ID, such as through list_watches.

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 the exact operation ('Elimina un webhook') and the identifier used to select the target ('por su ID'). This differentiates it from sibling tools like watch_hipocampo and remove_watch_dir, which handle registration or directory watches rather than deleting a webhook by ID.

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 alternatives such as list_watches, remove_watch_dir, or watch_hipocampo. The only implied usage is deleting a registered webhook by ID, but no prerequisites or exclusion 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, the description carries the full behavioral burden. It usefully discloses that content triggers embedding regeneration and that unspecified fields remain unchanged. However, it does not mention error cases, permission needs, reversibility, or side effects on related memories, which would be valuable 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 short, front-loaded with the main purpose and key behavioral notes, followed by a clear structured list of parameters. Every sentence contributes useful information without repetition or 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?

For a 5-parameter update tool with no annotations, the description covers purpose, core behavior, and all parameters. Since an output schema exists, the minimal 'Returns' section is acceptable. It lacks explicit usage boundaries and error conditions, but the essentials are present.

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

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

Schema description coverage is 0%, but the description's Args section compensates fully. It explains id as a numeric ID, content as new text with embedding regeneration, memory_type with example values, code as a short label, and categories as a list. This adds meaning well beyond the bare 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 starts with a specific verb and resource: 'Actualiza un recuerdo existente en el Hipocampo (memoria_vectorial).' This clearly states the operation and target. It also distinguishes itself from the many sibling hipocampo tools, none of which perform a general update of an existing 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?

The description implies usage: update an existing memory record. However, it does not explicitly mention when to use this tool versus alternatives like delete_hipocampo, link_hipocampo, or compress_hipocampo. There is no 'use when' or 'do not use when' guidance, so the usage context is only inferred.

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. It explains the tool's behavior (validates, verifies snapshots, detects contradictions, reports orphans) and indicates a read-only validation role, returning a report. It does not mention side effects or state changes, which would be a gap, but the described actions imply no modification.

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 and well-structured with three bullet points for the analysis steps. It avoids unnecessary fluff and is easy to parse, making it efficient for an agent.

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

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

The description covers the purpose, the specific checks performed, and the output (validation report with recommendations). It lacks details on error handling or edge cases, but for the given scope it provides sufficient context for an agent to know what to expect. The input schema is simple and fully described.

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 only parameter, rule_id, is clearly explained as the ID of the immune rule to validate. The description adds meaningful context beyond the bare schema, making the parameter's purpose unambiguous.

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 validates an immune rule (Nivel 4) and lists three specific analysis steps (verifies snapshots, detects contradictions, reports orphans). This distinguishes it from sibling tools that focus on other operations like search, graph, or maintenance.

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 validating immune rules, but does not explicitly state when to use it versus other similar tools (e.g., review_automatica). No clear 'use when' or 'do not use when' guidance is provided, leaving some ambiguity for an agent.

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 and does well: it discloses the action, trigger events, matching logic, the POST payload fields (event, id, content, metadatos), and the return value. It omits minor details like authentication requirements or idempotency, but the core behavior is fully transparent.

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 and well-structured with Args and Returns sections. It front-loads the primary purpose in the first sentence and contains no filler or repetition.

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 two-parameter tool with an output schema, the description is complete. It explains the trigger, parameters, payload, and return value, so an agent has everything needed to invoke 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%, so the description fully compensates. It explains pattern as 'Texto a buscar en contenido o metadatos del recuerdo' and clearly defines webhook_url as the URL that receives a POST with specific fields. This adds substantial meaning beyond the bare 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 a specific verb and resource: 'Registra un webhook' for memories whose content or metadata match a pattern. It specifies the triggering events (created/modified/deleted), which distinguishes it from sibling tools like add_watch_dir or unwatch_hipocampo.

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 the tool is appropriate: to receive webhook notifications about memory changes matching a pattern. However, it does not explicitly mention alternatives, exclusions, or when not to use it, such as when directory watching via add_watch_dir would be more suitable.

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