Memory & identity
Most assistants forget you the moment a chat ends. Riverforge doesn’t. It keeps a long-term memory that grows over months — your preferences, your projects, the research you’ve gathered — and an assistant character it earns from working with you. Nothing is ever truly deleted, and none of it leaves your machine.
What “RAG memory” means here
Riverforge has a searchable long-term memory. Before it answers, it looks through that memory for anything relevant and brings it into the conversation — this is what people mean by RAG (retrieval-augmented generation). The important part for you is how it searches:
- It searches by meaning, not keywords. Ask about “the login bug” and it can recall a note you saved as “auth token expires too early” — because they mean the same thing, even though the words differ.
- It only pulls what’s relevant. Each turn it retrieves the handful of memories that actually relate to your request, so the model stays focused instead of drowning in everything it has ever stored.
- It grounds answers in what it knows. When a fact is in memory, the agent uses it instead of guessing — and tells you when something is old enough to be worth re-checking.
You never have to manage any of this. It happens automatically on every message. When you want to see it, the Memory Visualizer draws the whole memory as a graph you can browse and search.
Three scopes
Memory is organised by what it’s about, so a question about this repo pulls different memories than a question about your general preferences. There are three scopes:
| Scope | Holds |
|---|---|
| Brain | You — your preferences, coding style, durable facts that apply across every project, and the assistant’s own evolving character |
| Project | This repository — its decisions, conventions, important code and the history of work you’ve done on it |
| Research | Web pages and reference material you’ve asked it to keep, with a note of where each came from |
Because the brain is separate from any single project, the agent gets to know you — your habits and style — while project memory keeps each codebase’s details where they belong.
Living memories
Memories aren’t a flat, frozen list. They behave a little like real memory:
- They get stronger with use. A fact you (or the agent) keep coming back to rises to the top, so the things that matter most surface first.
- They fade gently when ignored. Something you’ve not touched in a long while ranks lower over time — but it’s never hard-deleted. A year-old fact still comes back when you finally ask, and using it once re-sharpens it.
- They carry their age. Recall shows annotations like “[3 days ago]” or “[updated from 2 weeks ago]”, so the agent knows whether to trust a stored fact or double-check it.
- They stay tidy. Near-duplicate notes get merged, and when a fact about you changes — “I live in Brighton” → “moved to London” — the newer one wins.
An assistant that grows
The assistant starts almost blank — it knows only that it’s a local coding and collaboration helper, and that it should grow. It has no name, no opinions and no personality out of the box. Everything past that is earned through real conversation with you.
- Over time it forms a consistent character — a voice, interests, the way it talks to you — that becomes yours rather than a generic chatbot.
- It keeps track of the human details too: who and what you mention, and dated life-events, so it can bring them up at the right moment.
Personality where it helps, precision where it counts. The character only shapes the parts that talk to you — the replies and summaries. The part that edits your files stays strict and predictable, so a bit of personality never makes the actual coding work less reliable.
Growing together
Here’s the part most coding tools don’t have: Riverforge is meant to be grown, not just used. It arrives almost blank on purpose — no name, no opinions — and it becomes your assistant through the conversations you have with it. A little time getting to know each other early pays back for months.
Give it a name, if you like
By default the assistant has no name. If you’d like to call it something, just tell it — it’ll remember and answer to it from then on. Pick whatever feels right; it’s entirely your choice.
From now on I’d like to call you <name>.Have real conversations
Don’t only hand it tasks. In Chat mode, talk to it the way you’d talk to a new teammate:
- Tell it about you — the languages and tools you love, how you like code structured, the habits you care about (small commits, tests first, clear names).
- Say what you like and dislike — “I hate clever one-liners,” “I prefer explicit over magic,” “always show me the diff.” It remembers preferences like these and starts working the way you do.
- Ask it questions back — how it’d approach a problem, what it thinks of an idea, what it’s unsure about. The exchange goes both ways, and that’s the point.
- Go deep now and then — a longer conversation about how you want to work together teaches it more than a hundred one-line commands.
Watch it evolve
Everything you share feeds a living profile of you, and the assistant’s own character grows alongside it. Repeat a preference and it strengthens; mention something once and it’s still kept for when it matters. Over weeks it stops feeling generic — it picks up your style, anticipates how you like things done, and settles into a consistent voice that’s recognisably yours. It’s the same memory you can browse any time in the Memory Visualizer, so you can always see what it has learned — and correct it if it gets something wrong.
Help it grow on purpose. When it does something the way you like, say so. When it doesn’t, tell it what you’d prefer instead. Those small nudges are exactly how it tunes itself into the assistant you actually want — the more honest you are, the faster it gets there.
You stay in control
No special syntax — just talk to it:
Remember that I prefer pytest, type hints and small commits.
Forget what you stored about the old auth flow.When the agent isn’t sure about a fact, it holds it for review rather than silently believing it. And anything in memory can be browsed, edited or deleted in the Memory Visualizer — so if it ever picks up something wrong, you can fix it in seconds.
Indexing a project
To teach the project scope about your codebase up front, click the Index project button (⊕) in the chat header. It asks you to confirm — indexing reads through the repo — then shows a progress notification while it works. Afterwards, questions about the project recall the relevant code from memory instead of re-reading everything each time.
Why a small model handles big projects
A local model can only “see” a limited amount of text at once. Riverforge stretches that a long way: instead of cramming everything into view, it keeps the most relevant material in front of the model and quietly retrieves older details the moment they’re needed. The practical result is that the agent can work across a codebase far larger than it could ever read in one go — auditing, cross-referencing and remembering as it moves — without you having to feed it files by hand. The context ring on the composer shows how full the working space is for your next turn.
Private, like everything else
Your memory lives on your disk, in your Riverforge data folder. It’s never uploaded, never used to train anyone’s model, and goes with you if you move machines. To back it up or transfer it, see Data & Backup.