Besydr: Octomind’s Memory and Supervision for Claude Code, Codex, OpenCode and pi
A coding agent starts each session knowing only what your rules file says. It decides for itself when the work is done. It reads every line a tool prints, whether the task needs the line or not.
Octomind, our open-source coding agent, has handled these three things inside its own process. Besydr (say "besider") is that code moved into a separate program that runs on your machine, beside the agent. Octomind loads it as a plugin. The same program also connects to Claude Code, Codex, OpenCode and pi.
Besydr is available now at besydr.com. One thing first: no benefit has been measured yet. The last section says what was tested.
What does Besydr do?
It does three jobs.
Memory: a correction is made once
After a session, Besydr reads it in the background and stores short records called lessons. There are three kinds:
- Rules — an instruction you gave. Each rule must quote a message you wrote; a rule without a matching quote is dropped.
- Project facts — a lasting fact about how the project works. The agent gets it as an assumption to verify.
- Work memos — 150 to 600 words on one piece of work and how it ended, including failed attempts.
In later sessions Besydr adds the lessons that fit the current request to the agent's context, at most 2,000 tokens per request. The agent has no tool to search the store. Besydr alone decides what enters the context.
You can see what was stored. besydr ui opens a page in your browser, served on 127.0.0.1 only, that shows your sessions, the lessons and generated rules each session was given, and the tool calls a generated rule stopped. You can search and delete your lessons there.
Supervision: "done" is checked against your request
When you send a request, Besydr writes a checklist of what would show the request is fulfilled. It writes it from your words only, before any work. When the agent stops, a model compares the checklist with the tool calls, their results and the file changes. If something is missing, the agent goes back to work with the gaps as its next instruction. There are at most 3 checks per turn.
Three smaller mechanics sit beside the check:
- Standing rules. A rule you state in a prompt is kept in your exact words and repeated with every later request in the session, also after the client folds old messages into a summary.
- Tool admission. Before a tool call runs, Besydr can deny it when two models, asked independently, both find a concrete conflict with your words. When a model is unavailable or unsure, the call is allowed.
- Loop notes. When the same calls return the same results 3 rounds in a row, or 5 rounds bring nothing new, the agent gets a short note that suggests a different approach. The note is advice and never blocks a call.
Condensing: long tool output is cut to what the task needs
A plain-text tool result above about 5,000 tokens is split into chunks. A model answers three yes-or-no questions about each chunk: does it report a failure, does it hold the data the task asks for, does it name a path or line the agent must act on. Chunks with a yes are kept, with their neighbours. Besydr copies the kept lines from the original, so no model rewrites anything. The full original is saved to a file first, and the shortened result names that file.
An example from the session that wrote this post
We drafted this post in Claude Code with Besydr connected. The agent read our product list, a file of 242 lines. Besydr handed it 27 of them, with this notice:
CONDENSED by supervisor: kept 27 of 242 original lines relevant to the current task —
the condenser returned line numbers only; the kept lines are verbatim original text,
nothing was rewritten. Full original output, verbatim: <path to the saved file>
In this case the cut was too tight: the agent needed the whole list to add a product to it. It opened the saved file and read the rest. That is the design. The cut is a guess about what the task needs, and the saved original is how the agent recovers from a wrong guess.
Why does Octomind get every feature?
Octomind talks to Besydr through a plugin protocol that was built together with these features. The four other agents are connected through their own hooks or extension files. Besydr can only do what those allow. Where a client lacks a way to do something, Besydr turns the feature off for that client and does not imitate it.
| Feature | Octomind | Claude Code | Codex | OpenCode | pi |
|---|---|---|---|---|---|
| Lessons added to the agent's context | Yes | Yes | Yes | Yes | Yes |
| Learning from sessions | Yes | Yes | Yes | Yes | Yes |
| Completion check | Yes | Yes | Yes | Yes, except one-shot opencode run |
Yes |
| Tool admission | Yes | Yes | Yes | Yes | Yes |
| Loop notes after a tool call | Yes | Yes | Yes | Yes | Yes |
| Condensing of long tool output | Yes | Tools whose result reaches the model word for word | No | Yes, every tool | Yes, except failed calls |
| Blocking a prompt | Yes | Yes | Yes | No | Yes |
| Plan shown and applied | Yes | No | No | No | No |
Status view and /learning command |
Yes | No | No | No | No |
Two rows need a sentence each.
Condensing in Claude Code. Besydr shortens a tool's results only after it has seen that Claude Code shows the model that tool's result word for word. Bash, MCP tools, Grep, subagent answers and WebFetch start as known. Any other tool is learned by watching one call. Read is left alone, because Claude Code renumbers the lines of a replaced Read result from 1.
Condensing in Codex. Codex hooks have no field that replaces a tool's output, so nothing is shortened there.
The full list, with the reason for every gap, is in the clients documentation.
How does a team share what its agents learn?
Without a team server, each person's lessons stay on that person's machine, so a teammate's agent rediscovers what yours already learned. With a team licence, a team runs the same besydr program as a server on its own machines, started with besydr instance.
| What a session learned | Where it goes |
|---|---|
| A project fact or a work memo | To the team server at once, for everyone who works in that repository |
| A rule you stated about the project | Stays yours until a second person states the same rule; then the server makes one team rule from the two |
| A global lesson | Stays on your machine and is never sent |
Each person's Besydr still does all its work on that person's machine. What goes to the team server is the lesson record; code, transcripts and tool output are never sent. The server sends nothing to besydr.com except its own licence activation. When a session cannot reach it, the session uses the person's own lessons alone.
The server has a page of its own: open its address in a browser and paste a key. The admin key shows the team's sessions, lessons, rules and people. A person's key shows that person's view.
Nothing about team sharing has been measured on a real team yet. The team documentation has the setup.
What does Besydr cost?
Besydr is free with Octomind. It is part of Octomind's plugin system: Octomind lists Besydr in its default configuration and downloads it on first use, so you run no install command.
With Claude Code, Codex, OpenCode or pi, Besydr runs free for 14 days. After that it needs a licence. A licence is bought once and works for good. It includes every release published in its first 12 months, and each person can have it active on up to 3 machines at a time. A personal licence is for one person. A team licence is sold per seat: every member gets the same program, and the licence also unlocks the team server. Prices are on the pricing page.
Install Besydr with curl -fsSL https://cdn.besydr.com/install.sh | sh. Connecting another client is one more command, for example besydr install claude. The install page has the details. On Windows, Besydr works with Octomind only.
Besydr calls two models to do its work, and those calls are billed by your model account, not by Besydr. By default they go through OctoHub, the model gateway Octomind uses, with your Octomind login. You can set your own provider and key instead.
What has been measured?
Nothing that shows a benefit. In one A/B test on 6 single-session tasks, turning learning off scored better, turning the completion check off made no difference, and the difference between two runs of the same setting was larger than the effect of any setting. A single-session task has no earlier session to learn from, so that test cannot measure learning across sessions. A measurement on repeated sessions in one repository is still owed.
Besydr also adds cost of its own: its model calls, and up to 2,000 tokens of lessons per request. Whether condensing saves more than that has not been measured either.
Where to find it
- Product site and documentation: besydr.com
- Octomind: octomind.run
- Everything else we build: muvon.io/products



