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 disclosure burden and does add real behavioral context: a calibrated Noul-per-candidate path gated by HIPOCAMPO_TYPESAFE=1 with a 0.7 threshold, and a negation-probe embedding fallback with its comparison logic. It does not state whether the operation mutates state or what permissions/cost it incurs, but the disclosed internals are non-obvious and genuinely useful.

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 purpose is correctly front-loaded in one sentence, but the remaining text dumps implementation detail about negation-probe embeddings and threshold machinery that an agent does not need in order to select or call the tool. It is over-specified in the wrong 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?

An output schema exists so return values need no explanation, and the single parameter's meaning is partly covered. What is missing is operational context: whether this is a read-only detection pass, whether it is expensive (LLM call per candidate), and when to prefer it over related hippocampus maintenance tools.

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

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

Schema coverage is 0%, and the sole parameter is documented only as 'ID numérico de la memoria en memoria_vectorial', which clarifies the ID's origin and type beyond the bare schema. That is useful but minimal compensation for a completely undocumented schema, so a baseline-plus score is appropriate.

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

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

The opening sentence states a specific verb and resource: 'Detecta contradicciones semánticas de una memoria existente.' The operation is conceptually distinct from siblings like hipocampo_dedup or validate_immune_rule, so an agent can identify it. However, it never differentiates itself from those siblings explicitly, which keeps it short of a 5.

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

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

There is no guidance on when to invoke this tool versus alternatives, no prerequisites, and no exclusions. The two execution modes (TypeSafe vs fallback) are described, but those are internal implementation branches, not usage conditions for 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?

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 usefully discloses behavioral traits beyond the schema: compact mode truncates to an 800-character fragment while full/json include all content and metadata, and the operation is a read-style exact lookup. It does not state missing-ID error behavior or permission requirements, leaving some behavioral gaps.

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

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

The description is front-loaded with the core purpose, followed by structured Args and Returns sections. Every sentence adds relevant usage or parameter/output detail, with no 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 two-parameter retrieval tool with an output schema but no annotations and 0% schema descriptions, the description covers the missing ID-format semantics, format modes, and return behavior. It gives the agent enough to call the tool correctly without needing to open the output schema for basic understanding.

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 that id accepts numeric memory_vectorial IDs, prefixed forms (#4039, v4039), and memory_items IDs (vmi<uuid>). It also defines format values compact, full, and json, including the default and the output difference.

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 sentence states a specific verb and resource: 'Obtiene una memoria exacta por ID, sin pasar por el ranking.' It immediately distinguishes exact-ID retrieval from ranked search tools such as search_hipocampo / quick_hipocampo_search by saying it bypasses ranking.

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 clearly frames when to use it: deterministic retrieval for 'tráeme el recuerdo N' by known ID, explicitly not competing with dozens of ranked results. It stops short of naming a sibling alternative like search_hipocampo for the opposite case, so it lacks fully explicit when-not guidance.

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

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

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 supplied, so the description carries the full behavioral burden; it implies a read-only listing and names the returned fields, which is useful. But it says nothing about ordering, result limits, or scope (all memories vs. a filtered set), which a bare list tool would need for safe invocation.

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 the purpose front-loaded and the field list in a compact second sentence; nothing is wasted. It is slightly clipped rather than verbose, but cleanly structured.

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, the description need not explain return values, and it is complete enough to call a zero-parameter list tool. Still missing are scope, ordering, and how results relate to siblings like review_trade_knowledge, which matter for an agent choosing between them.

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 takes zero parameters, so the schema imposes no semantic burden and the baseline is 4. The description correctly signals that no input 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?

States a specific verb and resource ('Lista todas las memorias marcadas como conocimiento del oficio') and even enumerates the fields returned, so the agent knows exactly what set is retrieved. However, it never distinguishes itself from the similarly named sibling review_trade_knowledge, leaving ambiguity about which of the two to pick.

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 when-to-use guidance, no prerequisites, and no mention of the obvious alternative review_trade_knowledge. Usage can only be inferred from the tool name and the phrase 'conocimiento del oficio'.

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 carries the full behavioral burden. It discloses that memories are extracted and compressed into a summary, and that rerank applies a calibrated relevance judgment before compression. However, it does not state whether the operation is read-only or has side effects, nor any performance or permission implications, leaving gaps for an unannotated 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?

Purpose and usage are front-loaded in the first two lines, followed by structured Args/Returns. The formatting is efficient, though the Returns block and some Args detail are somewhat redundant against the schema and output schema.

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?

An output schema exists, so return values need not be re-described. Given zero schema coverage across 3 parameters, the description covers all of them adequately, and only minor behavioral detail (safety/side effects) 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, and it documents all three parameters: project_path (defaults to cwd when empty), k (default 8, max 20 – the max is new information beyond the schema), and rerank. The rerank text is in mixed Spanish and somewhat garbled ('Opcional (TypeSafe)'), which slightly reduces clarity.

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 (pre-load) and resource (project/workspace context) plus the mechanism: extracts memories from the project path and returns a compressed summary. Clear enough to distinguish from siblings like index_project or search_hipocampo, though it does not explicitly name an alternative. No sibling differentiation is spelled out.

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?

'Use this when starting work on a known project to restore working context' gives a clear triggering condition. There are no explicit exclusions or named alternatives (e.g., vs. quick_hipocampo_search), but the when-to-use signal is unambiguous.

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?

With no annotations, the description carries the full burden. It usefully declares 'Es solo lectura — no modifica datos' and that behaviour matches search_hipocampo, which covers the safety profile. However, it says nothing about pagination, default inclusion of pending memories, latency/rerank budget trade-offs, or any limits.

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 the purpose and read-only guarantee front-loaded, followed by a tight parenthetical enumerating options. No filler, though the enum listing is terse enough that it reads more as a hint than documentation.

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?

Output schema exists so return values need not be explained, and the read-only claim is covered, but for a 19-parameter search tool with zero schema description coverage the description leaves most inputs undocumented and gives no guidance on defaults or interacting options. It is under-specified relative to the tool's complexity.

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

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

Schema coverage is 0% across 19 parameters, so the description must compensate, and it only partially does: it names filter prefixes (code:/category:/id:/after:), the format enum (compact/full/json) and the rerank enum (auto/always/never). The remaining parameters (k, ids, nivel, offset, explain, session_id, memory_type, rerank_top_k, snippet_chars, include_scores, include_pending, rerank_budget_ms) get no explanation beyond their self-describing names.

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

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

States a specific verb+resource ('Búsqueda rápida en el Hipocampo') and explicitly identifies itself as a short alias of search_hipocampo with identical behavior, which lets an agent reason about the sibling relationship. It is clear what the tool does, though it never says what the Hipocampo corpus actually contains.

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 signals it is read-only and behaviourally identical to search_hipocampo, which implies either can be used, but it never states when to prefer this short alias over the full-named sibling or any conditions/exclusions. Usage is inferable rather than explicit.

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

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

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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the eligibility filter (infrastructure profile, 150/180 days), the two outcomes (reinforce resets counter, or allow decay), and a recommended cadence. However, it says nothing about what dry_run actually changes in behavior, nor about side effects of reinforcement beyond the counter reset.

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?

Purpose is front-loaded, the bullet list cleanly separates the two possible actions, and the cadence note closes it out. Some framing is redundant ('El agente puede:') but the structure is efficient 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?

An output schema exists, so return-value explanation is not required, and the review/decide workflow is described adequately. The gap is the unaddressed dry_run parameter and the absence of any guidance on which sibling tool to prefer for automated versus manual review.

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% for the single parameter dry_run, which defaults to true. The description never mentions dry_run or what a dry run returns versus a real run, so it fails to compensate for the documentation gap. The parameter name is somewhat self-explanatory, which keeps this from scoring 1.

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 (review) and resource (trade knowledge memories), and narrows scope precisely: domain_profile='infrastructure' memories at 150+ days out of 180 without access. An agent can tell what this does at a glance. It doesn't explicitly name sibling alternatives like review_automatica or decay_hipocampo, so it stops short of full sibling differentiation.

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 cadence ('cada 3 meses via systemd timer o manualmente') implies when to invoke, and the two action branches (reinforce vs allow decay) frame the workflow. But there is no explicit when-to-use versus siblings such as review_automatica or decay_hipocampo, and no prerequisites stated.

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

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

No annotations 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?

With no annotations, the description carries the full behavioral burden and does so: non-blocking insert, embedding generated in background via _finalize_save_bg, WARM tier with embedding=NULL until backfill, text-recalled in the interim, trigram warning-and-skip behavior, and semantic dedup (>0.9) that only logs. It also discloses permanence semantics (critico never archived, nivel compression rules) that no annotation could convey.

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?

Long but front-loaded and disciplined: the first lines carry the critical timing/tier behavior, then Args and Returns are clearly partitioned. Every sentence adds operational information, including the non-obvious snapshot_for mechanism, with no 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 an 11-parameter mutation tool with mutation side effects but no annotations, this is complete: it explains what happens on write, timing/visibility of the memory, dedup behavior, protection levels, and side-effect links. An output schema exists, so the terse Returns line is sufficient.

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

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

Schema description coverage is 0% across 11 parameters, so the description must compensate and it does — every parameter gets meaning, valid values and defaults (memory_type event/decision/profile, nivel episodica/semantica/automatica, autor agente/usuario/catalogo, snapshot_for's part_of linking to validate_immune_rule). This adds substantial meaning the bare schema cannot.

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?

'Guarda un recuerdo en el Hipocampo (memoria_vectorial)' states a precise verb and resource, and the surrounding detail (tiers, dedup, linking) makes it clearly distinct from siblings like update_hipocampo, delete_hipocampo and link_hipocampo. An agent can identify the tool's role without opening the schema.

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

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

Provides rich conditional guidance: when a near-identical memory is skipped unless force=True, when dedup runs in background without blocking, and what auto_link/snapshot_for/nivel accomplish. It never explicitly names an alternative tool for updating an existing memory, so routing versus update_hipocampo is left to inference.

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

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

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 provided, the description carries the full burden and does well: it declares read-only semantics ('no modifica memorias'), describes the default compact output fields, explains rerank modes (auto/always/never) and the boolean back-compat mapping, and gives budget/limit semantics for rerank. It omits permission or rate-limit considerations, which keeps it short of 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?

Front-loaded with purpose, then query syntax, then a parameter block — a sensible order for a 19-param tool. There is some duplication (query operators are re-listed as arguments), but for a schema this large the length is justified rather than padded.

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 19 parameters, no annotations, and an output schema that exists, the description supplies everything the agent needs: purpose, safety profile, query grammar, argument precedence, defaults and ranges, plus a brief note on the no-results case. Nothing material is left undocumented.

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 fully and it does: the Args block documents all 19 parameters, adds enums (nivel: episodica|semantica|automatica, memory_type, format, rerank), numeric ranges (k 1-20, rerank_top_k 3-20, rerank_budget_ms 100-5000, snippet_chars 80-2000), date formats, and the query mini-syntax with code/category/nivel/after/since/ids operators.

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 ('Busca en el Hipocampo') and clarifies the mechanism ('carriles estructurados + semánticos'), so the agent knows this is a hybrid structured/semantic search. It does not, however, distinguish itself from the sibling quick_hipocampo_search, so an agent still has to guess which search tool to pick.

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

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

It explains that query can be empty when argument filters are used and that explicit arguments take precedence over query syntax, which is genuine usage guidance. But it never says when to use this tool versus quick_hipocampo_search or get_hipocampo, and gives no exclusions or prerequisites beyond the read-only note.

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 burden and does so well: it discloses that content embedding is regenerated in BACKGROUND (non-blocking), that the row keeps its previous embedding until backfill and semantic search switches once ready, and that meta_patch is merged rather than replaced. Missing only operational details like permission/auth needs or error behavior.

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?

Front-loads the key behavioral facts (background embedding, partial update) before the Args block, and every sentence and arg line earns its place with no 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?

Complete enough for a 6-param mutation tool: it covers partial-update and merge semantics plus background embedding behavior, and an output schema already exists so return values need no elaboration. It stops short of error/permission context but nothing essential for correct invocation 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 and it does: every parameter is documented with meaning, optionality, and examples ('event', 'decision'; md5/bytes example), plus the crucial merge-vs-overwrite semantics of meta_patch. This adds substantial value 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?

States a specific verb and resource ('Actualiza un recuerdo existente en el Hipocampo (memoria_vectorial)'), and explicitly contrasts with the sibling save_hipocampo for the embedding behavior. An agent can distinguish it from save/delete without opening a schema.

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?

Clear context: it is an update of an existing memory, unprovided fields are preserved, and it behaves like save_hipocampo for background embedding regeneration. It names the sibling as a reference point but does not explicitly state when to choose update vs. save or other update-style siblings (set_nivel_hipocampo).

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.