Skip to main content
Glama

propose_memory_edit

Propose a human-reviewed text edit to an existing memory without altering it. The current version stays live until a person approves or rejects the change.

Instructions

Propose a text edit to an existing memory, for human review. Creates a PENDING memory carrying the edit; the target is left completely untouched and keeps injecting until a human approves. Approving it (review_memory action='approve') supersedes the target with the edited version; rejecting discards the proposal. old_text must occur exactly once — an ambiguous or absent anchor is an error, never a guess. field='content' (default) edits the body, field='instruction' edits the directive that injection renders. Use this instead of delete+save when you are correcting a memory you did not author: it keeps the current truth live until a person decides, and it cannot be used to silently rewrite a binding MUST.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "memory_id": "<memory_id>",
      "old_text": "<old_text>",
      "new_text": "<new_text>"
    },
    "name": "propose_memory_edit"
  }
}

Input Schema

NameRequiredDescriptionDefault
fieldNoWhich field to edit: `content` (default) or `instruction`. The instruction is what injection renders as the directive (§6.2), so the two are never conflated and there is no fallback from one to the other.content
api_keyNoAPI key for agent authentication (required if agent has a registered key)
agent_idNoID of the proposing agent — recorded as provenance on the pending memoryunknown
new_textYesReplacement text
old_textYesExact text to replace. Must occur exactly once in the target field — an ambiguous anchor is refused rather than guessed, because silently picking one would apply an edit nobody asked for. Case-sensitive.
memory_idYesID of the memory to edit

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv0.7.2

TDQS

A4.5/5.0
Behavior5/5

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

Annotations only declare the generic non-readonly, non-destructive, non-idempotent profile; the description adds the actual lifecycle: a pending memory is created, the target stays untouched and keeps injecting, approval supersedes the target, rejection discards. It also discloses the anchor-uniqueness failure mode ('an ambiguous or absent anchor is an error, never a guess'), which is behavior an agent cannot infer from annotations.

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?

Five tightly packed sentences, front-loaded with the core action and then the lifecycle and the anchor rule. Slight redundancy between 'the target is left completely untouched' and 'keeps injecting until a human approves', but both carry distinct meaning and nothing is 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 mutation tool with no output schema, the description covers the propose/review/reject lifecycle, the safety guarantee, and the anchor error condition, which is what an agent needs to call it correctly. It stops short of saying what the call returns (e.g. the pending memory identifier), a minor gap given no output schema exists.

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

Parameters3/5

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

Schema coverage is 100% and the schema descriptions already explain field='content' vs 'instruction', the exact-once anchor rule, and case sensitivity. The description restates those semantics with a bit of extra framing ('edits the directive that injection renders', 'never a guess') but adds no new format or constraint detail, so baseline 3 applies.

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?

States a specific verb and resource ('propose a text edit to an existing memory') plus the material scope ('for human review'; 'creates a PENDING memory'). Explicitly separates itself from delete_memory/save_memory via the 'instead of delete+save' line, so an agent can pick it without reading sibling schemas.

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?

Gives an explicit selection rule ('use this instead of delete+save when you are correcting a memory you did not author') and names the review path (review_memory action='approve') that resolves the proposal. It also states a hard exclusion: it cannot silently rewrite a binding MUST.

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