Besydr, say: besider

A supervising and self-learning loop for your coding agent

A coding agent runs inside a harness, the program that runs its loop: octomind, Claude Code, Codex, OpenCode or pi. On its own, the agent starts every session knowing only what your rules file says, and it decides for itself when its work is done. Besydr runs beside the harness on your machine. It learns rules from your corrections, holds the agent to them, checks finished work against your request, and lets the result of each check decide what it keeps.

It is free with octomind. With the other four harnesses it runs free for 14 days, then needs a licence.

The first release is not published yet. Only the octomind connection has been run in live sessions so far.

Where Besydr sits in a session

The harness reports four moments of a session to Besydr, and Besydr answers the first three. The agent has no tool to search the store. Besydr decides what the agent is given.

On your machine

Coding agent in its harness

Besydr beside it

  1. 1You send a prompt

    Besydr writes a checklist for the request, adds the stored lessons that fit it (at most 2,000 tokens) and repeats the standing rules you gave in this session.

  2. 2The agent works

    After each round of tool calls, Besydr adds a note when the agent repeats itself or keeps failing. Output of more than about 5,000 tokens from one tool call is narrowed to the parts the task needs, where the harness allows it.

  3. 3The agent stops

    A model compares the checklist with what the agent did. If something is missing, the agent continues with the gaps as its next instruction, up to 3 times.

  4. 4The session ends

    In the background, Besydr reads the session and stores new lessons. Every rule quotes a message you wrote.

Lesson store

Markdown files on your disk that you can read, edit or delete. Besydr reads them before each request and writes new ones after a session. The agent has no tool to search them.

Two models

One answers yes-or-no and scoring questions, the other writes text such as the checklist. By default both are reached through OctoHub, the model gateway octomind already uses, with your octomind login. You can set your own provider and key instead. No other session text leaves your machine.

If Besydr cannot be reached or does not answer in time, the agent goes on as if Besydr were not installed.

Each step is described in full on the mechanics and learning pages of the documentation.

The loop: learn, enforce, verify, keep or retire

Across sessions, the same work forms a loop of four steps. They run without a manual step from you, and each one feeds the next. A lesson is a record Besydr stores from a session.

  1. 1Learn

    After a session, Besydr reads it in the background and stores lessons: rules you stated, facts about the project, and a short memo of the work and how it ended. A rule is stored only if it quotes a message you wrote.

  2. 2Enforce

    A rule you state is repeated with every later prompt in that session. In later sessions, the lessons that fit a request are given to the agent with it, at most 2,000 tokens.

  3. 3Verify

    Before work starts, Besydr writes a checklist from your request alone. When the agent stops, a model compares it with what the agent did and sends the agent back with the gaps, up to 3 times. This is the completion check.

  4. 4Keep or retire

    A lesson earns credit when the agent used it and the check passed. A weak lesson that goes unused for 90 days is archived. Generated rules, which are off by default, are kept only if the check passes more often with them, or equally often at lower cost.

Each check result decides what stays, session after session.

A lesson or a repeated rule is advice to the agent. With generated rules switched on, which is off by default, a rule that can be written as a pattern on tool calls may become a guard, which denies the matching call. Only a guard denies a call.

Not measured yet. There is no measured benefit so far, and nothing on this site claims one. What was tested is listed in the introduction post.

Where existing tools stop

Of 14 projects checked by November 2026 (13 from their source, 1 from its README), none learns a rule from sessions, enforces it, verifies work against it and uses the result to keep or retire it. Commercial agents such as Cursor, Devin, Factory, Windsurf and Augment were not checked.

Kind of toolWhere it stops
Memory tools that add stored notes to a sessionNo enforcement and no verification.
Rule tools that enforceThe rules are written or triggered by hand, and results never change them.
Tools that learn from correctionsReminders only.

Problems of coding agents that Besydr addresses

A study of 20,574 coding-agent sessions in 1,639 repositories (Tang et al., EMNLP 2026) labelled 16,118 episodes where the developer had to push back. It covers Cursor, GitHub Copilot, Claude Code, Codex, OpenCode and Gemini CLI. One episode can carry several labels, so the shares add up to more than 100%. The chart shows its Table 2.

What the developer saw, as a share of 16,118 episodes Kinds Besydr is aimed at, in bold Other kinds
What the developer sawShare of episodes
Agent violates an explicit constraint 38.33%
Agent acts on a wrong reading of the request 26.95%
Agent misreports the status of its own work 22.58%
Code is logically or syntactically wrong 17.82%
Agent misreads the codebase or system state 11.56%
Agent acts beyond the stated scope 10.20%
Commands or tool calls are malformed 2.87%

The agent breaks a rule you already gave it

The largest group in the chart: an explicit constraint violated.

What Besydr does

Besydr catches the rule in the prompt where you state it and repeats it with every later prompt in that session. It stores the rule with your exact words. In later sessions the rule is added to the agent’s context when the task is related. With generated rules switched on, which is off by default, a rule that can be written as a pattern on tool calls may become a guard that denies the matching call.

Limit

A stated rule is advice to the agent. A guard covers only what a tool-call pattern can express, and it exists only after a trial.

The agent says the work is done when it is not

The third group in the chart: the agent misreports the status of its own work.

What Besydr does

Before work starts, Besydr writes a checklist of what would show your request is fulfilled, using only the request. When the agent stops, a model compares the checklist with the tool calls, their results and the diff. If something is missing, the agent continues with the gaps as its next instruction, up to 3 times.

Limit

The check is only as good as its model. In one test a model passed 65 of 65 runs, 23 of them failures.

The same mistake returns in the next session

The study reports that problems carry into the next session in the same repository.

What Besydr does

Each session leaves three kinds of record: rules you stated, facts about the project, and a short memo of the work and how it ended. Related ones are added to later sessions, including memos of failed attempts.

Limit

A record is added only when retrieval finds it relevant to the prompt.

You repeat the same correction

91.49% of the visible fixes needed the developer to push back.

What Besydr does

A correction is the signal Besydr learns from. It looks for the correction, quotes it and stores it, so you make it once.

Limit

A rule must quote your words. A correction you only implied is not learned.

What it does not do

  • Unclear requests. Besydr does not ask clarifying questions. A learned preference can fill some gaps.
  • Wrong code. The completion check catches an unmet request and missing evidence. It is not a code reviewer.
  • Malformed commands. Loop detectors notice repeats, not the error itself.
  • Work outside the request. A stated rule such as “do not touch unrelated files” is repeated with every request like any rule. A separate check of each call against your intent exists, but it is off by default.

Further problems it addresses

The rules file grows and the agent follows less of it

The largest root cause, 36.49%, is failing to follow an instruction the agent clearly received.

What Besydr does

A prompt gets at most 2,000 tokens of lessons, chosen for that prompt. A model filters them further, which you can switch off. They arrive next to the prompt instead of at the top of a long file.

Limit

This reasoning is not measured. Whether fewer, closer rules are followed more often is still to be tested.

Context is lost inside a long session

4.30% of the episodes name context that was not carried forward.

What Besydr does

Standing rules are kept outside the conversation and repeated with each prompt. After a compaction, which is when the agent folds a long conversation into a summary, everything added so far is sent again.

Limit

Whether a rule also survives inside the summary depends on the client.

Rules pile up and nobody knows which help

No study figure. This is a design concern.

What Besydr does

With generated rules switched on, which is off by default, a generated rule is applied in about half of the sessions it matches and withheld in the rest. It is kept only if the completion check passes more often with it, or equally often at lower cost. Unused lessons and rules retire.

Limit

A trial needs 10 completion-check results in each group, so rare rules take long to decide.

A teammate’s agent rediscovers what yours already learned

No study figure. This is a design concern.

What Besydr does

On the team instance, project facts and work memos are shared with the team as soon as they are stored. A personal rule becomes a team rule when a second person states the same one.

Limit

Team sharing is built after the local program and is not available yet.

Features in octomind, Claude Code, Codex, OpenCode and pi

A client is a harness that Besydr is connected to. Octomind gets every feature. Each other client gets the features its extension points allow. A missing feature comes from the client, and Besydr does not imitate it with a workaround.

FeatureoctomindClaude CodeCodexOpenCodepi
Lessons added to the agent’s context with each request Yes Yes Yes Yes, in the system prompt Yes, as a hidden message
Standing rules and checklist repeated, and sent again after a compaction Yes Yes Yes Yes Yes
Learning from sessions Yes Yes Yes Yes Yes
Completion check (agent sent back to work) Yes Yes Yes Yes Yes
Tool admission (a call can be denied; off by default) Yes Yes Yes Yes Yes
Notes after a tool call (loop and no-progress notes) Yes Yes Yes Yes Yes
Notices shown to you Yes, in a terminal session Yes Yes Yes, as a toast Yes
Condensing of large tool output Yes Bash, MCP tools and Grep No Yes, every tool Yes, except failed calls
Blocking a prompt Yes Yes Yes No Yes
Note at the end of a turn Yes No No No Yes
The agent’s tool list sent to Besydr Yes No No No Yes
Events when a subagent finishes Yes Yes Yes No No
Plan shown and applied Yes No No No No
Status view and /learning command Yes No No No No

the client carries itonly in partthe client has no place for it

Only octomind has been run with Besydr in live sessions so far. The Claude Code, Codex, OpenCode and pi connections are covered by automated tests against each client’s documented hook formats and have not yet been run in a live session.

A check mark means the client carries the answer and the adapter sends it. It does not mean the feature is switched on: some are off by default. Why a feature is missing from a client is in the clients documentation.

Where it runs and what it sends

Besydr runs on your machine and starts when the first client calls it. Its licence file is checked offline, and the program never calls home.

To do its work it sends text from your sessions to two models: one that answers yes-or-no and scoring questions, and one that writes text such as the checklist. By default both are reached through OctoHub, the model gateway octomind already uses, with your octomind login. You can set your own provider and key for either one. Calls through OctoHub count against your OctoHub account. Besydr sells no model usage itself.

A team server is not built yet, so besides these model calls nothing leaves your machine.

Cost of a session with Besydr

Besydr is built to save tokens and your time in two places, and it adds cost in two. The net effect has not been measured.

What it is built to save

5,000 tokens
A plain-text tool result above about this size is cut to the parts the task needs before the agent reads it. The full result stays in a file the agent can read. This works in octomind, OpenCode and pi (in pi not for failed calls), in Claude Code for Bash, for MCP tools that return only text and for Grep when it lists matching lines, and not in Codex.
Up to 3 times
When the agent stops with work missing, the completion check sends it back with the gaps as its next instruction, instead of handing the unfinished work to you.

What it adds

2,000 tokens
The most lessons added to one request.
1 to 4 model calls
What learning costs after a typical session: 1 call when there is nothing to learn, 2 when there are rules, 4 with a work memo. The checklist, the completion check and the cutting of tool output call a model as well.

With generated rules switched on, which is off by default, a rule can also be kept for cost alone: the same share of passed completion checks with 10% fewer model calls. Model calls are billed by your model account, not by Besydr.

Not measured yet. In an early test on 6 one-off tasks, the difference between two runs of the same setting was larger than the effect of any setting. A measurement on repeated sessions in one repository is still owed.

Pricing

Free with octomind

$0

The local program, when you use it with octomind.

Personal licence

$60 per year

The local program with any other client, after a trial of 14 days.

Team licence

$180 per seat per year

The team instance, and each seat’s use of the local program with every client. The team instance is built after the local program.

Pricing details and checkout

Questions

How is Besydr different from a memory tool?
A memory tool stores notes and adds them to a session. Besydr also repeats your rules, checks finished work against the request, and uses the results of those checks to decide which lessons and generated rules stay. The agent cannot search the store. Besydr chooses what the agent is given.
What does it learn from?
From what you say in a session: corrections, stated rules, and how the work ended. A rule must quote a message you wrote, so a correction you only implied is not learned. A project fact must cite messages or tool output. Each lesson is a Markdown file on your machine that you can read, edit or delete.
How is this different from a CLAUDE.md or AGENTS.md file?
A rules file is written by you, and the client loads it at the start of a session. Besydr writes its records from what you say in sessions, and each rule must quote a message you wrote. For each request it picks the records that fit, at most 2,000 tokens. It does not change rule files you wrote. Whether fewer, closer rules are followed more often is not measured.
How does it handle an agent that says the work is done too early?
Before work starts, Besydr writes a checklist from your request. 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 is sent back with the gaps as its next instruction, up to 3 times. The check is only as good as its model, and it is not a code review.
Does it reduce token use?
One part does. A plain-text tool result of more than about 5,000 tokens is cut to the lines the task needs, and the full result stays in a file the agent can read. This works in octomind, OpenCode and pi (in pi not for failed calls), in Claude Code for Bash, for MCP tools that return only text and for Grep when it lists matching lines, and not in Codex. Besydr also makes model calls of its own and adds up to 2,000 tokens of lessons to a request. The net effect on token use has not been measured.
What leaves my machine?
Text from your sessions goes to the two models Besydr calls: by default through OctoHub with your octomind login, or through a provider and key you set. Nothing else leaves your machine. The licence file is checked offline, and the program never calls home.
What does it cost?
Nothing with octomind. With Claude Code, Codex, OpenCode or pi it is free for 14 days, then $60 per year for one person. Model calls are billed by your model account, not by Besydr.
What happens when the trial ends without a licence?
With octomind nothing changes. With the other clients Besydr stops supervising the agent and adding lessons, and the client shows a notice at the start of a session. The lessons already stored stay on your machine.

Install

The first release is not published yet. When it is, this command installs the program on Linux and macOS. Windows is supported with octomind only. The install page covers each client and how to install a licence.

curl -fsSL https://cdn.besydr.com/install.sh | sh