Skip to main content
Glama

remember

Save durable facts, decisions, and personal details to a persistent memory vault. Retrieve them across sessions and AI tools.

Instructions

Save something to the user's persistent memory vault, afair, the substrate that travels across their sessions, AI tools, and years. Use it generously.

The user explicitly installed afair so their context doesn't reset. If a fact crosses your attention and looks even slightly worth more than the current message, save it. The cost of forgetting is the user re-explaining themselves next session; the cost of an extra remember is one append-only row that dedupes if identical.

WHEN TO CALL:

  • The user explicitly says "remember", "save", "note that", "keep this", "don't forget", "make a note", "add to memory", or any clear save-this signal.

  • The user shares a durable fact worth retaining across sessions, from any part of life: a work decision or deadline, a colleague's role, a friend's or family member's name and what matters to them, a birthday or anniversary, a preference (food, travel, how they like to work), a personal goal, something they are working through.

  • The user shows you content (an email, a meeting note, a document, a screenshot, a photo, a PDF, an audio clip) whose substance has reason to outlive this conversation.

  • You make a significant decision together with the user that should survive into future sessions.

  • The user corrects an earlier fact ("actually Sajinth is at Athara, not elvah"). Write the new fact AND pass the old event's content_hash in invalidates to mark it superseded.

DEFAULT: when in doubt, remember. Don't ask for permission. Don't narrate "I'll remember this for you." Just call it.

WHEN NOT TO CALL:

  • Conversational filler ("ok thanks", "got it", "sounds good").

  • Content the user is actively dictating to another destination.

  • Things you can easily re-derive from current code or state.

  • Personal details about other people that the user has not asked you to track.

ARGUMENTS:

  • content: A discriminated union. Either: {"type": "text", "text": "..."} for any text, OR {"type": "binary", "data_b64": "...", "mime": "image/png", "filename_hint": "screenshot.png"} for binary. Max 10 MB raw bytes. A JSON-string-serialized object (the same shape sent as a string) is also accepted and parsed, and a bare string is stored as text — the write is never rejected on shape.

  • context: Optional. Where this came from or what it relates to. Examples: "email thread with Sajinth", "Tuesday standup", "dinner with Mara", "Mum's birthday weekend". Aids future recall.

  • type_hint: Optional. What kind of thing this is, if you have a guess. Examples: "email", "meeting_minutes", "decision", "screenshot". Advisory only. The system may classify differently.

  • parent_hashes: Optional. Content hashes of events this one references (corrections, replies, threads).

  • invalidates: Optional. List of content_hashes that this new fact supersedes. Each target gets its own append-only invalidation event referencing it. Use when the user corrects a prior fact or a meeting outcome supersedes an earlier plan.

  • asserted_by: Optional. Who asserted this, one of "user" (the human stated it directly) or "model" (you inferred or synthesized it). Advisory provenance only: it is stored and served, but a self-reported "user" can NEVER raise the trust of a derived fact above the normal agent-derived level — operator-grade trust is earned only through the recall(decide=...) review loop. Omit if you're unsure.

  • actor: Optional. On WHOSE BEHALF this memory is written, when a single credential relays for many people (an organization's shared agent writing for different members). A free-form identifier kept verbatim — "slack:U0BKXTGBWLD", "alice@corp", "Alice from Sales". Omit for a personal vault or when the credential already identifies the writer.

DISAMBIGUATION — three different questions, don't conflate them: - client (served on recall hits): WHICH TOOL wrote this, derived server-side from the credential. You never set it. - actor (this argument): ON WHOSE BEHALF, when the credential is shared. You set it. Advisory only; it never substitutes for client and never raises trust. If absent, client is the best attribution. - asserted_by: whether a HUMAN or the MODEL asserted the fact. Same content written on behalf of different actors is stored as distinct events (attribution is content); identical content + same actor dedupes.

RETURN: {"ok": true, "event_id": "...", "content_hash": "sha256:...", "deduplicated": false, "invalidated": ["sha256:...", ...]}

  • deduplicated=true means an event with identical content+context already existed; nothing was added but the existing event_id is returned.

  • invalidated lists the content_hashes that were marked superseded in this call.

The substrate is the user's vault, not yours. Be a thoughtful librarian: save signal worth keeping; don't hoard ephemera.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
actorNo
contentYes
contextNo
type_hintNo
asserted_byNo
invalidatesNo
parent_hashesNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
okYes
event_idYes
invalidatedNo
content_hashYes
deduplicatedYes

Schema Changelog

Changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. First observedv0.1.0

TDQS

A4.9/5.0
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 excels. It explains beyond what annotations might cover: deduplication behavior (identical content+actor), return schema details (event_id, content_hash, deduplicated flag, invalidated list), size limits (10 MB for inline, up to 1 GB via blob-ref), compound event atomicity, and the 'asserted_by' trust model. No contradictions exist.

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 comprehensive and well-organized with clear sections (WHEN TO CALL, WHEN NOT TO CALL, ARGUMENTS, RETURN, etc.). It is front-loaded with the tool's purpose and bias. However, it is verbose in some parts (e.g., the full code examples in parameter descriptions and the disambiguation section) and could be tightened slightly without losing clarity.

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 7 parameters (1 required), 0% schema coverage, no annotations, and the presence of an output schema, the description is fully complete. It explains every parameter in detail, covers the complex content union with 4 variants, clarifies compound event atomicity vs. parent_hashes, and documents the return schema. The output schema exists and the description doesn't repeat it but rather adds behavioral context. No gaps remain.

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?

Even though schema description coverage is 0%, the description provides rich, detailed meaning for all 7 parameters. For content, it enumerates 4 discriminated union variants (text, binary, blob-ref, compound) with behavioral intent. It gives concrete examples for context, type_hint, parent_hashes, invalidates, and actor, and includes a detailed disambiguation block for client vs. actor vs. asserted_by. This far exceeds baseline requirements.

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 specific verbs like 'save' and 'remember', clearly identifies the resource as the user's persistent memory vault (afair), and distinguishes itself from siblings by explicitly contrasting with recall (for retrieval) and observe (implied passive). It thoroughly explains the tool's role as a durable, cross-session storage.

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?

Provides explicit WHEN TO CALL examples (user says 'remember', shares durable facts, shows content, makes decisions, corrects facts with invalidates) and WHEN NOT TO CALL categories (conversational filler, content destined elsewhere, re-derivable facts, unrequested personal details). Also includes a clear DEFAULT bias toward remembering without asking permission.

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

Install Server

Other Tools

Latest Blog Posts

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/afairai/afair'

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