DEV Community: BrethofAI

What changes in your working day when your agent stops forgetting

BrethofAI — Wed, 14 Oct 2026 22:16:20 +0000

You open a session with your agent the way you open a hundred others. Before any real work: the stack, the conventions, the decision from last Tuesday about why the auth flow is the way it is, the thing you tried in March that didn't work. You paste it in, or you point the agent at a markdown file you maintain by hand, or you type "as I discussed before" and hope. Then you work. Then the session ends and everything you spent establishing is gone.

If you run an agent daily, this is your routine, and you've stopped noticing it's a routine. "Save context" before closing. A CLAUDE.md you edit like a wiki nobody owns. Five md files of notes that are really just a memory you're operating by hand, for software that costs more than your editor.

Here's the strange part. The smartest tool on your machine is the only one that remembers nothing. Your editor remembers your settings. Your terminal remembers your history. Your agent — the thing that costs the most to brief — starts from zero every morning, and you've made peace with it.

We hadn't. We tried the fixes on offer, they all failed the same test, so we built one that doesn't. This is what it is, what it does on an ordinary Tuesday, and the one sentence that installs it.

Three things that were supposed to fix this

Judge every memory tool by one question: when the next prompt arrives, what does the agent actually know? Not what's stored. Not what's findable. What's in front of the model, right now.

Markdown files — CLAUDE.md and its cousins. Loaded once at session start, then frozen. Whatever you write there on Tuesday is what the agent believes all week, and nobody maintains the file because maintaining it is the same manual chore you were trying to escape. Within a month it's a junk drawer: three conflicting instructions, a stack list from two projects ago, a note-to-self that stopped being true. A snapshot, not a memory.

Memory tools the agent has to call. These store things well. But they wait to be asked: nothing arrives before the agent answers unless it decides, mid-turn, to search, and remembers to. And at session end the handover is whatever the next session thinks to ask about. A library you have to remember to use is not a memory.

Search hooks. The better ones do push something with every prompt: a few snippets of raw text that matched. That's real injection, and it's still not enough — snippets are retrieval, not briefing. They find fragments. They don't carry your standing rules, don't reconcile a fragment against what you decided later, and don't come with a reason attached. The agent gets a search result; it doesn't get told what's true.

All three fail the same way: the knowledge exists somewhere, and the moment of the prompt — the only moment that matters — gets nothing, or almost nothing.

The test, then

A working memory has to answer at three moments:

Session start. A brief, before you say anything: where we left off, the rules in force, what's next on the plan.
Every prompt. The records that bear on that specific prompt, arriving with it — without dumping the whole memory into your context window every turn.
"Why is it like this?" The decision, the date, the reason, and the option it beat — in the words of the conversation where it happened.

That's the spec. Everything else is implementation detail.

One working day with a brain instead of a memory

We run our own company's work on our own memory — it has run our estate since December 2025, archiving every conversation since April. This isn't a demo script; it's Tuesday.

Morning. Start the machine, open the session, say "continue." The brief is already there — the last session's handover note, the project rules, the next lines of the plan, an index of the playbooks for this project. No re-explaining. No "quick recap of the repo." The session picks up the top line of the plan and starts.

Midday. Each prompt arrives pre-briefed. Not with everything — with the records that bear on that prompt, and nothing else. When I ask about the rate limiter, the memory of the rate limiter conversation comes with the question. I stopped keeping md files in March and haven't missed them; there's no "save context" ritual because there's nothing to save — curation happened while we were talking.

Afternoon. Two agents on one project: one on the front end, one on the back end, each with its own key, working from one memory. Neither has to be told what the other decided — once the front-end conversation is curated, the back-end agent's next prompt that touches it carries what was settled. Later, the front-end agent suggests an approach for the settings page, checks the memory, and the answer is already there: that option was rejected in March, here's the day, here's the reason, in the words of that conversation. Nobody re-litigates a dead option because nobody forgot it was dead.

Everything above happens by saying it. I never file anything, never call a save tool, never run a sync. The agent manages the memory because the memory shows up in its context before it needs to be managed.

One honest trade: injection costs context. A brief and per-prompt records occupy tokens — that's what injection is. What you get back is tool calls, turns and hunting. On balance, that trade has been lopsided in our favor for months.

Why this one is different under the hood

Three layers, with different jobs:

Curated records are the truth of now. The memory reads your conversations in windows of five exchanges and keeps what the conversation settled — reconciling new facts against old ones, quietly retiring records that describe something you replaced. You never file anything; there's nothing to file.
The decision graph is how it got there. Every decision a line: dated, with its reason as it was said, and the option it beat. Reversals are new lines — history is never rewritten, so "why is it like this" always has an answer.
The full history is everything, kept in full and searchable by keyword or meaning. Records are what's true; the graph is what happened; the archive is the floor under both.

Two details that matter in practice:

Projects are walled off. Each has its own records, rules, graph and plan; nothing bleeds between them unless you call a cross-project search yourself. On hosted memory, scoped keys let you hand a teammate, a client or a subcontractor access to exactly the projects you choose — read-write, read-only or invisible — and nothing else.

Rules can't rot into a junk drawer. Each one is capped, the pool is capped, you're warned at 80%, and a save that would overfill is refused with the fix. Nothing you wrote is ever quietly trimmed or dropped.

And the privacy line, because it's the reason we built it this way: your memory lives on your machine (a local container, stored there and nowhere else) or in our cloud, encrypted. Our hub processes pieces of it to make memory and compose briefs, and keeps none of those pieces.

Why believe us

Because we run on it. Our own company's work has gone through it every day since December 2025. Before that it was md files, and almost everything from those months is lost — which is the whole argument in one sentence. Every conversation since April is still there, searchable.

And because of how it started. I tried most of the memory systems for AI agents. Each did a part of this, and none did what I needed. So I built the one that does.

Say one sentence

You don't need IT knowledge for this. The install is one sentence to your agent: "install brethof-brain." It fetches the client, wires the hooks, and checks its own work. The only human steps are the ones every application on earth asks for: sign up and choose local or hosted. On local, you approve a short code on brethof.ai and no key is ever shown, so your agent can run the whole install. On hosted, you copy your key and paste it once, with your passphrase, into a small window on your own screen, so your agent never sees either. Free to start, and it works with Claude Code, Codex, OpenClaw, Hermes and the other harnesses you're probably already running.

If you've read this far, you've accepted re-explaining as part of the job. It isn't.

Start at brethof.ai/brain/ — and tell your agent: install brethof-brain.

If you end up writing about it yourself, we run an affiliate programme — details at brethof.ai/brain/affiliate/.

Stop prompting. Start conversations with your agent.

BrethofAI — Tue, 13 Oct 2026 13:04:28 +0000

You have a folder. Somewhere in your repo or your notes app there is a growing pile of prompt templates: the system snippet, the codebase preamble, the style rules, the "always run tests before committing" reminder you paste in because the last agent forgot. Every session starts with the same ritual — copy, paste, re-explain, restate, and hope nothing drifts by turn ten. And every time the pile grows, it feels like progress. It is not. It is a symptom.

I ran that ritual for months. We stopped in December 2025, when our own agents started running with a memory system behind them — the same one we now ship as brethof-brain. Since then, not a single pasted preamble. This is what the shift actually looks like, including the part nobody tells you: the first week, when you drop the templates, is uncomfortable, and here is exactly how it goes wrong.

Why prompts can never be good enough

A prompt is a one-shot brief for a stateless session. That is the structural problem, not a skill problem. The rules that should hold forever — how commits are worded, which tests matter, what was already tried and rejected — get re-argued from zero every time you open a new session. So you write the prompt longer. Then it hits the point where the agent skims it, or the task drowns the rules, or the session drifts anyway and you start over.

The fix is not better prompt-writing. It is taking two jobs out of the prompt entirely:

Standing rules that bind every session automatically. Written once, loaded with almost every message, never re-pasted.
A brief composed before each prompt from whatever in the memory bears on what you are asking right now.

Once those exist, the prompt only has to carry the task. Everything else is already there when the agent answers. A prompt was never meant to be a memory; it was just doing the job because there was nothing else to.

What conversation looks like instead

The difference is easiest to see on a Tuesday morning. I open a session and type "continue" — and it is. The agent has the notes from where the last session stopped and the next lines of the project plan, so it picks up mid-task. No recap, no "here's the codebase structure", no five-bullet orientation message I used to spend the first ten minutes of every session writing.

The second difference shows up when I want a change. Instead of a template, it is a sentence: "the deploy script should always run the migration check first." Said once, deliberately, and it is a rule from then on — I have never restated it since. When a prompt touches a rule, the rule arrives with the prompt; I am not trusting the agent to remember, the briefing happens before it starts answering.

The third is the one that saves real money in tokens and real minutes in patience: the agent stops re-proposing things I already killed. The record that replaced the old idea arrives with the prompt, and when it digs, the rejection itself is there with its date and my reasoning. Nobody argues with a decision I made in March for the fourth time.

That is what "conversation" means here. Not chat for its own sake — it means the prompt stopped being a brief, because the brief is composed for it, every time, automatically.

What breaks when you first drop the templates

Here is the honest part, because the first week taught us more than the months since.

You reach for the preamble out of habit. The first few sessions after dropping the templates feel loose. Something is missing and you cannot name it, so you paste the old preamble "just in case." It was dead weight by then; the standing rules covered it. The habit broke around session five.

Rules need writing down once, deliberately. The memory does not read your mind. The stuff in your old templates — the conventions, the tone, the never-do-this list — has to be stated as rules, on purpose, once. If you skip this step and expect osmosis, you will have a bad first day and blame the wrong thing. Budget an hour.

Rules can rot into a junk drawer if you let them. We watched ours creep: near-twins, a stale one from a finished project, one that had grown into three paragraphs. This is why ours are capped at 1,000 characters each, and the memory points out twins and says when the rules are getting big — it never edits or deletes them for you. You do not need our caps, but you need some discipline: when two rules say the same thing, merge them.

Memory is not instant. An exchange becomes a record after the conversation settles, not the second you say it — the memory reads in windows, so it keeps what the conversation settled rather than every half-thought. The failure mode is saying something in session three, assuming it is now canon, and being surprised in session four. The fix: when it matters now, say it on purpose. When it matters eventually, let the curation catch it. Knowing which is which is most of the skill of talking to an agent that remembers.

How to make the switch

In order, runnable today:

Get the memory in place. Tell your agent: "install brethof-brain." That is the whole install — it fetches the client, wires the hooks, and checks its own work. You do the one human step: sign up, choose local or hosted, and approve the connection on brethof.ai when the installer asks.
Write your standing rules once. Empty your preamble folder into explicit rules before you delete it. General ones for everything; project-specific ones per project.
Stop pasting. Deliberately. Open the next session with just the task and see what the briefing already covers. You will find it covers more than you expected and misses exactly the things you never wrote down — which brings you to the test.
The test: whenever you catch yourself re-explaining something, that is not a prompt to write. It is a rule to save. Say "remember this" and move on.

The prompt pile was never a craft problem. It was a memory problem wearing a craft costume. Teach your agent once and stop gatekeeping it.

Disclosure: I build brethof-brain. How it works, in one page: https://brethof.ai/brain/how-it-works/

I tried most of the memory systems for AI agents. None did what I needed, so I built one.

BrethofAI — Sun, 11 Oct 2026 16:04:07 +0000

We hadn't. We tried the fixes on offer, they all failed the same test, so we built one that doesn't. This is what it is, what it does on an ordinary Tuesday, and the one sentence that installs it.

Three things that were supposed to fix this

Judge every memory tool by one question: when the next prompt arrives, what does the agent actually know? Not what's stored. Not what's findable. What's in front of the model, right now.

All three fail the same way: the knowledge exists somewhere, and the moment of the prompt — the only moment that matters — gets nothing, or almost nothing.

The test, then

A working memory has to answer at three moments:

Session start. A brief, before you say anything: where we left off, the rules in force, what's next on the plan.
Every prompt. The records that bear on that specific prompt, arriving with it — without dumping the whole memory into your context window every turn.
"Why is it like this?" The decision, the date, the reason, and the option it beat — in the words of the conversation where it happened.

That's the spec. Everything else is implementation detail.

One working day with a brain instead of a memory

We run our own company's work on our own memory — it has run our estate since December 2025, archiving every conversation since April. This isn't a demo script; it's Tuesday.

Afternoon. Two agents on one project: one on the front end, one on the back end, each with its own key, working from one memory. Neither has to be told what the other decided — the back-end agent's next prompt carries what the front-end conversation settled. Later, the front-end agent suggests an approach for the settings page, and the memory answers for me: that option was rejected in March, here's the day, here's the reason, in the words of that conversation. Nobody re-litigates a dead option because nobody forgot it was dead.

Why this one is different under the hood

Three layers, with different jobs:

Curated records are the truth of now. The memory reads your conversations in windows of five exchanges and keeps what the conversation settled — reconciling new facts against old ones, quietly retiring records that describe something you replaced. You never file anything; there's nothing to file.
The decision graph is how it got there. Every decision a line: dated, with its reason as it was said, and the option it beat. Reversals are new lines — history is never rewritten, so "why is it like this" always has an answer.
The full history is everything, kept in full and searchable by keyword or meaning. Records are what's true; the graph is what happened; the archive is the floor under both.

Two details that matter in practice:

Why believe us

And because of how it started. I tried most of the memory systems for AI agents. Each did a part of this, and none did what I needed. So I built the one that does.

Say one sentence

You don't need IT knowledge for this. The install is one sentence to your agent: "install brethof-brain." It fetches the client, wires the hooks, and checks its own work. The only human steps are the ones every application on earth asks for: sign up, choose local or hosted, copy the key, and paste it once into a small window on your own screen, so your agent never sees it. Free to start, and it works with Claude Code, Codex, OpenClaw, Hermes and the other harnesses you're probably already running.

If you've read this far, you've accepted re-explaining as part of the job. It isn't.

Start at brethof.ai/brain/ — and tell your agent: install brethof-brain.

If you end up writing about it yourself, we run an affiliate programme — details at brethof.ai/brain/affiliate/.

Your AI agent can install its own memory. You don't need a terminal.

BrethofAI — Tue, 06 Oct 2026 23:55:22 +0000

You've been here before. You find a tool that would genuinely fix the thing that annoys you — your AI agent forgets everything between sessions, so you explain the same project, the same preferences, the same decisions every morning. You open the install guide and hit a wall: pip install, config files, something about "hooks", a warning that assumes you know what a hook is. You close the tab. Not because you're incapable, but because the tool was written for somebody else.

This is the pattern for nearly every developer tool on the internet: a wall of commands, and an unspoken assumption that a human types them. If you can't run terminal commands, the tool is effectively not for you — no matter how much you need it.

The assumption is wrong, and it's worth seeing why before we show you the exception.

Someone has to do the installing — it doesn't have to be you

Look at what that wall of commands actually asks of a person: fetch some code, put it where the agent can find it, connect it to the agent, run it once to check it worked. Every one of those is a thing your AI agent already does all day. It fetches things. It edits files. It follows instructions and reports back. Installing a tool is, frankly, an easier job than the ones you already give it.

The reason you'd ever type those commands yourself is history: most tools were built before agents, by developers, for developers, and nobody revisited the assumption. The natural order is that you describe the outcome — "install this memory tool" — and the agent does the work, the way it does everything else you ask.

That's not a hypothetical. It's how our memory tool is installed.

How it actually works: two human steps, one sentence

The tool is called brethof-brain. It's a memory system for AI agents — your agent remembers you across sessions, projects and machines. Here is the entire install, end to end.

Your part, first. Sign up on the site, choose your edition and copy your key from the panel (the hosted edition also asks you to set a passphrase). That's the whole account part — registering and clicking a button, which is what every application on earth asks of you. It is not IT knowledge.

Then your part, spoken. You open your agent and say:

Install brethof-brain.

It does the rest: it fetches the client, wires the hooks into your harness, and checks its own work. Once, a small window opens on your own screen where you paste the key (and, on hosted, your passphrase), so your agent never sees either. You never open a terminal. You never read a README. If something needs deciding, it asks you in plain language, the way it would for any other task.

We're specific about where the human steps end because it matters: they end at that window. There is no "and then it helps to have someone technical nearby." That caveat would be a lie dressed as modesty.

What you get the morning after

You start your PC, open a session, and say "continue." The agent already knows what you were doing — what you decided yesterday, what you prefer, where things stand. You don't re-explain. You just carry on.

This is also where the memory earns its keep over time. Your agent stops re-proposing the thing you rejected in March, because the line saying so — with the day and the reason — comes back with its search. When you ask "why is it like this?", the answer is in the words of the conversation that decided it. And if you change your mind, the reversal is a new line; the old way stays on record as the old way.

You also stop maintaining the pile of notes some people keep to remind their agent who they are — the folder of markdown files that grows until it's a jungle nobody can navigate. There are no files to tend. The memory keeps itself; every session opens with your agent already briefed. You don't manage anything. You talk, it remembers.

But I don't run servers — which edition, and what's on my machine?

Two editions, and you pick by comfort, not by skill:

Hosted. We run everything. No container, no disk space, no setup beyond the passphrase you set at signup. Nothing to run on your machine at all.

Local. Your memory lives on your own machine and nowhere else — we process it, we never store it. This does mean something runs on your computer: a single container, a self-contained box that holds your memory and its search. Your agent installs it, not you. You never configure it.

If "a container on my machine" sounds alarming and "we run it" sounds restful, pick hosted. If keeping the memory on your own disk matters to you, pick local. Both are installed by the same sentence.

Try it: the whole thing is one sentence

Install brethof-brain.

Start free. If it works, you'll know by the second morning, when you say "continue" and it simply knows.

We built it this way because of a conviction we keep coming back to: AI should do the work for the human. Installing the tool that gives your AI its memory is work for the AI.

Disclosure: I build brethof-brain. How the install works, and the free plan (500 messages a month, no card): https://brethof.ai/brain/install/

If you ever want to recommend it, we run an affiliate programme through Lemon Squeezy: commission on every sale you bring, paid to you by Lemon Squeezy directly. Sign-up: https://brethofai.lemonsqueezy.com/affiliates

brethof-brain launches today: memory for AI agents that is already there when the session starts

BrethofAI — Tue, 06 Oct 2026 07:15:01 +0000

Every session starts from zero

If you run an AI agent, you already know the ritual. You open a session and re-explain the project: what it is, what was decided, what was rejected, why the build works the way it does. Some people keep this in md files — a CLAUDE.md here, a notes file there — and soon the agent is lost in an md jungle, reading stale half-truths from March alongside the things that are true today. Either way, you are the memory. You retype the same context a thousand times a day, and the agent repays you by re-proposing the approach you killed months ago, because nothing told it not to.

The models are getting smarter every month. But a model without memory meets your project fresh every morning. Without memory, they're all dumb — the intelligence is wasted on re-deriving what you already told it.

What memory should actually do

Before describing ours, here is what a fix has to pass. Three tests.

Already there when the session starts. A brief opens every session — where things stand, what was settled, what comes next — and on every prompt, the records that bear on that prompt arrive with it. No tool calls. No turns spent hunting through files. If the agent has to go looking, the memory isn't memory, it's a library with bad opening hours.

It keeps what the conversation settled. Not every half-thought on the way — what the exchange actually concluded. A memory that archives noise is a junk drawer with a search box.

It remembers decisions, not just facts. Records keep what is true now. But "why is it like this?" needs the history: every decision dated, with its reason and the option it beat. History never rewritten — a reversal is a new line, and the old way stays on record as the old way.

I tried most of the memory systems for AI agents. Each did a part of this, and none did what I needed. So I spent almost a year building the one that does.

Meet brethof-brain

brethof-brain is memory for AI agents that is already there when the session starts.

It works in layers, because a memory is more than a transcript. The full chat history — every session kept in full and searchable by keyword or by meaning. Curated records — the current truth of each project, which the memory builds itself by reading your conversations in stretches of five exchanges: it keeps what the conversation settled, reconciles new facts against old ones, and you never file anything by hand. Rules — standing instructions, yours, loaded with most messages, so every agent on every project works the same way. Playbooks — a procedure written once as markdown, run by any agent on any project the same way every time.

Under the records sits the graph of decisions: every decision dated, with its reason, what it replaced, what was tried and rejected along the way. When your agent suggests the thing you rejected back in March, the line saying so — with the day and the reason — comes back with the search. And the Ledger quietly catches the things you said you'd do, so they're reviewable instead of lost. Check it. You'll find the ideas you thought about and never implemented.

No "save my context" ritual. Nothing to remember. You start a session and say "continue," and you carry on. You can run ten projects at once, each walled off — its own records, rules, graph and Ledger — and nothing bleeds between them. One memory serves many agents: one on the front end, one on the back end, or one building and a second checking its work with the whole record in front of it. Your agent never re-proposes what you already killed, because the memory carries the kill.

Why we built it

We built it because we were the problem. We were fed up explaining the same thing to our agents a thousand times a day. We were lost in the md jungle ourselves. We started in December 2025 with md files, and almost everything from those first three months is gone — that is what md files do. In March we moved it onto a database, and every conversation since April is still there, searchable. Our own days run five to seven projects with several agents in parallel on one shared memory — this product was not tested on a demo tenant, it is proven every working day on its own makers, and it has been running since December 2025.

Two convictions drove the design. Teach your agent, don't gate it — memory should make the agent smarter, not add steps between you and it. And AI should do the work for the human. We try to do the work for you.

What stays private

One choice at signup, and it decides where your memory lives.

Local: the memory — records, archive, graph, search — lives in one container on your own machine. We process it; we never store it. When a piece of memory needs judging or a session needs its brief, your box sends that piece to our hub, and the hub keeps none of it.

Hosted: the whole memory is encrypted under a key derived from a passphrase only you set and hold. It unlocks when you start a session and locks itself after a short idle period. While locked, it is ciphertext to everyone, including us — forget the passphrase and no one can open it.

The hub processes pieces and stores none of them. What it holds durably is small and dull: your standing rules and one line per project saying what the project is. Processing runs in a secure instance in Zurich, Switzerland, in a Tier III+ datacenter. The model that does the thinking is bound by contract — the provider's commitment, not our guarantee — not to log, retain or train on what passes through.

You own the data. On hosted memory, export the whole history, delete a project, redact an exact phrase, or delete the account, from the panel; a local memory sits on your own disk, in your own hands. And because the client is source-available, not just trusting black boxes: you can read every line of it and see exactly what leaves your machine.

How to start — free

The install is the least work of any developer tool we know, because you barely do it: tell your agent "install brethof-brain." It fetches the client, wires the hooks, and checks its own work. You need no IT knowledge.

The one step a human does: sign up — email, GitHub or Google — choose local or hosted, copy the key. The install opens a window on your own screen where you paste it, and for hosted your passphrase, where your agent never sees either. That's it.

The free plan gives you 500 messages a month, no card. At the limit, the memory stops learning but keeps serving: the session brief, the per-prompt records, every search and the full history keep working — recall is never metered.

It runs on twenty proven platforms, each installed clean-machine and green in our rig: Claude Code, Codex, Qwen Code, OpenCode, Kilo Code, dsh, OpenClaw, Hermes Agent, GitHub Copilot CLI, Pi, CodeBuddy, Devin CLI, Kiro CLI, Qoder CLI, goose, Gemini CLI, Antigravity CLI, Cline, Amp and MiniMax Code.

If you were going to tell people about it anyway, we run an affiliate programme: brethof.ai/brain/affiliate/.

That's the whole pitch. Open a session, tell your agent "install brethof-brain," and the next session starts with your agent already briefed.

brethof-brain launched today, 6 October 2026. Start free at brethof.ai/brain.

The local voice stack that beats the cloud at its own benchmarks

BrethofAI — Mon, 25 May 2026 20:57:05 +0000

Brethof Voice Pro 2.0 — offline voice-to-text and 38-language translation, 100% on your machine.

Every major dictation tool — Dragon, Otter, Google, Apple, the cloud transcription service of the week — captures your voice on your machine, streams it to a data centre, transcribes it there, and sends text back. Sometimes the audio is stored. Sometimes it trains a model. Sometimes it's 'anonymised', a word that stopped meaning much years ago.

Watch what people actually dictate and you see why that matters: medical notes, legal drafts, interviews with named sources, therapy summaries, deal memos, personal journals. The most sensitive text a person produces — uploaded by default, often against HIPAA, GDPR, or plain decency, because there was no alternative.

Brethof Voice Pro is the alternative, and 2.0 is the release where 'local' stops being a compromise: it transcribes, translates, dictates into any app, and trains on your own voice — all on your hardware, with no cloud mode to forget to switch off.

The engine: GGUF + llama.cpp, 5–7× faster than Whisper

Voice Pro runs Qwen3-ASR on llama.cpp with GGUF-quantised models. What that buys you:

5–7× faster transcription than Whisper, with a ~400 ms cold start — weights are memory-mapped, so the first hotkey press after a reboot is already listening.
An 83 MB install on Windows (161 MB on Linux) — one binary that runs on CPU, NVIDIA, AMD, and Intel GPUs via Vulkan. No CUDA-only lock-in, no runtime wheels to match to your hardware.
A genuinely state-of-the-art base model. Qwen3-ASR posts 1.84% average word error rate across a 10-language test and 4.5% on English — where OpenAI's Whisper Large-v3 sits at 7.4%. Its language identification is 97.9% accurate across 30 languages, vs Whisper Large-v3's 94.1%.

Smaller, faster, and more accurate than the model everyone benchmarks against — running entirely on your box.

What's new in 2.0: offline translation

The headline feature is translation that never leaves your machine, across 38 languages, powered by Tencent's Hunyuan-MT2 (open-sourced May 2026). It earns the billing: the Hunyuan-MT line took first place in 30 of 31 categories at WMT25, and MT2 is a step beyond it — its translation quality is comparable to Google Gemini 3.1 Pro on the FLORES-200 benchmark (XCOMET-XXL), in a model small enough to run on your own GPU.

We benchmarked both tiers ourselves — COMET-22, higher is better, across EN↔Polish, EN→Chinese, German, and Arabic:

Tier	Size on disk	COMET-22
Fast (1.8B)	~1 GB	87.6
Quality (7B)	~4.3 GB	89.0

Both run locally — sub-second on a GPU, and the Fast tier is sub-second even on CPU. Because the engine gives us per-engine device control, you can run ASR on one GPU and translation on another, or pin the 7B model to CPU on a VRAM-tight laptop.

Translation shows up everywhere transcription does:

Transcribe popup — a 'Translate to' dropdown on file, mic, and system-audio capture.
Voice keyboard — pick one or several targets; it types the translation (one per line, inline, or primary-only).
Subtitle translator — translate every cue of an SRT/VTT, keep the timings, optional bilingual mode (source line with the translation beneath).

The core, end to end

Transcription takes three inputs in one popup: an audio or video file (drag-and-drop; it pulls the track out of mp4/mkv/mov/webm and a dozen more formats), the microphone, or system audio — whatever is playing on your speakers, so you can capture a meeting, a browser tab, or a video. Output is plain text or SRT with timestamps; add the optional Forced Aligner for word-level timestamps.

Good for: transcribing interviews, turning a recorded talk into subtitles, capturing a call you're in without a bot joining the room.

The voice keyboard is push-to-talk dictation into any focused app. Default F9, hold-to-talk or toggle, optional right-mouse trigger; it injects text at the OS level — editor, browser, terminal, chat box. Turn on live translation and you speak English while it types Polish.

Good for: dictating commit messages into your IDE, replying in a language you read better than you write, drafting hands-free.

Hotwords do two jobs from one field: they bias ASR toward your brand names and jargon (so 'VFIO' stops becoming 'VEAF1'), and they pin terminology for the translator. Noise reduction (DeepFilter) is included but off by default — it hurts quality on short clean clips, so it's there for noisy rooms when you need it.

Train it on your own voice — and beat the big model

This is the part the cloud can't do. Every time you correct a misheard word, the audio-and-correction pair is saved to a local dataset, and the main window shows your running sample count. One click runs a LoRA fine-tune (it auto-selects an NVIDIA CUDA backend if you have one, CPU otherwise), then merges and exports the result to GGUF — and you switch to your personal model right from the main screen.

Does it actually work? We fine-tuned the small 0.6B model on about 11 hours of Polish. It scored 6.10% WER — beating Whisper Large-v3's 8.40% on the same audio. A model a fraction of the size, adapted on-device to one language and voice, out-performing the big general model. Nothing left the machine to get there.

Good for: strong accents, field vocabulary (medical, legal, engineering), or simply grinding your error rate down over a few weeks of normal use.

For developers: the MCP server

Voice Pro ships as a Model Context Protocol server — 19 tools exposing ASR and translation to any MCP agent: Claude Desktop, Claude Code, Cursor, Cline, OpenClaw, Hermes. Same binary, just --mcp; transport is stdio, so there's no port, no localhost binding, no firewall prompt:

{
  "mcpServers": {
    "brethof-voice": { "command": "brethof-voice", "args": ["--mcp"] }
  }
}

Now your agent can transcribe files, record and transcribe the mic, translate text and SRTs, switch compute devices, and manage voice profiles — locally, with no API keys and no per-minute billing. 'Transcribe this interview and give me a German SRT' becomes a fully offline operation.

Good for: agent pipelines that process audio without shipping it to a third party, batch subtitle jobs, and voice-driven tooling you actually control.

Languages, stated honestly

No rounded-up number:

Transcription: 30 selectable languages + 22 Chinese dialects the model recognises automatically (52 languages and dialects in total), plus auto-detect.
Translation: 38 languages via Hunyuan-MT2.
23 languages work in both directions — speak it, see it written, then see it in any of the others.

They don't perfectly overlap (ASR handles Danish, Greek, Finnish, and Swedish that translation doesn't; translation handles Hindi, Bengali, Tamil, and Ukrainian that ASR doesn't surface), so the feature tour publishes the full per-language table with a tick in each column. No asterisks.

The privacy guarantee

No cloud mode. There is no toggle to send audio to a server for better accuracy. Your CPU or GPU is the only option.
No telemetry. No usage stats, no crash phone-home. The only network calls are a license check, an update check, and the model downloads you trigger — all documented, all disableable.
Audio never hits disk. The buffer lives in RAM during transcription and is freed the moment the text is produced. Nothing to leak, nothing to recover.

Your voice is the most personal data you generate. It shouldn't leave your machine unless you explicitly send it somewhere. That isn't a tagline — it's why the product exists.

Platforms

Linux x86_64 — Ubuntu 22.04+, Fedora 38+, Arch, Debian 12+, CachyOS, openSUSE; X11 and Wayland; a single portable binary, no install.
Windows x64 — 10 (21H2+) and 11; per-user graphical installer, no admin rights.
macOS — not yet; on the roadmap, no ETA.

It runs CPU-only on 8 GB of RAM with an AVX2 chip. For GPU acceleration you need Vulkan 1.2+ drivers — which means NVIDIA, AMD, and Intel Arc all work from the same build, not just CUDA cards.

Try it

Pay once, own it forever — no subscription. There's a 14-day free trial with every feature unlocked and no credit card. Download for Linux or Windows at brethof.ai/voice.

Local. Private. Slightly opinionated.

Don't summarize your memory — search it

BrethofAI — Fri, 22 May 2026 15:54:00 +0000

Every long session with an AI coding agent eventually hits the same wall: the context window fills up, the conversation gets compacted, and a summary takes the place of what actually happened. Summaries are lossy by design. The decision you made three sessions ago, the reason you ruled out approach B, the exact path you fixed last Tuesday — quietly gone, because something decided they weren't important enough to keep.

I got tired of re-explaining my own project to my own assistant. So I built brethof-mind: long-term memory for Claude Code (and Claude Desktop), built on SurrealDB. The core idea is in the title — instead of summarizing your history down to fit, keep all of it and search it.

It's open source (MIT), runs 100% on your machine, and talks to no external API.

🔗 https://github.com/BrethofAI/brethof-mind

Two memories, not one

Most "memory" tools give you a single bucket of notes. brethof-mind keeps two layers, because they answer different questions:

Curated memory — the things you decide are worth pinning: architecture decisions, locked rules, project status, bugs and their fixes. Small, high-signal, hand-or-agent-curated.
Full chat archive — every session you've ever had, stored verbatim and searchable. This is the safety net: when a summary would have dropped a detail, the raw exchange is still there to retrieve.

The curated layer answers "what did we decide?" The archive answers "what did we actually say back in March?" Together they mean a compaction is no longer a memory wipe — it's just the working context shrinking while the real record stays intact.

Three ways to search

Different questions want different retrieval. brethof-mind exposes all three over MCP:

Full-text (BM25) — when you know the words. SurrealDB's full-text index, lowercased + stemmed.
Vector similarity (HNSW) — when you know the meaning but not the words. Embeddings come from fastembed (all-MiniLM-L6-v2, 384-dim) — local, fast, no API key.
Graph traversal — records link to each other (decision → supersedes → decision; episode → covers → topic), so you can walk relationships, not just match text.

There are 7 MCP tools in total — semantic_search, search_memory, search_chat, query_raw, save_memory, save_commit, load_project — so the agent can pick the right retrieval for the question instead of being stuck with one.

100% local stack

No cloud, no telemetry, no keys leaving your box:

SurrealDB for storage (vector + full-text + graph in one engine).
fastembed for embeddings, on CPU.
FastMCP over stdio for the server.
Credentials via env vars; projects configured in a simple projects.json.

Install

git clone https://github.com/BrethofAI/brethof-mind
cd brethof-mind

# 1. Bring up SurrealDB
docker compose up -d

# 2. Configure
cp .env.example .env                    # set DB creds
cp projects.example.json projects.json
python mcp-server/scripts/init_db.py    # create namespace + schema + indexes

# 3. Register the MCP server with Claude Code (claude mcp add ...)
# 4. Drop the hooks into your Claude settings (see settings.example.json)

Full steps are in the README.

The hooks are where it gets nice

The MCP tools are useful on demand, but the hooks make memory ambient — you don't have to remember to remember:

SessionStart loads the relevant project memory into context the moment you open a session.
UserPromptSubmit nudges the agent to search memory first before answering questions about past decisions.
Stop archives the session into the searchable chat history when you're done.
A commit hook records each commit as a memory record, so your project history and your conversation history live in the same searchable place.

The result: start a fresh session and your agent already knows where the project stands — no re-briefing.

Works with

Claude Code and Claude Desktop today (Desktop runs the Claude Code engine under the hood, so it gets the full hooks experience). OpenClaw and Hermes integrations are next.

Why it's free

brethof-mind is MIT and will stay free. It comes from the team behind Brethof Voice Pro (local, offline voice-to-text) — same principle: your data stays on your machine. This is the tooling we use ourselves; sharing it because the "summarize-your-memory" default deserves a better answer.

If you try it, I'd genuinely like feedback on the hook design — that's the part with the most room to get smarter.

https://github.com/BrethofAI/brethof-mind

Transcribe, Translate, Timestamps, Fine tune, MCP server ALL in 1 app

BrethofAI — Fri, 22 May 2026 11:00:59 +0000

Brethof Voice Pro v2.0.0 — offline speech-to-text, translation, and a voice keyboard in one app

Your voice, transcribed and translated on your own machine. No cloud, no subscription, nothing leaving your laptop.

Brethof Voice Pro just hit v2.0.0 — and it's no longer "just" dictation. It's a full local voice + translation layer for your desktop and your AI stack.

What it does

🎙️ Transcribe 30 languages + 22 Chinese dialects (52 in total) — from a file, your mic, or your system audio (meetings, videos, anything playing through your speakers).
🌍 Translate across 38 languages, fully offline. Choose the fast model or the quality one (Tencent's Hunyuan-MT — #1 in 30 of 31 categories at WMT25).
⌨️ Voice keyboard — dictate into any app with a hotkey. New in v2.0: pick several target languages and it types the translation as you speak.
📝 Timestamped subtitles — export SRT/VTT, sentence- or word-level.
🧠 Fine-tune it on you — every correction trains a personal model (one-click LoRA), so it learns your voice and your vocabulary.
🔌 MCP server — 19 tools so Claude or any MCP client can drive transcription and translation inside your own pipelines.

Why it's different

100% local. Audio and translations never leave your machine. Linux & Windows; GPU optional — runs on a plain laptop CPU.
All in one app. Transcribe, translate, subtitle, dictate, fine-tune — no stitching five tools together.
No subscription. Pay once, own it forever. 14-day free trial, no credit card.

👉 brethof.ai/voice

I Built a $49 Voice-to-Text App That Never Touches the Cloud

BrethofAI — Thu, 16 Apr 2026 07:32:31 +0000

Why I Built Brethof Voice Pro

I got tired of two things:

Voice-to-text tools that only work well in English
Every good STT solution either costs $700 (Dragon) or sends your voice to the cloud monthly

So I built something different.

What It Does

Brethof Voice Pro is a desktop app (Windows + Linux) that converts speech to text using AI — entirely on your device. Press Ctrl+D, speak, text appears where your cursor is.

Zero cloud calls during transcription. Models download once on first launch, then it works fully offline.

The Tech Stack

Qwen3-ASR engine — 1.84% word error rate across 10 languages (arXiv 2601.21337)
GGUF models via llama.cpp — 6 quantization tiers from 1 GB to 3.2 GB
Vulkan GPU acceleration — works on NVIDIA, AMD, Intel, and CPU-only
DeepFilter noise reduction
36 languages with auto-detection

Why It Matters

If you speak Thai, Polish, Arabic, Vietnamese, Korean, or dozens of other languages — there has been no good voice-to-text option for you. Dragon doesn't support most languages. Google's API charges per-minute and requires internet. Whisper's accuracy on non-English languages is mediocre.

Qwen3-ASR changes this. State-of-the-art accuracy across 36 languages, running locally on consumer hardware.

Pricing

$49 one-time. Perpetual license. No subscription.

Compare: Dragon $699. Otter.ai $100-240/year. Google STT per-minute cloud pricing.

14-day free trial, no credit card: brethof.com

Happy to answer questions about the architecture, GGUF quantization, or Vulkan vs CUDA tradeoffs.