Connect your agent in a couple of minutes. Then, in plain language: what your memory does for you, how to teach it, and what happens when it fills up.
One account powers every agent you run, on every machine you run it on.
Create your account at brethof.ai/account, open the Memory tab, start the free plan, and create an API key. No credit card.
Pick your platform below. Most of them are one line — and on any of them you can simply say “install brethof-brain” and let the agent do it.
Ask your agent to search memory for anything, even something trivial. A well-formed answer — even “no results” — means you are connected. That is the entire test.
from the Claude Code plugin marketplace — no clone, no pip
native plugin on dsh's own extension points
clone the client repo and run it; then run /hooks once inside Codex and trust the brethof-brain entries
clone the client repo and run it; writes ~/.qwen/settings.json
gateway plugin, straight from the registry
native SDK plugin
one plugin file into ~/.config/opencode/plugins/ — the same adapter serves Kilo Code
the same plugin file into ~/.config/kilo/plugin/ — CLI, VS Code and JetBrains
Installed but seemingly unused? Where a platform has hooks or plugins, memory is pushed to your agent and nothing needs teaching. Where it does not, the agent has to be told to pull — so the setup scripts write a memory section into the platform’s own context file (~/.codex/AGENTS.md, ~/.qwen/QWEN.md). If memory looks connected but the agent never reaches for it, that file is the first thing to check.
Created and revoked in the account panel, with two-factor authentication recommended — and enforced at sign-in once you turn it on. One key can serve many agents on many machines; plans differ only in how many separate keys you can hold. On Business and up a key can be scoped: limited to chosen projects, read-only or read-write. That is the right shape for a contractor or a single-purpose agent.
Just names. Pass a project when saving or searching and it exists from that moment — no setup, no limit on how many, on any plan including Free. Use one per codebase, client or venture. Your agents can search inside one project or across all of them, and a shared layer above them holds the few facts true everywhere.
Nobody summarizes sessions here, and you never run a “save my context” ritual. When you correct your agent on Tuesday, every agent knows on Tuesday.
Each turn your agent completes is archived, and the memory service reads it within seconds: new decisions and facts saved, changed ones updated in place, claims reality has overtaken removed. Nothing has to be filed by hand for the memory to build itself. When you do want something kept on the spot, say so — your agent saves it directly, which is useful when precision matters or a fact belongs to another project.
Saved memory is the current truth — curated, dense, up to date. Conversation history is the complete raw recording of everything ever said. When your agent needs what the team believes now, it searches memory; when it needs the exact error message from three weeks ago, it searches history. Old statements in history are snapshots of their moment. Memory is what is true today.
As you work, memory builds a graph of everything your sessions touch — files, services, tools, decisions, errors — each with its current status. A decision that was later reversed stays in the graph marked as a dead end, so no agent re-proposes last month’s rejected idea. Your agents see the relevant entries automatically when a topic comes up.
Recall is never metered and never stops at a limit. Searching, session-start context, per-prompt recall and graph lookups are not counted against an allowance and you are never billed by the search — on any plan, Free included. Plans meter two things and only two: how much your memory holds, and how much it learns each month. Spend either and what pauses is new recording or new learning — your stored memory goes on answering.
Once the plugin is in, there is no ritual to learn and no command to remember. The best sign it is working is that you stop thinking about it.
What changes is how you talk to your agent. You can now say things like “what did we decide about the payment retries?” or “remember that the staging box is the one with the old certificate” — in plain language, mid-conversation. Your agent picks the right tool; you never name one.
You do not need this list. It is here so you know what is possible when you ask for something specific.
One thing an agent deliberately cannot do: delete an entire project. That single act reaches the raw archive, so it lives in your account panel, where a human types the name.
As your conversations are archived, the Brain watches them for intentions — things you said you’d do and didn’t. Each becomes one row in that project’s ledger: undecided, waiting for you. No statuses, no archive. A row waits, gets dropped, or becomes work.
Say “check the ledger” in any session. Your agent reads the pile and attaches a verdict to every row — done (with the evidence it found), pointless now, still worth doing — and you answer in single words: drop, keep, go. Decided rows are removed on the spot. Fifteen rows takes about two minutes.
For the rows you keep, ask your agent to turn them into goal briefs —
self-contained, one per row — and hand them to your harness’s autonomy
command (/goal in Claude Code, and its equivalents elsewhere). The
harness runs each to completion on its own. Review in the evening; the work happens
while you sleep.
Two habits make it sing. Review often — a pile visited daily stays a handful of rows. And delete brutally — nothing is lost, because an idea that still matters will be said again, get re-filed, and be judged fresh against the project as it is then.
A playbook is a procedure written as a markdown document and stored once for your whole account. Any of your agents, in any project, on any machine, can fetch it and run it in its own environment — the Brain stores and serves; your agent executes.
Ask your agent to save a playbook, and shape it like a runbook: headings for the stages, fenced code blocks for the exact commands, and a one-line annotation saying what it does — that line is what shows up when agents browse the list. Saving under the same name replaces the previous version, so a playbook is always exactly one current document.
“Run the deploy playbook” is the whole interface: the agent fetches it and follows it where it stands. Pair it with a schedule for the full effect — an agent that runs “fetch the weekly-report playbook and execute it” on a cron becomes a job you wrote once in plain English and never look for again.
Everything else your memory holds is found when searched. A rule is different: a standing instruction that loads into every session automatically, without anyone looking it up.
Rules are how you stop repeating yourself — the conventions, constraints and hard-won corrections your agents must never forget. Good ones sound like laws: “never deploy on Friday,” “this project uses tabs, not spaces,” “the client’s name is spelled Brethof, never Brefoth.” Short, absolute, and still true next month.
Ask your agent to save a rule and it is asked exactly one question in return — where must this text live?
A law that binds all your work, everywhere it happens.
A law for one codebase, client or venture.
Useful, but it does not need to be in front of you at all times. Still saved, still found the moment anyone searches for it.
That third option is the important one, and it is chosen more often than the other two. A rule is expensive: it occupies room in every session forever, and it teaches the curator what matters. Filing ordinary knowledge as a rule is exactly how a memory silts up until nothing stands out.
Each project has its own curator deciding what is worth keeping there, and your rules are its syllabus. Save one and, within minutes, that project’s curator has re-learned what the project is and what matters in it. This is why a project with a handful of sharp rules remembers noticeably better than one with none.
Rules are capped in length on purpose — if it does not fit, it is probably knowledge wearing a rule’s clothes. Merge duplicates into one, and delete rules that have gone stale; nothing prunes them for you, because nothing else should be allowed to decide what your laws are. A dozen rules you believe in beat fifty you have stopped reading.
The only real decision is how you slice them: one per codebase, client or venture is the pattern that works. Too few and unrelated work bleeds together; too many and context scatters. Starting a project with a one-sentence purpose — what it is and what should be remembered there — is the single highest-value minute you can spend. It teaches the curator from day one instead of leaving it to infer your intent from fragments.
Your stored memory keeps answering, whatever else is capped. Recall is the one thing a limit never takes away.
Three different things are metered differently, and it is worth knowing which is which. Recording is limited by storage. Learning is limited by your monthly allowance. Recall is limited by neither — searching, session briefings and per-prompt recall keep working for as long as your memory is on our live systems.
Your history keeps being recorded, and all of it stays searchable. Recall keeps working — briefed at session start, matching memory on every prompt, the graph. What stops is learning: no new memories are distilled from your conversations, and the graph stops growing. A top-up pack or an upgrade starts it again.
Nothing new is saved — that is what full means. Recall keeps working across everything already stored, so your agent is still briefed and still remembers what it knew yesterday. Add storage or move up a plan, and recording resumes where it left off.
No recording, no learning — and recall still works. If you hear that your Brain is off, it is off for new memory only. Everything already in it answers exactly as it did before, and your agent goes on using it.
The Brain pauses immediately — there is no grace period. Your stored memory still answers, though, right up until it moves to cold storage on day 7. After that recall stops because the memory is no longer on live systems: physically, not by policy. Day 30 is deletion. The full schedule, and the emails that come with it, are in the Privacy Policy.
While a limit is biting, no new memories are distilled. That leaves a gap in your memory covering that period, and we do not go back and fill it in afterwards. That is a deliberate design law, and you should know it.
A memory is only ever made from a conversation as it happens. A record written later, from material already weeks old, would overwrite what has been true since — and your memory would start confidently asserting things that stopped being true. We would rather leave a hole than manufacture a confident lie.
So, plainly: the gap is permanent as memory. Your raw conversation history from that period is still there and still searchable, so the record is not lost — only the distilled layer has the hole. The longer a limit runs, the further your memory drifts from the work you are actually doing. And it does not repair itself when you resume: your agent corrects outdated memories as it meets them, and the weekly reconciliation compares your memories against each other, retiring the ones your newer memories contradict. Both of those run forwards, never backwards.
Nobody is cut off quietly. You get an email as you approach a limit and another when it bites, a notice inside your agent’s session when it starts, and a short line on every prompt while a limit is active. The 90% warning threshold is yours to set in your account, or to turn off.
Ask your agent to clean up a project’s history older than some cutoff (90 days minimum — recent history is what memory works from, and nothing inside it can be removed by anyone). Delete removes the old raw history outright and is free; summarize first compresses each old conversation into a permanent memory before removing it, and the preview shows exactly what that costs from your monthly allowance. Saved memories are never touched, and freed space lowers your metered storage.
Upgrades apply immediately. Downgrades apply once your memory fits the smaller plan — prune, or keep the add-on until it does. Nothing is ever deleted by us, on any plan change.
Yes. Your memory lives in its own isolated database, encrypted at rest and in transit. Nobody else’s agents can reach it, and we do not train on it. Stored, indexed and searched in the EU. The one thing that leaves is the curation pass, to a provider whose published terms commit that inputs and outputs are transient and never trained on — the security page sets out exactly what goes and what never does.
That is the point. Every agent using your keys reads and writes the same memory, kept consistent turn by turn — five agents on one project see one truth. Scoped keys, on Business and up, let you give a person or an agent access to only chosen projects.
Claude Code, Codex, Qwen Code, OpenClaw, DeepSeek Harness (dsh), Cline, OpenCode and Kilo Code. A platform is listed only when the whole loop works there — briefed at session start, matching memory pulled in on every prompt, and the conversation archived. There is no half-supported tier, because a half-working platform would be somebody’s only platform. More are wired and waiting on vendor accounts; they appear here the day they are proven, not before.
No. Everything — embedding, curation, search — runs inside the service. One brethof-brain key is all any agent needs.
Yes — ask your agent, or use your account panel. Those are the two doors into your memory, and deletion works through both. Some of it is deliberately limited: the protections that stop an agent erasing your past apply to you as well, and the Security page sets out exactly where the lines are. For full account deletion, write to [email protected].
Each project’s pile of undecided intentions — things you said you’d do in conversation but didn’t. Ask your agent to “check the ledger”, decide each row in a word, and turn the keepers into goals your agents execute. The section above has the detail.
No credit card, and the brain is the same brain the biggest plan runs. Only the size of the memory and the pace of its learning differ.
Local speech-to-text that learns your voice. Perpetual licence. Our flagship.
PAID · flagship
Long-term memory for your AI agents — full-text + vector + graph. Briefed at session start, recalled on every prompt, archived automatically.
PAID · free tier
Print-ready digital models. GLB and OBJ included. Lifetime access.
PAID · digital catalog
Five printers and real capacity. No self-serve shop yet — tell us what you need and we quote it by email.
BY ARRANGEMENT · email us
Our YouTube channel. A cyber-tiger host walks through local AI tools and what they actually do.
CHANNEL · live
Curated GitHub lists for AI coding agents, MCP servers, local AI and Linux for AI. Every entry carries a source link.
FREE · curated
Long-form how-tos for local AI on Linux, Windows and macOS, with the configuration files included.
FREE · live
Negative-curation: practices and tools that waste your time, ranked. Receipts required.
FREE · live
Who we are, why we build privacy-first AI, and what we won't do.