wadachi

by EliaCinti

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.14.1
Disambiguation2/5
Multiple tools overlap in purpose: recall, recall_associative, and related_memories all surface related memories with subtle differences. Similarly, sleep and consolidate both propose merge candidates, and review_procedures overlaps with housekeeping. The boundaries are not always clear despite descriptions.
Naming Consistency2/5
Many tools follow verb_noun (store_memory, get_memory, delete_memory), but there are inconsistent outliers like why, as_of, sleep, reflect, brain_status, memory_graph, and recall_associative. The mixed conventions make the set feel unpatterned and harder to predict.
Tool Count2/5
At 31 tools, the server is well over the typical well-scoped range (3-15). While the memory domain is broad, several tools could be consolidated (e.g., sleep and consolidate, recall and recall_associative), making the surface feel bloated rather than focused.
Completeness3/5
Memory CRUD is fully covered, and advanced features like belief tracking, insights, and graph operations are present. However, decisions lack update/delete operations, projects lack update/delete, and list_memories does not filter by tags. These gaps create dead ends for secondary entities.
Average 4.2/5 across 31 of 31 tools scored. Lowest: 3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 42 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It implies a read-only operation ('Check') but does not state whether it is safe, what it returns, or any side effects, which is insufficient for transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, short sentence with no superfluous content. It is appropriately concise for a simple tool, though it could be criticized for under-specification, that is a content issue, not a structure issue.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, it is relatively simple. However, the description does not explain what 'health and statistics' means or what the output schema contains, leaving significant ambiguity about the tool's behavior and return value.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and schema coverage is 100% (vacuously). The description adds some context by indicating the tool is a health/statistics check, but since there are no parameters, the baseline is appropriately set to 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the verb 'Check' and identifies the resource as 'Brain', which is a specific action. However, 'health and statistics' is vague and does not specify what aspects of health or which statistics are included, making it less precise than examples like 'List ALL calls in date range'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any guidance on when to use this tool versus alternatives. Sibling tools handle memory operations, but the description does not mention these or any exclusions, leaving the usage context implied at best.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It implies a read-only list operation but does not define 'recent', default ordering, or any side effects. This lack of behavioral detail leaves uncertainty for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with a single introductory sentence followed by a clean argument list. Every word earns its place, and the purpose is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool, the description covers purpose and parameters adequately. However, the term 'recent' is undefined, and there is no mention of ordering or filter exactness. The existence of an output schema reduces the need to describe return values, but some context is still missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no descriptions (0% coverage), so the description compensates by explaining both parameters: project filters by name, limit sets maximum returns. This adds meaningful semantics beyond the bare parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists recent decisions with an optional project filter, which is a specific verb+resource. It is distinct from sibling tools like list_memories or list_projects by the resource 'decisions', but it does not explicitly differentiate itself or mention alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, such as store_decision or recall. The description only states what the tool does without any context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that results are ranked ('most strongly linked') and mentions the concept of 'typed' relationships, which is helpful. However, it doesn't explain what 'typed' means or any potential side effects, though 'Show' implies a non-destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise: two sentences plus an args list. It front-loads the primary purpose and includes only essential parameter details with no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read tool with an output schema present, the description covers the core behavior and all parameters. It doesn't need to explain return values thanks to the output schema. The only gaps are the vague 'typed' terminology and lack of differentiation from similar tools, but these don't undermine overall completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning beyond the plain schema types and defaults by explaining that memory_id is the starting point to expand from and limit is the max neighbours to return. Since schema coverage is 0%, this compensation is necessary and effective.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb ('Show') and identifies the resource ('memories most strongly linked to a given one'). The phrase 'typed neighbours' adds specificity but is not fully explained. It doesn't explicitly distinguish from sibling tools like 'expand_memory' or 'recall_associative', so it misses some differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you want to explore related memories from a starting point. However, it provides no explicit guidance on when to prefer this over alternatives like 'expand_memory' or 'memory_graph', and no exclusions or preconditions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'Log' implies a write operation, but the description lacks details on persistence, side effects, permissions, or reversibility. It only mentions the benefit ('invaluable for understanding past choices') without behavioral specifics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences plus a parameter list. Every sentence is purposeful and front-loaded with the main action. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose and parameter semantics. However, it does not mention prerequisites (e.g., project existence), return values, or how it integrates with other tools. For a simple logging tool, this is adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description compensates with clear explanations for each parameter (decision, rationale, alternatives, context, project). It adds meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The verb 'log' and resource 'decision' clearly state the action, and 'for future reference' adds purpose. It distinguishes from siblings like store_memory and list_decisions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for recording decisions and understanding past choices, but does not explicitly mention when to use it vs alternatives or when not to use it. It provides context but no exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It mentions the core side effects (marking accepted, promoting to memory, linking to source memories) but does not explain edge cases, reversibility, permissions, or what happens to the insight after promotion. This is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: a one-sentence summary followed by a minimal Args list. There is no filler or repetition. It earns its place with useful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with only two parameters and an output schema exists, so return format is not needed. However, the description lacks mention of any prerequisites or state requirements (e.g., the insight must already exist and be pending). This is a minor gap, but the core action and parameters are fully covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only parameter titles with 0% description coverage. The description compensates by including an Args section explaining both parameters: 'insight_id: The insight to accept' and 'project: Project for the promoted memory.' This adds semantic meaning, though the description of 'project' leaves its default behavior ('global') to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('accept') and resource ('insight'), and explains the outcome: 'mark it accepted and promote it to a real memory linked to its source memories.' This distinguishes it from the sibling tool 'reject_insight' and any other operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 like reject_insight, list_insights, or reflect. The description implies the action but does not specify conditions for acceptance, prerequisites, or situations where this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that extraction runs via the local `claude` CLI, requires `graphifyy`, and caches results under BRAIN_DIR/.constellation for fast access by other tools. It does not mention potential destructive overwriting or performance details, but the provided context is substantive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (four sentences), front-loads the primary purpose, and each sentence adds value: purpose, execution method, dependency, and caching behavior. There is no redundant or filler text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides useful context (caching, prerequisites, execution method) and an output schema exists, so return values need not be described. However, the unexplained `project` parameter and lack of guidance about when to use versus alternatives make the description incomplete for a fully informed decision.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one optional parameter (`project`) with 0% description coverage, and the description does not mention this parameter at all. The description should have explained what `project` controls (e.g., scope or target), but it remains completely undocumented, leaving a significant gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: '(Re)build the Graphify entity knowledge graph over the brain.' It uses a specific verb (rebuild) and resource (entity knowledge graph), and distinguishes it from sibling tools like `memory_graph` by naming Graphify and mentioning extraction via the local `claude` CLI.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (to build/rebuild the graph) and mentions prerequisites (graphifyy installed) and side effects (caching). However, it does not explicitly contrast with alternatives like `memory_graph` or state when not to use this tool, leaving usage guidance largely implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior. It mentions an optional status filter but omits that the schema default is 'proposed' (as seen in the input schema). This could mislead an agent into thinking all insights are listed when no filter is provided. The read-only nature is implied by 'List', but the default filtering behavior is a significant undisclosed trait.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, front-loaded with the primary action and resource. It includes the key optional filter without unnecessary words. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter list tool with an output schema, the description covers the core purpose and filter options. However, it fails to disclose the default 'proposed' status, which is critical for correct invocation. It also does not mention any pagination or ordering behavior, though this may be less critical given the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning beyond the raw schema by enumerating the valid status values: 'proposed | accepted | rejected'. The schema only shows a string or null type with no enum, so this is valuable semantic information. It does not mention the default value, but the core parameter meaning is well covered.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'List reflection insights'. It uses a specific verb ('List') and resource ('reflection insights'), which distinguishes it from sibling tools like list_memories or list_decisions. The optional status filter is also mentioned, adding precision.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context: it is for listing insight results from the reflection process, while sibling tools like accept_insight and reject_insight are for modifying them. It does not explicitly state exclusions or alternatives, but the context is clear enough for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It adds behavioral scope ('all registered projects') but does not explicitly mention read-only semantics, pagination, or auth requirements. The verb 'List' implies a safe, non-mutating operation, but more detail could be provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no redundant wording. It immediately conveys the action and target, earning a perfect score for conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (zero parameters, output schema provided), the description is complete. It doesn't need to explain return values because the output schema covers that, and it correctly specifies the scope of projects listed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there are no parameter semantics to explain. The baseline for zero-parameter tools is 4, and the description appropriately reflects that no input is required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and the resource ('registered projects'), making it distinct from sibling tools like list_memories and list_decisions. The qualifier 'all registered' precisely scopes the operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like list_memories or list_decisions. The description gives no contextual cues or exclusions, leaving the agent to infer usage solely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full burden. The verb 'List' clearly indicates a safe read-only operation, and the optional filters are described. However, it omits details such as ordering, pagination, exact vs. partial matching, and whether all memory fields are returned, which leaves some behavioral ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the main purpose, and uses a clear structured format for arguments. Every sentence contributes to understanding, with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with two optional parameters and an output schema present, the description adequately covers the core purpose and parameter semantics. It does not explain return shape or potential limits, but the output schema presumably covers the return structure, and the tool's simplicity means these omissions are not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Since the schema has 0% description coverage, the description effectively compensates by explaining that 'project' filters by project name and 'category' filters by the listed categories (architecture, bugfix, config, pattern, context, reference, note). This adds meaningful semantics beyond the raw schema, which only defines types and defaults. It could go further by clarifying filter matching rules, but it is already valuable.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb 'List' and a clear resource 'memories in the Brain', and by stating 'all memories' it distinguishes itself from related tools like get_memory or related_memories. There is no ambiguity about what this tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you need to list memories with optional filters, but it does not explicitly discuss when to choose this tool over siblings like recall, related_memories, or get_memory. No exclusion criteria or alternative names are mentioned, so usage guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as side effects, permission requirements, reversibility, or what happens if the project already exists. For a mutation tool, this lack of transparency is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a one-sentence purpose followed by a clear Args list. Every sentence adds value, with no fluff or repetition of schema metadata.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core purpose and parameters, and an output schema is present, but it omits potential edge-case behavior (e.g., overwriting existing projects, constraints on paths). For a simple registration tool, this is adequate but not fully comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has no property descriptions (coverage 0%), but the description's Args section adds meaningful guidance: 'name' gets an example, 'paths' gets its purpose ('for auto-detection'), and 'description' is clarified. This fully compensates for the schema's lack of semantic detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Register') and resource ('a project') with a clear purpose: 'so the Brain can auto-detect it from the working directory.' This distinguishes it from read-only siblings like list_projects and memory retrieval tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The context is clear: use this when you want to register a project for auto-detection. It does not explicitly mention when not to use it or alternatives, but the intent is unambiguous and no exclusions are needed for a simple registration tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the key behavior 'kept on record, marked rejected', which is important context. However, it does not mention potential restrictions, reversibility, or how rejection affects listing or retrieval.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: a one-sentence purpose plus a compact Args section. There is no redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the presence of an output schema, the description covers the main purpose and parameter adequately. It could benefit from a note about when rejection is appropriate or whether the insight remains visible, but for a small state-change tool it is nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema only provides the type (integer) and required status for insight_id. The description adds semantic meaning with 'The insight to reject', clarifying the parameter's role. With only one parameter, this is adequate and exceeds what the schema alone offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Reject' with the resource 'insight' and adds a clarifying parenthetical 'kept on record, marked rejected' that distinguishes it from deletion or acceptance. This clearly differentiates from sibling 'accept_insight' and other memory tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you want to reject an insight, and the parenthetical hints that the record is retained, but it does not explicitly state when to use this tool versus alternatives like 'accept_insight' or when not to use it. Context is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden. It transparently states this is a retrieval operation, implying no side effects, but it does not explicitly note read-only behavior or what happens if the memory does not exist. The 'retrieve' wording is adequate for a simple getter but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, front-loading the main purpose in the first sentence. The Args block is necessary given the schema's lack of parameter descriptions, and every word earns its place with no extraneous content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter retrieval tool, the description is nearly complete. It defines the action, the parameter, and with an output schema present, does not need to explain return values. It could be enhanced by mentioning error behavior or relationship to recall, but these are outside the core scope.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the description compensates with an Args section explaining that memory_id is a numeric ID of the memory to retrieve. This adds clear meaning beyond the raw integer type in the schema and fully clarifies the only parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: retrieving the full content of a specific memory by ID. This verb+resource structure is specific and distinguishes it from siblings like list_memories (which lists) and recall (which likely performs semantic retrieval).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a memory ID is known, but it does not explicitly state when to use this tool versus alternatives like recall or related_memories. There is no when-not guidance or mention of alternatives, so it relies on the reader to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 that the Graphify entity graph is included only if built, and that focus_id centers the diagram. However, it does not explicitly state that the tool is read-only, nor does it mention any limitations or resource implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: a one-sentence overview followed by a structured args list. Every piece adds value, and it is front-loaded with the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose, parameters, and a key conditional behavior. An output schema exists to describe return values, so the lack of return format details is acceptable. It is complete enough, though it could benefit from explicit usage examples or edge-case handling (e.g., when the entity graph isn't built).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description's args section explains each parameter clearly: project scopes to a project, focus_id centers the diagram, and include_entities toggles the entity graph summary. This fully compensates for the schema's lack of documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides an overview of the brain as a graph, listing specific outputs such as hubs, orphans, components, a Mermaid diagram, and the Graphify entity graph. This distinguishes it from sibling tools like recall and brain_status, which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for graph overview and analysis but does not explicitly state when to prefer this tool over alternatives or provide exclusions. It lacks guidance such as 'use this for structural queries' or 'instead of list_memories'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden of behavioral disclosure. It does explain the graph-aware recall behavior for the 'neighbors' parameter, which is valuable and non-obvious. However, it does not explicitly state that this is a read-only operation or mention any side effects, rate limits, or other behavioral nuances, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with a first sentence stating the core purpose. The Args section is structured with each parameter on its own line and brief, useful explanations. There is no redundant or filler content; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose, usage context, and all parameters. An output schema exists, so the lack of a return-value description is acceptable. The tool is simple, and the description provides sufficient context for an agent to select and invoke it, though it lacks explicit alternative tool guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides no parameter descriptions, so the description fully compensates. Each parameter is clearly explained: query as 'Natural language query', project with scoping semantics (None = search all), limit as 'Maximum number of results', and neighbors with a detailed explanation of graph-aware recall. This goes beyond basic schema information, especially for the complex 'neighbors' behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Search the Brain semantically,' which clearly identifies the action (search) and the resource (the Brain). It also states 'Use this to find relevant memories before starting work,' providing clear context. However, it does not explicitly distinguish this tool from siblings like 'related_memories' or 'recall_associative', so it lacks explicit differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly tells the agent when to use this tool: 'Use this to find relevant memories before starting work.' This provides a specific context. It does not mention alternative tools or exclusions, but the stated use case is clear enough to guide selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It explicitly states 'Read-only — never edits your operating instructions,' which is a key safety trait. This goes beyond the schema and adds value. It does not mention permissions or rate limits, but for a read-only review operation, the stated non-mutating behavior is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with two sentences covering purpose and safety, plus a single-line argument explanation. Every sentence earns its place, and the most important information is front-loaded. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and an output schema, the description covers purpose, safety, and parameter semantics well. The absence of usage guidelines (e.g., when to choose this over sibling tools) is a minor gap, but given the tool's simplicity and the output schema's presence, the overall context is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the description fully compensates with a clear explanation: 'Args: project: Scope to a project (None = whole brain).' This explains the parameter's meaning, the None behavior, and default scope, making the parameter semantics completely clear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with a specific action: 'Find recurring-incident clusters and propose always-on rules for review.' This clearly states the tool's function with a distinct verb and resource, and the phrase 'propose' differentiates it from directly applying rules. It does not explicitly name sibling alternatives, but the focus on procedures and recurring incidents makes it distinguishable from tools like review_beliefs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied: you use this when you need to detect recurring incidents and propose review rules. However, no explicit 'when to use vs. when not to use' or alternative tools are mentioned. The description provides clear context but no exclusions, so it earns a middle score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses key behaviors: returns COMPLETE content, accepts up to 10 ids, and ids derive from get_context/recall. However, it does not disclose potential side effects, error handling, or whether any permissions are required. The read-only nature is implied but not stated explicitly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the purpose, and the Args section is compact and directly informative. No redundant words or restatement of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no enums, has output schema), the description is largely complete: it specifies the ID source, maximum count, and purpose. It omits error behavior and does not explicitly state that get_context/recall must be called first, but the reference to their #id pointers implies that prerequisite.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only the type and array structure for 'ids', with no description. The text compensates by explaining the ids are pointers from get_context/recall and limited to max 10, adding meaningful context beyond the raw schema. This is sufficient for correct invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Drill-down dal contesto compatto: il contenuto COMPLETO di una o più memorie.' It uses a specific verb ('drill-down'), names the resource ('memories'), and distinguishes from siblings by emphasizing it returns complete content from compact context, unlike recall/get_context which provide compact summaries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context by specifying the IDs come from '#id pointers of get_context/recall', indicating when to use it. However, it does not explicitly state when NOT to use this tool versus alternatives like get_memory or recall_associative, lacking explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It explicitly discloses that history is preserved on every update and that the operation is non-destructive. This addresses safety and system behavior. However, it does not mention return format, ordering, or error handling, though an output schema exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise: one sentence for the action, one for safety context, and a clean args block. Every word earns its place, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter, read-only tool with an output schema, the description covers the core purpose, the parameter, and safety. It leaves a minor ambiguity about whether the current version is included in the history, but the output schema likely clarifies this. Overall, it is sufficiently complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one required parameter (memory_id) with zero description coverage. The description provides a clear definition: 'The memory whose edit history to retrieve.' This adds meaning beyond the bare schema and fully covers the single parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Show') and a clear resource ('prior versions of a memory'), distinguishing it from sibling tools like get_memory (current version) and recall (query). It also adds context about history being preserved non-destructively, which reinforces its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (retrieve edit history) but does not explicitly state when to prefer this over alternatives like get_memory or as_of. No exclusions or alternative guidance is provided, leaving the agent to infer from the tool name and siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that deletion is permanent, which is a critical trait for a destructive operation. However, it does not mention potential side effects, error behavior, or permission requirements, though the permanence warning adds substantial transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: one action sentence and one parameter line. It front-loads the key information and contains no fluff, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has low complexity (one integer parameter, output schema present). The description covers the action, permanence, and parameter meaning. It does not mention edge cases like missing IDs or cascading effects, but given the simplicity and presence of an output schema, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has zero description coverage for memory_id, but the description explains it as 'the numeric ID of the memory to delete', providing essential meaning beyond the bare integer type. This fully compensates for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'delete' and identifies the resource as 'a memory from the Brain', clearly differentiating from siblings like get_memory, update_memory, and list_memories. The action and target are unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide explicit guidance on when to use this tool versus alternatives such as flag_stale or update_memory. Usage is implied by the tool's name and the action it performs, but no exclusions or alternative references are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full transparency burden. It usefully discloses that the memory is not deleted, remains recoverable, and becomes annotated in recall. However, it does not detail reversibility, exact recall visibility, or failure modes, leaving minor gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description leads with a one-sentence summary that captures the core behavior, then provides terse argument descriptions in a structured Args block. No wasted words; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple operation, the description covers operation semantics and all parameters. It does not explain exact recall behavior or how to revert the flag, but with an output schema present and focused args, the description is highly complete for its complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must fully compensate. It explains every parameter: memory_id as the target, reason as justification for staleness, and superseded_by as the replacing memory if any. This is complete and adds clear meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource: "Mark a memory as stale", and adds crucial scope with "kept and recoverable, but annotated in recall" which clearly distinguishes it from delete_memory and update_memory. The purpose is unambiguous and operationally specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The effect "kept and recoverable" implies use for memories that should be preserved but deprioritized, but there is no explicit when-to-use versus alternatives like delete_memory or update_memory. No exclusions or alternatives are named, leaving usage context to be inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses important behavioral detail: 'None args keep the current value' clarifies that omitted fields are preserved, not cleared. This goes beyond schema defaults and adds practical semantics for a partial update.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by a compact and structured argument list. Every line earns its place, and the length is appropriate for six parameters. No redundant or filler language.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is complex (six parameters, no annotations), but the description covers the main behavior and all parameter meanings. An output schema exists, so return values need not be explained. Minor gaps like error handling or validation rules are not addressed, but core usage is fully covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description fully compensates. Each of the six parameters gets a concise, meaningful explanation (e.g., status enum values, valid_until as an expiry date, superseded_by as a replacement ID). These add semantic value beyond the schema's types and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update a memory's belief envelope') with a specific verb and resource. The term 'belief envelope' distinguishes it from more generic tools like update_memory, and the parameter list confirms specialized functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage is implied through the parameter descriptions and the 'None args keep the current value' note, but it doesn't explicitly state when to use this tool versus alternatives like update_memory or review_beliefs. No exclusions or alternative tools are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that content supports markdown, project scoping defaults to global, and category has a fixed set of values. However, it does not address potential overwriting, duplicate handling, or permissions, leaving some behavioral ambiguity for a write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, with a single opening sentence and a clean Args list. Every line adds value, no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers all parameters and the main purpose, and an output schema exists to define the return value. However, it leaves some contextual gaps (e.g., behavior on duplicate titles, whether memories can be overwritten), which prevents a perfect score. Given the tool's simplicity, it is still largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides no descriptions for parameters, but the description compensates fully by explaining each parameter: content's markdown support, title's purpose, project's 'global' convention, tags with an example, and an explicit enumeration of category values. This exceeds schema information and makes the parameters self-explanatory.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Store') and resource ('knowledge in the Brain for future sessions'), distinguishing it from sibling tools like recall, list_memories, update_memory, and delete_memory. The intent is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description establishes a clear use case (storing new knowledge for future sessions) but does not explicitly mention alternatives or exclusions. Context is clear, but there's no guidance on when to prefer this over store_decision or update_memory, so it earns a 4 rather than 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses key non-obvious behaviors: the reconstruction from version history, the distinction between the current query search and historical content, and the indication of superseded/expired memories. This goes beyond a simple 'get memories as of date' statement.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a purpose statement, a behavioral explanation, and a labeled Args list. It is slightly verbose, but every clause adds useful nuance (e.g., 'searched today, content returned as of the date'), so the length is justified.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a complex temporal reconstruction, and the description covers the main aspects: what it does, how it reconstructs, and what parameters are needed. It relies on an output schema (which exists) to detail return structure. It does not mention error cases or edge like invalid dates, but for a read-only query tool it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the description explains each parameter in operational terms: date is the reconstruction point, query is an optional filter that is searched today but content returned as of date, project scopes the result, and limit caps the number. This adds meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with an evocative metaphor 'Time-travel: what did the brain believe at a given date?' and then clearly states the tool returns memories that existed in the past with their content as it was reconstructed from non-destructive version history. This is specific and distinguishes it from sibling tools that operate on current state.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context by explaining that it reconstructs a past state, implying use when historical perspective is needed. It does not explicitly name alternative tools or when NOT to use it, but the temporal focus and optional filters make the intended use obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral disclosure. It reveals that it reuses the Graphify graph with no extra LLM cost, and importantly, it saves candidates as proposed insights (unless store_them=False), which is a side effect. It does not fully detail other behaviors like permission needs or response structure, but covers the key aspects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is succinct and well-structured: a brief opening sentence explaining purpose and side effects, followed by a clean Args list. Every sentence provides necessary information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose, usage context, side effects, and all parameters. It mentions that candidates are saved as proposed insights, which gives workflow context. Since an output schema exists, the absence of return-value explanation is acceptable. Could mention prerequisites like graph state, but overall it is quite complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The default schema coverage is 0%, so the description fully compensates by providing clear meanings for each parameter: project scopes to a project (with None special meaning), limit sets max candidates, and store_them controls persistence. This adds substantial value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('surface') and resource ('cross-project analogies and non-obvious connections across memories'). It explicitly distinguishes itself from recall ('that recall cannot reach'), showing a clear differentiation from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (when cross-project analogies or non-obvious connections are needed) and contrasts it with recall. It also outlines the workflow with accept_insight/reject_insight, but it does not explicitly list alternative tools 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It adds useful behavioral detail: content and tags replace existing values, and passing None keeps current values. It does not disclose error handling or side effects, but the core update semantics are well-covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences plus a clean Args block. It front-loads the purpose and then efficiently explains each parameter without unnecessary text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the presence of an output schema, the description covers the essential aspects: purpose and parameter semantics. It lacks explicit error behavior (e.g., what happens if memory_id doesn't exist), but this is a minor gap for a basic update tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining each parameter's role and the None-preserving behavior. This adds significant meaning beyond the raw schema, which only lists types and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Update an existing memory's content or tags', specifying the verb (update), resource (memory), and what fields can be changed. This distinguishes it from sibling tools like delete_memory (delete), store_memory (create), and get_memory (retrieve).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage on existing memories ('existing memory') and clarifies that content and tags are optional, making it clear when to use this tool. However, it does not explicitly mention alternatives or when-not-to-use scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the full behavioral scope: it returns matching decisions with rationale, rejected alternatives, context, evidence from memories, and supersession. It also notes the effect of the 'limit' parameter. However, with no annotations, it does not explicitly state whether the operation is read-only or lacks side effects, though the nature of the query strongly implies it. This is strong transparency but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a purpose statement, followed by a concise example of usage and return content, then the parameter list. There is no fluff or repetition; every sentence contributes value. The formatting is clean and easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is complex (decision provenance with multiple output components), but the description covers the input semantics, the output structure, and the scope controls. An output schema exists, but the description goes beyond that to explain the meaning of the results. No critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description includes an Args block that explains each parameter in plain language: 'question' is a natural-language why-question, 'project' scopes to a project, and 'limit' caps the number of decisions. Since the schema provides no descriptions for these parameters, this is essential and fully compensates, exceeding the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Interrogate decision provenance' and provides a concrete example ('why do we use X and not Y?'). It specifies the return payload (decisions, rationale, rejected alternatives, context, evidence, supersession), which distinguishes it from sibling tools like recall or list_decisions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear scenario for when to use the tool: when asking a 'why' question about decisions. It does not explicitly mention alternatives or exclusions, but the example and problem domain make the intended usage obvious. No 'when not to use' guidance is provided, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 reveals key behaviors: detects project from cwd, returns ~300-600 token overview, truncates by relevance not age, and supports two formats. It implies a read-only operation without stating so explicitly, and doesn't mention potential side effects, but the description is largely transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a clear opening instruction, a compact summary of functionality, and a tidy Args list. Every sentence contributes value, and it remains readable despite covering multiple aspects.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 5 parameters and an output schema, the description covers the purpose, workflow, parameters, and output characteristics. It is sufficient for an agent to know when and how to call it, and what to expect in return.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description explains every parameter with meaningful details (e.g., 'max_tokens: Token budget for the dense format — truncated by relevance, not by age.'). It adds clarity beyond the schema, especially for format and max_tokens.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to auto-inject relevant context at the start of a session, with a specific output (compact overview of pointers and stats). It distinguishes itself from siblings by emphasizing it is the first tool to call for session context, unlike search/recall tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to 'Call this FIRST' and provides a follow-up action ('Drill into anything with expand_memory(ids=[...])'). It also explains when to set task_description to improve relevance, giving clear context for use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries the full burden of behavioral disclosure. It explicitly states that sources are kept and recoverable, never deleted, and that provenance is appended automatically, which gives the agent important expectations beyond the bare operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the purpose, and followed by an efficient parameter list. Every sentence adds functional information, and there is no fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists and all parameters are described with meaningful semantics, the description is complete for an agent to select and invoke the tool correctly. It also discloses the key behavioral constraint (sources never deleted) that is not otherwise available.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Although the schema itself has no descriptions (0% coverage), the description compensates fully by explaining each parameter: source_ids are the memories being consolidated (≥2), content is the synthesis with provenance appended automatically, and title/project/tags are for the new merged memory.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The phrase 'Merge redundant memories: store the synthesis as a NEW memory and mark the sources superseded' clearly states the verb (merge), resource (memories), and the specific outcome (creating a new memory and superseding sources). This distinguishes it from siblings like store_memory, update_memory, and delete_memory.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear context: use for redundant memories that need consolidation. It does not explicitly name alternatives or exclusion conditions, but 'redundant memories' plus the merge semantics make the intended usage obvious relative to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does so excellently: it explicitly declares 'Read-only — it suggests, never deletes.' It also details the types of staleness it detects, giving the user a full understanding of what will happen.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise but information-dense, starting with the main purpose, then the criteria, then the side-effect guarantee and the confirmation action, followed by the arg. Each sentence contributes meaning without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity tool with one optional parameter and an output schema, the description covers all necessary aspects: purpose, usage context, parameter semantics, and behavioral transparency. The output format is conveyed by the output schema, so no further description is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only the parameter name and type with default null. The description adds crucial semantics: 'Scope to a project (None = whole brain).' This fully explains the meaning and usage of the only parameter, compensating for the 0% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool scans the brain for memories that are likely stale and need review, specifying exact criteria (superseded, past deadline, conditional, flagged). It clearly distinguishes itself from siblings like recall or list_memories by focusing on review/suggestion rather than retrieval or modification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context for when to use the tool: to find stale memories that need review. It also indicates the read-only nature and suggests using flag_stale to confirm. However, it does not explicitly mention when not to use it or recommend an alternative tool (e.g., review_procedures for procedures), so it lacks explicit exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It clearly states 'read-only' and 'Nothing is changed', and details the types of findings (merge candidates, decay candidates, orphans). This provides strong transparency, though it omits potential performance implications or whether the analysis might be resource-intensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and efficient. It uses a metaphor, then lists concrete outputs, gives action guidance, and documents parameters. Each sentence earns its place; no wasted words. The length is appropriate for the complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is complete for a read-only analysis tool with two optional parameters. It explains the purpose, behavior, outputs, and next steps. An output schema exists, so return value details are not required. The coverage of parameter semantics and usage guidelines makes it robust.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only titles and defaults, with no property descriptions. The description compensates fully by explaining both parameters: 'project: Scope to a project (None = whole brain)' and 'min_similarity: Cosine threshold for merge candidates inside a community.' This adds meaningful semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'walk the graph and PROPOSE housekeeping (read-only)'. It identifies the resource (the memory graph) and the action (proposing housekeeping candidates), and distinguishes itself from siblings by explicitly noting it is read-only and that mutations are handled by merge_memories/flag_stale.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly explains when to use this tool and what to do with its results: 'Nothing is changed — you (or your agent) act with merge_memories / flag_stale.' It names the alternative tools and clarifies the workflow, making the usage context unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries the full transparency burden. It explicitly states 'READ-ONLY' and 'Nothing is modified', which is critical for a tool that could be mistaken for a mutating operation. It also discloses the eventual fate of sources after merge_memories: 'marked superseded (never deleted, always recoverable)', giving recovery guarantees without needing annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-structured: a one-line purpose with the read-only caveat, a short behavioral explanation, a clear workflow sentence, and an Args list. Every sentence adds value—no filler or repetition of schema defaults. The front-loading of 'READ-ONLY' is strategically effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 optional parameters and no annotations, the description covers purpose, usage workflow, behavioral guarantees, and parameter semantics. An output schema exists, so the absence of return-value details is acceptable. It provides everything an agent needs to decide when to call it and what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description is the sole source of parameter meaning. It explains all three parameters clearly: 'project' scopes to a project or None for whole brain, 'threshold' defines the cosine similarity cutoff for redundancy, and 'max_groups' caps the number of returned groups. This goes far beyond the bare schema titles.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Propose groups of redundant/overlapping memories to merge.' It clearly distinguishes from siblings like merge_memories by emphasizing the read-only proposal nature. The parenthetical '(READ-ONLY)' and the explanation that nothing is modified further solidify the purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use and when-to-then-use-alternative guidance: 'review the groups, write a synthesis yourself, then call merge_memories(...)'. This tells the agent exactly how to proceed after calling this tool, effectively naming merge_memories as the complementary next step. It also clarifies that this tool is for proposing, not executing merges.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it delivers. It discloses the internal algorithm (seeding, propagation along citation/semantic/shared-entity edges) and the return format (associative ranking plus the plain-cosine baseline for comparison). This goes beyond a simple 'recall' and lets the agent predict behavior and output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact: a one-sentence overview, a one-sentence contrast with recall, a one-sentence return description, and a bulleted Args list. No filler; every sentence adds critical information, and the most important details are front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (graph propagation, multiple edge types) and that an output schema exists, the description covers what the tool does, how it differs from the main sibling, and what it returns. It doesn't need to replicate output schema details, and no critical gaps are apparent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description's Args section is essential. It defines all three parameters: query as 'Natural language query', project with scope semantics ('None = whole brain'), and limit as 'Number of results'. This adds meaning beyond the schema's type-only definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource: 'Spreading-activation recall over the memory graph (HippoRAG-style).' It immediately distinguishes itself from sibling `recall` by contrasting its mechanism (propagating activation along edges) with pure cosine top-k, making the tool's unique purpose clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to prefer this tool: 'Unlike recall (pure cosine top-k), this seeds... so strongly-connected memories surface even when not textually similar.' This gives the agent a clear decision rule between recall_associative and recall, and implies that recall is the alternative for straightforward similarity searches.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![wadachi MCP server](https://glama.ai/mcp/servers/EliaCinti/wadachi/badges/card.svg)](https://glama.ai/mcp/servers/EliaCinti/wadachi)

Score Badge

Copy to your README.md:

[![wadachi MCP server](https://glama.ai/mcp/servers/EliaCinti/wadachi/badges/score.svg)](https://glama.ai/mcp/servers/EliaCinti/wadachi)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/EliaCinti/wadachi'

If you have feedback or need assistance with the MCP directory API, please join our Discord server