Agent Memory · Checks for what an agent remembers about the people it works for

An agent remembers well when the principal stays in charge.

An agent's memory serves its principal when it keeps only what a written scope names, every memory carries where it came from, the principal agreed to be remembered and sees, corrects and switches off what is kept, a removal request clears it everywhere, a new fact retires the old one, stored memory crosses only on the principal's word and on the record, the principal takes all of it with them on request, and memory leaves on a stated schedule. Agent Memory checks each of those with eight tools: eight checks. Your agent sends the memory design, stored memories, consent setup, deletion flow, update flow, sharing flow, export flow or retention rules in the call, and each tool returns a signed report with every status, match and verdict decided from it.

See the tools Read the contract

Tool access: 0.10 USDC / call
Tools: Eight tools: eight checks
Connection: /mcp
Result: Signed report

The eight tools.

Each tool reads one kind of memory material and answers one question about it. The report names the category, memory, place, conflict, crossing, request or period behind every status, so your agent and you can see why it reads the way it does.

`wever_memory-scope-check`

Reads: An agent’s memory design: the written scope with the categories kept and excluded, how memory is keyed and what decides each write, with each category’s kind, purpose and keying, and the stored memories seen.
The signed report states: What the agent keeps, what is excluded by rule and whether each principal’s memory is kept apart or in one global store, with every memory outside the scope.
Price: 0.10 USDC per call
Verdicts: keeps_too_muchscope_gapsscope_unverifiedscope_bounded

`wever_memory-provenance-check`

Reads: Stored memories as supplied, each with its source, the call, message or record behind it, what an inference was drawn from and whether it is labeled, with how the design records sources.
The signed report states: Memory by memory, whether each carries where it came from, observed, stated, inferred or imported, with every inference that reads as fact named.
Price: 0.10 USDC per call
Verdicts: rumors_keptprovenance_gapsprovenance_unverifiedmemories_sourced

`wever_memory-consent-check`

Reads: A memory setup: when the principal is asked whether to be remembered, how they agree, what the agreement covers and whether it is recorded, with their controls to see, correct and switch memory off.
The signed report states: Whether the principal agreed to be remembered, what that covers against what is kept, and whether they see, correct and switch off their memory on their own.
Price: 0.10 USDC per call
Verdicts: remembered_without_consentconsent_gapsconsent_unverifiedprincipal_in_control

`wever_memory-deletion-check`

Reads: A deletion flow: every place the memory lives, backups and derived summaries, profiles and indexes included, with what a removal request does in each, the confirmation and the requests seen.
The signed report states: Place by place, whether a removal request clears the memory, and whether the principal gets a confirmation they can check.
Price: 0.10 USDC per call
Verdicts: deletion_incompletedeletion_gapsdeletion_unverifieddeleted_everywhere

`wever_memory-conflict-check`

Reads: A memory update flow: when a contradiction is noticed, which fact wins, who hears of it and what becomes of the old fact, with the contradictions seen and how each resolved.
The signed report states: Which fact wins when a new one contradicts a remembered one, whether the principal hears of it, and whether the stale fact is retired.
Price: 0.10 USDC per call
Verdicts: stale_facts_winconflict_gapsconflict_unverifiedconflicts_resolved

`wever_memory-sharing-check`

Reads: A memory-sharing flow: each way stored memory crosses to another agent, tool or principal, under whose instruction, how it is logged and what the recipient may do, with the crossings seen.
The signed report states: Crossing by crossing, what stored memory moves, on whose word and whether it is on the record, with every path nobody declared.
Price: 0.10 USDC per call
Verdicts: memory_wanderssharing_gapssharing_unverifiedsharing_instructed

`wever_memory-export-check`

Reads: An export flow: how the principal gets an export, its format, the categories and inferences it includes, each item’s source and how long it takes, with what is kept and what is withheld.
The signed report states: Whether the principal takes everything remembered about them in a readable form, inferences included, and what is withheld and why.
Price: 0.10 USDC per call
Verdicts: memory_lockedexport_gapsexport_unverifiedprincipal_can_take_it

`wever_memory-retention-check`

Reads: A memory setup’s retention: the stated period and what it counts from, how it is applied and what happens when the relationship ends, with categories on their own period and the memories seen.
The signed report states: Whether a stated retention period exists, whether old memories are purged or reviewed on it, and what survives the end of the relationship.
Price: 0.10 USDC per call
Verdicts: kept_foreverretention_gapsretention_unverifiedretention_enforced

Start with the two free tools.

On https://weverlabs.com/mcp-free, anonymous and with no wallet, two Agent Memory tools read supplied memory material at summary depth. Each returns an unsigned result in the family's report shape and ends with a line naming the main tools.

`wever_memory-snapshot`

Reads: What is recorded about one subject: each fact as stored, with where it came from and when it was recorded.
Returns: The record as one plain list of facts, each with its source and its age in plain words, or not stated.
Access: Free on /mcp-free

`wever_memory-scope-sample`

Reads: One memory scope’s headline: whether it is written down, the categories kept and excluded, how memory is keyed and the retention headline.
Returns: Whether a stated memory scope exists, with the categories kept, the categories excluded and the retention headline. The memory scope check gives the full audit.
Access: Free on /mcp-free

How agents and people use it.

Your agent

Restates what it holds about a subject with wever_memory-snapshot whenever the principal asks what it remembers, so both start from one plain record of each fact, its source and its age.
Calls the check that answers the question on https://weverlabs.com/mcp at the moment it matters: when it designs what to keep, before it acts on an inference, when a new fact contradicts an old one, before memory crosses to another agent or tool, when a principal asks to export or delete, and on each retention review.
Acts on the verdict and keeps the signed report with the memory design, so the next change starts from a record.

You

See each gap named with the change that closes it.
Know what your agent keeps and why, where each memory came from, whether the people it works for agreed and stay in control, and whether delete, export and retention do what they say.
Verify any report against Wever's published trust key whenever you need to show where a verdict came from.

A worked example

Forgotten in the store. Remembered in the profile.

The request

{
  "name": "wever_memory-deletion-check",
  "arguments": {
    "flow": "forget-me requests",
    "target": "30 days",
    "places": [
      {
        "name": "memory store",
        "kind": "primary_store",
        "on_request": "deleted"
      },
      {
        "name": "nightly backup",
        "kind": "backup",
        "on_request": "marked_deleted"
      },
      {
        "name": "traveler profile",
        "kind": "profile",
        "on_request": "left"
      }
    ],
    "confirmation": {
      "sent": true,
      "names_places": true,
      "checkable": "receipt"
    }
  }
}

What the report returns

Verdict: deletion_incomplete.

Finding, derived left	1 summary, profile or index derived from the memory survives its deletion: traveler profile.
Finding, marked not deleted	1 place only marks the memory deleted and keeps it: nightly backup.
Fix, derived left	Delete or rebuild every summary, profile and index derived from the memory when removal is requested.
Fix, marked not deleted	Delete the memory where it is only marked deleted, or purge marked memory on a stated schedule.

Delete does not delete everywhere: derived left.

The traveler asks to be forgotten. The flow deletes the memory store and confirms with a receipt, while the nightly backup marks the memory deleted and keeps it, and the traveler profile built from that memory stays as it was. The report names both, so the owner deletes or rebuilds the profile on every removal request and purges marked memory from the backup on a stated schedule.

Call it from your agent.

Connect to https://weverlabs.com/mcp and call any of the eight tools. Each call costs 0.10 USDC on Base. Eligible calls share 10 free calls per wallet over a rolling 30 days with the other paid tools. For free access, send X-Wever-Wallet-Proof signed over the exact JSON arguments and the tool route. The payment challenge supplies the x402 terms for a paid call.

Every report comes with an Ed25519 receipt signed with Wever's published trust key. The Agent Memory contract lists the schemas, limits, verdicts and signing details. For which stores hold run state and cross-session memory, Agent Oversight; for keeping run state and durable memory apart, Agent Accountability; for consent to share live context, Agent Operations; for what a handoff format carries, Agent Handoffs.

Browse all tools