TerraWeaver — your memory, for every AI agent

One personal memory you own. It grows with every conversation and follows you from one agent to the next.

Site and demo: https://terraweaver.life · Video: https://www.youtube.com/watch?v=CgP7w1Y7mlo

Your agent forgets what you said in passing, or remembers it in its own words: "up to 400" with no idea that it was the budget for the vacuum, "she" with no idea who. You end up dictating facts to it, and it still decides alone what is worth keeping.

TerraWeaver is a memory that listens instead of waiting to be told. It hears the whole conversation by itself, keeps what you say about your life in your own words — rewritten only so that it stands alone — reads and structures it in the quiet, and answers the agent with facts and the words they stand on, never decisions. It lives on your machine and keeps no secrets.

Built for the Nebius × NVIDIA Global AI Hackathon, Personal AI track. Every language-model call is an NVIDIA Nemotron model on Nebius Token Factory; search by meaning uses a small local embedding model by default, or an NVIDIA Nemotron embedding model through OpenRouter when set (the demo does); web search is Tavily.

Your memory. Every AI agent.

One personal memory you own. It grows with every conversation and follows you from one agent to the next.

1. Yours, for any agent. It speaks MCP through two doors, say and ask, so any agent can use it, and what it keeps is plain files on your machine: a Markdown journal you can read.
2. It remembers on its own. Hooks pass every message of the conversation; the agent is never asked to remember to save, and cannot forget to.
3. Trust: your own words. What is kept is what you said, rewritten only so that it stands alone; every fact is shown with the entry it comes from, checked by code. Secrets are withheld before any model sees them, private matters are not put into web queries, and names are kept out of them by code.
4. Quality. Time, change and links are kept (what happened when, how many, how it stands now, where we left off), topics are kept current from the web, and reading costs the same for each entry however long the history is.

Active, not a store

A passive memory is a store: the agent writes into it and reads from it, and everything depends on the agent remembering to. This one acts by itself:

It…	How
hears every message, the user's and the agent's	Claude Code hooks pass both sides; the agent passes nothing
keeps what is personal, in the user's words	the decision model gates; Nemotron 3.5 Super VL resolves "it", "those", "up to 400" from the agent's message, then the agent's message is dropped
reads in the quiet	as soon as an entry is kept, beside the conversation, the memory reads it into things, values and links
notes interests	every question of the user's is kept with how often it comes back: what to get ready for next time
keeps topics fresh	a topic without a web update for a month is looked up in the background (Tavily), at most once an hour; what matters is kept in the journal, marked as from the web
protects	secrets are withheld before any model sees them; web queries are made from the topic, the model is told to leave out private details, and code drops any query that holds the name of a person in the memory

What it looks like

Over a month, in passing, inside talks about a calendar, a weekend and a dinner:

The eleventh is my wife Mila's birthday. · Mila hates crowds, a small jazz gig would suit her. · Yes, please (to the agent's "skip the Thai place?") · A quiet evening, just the two of us. · Her mother Vesna may still be staying with us.

Today, in a new session, the user only says: help me plan her birthday evening. Nobody asks the memory anything. The hook passes the message, the memory puts beside it the facts it holds on that matter, and the agent answers: the date, quiet and just the two of them, jazz, no peanuts (Mila is seriously allergic), and Vesna who may be staying.

The same for a number: sums said in passing over weeks (a TV, a soundbar, a washing machine, a plumber; a car service that is not the home), then how much have we spent on the home since October? The memory gathers the facts with their days, and the agent adds them up.

How it works

flowchart LR
    U([User]) <--> A[Agent<br/>Claude Code]
    A -- "hooks: every message,<br/>both sides" --> S["say"]
    A -- "what it needs" --> Q["ask"]
    subgraph M [Memory — memory/]
      S --> I["intake<br/>gate · rewrite · questions"]
      I --> J[("journal<br/>user's words")]
      I --> N[("interests")]
      J -. "in the quiet" .-> W["world<br/>things · values · links"]
      Q --> P["find: words,<br/>meaning, topics"]
      W --> P
      J --> P
      N -. "a topic comes back" .-> R["refresh<br/>questions → queries"]
    end
    R -- "Tavily" --> WEB[(web)]
    R -- "what matters,<br/>marked as from the web" --> J
    P -- "facts + the words<br/>they stand on" --> A

Two doors. say(messages) — what was said, with who said it; with the Claude Code plugin the hooks call it and the agent never does (X-Personal-Hooks: on tells the server so, and it refuses a second copy). ask(question) — the agent's own question: answered with the facts the memory holds on it and the words they stand on.

The intake (memory/intake/) reads one user message with the agent's message just before it — never more: what came earlier the memory already holds. The decision model, shown the last four messages, says whether there is anything personal; Nemotron 3.5 Super VL, thinking, rewrites the message to stand alone and copies its questions out. The prompts are plain files in memory/intake/prompts/.

以上为 README 的开头部分。其余内容请阅读原文。 查看完整 README ↗