Skip to main content
Glama

remember

Save durable project facts for future AI sessions across tools, linked to relevant files so they are flagged when code changes.

Instructions

Save a durable fact about this project so future sessions, in any AI tool, know it. Use this, not a built-in memory or notes file, whenever the user asks you to remember something about the project.

Good facts: conventions ("we use pnpm, not npm"), setup gotchas ("tests need DOCKER_HOST set"),
decisions and their reasons. Not: temporary task details or anything in the code already.
files: repo-relative paths this fact depends on (e.g. ["docker-compose.yml"]), so the memory
can be flagged when those files change.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
factYes
filesNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A4/5.0
Behavior3/5

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

With no annotations, the description must carry the behavioral load. It does disclose real traits: the fact persists across sessions and tools, and dependent files cause the memory to be flagged when those files change. However, it says nothing about what happens when a conflicting or duplicate fact already exists (notable given siblings like list_conflicts and resolve_conflict), nor about failures or permissions.

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?

Front-loaded with purpose, then usage, then content guidance, then the auxiliary parameter. Every line contributes, though the 'files' paragraph reads like schema documentation appended with a leading lowercase parameter name, which slightly breaks the prose flow.

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?

An output schema exists, so return values need not be explained, and the description covers persistence semantics, trigger conditions, and the file-linkage behavior well. The remaining gap is conflict/duplicate handling, which is meaningful in a toolset that exposes list_conflicts, resolve_conflict, and mark_outdated.

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 must compensate, and it largely does. The 'files' parameter is fully explained (repo-relative paths, concrete example, and the purpose of the linkage), and 'fact' receives content guidance via the good/bad fact examples, which is more useful than a bare type declaration.

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 states a specific verb and resource ('Save a durable fact about this project') plus the scope that matters: durable across future sessions and any AI tool. It clearly separates itself from an external alternative (built-in memory or notes file), but it never distinguishes itself from its actual siblings such as recall, replace_memory, or mark_outdated, so an agent gets no routing help within the tool family.

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?

It gives an explicit when-to-use trigger ('whenever the user asks you to remember something about the project'), an explicit when-not ('temporary task details or anything in the code already'), and contrasts with a competing mechanism ('use this, not a built-in memory or notes file'). Good-fact and bad-fact examples remove remaining ambiguity.

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