session manager · chat client · archive

One place to run every coding agent,
and one archive of everything they did.

Claude Code, Codex, OpenCode, Qwen Code, Hermes and maki, side by side over one protocol. Every session they ran is in one searchable record, whichever of them ran it and whoever started it. An IDE, real terminals, a scratchpad and a token meter sit over the top. 

git clone https://github.com/kdlslyv/mechabedo.git
cd mechabedo && deno task prep
deno task ship
deno task prep
deno task dev
# http://localhost:4776
cp docker/mechabedo.config.example.jsonc ./config/
docker compose up -d
  • 6harnesses, one wire
  • 1artifact, four jobs
  • 2languages in the editor
  • 0package managers but deno

One wire, six harnesses.

The harness is a backend, not a product. Every one of them speaks the Agent Client Protocol, so there is one renderer, one permission prompt, one queue, and no per-harness interface to keep in step. A harness that cannot speak it is not driven.

How each harness is driven
harnesshow it is drivenenhanced through
Claude Codethe official ACP adaptera linked plugin
Codexcodex-acp over stdioadditional directories
Qwen Codeqwen --acp, its own agentthe system-defaults scope
OpenCodea proxied server processits own config
makimaki acp, its own agentskills on disk
Hermesa driven CLIa fixed profile

A session outlives its process

Close the app and come back: the session is still there with its history, and the process is restarted underneath it when you send the next prompt. A busy session takes a queue rather than a refusal, and a turn a person stopped wakes nothing.

One enhancement layer, injected six ways

Skills and agents are materialized once and pushed into every harness mechabedo starts, through whatever mechanism that harness actually has. It also inherits the rules, skills and MCP servers already on disk instead of asking you to migrate.

The Logbook remembers what you forgot.

Every session on the machine, imported from each harness's own history rather than transcribed from what happened to be on screen. The ones you drove by hand in a terminal are in there too.

Search, read, replay

One tiling surface: search across messages and sessions, read a transcript a page at a time, or replay one as it was streamed. A standalone CLI and a full terminal UI read the same data.

Agents read it too

The archive is a tool surface. A running session can find the decision an earlier one made instead of guessing at it again. That is the reason for keeping it.

The numbers

Tokens, turns and cost across the whole archive, priced per model, with a subscription projection attributed against what actually ran locally.

Yours, and portable

It is a Postgres database on your disk. Snapshot it, export it as JSONL, or sync it between two machines as encrypted blobs through a host you run.

Everything a session needs, in the same window.

An agent that can only talk is half a tool. These are the surfaces that sit beside the conversation, all of them driving the same server and the same database.

BedoIDE
Monaco behind a real language client over your agents' working directories. Roslyn for C#, tsserver or deno lsp for TypeScript depending on the directory. A project rail, search and replace across the tree, the diff, and the changes list.
Terminals
Real shells, as many as you open, floating or docked as a tab, all over one socket. A terminal carries its shell between the two homes rather than restarting.
NoteMap
A page of characters laid out by hand instead of flowing text. Overwrite typing, rectangular selection, shiki over its code fences and dprint inside them.
Token flow
Tokens per minute across every session on the machine, including harnesses you started in a terminal, driving a generative instrument you can leave running.
The orchestrator
Server-side jobs that supervise a session from outside it, when it finishes a turn, when it halts, or on a clock. Step a workflow, judge a tool call and cancel it, or fan a task list out over a worker pool.
The companion
A floating assistant on its own app root with a Live2D or VRM stage, wired through a meta layer that lets it see the app and drive it. It points at things with a drawn mark and its own hand.
The browser bridge
An extension that an open mechabedo page pairs, so an agent can read and drive the tab you are looking at. The extension holds no credential.
Beam
Reach the desktop you left running from a browser somewhere else, through a tunnel it dials out itself. Share archived logbooks as encrypted buckets over the same host.

One artifact. Four jobs.

The same entrypoint becomes a server, the token daemon, a native window over a server it started itself, or a command line, chosen at startup from how you invoked it and whether the build carries a webview.

servethe API and the built SPA, one process, behind your own proxy
desktopthe same server behind a CEF window, on every desktop target
daemonthe machine-wide token meter, which outranks any server
monitorthe transcript and metering command line, standalone

The server owns the database

One PGlite instance per installation, on disk, reached from the browser over the PostgreSQL wire protocol through a WebSocket. Two databases mean two tables that drift, so there is one. The browser's own copy is an opt-in escape hatch.

Configuration is data

A table in that database, not a pile of files and not localStorage. Which means the theme, the prompts, the fonts and the kits are rows, and a palette change is an edit rather than a build.

Written down, on purpose.

The documentation is the reference, written for whoever works on the code next, whether that is a person or an agent. Every load-bearing decision has a record with the alternatives it beat, and every capability area has a chapter that says how it works and why.

.agents/knowledge/

One chapter per capability area. What it is, how it works, where the pieces are.

.agents/adrs/

One decision per file, with its alternatives and consequences. Numbers are allocated by reserving the file, because several agents work this tree at once.

AGENTS.md

The brief: the toolchain, every command, the conventions, and the working discipline a change is expected to follow.

Apache-2.0. Contributions welcome, corrections more so.

mechabedo was built by reading a lot of other people's work, and it says so. NOTICE names every project whose design is visible in the source. If yours is in there and I credited it badly, open an issue.

Read the source Open an issue

The app sends one anonymous ping when the server starts: version, channel, os, arch, a random install id and whether it is the first run. Nothing else, ever, and MECHABEDO_ANALYTICS=off or a switch in Settings stops it. The receiving umami is self-hosted and keeps no raw address.