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

With no annotations, the description carries the full burden and does disclose non-obvious behavior: clustering of similar errors into warnings at ≥3 occurrences and reinforcement of similar errors for retrieval. It still omits whether this is a persistent write, what auth/permissions are needed, and what the call returns.

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

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

Three terse fragments, action front-loaded with behavioral detail trailing. No wasted words, though the telegraphic style leaves gaps that fuller sentences could close.

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

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

For a 5-parameter mutation tool with no annotations and no output schema, the description covers the reporting act and emergent clustering behavior but leaves persistence, permissions, and return behavior unstated.

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 100% and the nested context object is documented, so the schema carries the parameter load. The description adds no field-level meaning of its own; baseline 3 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?

States a clear verb+resource ('Report errors') and adds two behavioral traits (pattern auto-detection, Hebbian boosting). However, it never distinguishes itself from its obvious sibling memory_alarma, which an agent must choose between.

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?

'Report errors immediately' gives a weak timing hint but no when-to-use vs. memory_alarma, no prerequisites, and no exclusion conditions. The agent gets no routing guidance among the many cuba_*/memory_* 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 must carry the full behavioral burden. It goes beyond CRUD by stating 'Auto-boosts neighbors on access,' which is a notable behavioral trait. However, it does not detail what happens on delete or any authorization needs.

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 concise sentences: first states purpose and resource, second adds behavioral trait and sibling alternative. Every sentence earns its place, with no wasted words. Front-loaded with key 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?

Given no output schema, the description could mention what the tool returns (e.g., the entity object). However, for a CRUD tool with clear input schema, the description is largely complete for invocation. The auto-boost behavior is a nice addition.

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 100%, so baseline is 3. The description adds context that entity_type can be one of the listed types, but for most properties, the schema's descriptions are already sufficient. The description does not add significant new meaning beyond the schema.

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

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

The description clearly states 'CRUD knowledge graph entities (concepts, projects, technologies, patterns, people)', which specifies the verb (CRUD) and resource (knowledge graph entities). It distinguishes itself from sibling cuba_cronica by noting that tool is for transient info.

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 provides a usage guideline: 'For transient info use cuba_cronica instead.' This tells the agent when not to use this tool and what alternative to choose, which is strong 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?

With no annotations provided, the description carries the full behavioral burden and does disclose key traits: append-only, SHA-256 hash chain, and UPDATE/DELETE blocked at the PostgreSQL trigger level. It does not cover auth requirements or rate limits, but it gives useful tamper-evidence context beyond the schema.

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

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

The description is a single compact sentence that front-loads the tool's core property. It wastes no words, though it could have used one clause to name the actions.

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 schema fully describes the four parameters and action enum, but there is no output schema and no annotations. The description explains the audit-log guarantees but omits what each action returns and any permission or operational constraints, leaving it only minimally complete for a multi-action tool.

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

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

Schema description coverage is 100%, so the enum actions, payload, event_action, and limit are already well documented in the schema. The description adds no additional parameter meaning, which is the baseline expectation when the schema does the heavy lifting.

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 what the resource is (a tamper-evident audit log) but not what the tool actually does as a command. It does not mention the append/verify/tail operations, so an agent must open the schema to learn the tool's verbs, and it does not distinguish this tool from the sibling memory_archivo.

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 alternatives such as memory_archivo or the other cuba/memory siblings. The description gives no conditions, prerequisites, or routing advice.

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, so the description carries the full burden. It does usefully disclose the optimistic-concurrency contract on put and that lock is a short lease, which is real behavioral context. However, it omits permission/auth needs, lease expiry consequences, and what patch/watch_hint/unlock actually do.

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 dense sentences, front-loaded with the resource definition followed by the two sharpest behavioral caveats. No filler or redundant restatement of the 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?

For a 9-parameter, 7-action tool with no annotations and no output schema, the description explains only put and lock. The semantics of list, get, patch, unlock, and especially the non-obvious watch_hint are never touched, leaving the agent under-informed about most operating modes.

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 100%, so the schema already documents all nine parameters with enums and defaults. The description's mention of base_version and ttl/lease semantics largely restates what the schema already carries, so baseline 3 is correct.

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 resource and scope: 'Shared versioned artifacts between agents on the same daemon (and peers)', plus the alias memory_artifact. An agent knows this is an artifact store, though it does not distinguish itself from any of the many sibling memory_* / cuba_* tools.

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

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

Gives narrow action-level guidance: put needs base_version for optimistic concurrency, lock is a short lease. But with seven enum actions (list/get/put/patch/lock/unlock/watch_hint), it never says when to use one versus another or versus a sibling store, leaving most routing to inference.

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

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

With no annotations, the description carries the whole burden. It usefully discloses a side effect — that trust scores are Beta(alpha,beta) credibilities 'updated by resolve outcomes' — and distinguishes read actions (stats/history/metrics) from write actions (resolve), but says nothing about permissions, persistence, or reversibility of resolve/trust updates.

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 dense sentences, purpose first, relationship second, with no filler. Every clause carries information.

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

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

For a four-parameter, multi-action tool with no output schema and no annotations, the description adequately conveys the workflow and what metrics/trust represent. It stops short of describing result shapes for stats/metrics, but nothing critical 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 100% and the action enum already explains each mode, so the baseline is 3. The description adds little parameter detail beyond restating the calibration concept, though it does clarify the causal link between resolve and trust.

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: track predictions, mark outcomes, compute P(correct|level), and names the calibration purpose explicitly. It is clear what the tool does, but it never distinguishes itself from its sibling memory_calibrar, which appears to be the same concept in a different namespace.

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 upstream/downstream relationship ('closes the feedback loop between faro verify and eco correct'), which implies when to use it, but gives no explicit when-to-use or when-not guidance and no distinction from memory_calibrar or cuba_eco.

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 that the call routes through the same dispatcher as a direct call so behaviour is identical, which is real behavioral context. However, it says nothing about error behaviour for unknown tool names or side-effect/auth implications, leaving gaps for a no-annotation 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?

Three tight sentences, front-loaded with the core purpose followed by the discovery path and the behavioral guarantee. Every sentence 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?

For a dispatcher with a fully-described 2-param schema and no output schema, the description covers what the tool does and how to find arguments. It is nearly complete, though it omits error handling for invalid tool names or malformed args.

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 100%, so both parameters are already documented in the schema, establishing the baseline of 3. The description adds only a pointer (use cuba_tools detail='full' for exact arguments) rather than richer semantics for 'args' or 'tool'.

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 action (invoke any tool by name) with an explicit scope (including tools not pre-loaded in this session), which cleanly differentiates it from the concrete sibling tools. An agent immediately understands this is a generic dispatcher.

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

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

Explicitly names the discovery alternative (cuba_tools) and the exact condition/setting (detail='full' to see the precise arguments). This is direct when-to-use guidance with a named sibling.

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 restates the firing conditions that the condition_type enum already covers, but discloses nothing about persistence, permissions, or what happens on repeated fires beyond what the schema already says. For a stateful mutation tool this is thin.

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

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

Two short sentences, front-loaded with the core concept and followed by a clarifying analogy. Efficient with no obvious filler, though the second sentence is illustrative rather than informational.

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

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

There is no output schema, and the description does not explain the overall action workflow (create/list/delete/check) or what check/list return. The rich parameter schema partially compensates, but for an 8-parameter mutation tool with no annotations, the prose leaves meaningful 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 100%, so the schema already documents all 8 parameters well (including the detailed allow_secret explanation). The description adds no parameter-level meaning beyond the schema, which is the expected baseline when the schema does the heavy lifting.

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 concept (prospective memory) and enumerates the trigger conditions (entity access, session start, error match), with a concrete usage analogy. It is clear what the tool does, but it never differentiates itself from the many similarly-named siblings (memory_centinela, cuba_alarma/cuba_vigia, cuba_eco), so an agent cannot easily tell which radar-style 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?

The quoted example ('Remember to remind me about X when Y happens') illustrates the intent but gives no explicit when-to-use guidance, no exclusions, and no named alternative among the ~50 siblings. The agent must infer that this is the reminder/trigger tool from concept 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 usefully discloses the composition and prioritization order of the returned recall (recent writes, then WM mentions, then importance), which is real behavioral information. However, it says nothing about side-effect profile, whether the call mutates session state, or what happens when budget is exhausted.

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 resource, then the usage directive, then the alias. Three sentences, no filler, though the parenthetical ordering clause makes the first sentence heavier than it needs to be.

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?

No output schema exists, so the description correctly compensates by describing what the returned context contains and in what priority order. Combined with the 100%-documented parameter, an agent has enough to invoke it, with only the side-effect profile 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 100%, with budget_chars documented as 'Max serialized size (default 12000)', so the baseline is 3. The description adds no further semantics about the budget parameter, and for a single-parameter tool that is acceptable but not additive.

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 resource — the agent's visible context window — and enumerates its ingredients (working memory, agent notes keyed by Mcp-Client-Id, artifact index, recent-write recall). This is specific enough to distinguish it from sibling memory tools, though the enumeration is dense and the 'alias: memory_context' note blurs rather than sharpens the 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?

Gives explicit timing ('call at the start of a turn') and a named alternative action for a related need ('call cuba_cronica add BEFORE editing'). It stops short of stating when not to call it, but the routing guidance is clear and actionable.

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 provided, so description bears full burden. It discloses read-only nature and method used, but lacks details on return format, error handling, or behavior when no contradictions are found. Partial transparency.

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

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

Extremely concise: two sentences front-load the purpose and key behavioral trait (read-only). No wasted words.

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?

No output schema and description does not explain return values or response format. For a tool involving contradiction detection with embedded methods, the description is insufficient for an agent to fully anticipate results.

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 100% with adequate parameter descriptions. Tool description adds no extra parameter semantics beyond method context, so baseline score of 3 is appropriate.

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

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

Description clearly states the verb 'detect' and resource 'semantic contradictions between observations'. It specifies the method (embedding cosine distance + negation heuristics) and explicitly notes it's read-only, distinguishing it from sibling tools.

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

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

No guidance on when to use this tool versus siblings or when not to use it. The 'read-only' note implies safety but does not provide context for selection among alternative 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?

With no annotations, the description carries the full burden but does disclose two important behavioral traits: auto-creation of missing entities and a dedup gate that blocks near-duplicates. It still omits mutation/destructive behavior, authentication requirements, reversibility, and return behavior, so it is only partially 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 five short sentences and front-loads the core purpose before covering episodic memories, timeline, auto-creation, and deduplication. Each sentence carries useful information, though the action coverage is somewhat fragmented rather than systematically organized.

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 7-action, 10-parameter memory tool with no annotations and no output schema, the description covers the main observation attachment, episodic memory, timeline, auto-creation, and dedup concepts. It leaves out explicit treatment of delete, list, and batch_add actions, but the schema's 100% coverage compensates for those 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 100%, so the schema already documents all 10 parameters thoroughly, including enums and nested batch objects. The description only names episode_add, episode_list, and timeline actions and adds no syntax or format detail beyond what the schema provides, matching the baseline for high schema coverage.

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

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

States a specific verb and resource ('Attach facts/lessons/decisions to entities') and extends that to episodic memories and timeline views. The purpose is clear, but it does not explicitly distinguish this tool from the many similarly named sibling memory tools such as memory_cronica.

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 mentions that episodic memories are managed via episode_add/episode_list and that timeline shows chronological history, which gives some action-level context. However, it provides no guidance on when to choose this tool over alternatives like memory_cronica or when to use add vs batch_add vs delete, so the agent must infer usage from the schema.

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

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

No annotations are provided, so the description carries the full burden. The schema's allow_secret description does disclose a real behavioral trait (credential detection and verbatim clear-text storage), but that appears in the schema, not the description. The description itself says nothing about persistence, secret-refusal, or that records are searchable/exportable — significant gaps for an un-annotated mutation tool.

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

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

Single short sentence, front-loaded, no filler. It underspecifies rather than overexplains, so conciseness is fine even though content is thin.

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?

Eight parameters, a three-way action enum, no annotations, no output schema, and a credential-handling behavior with real safety consequences — the description should at least route between record/query/list and warn what recording persists. It doesn't, leaving the agent reliant entirely on schema text.

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 100%, so the baseline is 3. The description adds no parameter-level meaning beyond what the schema already documents per-field (query text, title, alternatives, allow_secret, etc.).

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 verb pair ('record and query') and resource ('architecture/design decisions'), which is clearer than a bare name. However, it doesn't distinguish itself from the sibling memory_decreto or from other memory_*/cuba_* decision-adjacent tools, leaving an agent to guess which of the 50+ siblings handles decision records.

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 when-to-use guidance, no prerequisites, no mention of when to pick this over memory_decreto or cuba_cronica. The 'action' enum (record/query/list) is the only hint of use-case branching, and it lives in the schema, not the description.

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 well: it explains that positive/negative use Oja's rule to boost or decrease importance, that correct overwrites content, that 'pending' lists withheld memories from untrusted text, and that promote/quarantine flip retrievability. It also notes the gate covers observations, episodes and errors. What is missing is the reversibility of promote/quarantine, whether feedback is idempotent, and any error conditions. Strong but not complete.

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 long block that mixes two unrelated functional areas (RLHF feedback and quarantine transitions) without headings or bullets, and it front-loads the RLHF part before the gate. It is not padded, but the structure makes it hard to scan and the opening sentence assumes the reader already knows what 'cuba_eco' is.

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 8-parameter tool with no annotations and no output schema, the description covers the main behaviors: how feedback changes importance, how corrections replace content, and how the quarantine gate filters, promotes and quarantines across three kinds. It does not describe the pending return format in detail beyond naming the three lists, and it does not state what the tool returns for other actions, but the schema elsewhere is fully documented and this is close to 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 coverage is 100%, so the schema already documents every parameter including the enum semantics and the kind selection. The description adds context that 'kind' exists to target observations, episodes or errors and that pending ignores it, but this largely repeats what the schema descriptions already state. Baseline 3 is appropriate when the schema does the heavy lifting.

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 two distinct capabilities (RLHF feedback and a quarantine gate) with specific actions, but the tool name 'cuba_eco' provides no hint and the description begins mid-thought. It is possible to reconstruct the tool's purpose from the text plus the action enum, but the description itself is vague about the overall scope (is this one tool or two merged together?) and does not distinguish it from siblings like memory_eco or cuba_centinela.

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 when-to-use guidance. The description explains what each action does but never states when to choose positive vs correct, or when to use pending before promote. The sibling list is long and no alternative tool is named for any scenario. Usage is implied only by action semantics.

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 reveals that the tool returns a warning if a similar approach failed before (via 'proposed_action'), but with no annotations provided, it fails to disclose other behavioral traits such as read-only status, required permissions, or potential side effects. The behavioral transparency is minimal.

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

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

Two sentences, front-loaded with purpose, no unnecessary words. Every sentence adds value—the first states what the tool does, the second gives a key usage hint. Excellent conciseness.

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

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

The description is brief and lacks details about return values, result ordering, pagination, or error handling. While the tool has a moderate number of parameters (4), the lack of output schema and limited context means the description is minimally complete for an effective search 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 input schema already provides full descriptions for all 4 parameters (100% coverage). The description adds a brief usage note about 'proposed_action,' but it does not provide additional meaning beyond what the schema already states. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Search past errors/solutions.' It uses a specific verb and resource, making it distinct from vague descriptions. However, it does not explicitly differentiate from siblings like cuba_remedio (which might also deal with errors/solutions), but the purpose is still clear.

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

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

The description provides a specific usage tip for the 'proposed_action' parameter, but it lacks any guidance on when to use this tool versus alternative tools (e.g., cuba_remedio or cuba_cronica). No mention of context or exclusions.

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

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

With no annotations, the description carries the full burden and discloses meaningful behavior: grounding scores, verify-mode confidence levels, session-aware boosting, temporal filtering, and optional MMR, OOD abstention, and token budgeting. It does not cover auth requirements or default operational details like the compact response format, which are left to the schema.

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

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

The description is front-loaded with purpose and is reasonably sized for a 17-parameter tool. It uses multiple short sentences to cover distinct features, though it could be slightly tighter.

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 complex search tool with no output schema and 100% schema coverage, the description provides enough context to understand the main modes and optional behaviors. It mentions returning grounding scores, but does not elaborate on the return shape, which is acceptable given the detailed parameter schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions mode verify, temporal filtering, diversification, OOD abstention, and token budget, but these largely restate or lightly expand on what the schema already documents, adding little parameter-specific meaning beyond the structured fields.

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: searching memory to ground responses. It clearly explains the tool's role in retrieval and grounding, though it does not differentiate itself from sibling tools such as memory_faro or cuba_contexto.

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

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

It gives clear contextual guidance: search memory BEFORE answering to ground responses. It does not explicitly name when not to use the tool or which alternatives to prefer, but the timing guidance 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?

No annotations are provided, so the description fully covers behavioral traits: it states the operation is 'cascading', 'hard-delete', 'IRREVERSIBLE', and lists affected areas (observations, relations, errors, sessions). No contradictions found.

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

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

Two sentences, zero filler. First sentence states the action and scope; second sentence emphasizes irreversibility and a precondition. Every word is purposeful.

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 destructive tool with no output schema, the description provides ample context about the effect and prerequisites. It could mention the return value (e.g., success/error), but the warnings make it largely 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 coverage is 100% with clear descriptions for both parameters. The description adds the safety requirement 'Requires confirm=true' but does not significantly enhance understanding beyond schema. Baseline score of 3 is appropriate.

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

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

The description uses specific verbs ('cascading hard-delete') and clearly identifies the resource ('entity and ALL references across observations, relations, errors, and sessions'). It distinguishes itself from sibling tools like 'cuba_receta' or 'cuba_archivo' by focusing on complete erasure.

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 mentions 'GDPR Right to Erasure' as a use case and highlights the need for 'confirm=true', but does not explicitly state when not to use it or compare it to alternatives among siblings. Clear context but lacks exclusions.

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

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

No annotations are provided, so the description carries the burden. It does disclose a key behavioral trait, 'Read-only', which is valuable safety context. However, it omits the backward-traversal/ranking behavior, depth limits, and result-count capping that shape what the agent gets back.

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 waste; the core purpose leads and the read-only qualifier follows. Nothing needs trimming.

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 read-only inference tool with no output schema and no annotations, the description covers purpose and safety but says nothing about the shape of the returned hypotheses (ranking, count, depth) or about the backward traversal mode already documented only in the schema.

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

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

Schema coverage is 100%, so the schema already documents action, effect, limit, and max_depth with defaults and the ranking formula. The description adds no parameter meaning beyond that, so baseline 3 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?

States a specific verb+resource: 'find plausible causes of an observed effect', and names the inference type (abductive). An agent can tell it produces candidate causes rather than a stored hypothesis (contrast with the memory_hipotesis sibling), though it never names that sibling explicitly.

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 is implied by 'observed effect' input, but there is no explicit when-to-use, when-not-to-use, or guidance on choosing this over memory_hipotesis or cuba_reflexion/cuba_contradiccion.

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

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

No annotations exist, so the description carries the full behavioral burden and does so: it discloses the shared dedup/PE-gating/embedding pipeline, that no route deletes, that untrusted content lands quarantined and is withheld from cuba_faro until promoted (inspectable via cuba_eco action=pending), that allow_secret stores verbatim in clear and is globally searchable/exportable, and that supersede_conflicts marks old observations superseded rather than deleting them.

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?

Dense but front-loaded: the action breakdown comes first, followed by pipeline behavior, with no filler sentences. Some jargon ("PE-gating", "v0.11") assumes prior context and the middle sentence is packed, but every clause carries 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?

With no annotations and no output schema, the description supplies the safety and side-effect context an agent needs (quarantine, credential refusal, non-deletion, supersession). Given the complexity of 8 parameters and three modes, it is nearly complete; it stops short of describing failure/return behavior for long-running bulk ingests.

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 100%, so the schema already documents all 8 parameters, including the action enum and the untrusted/allow_secret/supersede_conflicts semantics. The description's action breakdown largely restates what the schema parameter descriptions already say, so it adds only marginal value over structured data — baseline 3.

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?

Opens with a specific verb+resource ("Bulk knowledge ingestion") and then decomposes the three actions with what each does, so an agent can tell ingest (raw), parse (paragraph split + classify) and auto_extract (LLM sampling extraction) apart. It does not explicitly name or differentiate from the sibling namespaces (memory_ingesta, etc.), 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?

Gives explicit routing guidance per action: 'ingest' is the fast raw path, 'parse' splits long text, and 'auto_extract' is opt-in with a clear prohibition ('do not use it as the default write'). It also states the condition for the untrusted flag (text you do not control) and for allow_secret (only to override a false credential match).

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 does disclose real behavior: the project arg upserts into brain_projects and future handlers will scope reads/writes to that project. But it says nothing about persistence, permissions, or what 'end' does to a session, leaving significant 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?

Two sentences, front-loaded with the core purpose before the version-specific detail. Efficient, though the 'v0.8' versioning preamble is mildly meta and could be trimmed.

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

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

This is a 7-parameter, 4-action dispatch tool with no annotations and no output schema, yet the description never explains the actions that drive the tool. An agent must open the schema to learn that 'start', 'end', 'list' and 'current' exist and what each requires, which is a substantial completeness 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 100%, so the baseline is 3. The description's project note largely restates what the schema description for 'project' already says ('created on first use', 'omit to keep session global'), so it adds little meaning beyond the structured fields.

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: 'Track working sessions with goals and outcomes.' An agent understands the domain immediately. However, it offers no differentiation from the obvious sibling memory_jornada, so an agent cannot tell from the description which of the two session-tracking tools 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 mention of the start/end/list/current lifecycle, and no routing to or away from memory_jornada. The only conditional content is about the optional 'project' arg, which is schema-level detail rather than usage 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses two side effects: that this is an LLM-backed (costly) operation and that verdicts are cached in brain_judgments. It does not state permissions required, cost bounds, or whether cached verdicts are reused/overwritten, leaving meaningful gaps for a mutating, LLM-invoking tool.

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

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

Two tight sentences with no filler, and the core purpose and the similarity band are front-loaded. The phrasing is dense but every clause contributes 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?

There is no output schema and no annotations, so the description should do more of the explanatory work. It names the cache destination but never describes what a verdict returns or its shape, and the two actions are only clarified in the schema. Adequate to route a call but incomplete for a judge tool without structured output.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters including the action enum and max_pairs cost control. The description adds no syntax or format detail beyond that. Baseline 3 is appropriate when the schema does the heavy lifting.

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: an LLM-judge that resolves semantically-conflicting observations in a defined cosine-similarity band. It clearly positions itself against heuristics ('where heuristics miss vocabulary-different conflicts'), which aids differentiation. It stops short of naming any actual sibling tool (e.g., memory_juez or cuba_contradiccion), so selection vs. siblings remains inferential.

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

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

It gives a concrete triggering condition: use when observations fall in the ambiguous 0.6-0.8 band and vocabulary-different conflicts would evade heuristics. That is clear when-to-use context. It offers no explicit when-not-to-use or pointer to an alternative tool, so it does not reach the top of the scale.

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 well: it discloses the TTL auto-expiry lifecycle and that cuba_zafra's REM cycle bulk-purges entries. It omits write/overwrite semantics and read/clear behavior, but the credential-refusal behavior is covered in the schema.

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

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

Three dense sentences, front-loaded with the definition and followed by usage and lifecycle. The 'v0.9, Baddeley 1992' citation is mildly ornamental but does not bloat the text.

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

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

For a 5-param tool with no annotations and no output schema, the description supplies purpose, when-to-use and lifecycle. It could say more about the write/read/clear actions and what a read returns, but the schema covers the parameters adequately.

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 100%, so the baseline is 3; the schema already documents tag, action enum, content, ttl_seconds and allow_secret in detail. The description only echoes ttl_seconds expiry, adding little parameter meaning beyond structured fields.

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 resource ('working memory buffer... TTL-bounded scratchpad') and explicitly positions it relative to siblings by calling it 'orthogonal to episodic and semantic memory'. An agent can distinguish it from the many memory_* tools without opening any 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?

Gives concrete use cases: 'inter-step plan state during long-horizon agent tasks, tentative observations, cross-tool-call reminders inside one session'. Clear context for when to reach for it, though it does not explicitly name a sibling as the alternative or state 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?

No annotations are provided, so the description carries the full behavioral burden. It explains the core persist/restore behavior and the survival purpose, but does not disclose side effects, storage semantics, whether snapshots overwrite previous ones, or what exactly happens during restore beyond re-injection. This is adequate but incomplete for a stateful session tool.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the protocol name and core operation immediately, and every phrase contributes to understanding what the tool does.

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 a fully documented schema, the description covers the essential idea. However, with no output schema and no annotations, it should clarify return behavior for restore and differentiate from the sibling memory_pre_compact tool. The core is present, but important routing and output context 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?

The single action parameter has 100% schema description coverage, including detailed enum semantics for snapshot and restore. The tool description adds the conceptual 'compaction-survival' framing but no additional parameter syntax or format details beyond what the schema already provides, so the baseline score of 3 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 a specific protocol and verb pair: persist and restore a session summary across /compact. It is clear what the tool does, but it does not differentiate itself from the sibling memory_pre_compact tool, leaving some ambiguity about which one an agent should choose.

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

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

The phrase 'across /compact' implies the usage window (before and after compaction), and the schema's action enum explains snapshot vs. restore timing in more detail. However, the description itself gives no explicit when-to-use guidance, no alternatives, and no exclusions relative to memory_pre_compact.

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 visibility rule that legacy NULL project_id rows are hidden while a project is active unless faro include_unscoped=true or a backfill is run – genuinely valuable state behavior. It omits, however, the side effects and reversibility of the mutating actions (rename, merge, backfill), any permission requirements, and what switching projects does to the current session.

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 dense sentences with the core concept front-loaded and the visibility caveat appended efficiently. It is jargon-heavy (v0.8, cuba_jornada, faro include_unscoped) but every sentence carries information and there is no padding.

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 seven-action tool with no annotations and no output schema, the description covers the conceptual model and one important visibility caveat, but it does not describe the semantics or effects of the individual actions (switch, rename, merge, stats) beyond what the schema enum already encodes, leaving an agent to infer operational behavior.

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 100%, so the schema already documents all four parameters including the backfill/confirm semantics. The description adds the session-binding context but otherwise does not extend parameter meaning beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description clearly conveys the resource and intent – project scoping that isolates memories per project – and explains the mechanism (active project bound to session via cuba_jornada start --project NAME). However, it does not explicitly state that this tool exposes the project management operations (list/current/switch/rename/merge/backfill), which the agent only learns from the schema enum, and it does not differentiate itself from the sibling memory_proyecto.

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 context in which project scoping matters (multiple projects sharing one DB) and explains how the active project is established, but it never states when to call this tool versus alternatives like cuba_jornada or memory_proyecto, nor which action to reach for under what circumstance.

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 must fully disclose behavior. It mentions 'Relations strengthen with use (Hebbian)' but does not explain what that means for the agent (e.g., automatic persistence, side effects). Critically, the delete action is omitted entirely, leaving a major behavioral gap unaddressed.

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 (two sentences) and front-loaded, but it omits the delete action entirely. This conciseness comes at the cost of completeness. Every sentence is functional, but the omission is a critical gap.

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 9 parameters, multiple actions, no output schema, and no annotations, the description is moderately complete. It covers create, traverse, infer, and predict, but misses delete and does not explain how bidirectional, persist, or max_depth interact with the overall behavior. The Hebbian mention is vague.

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 100%, so baseline is 3. The description adds some context (e.g., Hebbian strengthening and Adamic-Adar for predict), but this largely duplicates what's already in the action parameter description. It does not significantly deepen understanding of individual parameters beyond the schema.

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

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

The description states 'Create edges between entities' but the tool also includes delete, traverse, infer, and predict actions. The first sentence is misleading as it implies only creation. It lists the relation types and explains other actions, but fails to mention delete, making the purpose incomplete.

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

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

No guidance is provided on when to use this tool versus its siblings (e.g., cuba_vigia, cuba_proyecto). The description details when to use each action within the tool (traverse vs infer vs predict), but does not help an agent choose between this and other 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?

With no annotations, the description carries the full burden and discloses genuinely non-obvious behavior: ranking is by reliability rather than read frequency, and the memory only learns from action='outcome' reporting. The caveat that a persistently failing recipe is worse than none is a real behavioral warning. It does not cover permissions, what delete destroys, or result 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?

The conceptual framing is front-loaded and the actionable 'report the outcome' instruction follows immediately. The concluding aphorism about failing recipes is slightly rhetorical but reinforces the stakes rather than padding, so it mostly 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 10-parameter tool with no annotations and no output schema, the description adequately explains the mental model and the critical feedback loop, and the schema carries full parameter documentation. Return-shape details for get/search are left implicit, which is a minor gap given no output schema exists.

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 100%, so the parameter baseline is 3. The description adds meaning on top by singling out action='outcome' as the teaching mechanism and implying the reliability semantics that the enum alone does not convey, warranting a modest bump.

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 the resource (procedural memory / recipes for how things are done) and gives concrete examples (bring up dev services, run tests, deploy, migrate). Critically, it distinguishes itself from siblings with 'The other tools remember what is TRUE; this one remembers what to DO,' so an agent can route between the two memory families without reading both 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?

It gives explicit operational guidance — report the outcome with action='outcome' after running a recipe or 'the memory learns nothing' — and frames when this tool is the right choice versus the fact-memory siblings. It stops short of saying when NOT to use it (e.g. for exploratory or non-reproducible steps), so it lacks full exclusion coverage.

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 does disclose the key trait 'Read-only', which is genuinely useful safety information, but says nothing about output shape, cost, or side effects beyond that. The read-only claim is also largely implied by the schema's 'Reports...' wording, so the added value is modest.

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

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

Two sentences, front-loaded with the purpose and ending with the safety trait. Nothing is wasted or 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?

For a single-parameter, read-only analysis tool the definition is nearly sufficient: the schema's enum description enumerates what the analysis reports (isolated entities, hubs, silos, observation gaps, density anomalies), which effectively covers the return content despite there being no output schema. The main missing piece is any guidance on when to use it versus its siblings.

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 100% and the single 'action' enum is fully documented in the schema itself, including what the analysis reports. The description adds no parameter-level meaning beyond that, so the baseline of 3 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?

States a specific verb ('Analyze') and resource ('the knowledge graph') with a clear scope ('structural gaps'). It is clear what the tool does, but it does not distinguish itself from the sibling memory_reflexion, which likely performs the analogous analysis over memory.

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

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

No when-to-use context, no prerequisites, and no alternatives are named. The many sibling tools (cuba_* / memory_* pairs) make routing ambiguous, and the description offers no help in choosing this one over memory_reflexion.

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 does disclose a meaningful side effect — that similar unresolved errors are cross-referenced — but says nothing about permissions, reversibility, or whether the resolution is broadcast/persisted elsewhere, and the sensitive allow_secret behavior is only covered in the schema.

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 front-loaded sentences with no filler; the action comes first and the side effect second. It is efficiently sized, if a little terse for a mutation tool.

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

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

With no annotations and no output schema, the description should say more about what happens on success and what the cross-referencing returns. It covers the core mutation but leaves the agent guessing about the response and about failure modes.

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 100%, so error_id, solution, and allow_secret are already fully documented including the credential-refusal warning. The description adds no parameter-level detail beyond what the schema provides; baseline 3 is appropriate.

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

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

The description gives a concrete verb+resource: marking an error as resolved with a solution, plus the cross-referencing side effect. That is far clearer than the opaque tool name 'cuba_remedio', though it does nothing to distinguish this from the many similarly cryptic siblings (memory_remedio, cuba_alarma, etc.).

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 or when-not-to-use guidance, and no alternative tool is named. The agent must infer that this is the call to make after fixing a problem, with nothing saying how it relates to the sibling remedio/alarma 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?

With no annotations, the description carries the full burden; it usefully discloses the auth requirement (CUBA_PEER_TOKEN) and the default working directory, and the schema itself documents the destructive-import guard (tombstone threshold + confirm). However, the description never warns that import can delete observations, which is the highest-risk behavior for this tool.

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

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

Two sentences, no filler, with the core purpose front-loaded and the action taxonomy immediately following. Efficient for a nine-action tool.

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

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

For a 16-parameter, nine-action tool with no output schema, the description covers the purpose, the local/remote split, and the auth requirement — enough to select and call it. The main omission is any statement about import's destructive potential, which the schema only implies.

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 100%, so every parameter, enum, and default is already documented in the schema. The description's action-grouping sentence adds framing but no parameter detail beyond what the schema provides; baseline 3 is appropriate.

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

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

States a specific resource ('export/import of the knowledge graph') and its distinguishing context ('between machines that share no database'). It does not, however, differentiate itself from the sibling memory_sync, so an agent comparing the two gets no explicit contrast.

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?

Groups the nine actions into two behavioral families — local-directory actions (export/import/diff/status) versus peer-over-HTTP actions (pull/notify/fetch/conflicts/resolve) — which tells an agent which mode applies. It gives no when-not guidance or comparison to sibling sync 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?

With no annotations, the description carries the full behavioral burden and does well: it discloses the server's 31-tool count, the lean profile behavior, that query matches names and descriptions, and that detail='names' is cheapest while 'full' returns exact argument schemas. It lacks auth/rate-limit notes, but for a read-only discovery tool this is strong context.

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

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

The description is compact and front-loaded: purpose first, then environmental context, then usage pattern, then detail-level guidance. Every sentence adds useful information without 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 2-parameter discovery tool with no output schema, the description covers the essential context: why the tool exists, how to search, how detail levels affect results, and what to do with found tools. It could mention output limits or empty-result behavior, but the definition is largely complete.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds value beyond the schema by giving concrete capability search examples ('audit', 'decay', 'contradiction', 'session') and characterizing detail='names' as cheapest and 'full' as the exact call 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 verb (find/load) and resource (MemoryIndustry tools and their schemas), and explains that the tool exposes non-preloaded tools on demand. An agent can immediately tell this is a discovery/schema-loading tool rather than a direct memory 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?

It clearly explains when the tool is needed: under CUBA_TOOL_PROFILE=lean, only the core is preloaded and the rest must be found here. It also routes the agent to cuba_call for invocation after discovery, though it does not explicitly discuss when to bypass this tool or how it differs from the sibling memory_tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It never says whether the metrics are read-only, computationally expensive (Leiden clustering and betweenness centrality are heavy), whether they mutate graph state, or what latency to expect.

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?

It is a single short line, which is efficient, but roughly half its content is a bare enumeration that duplicates the enum values already present in the schema. It is under-specified rather than truly concise.

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

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

The sole input parameter is fully documented by the schema, so the input side is covered. With no output schema and no annotations, the description leaves the return shape and operational cost of these analytics unstated, which is a real gap for a multi-mode analytics tool.

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

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

Schema description coverage is 100% and the enum's per-value descriptions are far richer than the description text (e.g. 'Leiden clustering', 'harmonic + closeness centrality + k-core ranking'). The description merely restates the enum keys, adding no meaning beyond the schema, so the baseline 3 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 names the domain (knowledge graph analytics) and lists the six metric modes, so an agent can tell roughly what kind of tool this is. However, it is a noun fragment with no verb and no indication of what the tool actually returns or does with the graph, and it does not differentiate this from sibling analytics/supervision tools like cuba_centinela or cuba_calibrar.

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 statement of when to reach for this tool versus alternatives, no prerequisites, and no mention of the large family of cuba_* siblings that perform adjacent analyses. The agent must infer usage entirely from the metric names.

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 must carry behavioral disclosure. It lists useful output fields and the identity-check purpose, but does not explicitly confirm that the operation is read-only, side-effect-free, or what permissions are needed.

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

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

The description is a single, front-loaded sentence that identifies the tool's function and key return fields. The alias note at the end is short and earns its place by cross-referencing the sibling name.

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-argument, read-only diagnostic tool with no output schema, the description is nearly complete: it states the purpose, lists the returned identity fields, and provides the alias. Only explicit usage guidance 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?

The tool has zero parameters, and the description correctly does not discuss parameter semantics. Per the rubric, a no-parameter tool has a baseline of 4 for this dimension.

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: 'Identify this MCP client against the MemoryIndustry daemon.' It lists the identity fields returned, making the tool's scope clear. It does not differentiate from most siblings beyond noting the memory_whoami alias, so it stops 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 explicit when-to-use or when-not-to-use guidance. The alias note helps an agent recognize the equivalent memory_whoami tool, but no conditions or alternatives are described.

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 disclosure burden, yet 'maintenance' hides that several actions (prune, decay, merge, reembed) mutate or delete data. It says nothing about reversibility, confirmation requirements, or the dry-run default for prune, all of which matter for an unannotated multi-action 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?

A single front-loaded sentence establishes purpose and scope before the action list, with no filler. The action enumeration partially duplicates the schema enum, costing a point.

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 ten-action dispatcher with destructive operations, no annotations, and no output schema, the description is too thin: it omits safety posture, confirmation behavior, and any differentiation from the parallel memory_zafra sibling. An agent would need to open the schema to understand the tool at all.

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 100% and each parameter is thoroughly documented in the schema (including confirm's dry-run semantics and allow_secret's credential refusal), so the description adds nothing beyond listing action names already present in the enum. Baseline 3 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 names a resource (memory) and a scope (the active project) and enumerates the nine operations the tool performs, so an agent can tell it is a maintenance dispatcher rather than a read/write CRUD tool. It falls short of a 5 because the opaque name 'cuba_zafra' is never explained and it does not distinguish itself from the near-identical sibling memory_zafra.

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?

'Scoped to the active project' is the only contextual hint; there is no statement of when to reach for this tool versus its siblings (cuba_zafra vs memory_zafra) or which of the ten actions fits a given situation. Action-level guidance lives only in the schema, not the description.

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 disclose non-obvious traits: auto-pattern detection with a ≥3-similar warning threshold, and Hebbian boosting of similar errors for retrieval. It still omits whether the record persists, side effects, or the return shape, but it adds real behavioral context beyond the raw schema.

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

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

Three tight sentences, front-loaded with the alias and purpose, then the two behavioral notes. No filler; every clause conveys information an agent can act on.

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

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

For a 5-parameter, nested-object tool with no annotations and no output schema, the description covers the distinctive behaviors but leaves open what the call returns and whether/how the error is stored. Adequate but with clear gaps given 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 description coverage is 100%, including detailed guidance on allow_secret and the context object shape, so the schema does the heavy lifting. The description adds nothing about parameter semantics, making the baseline 3 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?

States a specific verb and resource ('Report errors immediately') and flags that this is an alias of cuba_alarma, so an agent knows it duplicates that sibling. It does not differentiate itself from the broader error/history siblings like memory_expediente or memory_remedio, but the core purpose is unambiguous.

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

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

The imperative 'Report errors immediately' implies the usage context (capture an error as it occurs), but there is no explicit when-to-use versus when-not, and no named alternative for related needs. Usage is only implied.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose a non-obvious side effect: neighbors are auto-boosted on access. Beyond that it says nothing about mutation semantics (delete reversibility, permission requirements, whether update overwrites unspecified fields), leaving meaningful behavioral gaps for a write-capable 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?

Three compact sentences, front-loaded with the alias/identity and the core CRUD purpose, then the side effect, then the alternative-tool escape hatch. 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 4-parameter CRUD tool with no output schema and full schema coverage, the description covers what it operates on, a key side effect, and one routing rule. It is nearly complete but omits return-shape expectations and per-action behavioral differences that an agent calling delete or update would benefit from.

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 100% and every parameter is documented inline (name, action enum, new_name, entity_type), so the description need not carry parameter detail. It adds only the loose mapping of entity types to the entities it manages, which is largely redundant with the entity_type schema description.

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

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

States a specific verb set (CRUD) and resource (knowledge graph entities) and enumerates the entity types it operates on. It also declares itself an alias of cuba_alma and routes transient-data callers to cuba_cronica, so an agent can place it relative to siblings 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?

Explicitly names the alternative tool (cuba_cronica) and the condition selecting it (transient info). That covers one important when-not case, but there is no guidance on when to prefer create vs update vs get, or when to use the alias rather than cuba_alma.

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

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

With no annotations, the description carries the full burden and delivers real behavioral substance: append-only semantics, SHA-256 hash chain tamper detection, and UPDATE/DELETE blocked at the PostgreSQL trigger level. It does not cover permissions, whether verify returns a boolean or a chain report, or cost of walking a large chain.

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 dense sentence with the alias qualifier first and the defining behavioral traits front-loaded. Nothing is wasted or 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?

For a 4-parameter, no-annotation, no-output-schema tool, the description explains the storage model well but is silent on what verify/tail actually return and on limits of the chain walk. An agent knows what the store is but not fully what a call yields.

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 100% with the action enum, limit, event_action and payload all documented inline, so the schema already does the heavy lifting. The description adds no parameter-level detail beyond what is in the schema, which is the baseline 3 case.

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 resource — an append-only, tamper-evident audit log — and the alias note ('alias of cuba_archivo') tells an agent this duplicates a sibling, aiding routing. The verbs (append/verify/tail) live only in the schema, so the description itself does not state the operations, keeping 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 choose this tool, when not to, or which sibling action replaces it other than the bare alias note. The action enum in the schema implies three modes but the description never frames them as usage scenarios.

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 discloses the optimistic-concurrency contract for put and the leased nature of lock, but omits what happens on a version conflict, whether lock blocks other writers, and any auth or persistence scope beyond 'same daemon'. Partial but genuinely additive.

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 compact sentences, front-loaded with the resource definition, then the two most consequential behavioral clauses, then the alias. Dense and free of filler, though the alias parenthetical is slightly awkwardly placed.

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 nine-parameter, seven-action tool with no annotations and no output schema, the description covers the versioning and lease mechanics but leaves action semantics (especially watch_hint and unlock) unexplained. Adequate but with clear gaps for a tool of this complexity.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters (including base_version's 'omit or 0 to create'). The description's summary that put 'requires base_version' slightly overstates the schema, which allows omission for creation. Baseline 3 applies since the schema does the heavy lifting.

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 core resource and model clearly: shared, versioned artifacts between agents on the same daemon and peers. It does not enumerate the seven actions, nor does it distinguish itself from the many similarly named sibling alias tools (cuba_artefacto, memory_archivo, cuba_pizarra), so an agent still needs the schema to know what operations exist.

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?

Gives two action-specific conditions ('put requires base_version', 'lock is a short lease') but no when-to-use vs. alternative guidance, no prerequisites, and no explanation of the remaining actions (get, list, patch, unlock, watch_hint). Usage is implied by the action enum rather than directed.

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 hints that 'resolve' marks outcomes (a mutation of stored prediction state) and that the tool persists calibration data across calls, but it says nothing about permissions, reversibility of a resolve, or persistence scope. Useful but incomplete for a state-mutating feedback tool.

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

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

Two tight sentences with the purpose front-loaded after the alias tag, and no redundant restatement of the schema. Slightly diluted by the bracketed alias metadata, but otherwise efficient.

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

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

For a five-action tool with no output schema and no annotations, the description conveys the overall purpose but not the return shape of stats/trust/metrics or the effect of resolve. The schema covers action semantics, so nothing critical is missing, but the behavioral gaps remain.

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

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

Schema coverage is 100% and every parameter (action enum, outcome, verify_id, limit) is already documented in the schema, so the description adds no syntax or format detail beyond it. Baseline 3 is appropriate when the schema does the heavy lifting.

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 specific operations (track verify predictions, mark outcomes, compute P(correct|level)) and identifies the two siblings it bridges, faro verify and eco correct, so an agent can place it in the workflow. It is clear but the '[alias of cuba_calibrar]' prefix adds disambiguation noise rather than purpose detail, keeping it just short of 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?

'Closes the feedback loop between faro verify and eco correct' implies the context in which this tool belongs, but there is no explicit when-to-use or when-not, and no statement of which action to pick. Usage is inferable rather than stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that the call 'goes through the same dispatcher as a direct call, so behaviour is identical', which reassures about equivalence. However, it says nothing about error behavior for unknown tool names, argument validation failures, or any side effects, leaving notable gaps for a mutation-capable meta-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?

Three tight sentences with no filler; the alias note and the core dispatch capability are front-loaded, followed by the discovery instruction. Efficient, though the bracketed alias prefix is slightly awkward as an opener.

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

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

There is no output schema, so return values need not be explained, and the description notes behavior is identical to a direct call. For a 2-parameter dispatcher with a nested args object, this is largely complete; only failure modes for bad tool names are unaddressed.

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 100%, so both parameters are already documented in the schema. The description adds only the hint that detail='full' reveals 'the exact arguments', which is a mild supplement rather than new syntax or format guidance. Baseline 3 is appropriate when the schema does the heavy lifting.

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: 'Invoke any MemoryIndustry tool by name — including the ones not pre-loaded in this session.' This clearly identifies it as a generic dynamic dispatcher, and it names its relationship to cuba_call (alias) and cuba_tools (discovery path). It does not fully distinguish itself from the many sibling memory_* tools, but the dispatcher role is unambiguous.

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

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

Gives an explicit workflow: discover tools first with cuba_tools using detail='full' to see exact arguments. This tells the agent when this tool is appropriate (calling tools not pre-loaded). It stops short of stating when NOT to use it, e.g., preferring a direct pre-loaded tool when available.

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 the firing conditions (entity access, session start, error match), which is the core behavioral trait, but says nothing about persistence across sessions, what happens on expiry, authorization needs, or limits beyond the schema's own field notes.

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 tight sentences with zero filler, routing metadata (alias) front-loaded and the purpose plus example immediately after. Every clause 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 an 8-parameter tool with no output schema and no annotations, the description covers the purpose and trigger semantics adequately, and the schema documents parameters and actions thoroughly. The gap is that the four actions (create/list/delete/check) and the tool's persistence model are left entirely to the schema.

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

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

Schema description coverage is 100% and the parameter descriptions are unusually rich (enum meanings, allow_secret credential warning, cross-session note channel), so the baseline is 3. The description adds only conceptual framing ('when Y happens') and no details beyond the schema.

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

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

States a specific resource and behavior: 'Prospective memory: triggers that fire on entity access, session start, or error match.' The example ('Remember to remind me about X when Y happens') nails the mental model. It only partly differentiates from siblings, noting it is an alias of cuba_centinela but not what the alias relationship implies for selection.

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 quoted use case implies when to reach for it, but there is no explicit when/when-not framing and no routing to alternatives such as memory_remedio, memory_alarma, or memory_pre_compact. Usage is inferable rather than stated.

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

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

With no annotations, the description carries the full burden, and it does disclose useful behavior: the composition and ranking order of the window ('recent writes, then WM mentions, then importance'). However, it says nothing about permissions, side effects, idempotency, or cost of calling it, so the behavioral picture is partial.

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 alias is front-loaded, then content, then usage, in a tight block with no filler. The parenthetical ranking clauses are dense but informative. Slightly crowded, but every clause carries 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?

For a read-style context-retrieval tool with no output schema and one well-documented parameter, the description explains what the caller gets back and when to invoke it. It is complete enough to call correctly, missing only edge behavior like truncation or empty-window cases.

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 100%, so budget_chars is already documented in the schema. The description adds no additional meaning about the budget parameter, so the baseline 3 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 names the resource (the visible context window) and enumerates its exact contents: working memory, agent notes, artifact index, and recall of recent writes. It also flags itself as an alias of cuba_contexto, which helps an agent reconcile the duplicate. It is specific, though it never uses a clear retrieval verb like 'returns' or 'loads'.

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

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

It gives an explicit trigger ('Call at the start of a turn') and a related-tool instruction ('call cuba_cronica add BEFORE editing'). That is real when-to-use guidance with a named alternative, but it stops short of stating when NOT to use it or how it differs from the many other memory_* retrieval 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 burden. It does disclose two useful traits: the method (embedding cosine distance + negation heuristics) and that the tool is read-only. However, it says nothing about runtime cost, scope limits, or the shape of results.

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

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

Three tight fragments, zero padding, and the core purpose is front-loaded before the implementation note and the read-only flag. Every clause carries 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?

No output schema exists, so the description would ideally sketch what a scan returns (contradiction pairs, confidence, etc.), and it does not. For a simple two-parameter read-only scan it is minimally adequate but leaves the result shape opaque.

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 100%, and the schema already explains both `action` and the omit-to-scan-top-entities behavior of `entity_name`. The description adds no syntactic or semantic detail beyond that, so the baseline 3 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?

States a specific verb and resource: 'Detect semantic contradictions between observations of the same entity.' The bracketed alias note (['alias of cuba_contradiccion']) also distinguishes it from the sibling cuba_contradiccion, so the agent knows the two are functionally the same.

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 is only implied: the agent can infer you call it when you want contradictions found, and the alias note hints it is interchangeable with cuba_contradiccion. There is no explicit when-to-use, when-not-to-use, or prerequisite 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?

With no annotations at all, the description carries the full burden but does add real behavioral context: auto-creation of missing entities, a dedup gate blocking near-duplicates, and the differentiation of episode vs timeline storage. It says nothing about destructive delete semantics, batch limits, or the credential-refusal/allow_secret exposure behavior that matter for a mutating multi-action 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?

Four tight sentences, front-loaded with the alias and the core operation, then the episodic/timeline additions and two behavioral caveats. No filler, though the alias-first framing arguably wastes the opening clause.

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 7-action tool with 10 parameters, no annotations, and no output schema, the description sketches the shape but leaves delete, list, and batch_add behavior unspecified and gives no return-value or pagination context. Adequate as a minimum-viable overview, not complete.

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

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

Schema coverage is 100%, so the schema already documents all 10 parameters including enum values for action, source, and observation_type. The description adds only loose mapping of episode_add/episode_list/timeline to the action enum, which the schema itself restates — baseline 3 is appropriate.

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

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

Names a concrete verb+resource ('Attach facts/lessons/decisions to entities') and enumerates the additional functions (episodic memories, timeline view). The alias note points to cuba_cronica, which is a sibling, but nothing states how this differs functionally from memory_remedio, memory_expediente, or cuba_cronica beyond the alias equivalence.

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 is implied rather than directed: the description explains that episode_add/episode_list handle events and timeline gives chronological history, so an agent can infer when to pick each action. It never says when to prefer this tool over the many memory_*/cuba_* siblings, nor any 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?

No annotations are provided, so the description carries the full behavioral burden and it discloses essentially nothing: not that records persist and are searchable/exportable, not that the secret heuristic can refuse input, not that this is a lightweight alias. The allow_secret schema text carries the one real behavioral signal, not the description.

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 compact bracketed alias note plus a single verb-resource sentence; front-loaded and free of padding.

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 8-parameter tool with no annotations and no output schema, the description is too thin: it never enumerates the three actions, never explains persistence or retrieval scope, and leaves the agent to reconstruct intent from the schema alone.

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 100%, so every parameter including allow_secret and its implications is already documented in the schema. The description adds no parameter-level meaning, which is the expected baseline when the schema does the heavy lifting.

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?

Names a specific verb pair (record/query) and resource (architecture/design decisions), and discloses it is an alias of cuba_decreto, which helps an agent reason about duplicate siblings. However it omits the third supported action 'list', so the purpose statement is not fully accurate.

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 record versus query, when to use list, or how this differs from related siblings like memory_proyecto or memory_contradiccion. The agent must infer usage entirely from the action enum.

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 disclosure burden. It usefully explains the Oja's-rule importance effect and the retrievability semantics of the gate, plus that 'pending' withholds memories from search because they came from untrusted text. It omits permissions, persistence/reversibility guarantees, and response shape, leaving meaningful gaps for a mutation tool.

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

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

Two compact sentences that front-load the alias and primary purpose before the gate explanation. Dense but largely earning its place; the bracketed alias and repeated comma-clauses add minor friction.

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 8 parameters, no output schema, and no annotations, the description covers the core action and gate behavior adequately and explains the important allow_secret-style nuance indirectly. Some parameter-level detail (entity_name, output format) is left to the schema, but nothing critical to calling it 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?

Schema description coverage is 100%, so the schema already documents every parameter richly (including enum meanings for kind/action). The description adds conceptual framing for 'kind' spanning observations, episodes, and errors but no syntax or format detail beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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 concrete verbs and resources: RLHF-style feedback (positive/negative/correct) and a quarantine gate (promote/quarantine/pending). The bracketed '[alias of cuba_eco]' distinguishes it from that sibling explicitly. It stops just short of a crisp one-line statement, folding two capabilities into a dense paragraph.

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 what each action does conditionally (positive boosts, negative decreases, correct updates, promote makes retrievable, quarantine withdraws), which implies when to pick each. However, it gives no explicit when-not guidance and never routes to an alternative tool among the many 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the anti-repetition warning behavior triggered by proposed_action, but says nothing about return format, permissions, or result semantics.

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

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

Two compact sentences with the core purpose front-loaded and no wasted words. The alias note is placed first, which is mildly noisy but does not bury the main function.

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?

No output schema and no annotations, so the description must stand alone for a search tool. It is adequate for selection but thin on what a result set looks like or how the warning surfaces.

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 100%, so the schema already documents all four parameters including the anti-repetition meaning of proposed_action. The description largely restates what the schema provides, so baseline 3 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?

States a specific verb ('Search') and resource ('past errors/solutions'), so an agent knows it retrieves prior failure/solution records. It does not distinguish itself from the many sibling tools (memory_remedio, memory_cronica, etc.) beyond noting it is an alias of cuba_expediente.

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 is implied ('search past errors/solutions') and the proposed_action guard condition is stated, but there is no explicit when-to-use or when-not-to-use guidance versus the numerous sibling memory_/cuba_ 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?

With no annotations, the description carries the full burden. It discloses genuinely behavioral traits: session-aware goal boosting, grounding-score returns, confidence tiers (verified/partial/weak/unknown), and optional MMR/OOD/token-budget machinery. However it never states the operation is read-only/non-destructive, nor any auth, rate-limit or side-effect profile, so it is only adequate.

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