loading...

2026-05-24 12:30:50.50.504

harness-multitool







harness-multitool is the next generation of AI harness: one Rust program in which coding agents run on Claude Code, Codex, OpenAI-compatible APIs or a local Ollama model, talk to each other, keep every project's knowledge in a journal and maps, and close their work only on evidence. Almost every part of it is an interface you can replace.

It grew out of claudebase, the harness I built around Claude Code sessions. harness-multitool keeps what worked there: reachable sessions, agent-to-agent messaging, the project journal, mind maps and flowcharts. It drops the idea of one vendor. Its agents run in its own terminal interface, on any adapter, and one conversation moves between them.

→ Try it in your browser: harness-multitool.dev. The real terminal interface, compiled to WebAssembly, plays a scripted session there. Each of the How-to pages shows one task live.

What it does

  • One harness, many adapters. The unmodified Claude Code and Codex CLIs run as delegates over their JSON streams, each signed in by its own program to the user's own subscription. The harness's own agent loop runs on Anthropic and OpenAI-compatible APIs, Ollama and other local servers, or a ChatGPT plan.
  • One conversation in every form. A conversation is the harness's own log. Claude Code's transcript, Codex's session files and an API's request history are its forms. Move a conversation from Claude Code to Codex to a local model and back, and each picks it up where it was.
  • A knowledge graph per project. Agents record decisions, findings, bugs and changes in the project's journal, with mind maps and live flowcharts linked to the entries. The next session reads it instead of rediscovering.
  • Done means proven. Every feature or fix runs as a branch: a todo with its test protocol, the change, a verification with its proof, and only then the close.
  • Modes with their own tools. Plan mode lets nothing change until you approve, in the window or with a button on Telegram. Orchestration lets one agent start others in tabs and close their tasks on proof. Step-debug walks a running pipeline one approved step at a time, on a live flowchart.
  • Agents that talk to each other. Every conversation on the machine has a nick and can reach another with agent_send.
  • A daemon that hosts them. It holds every conversation, keeps agents working when a window closes, and is the single entry point of callbacks.
  • Callbacks by design. Every conversation has its own callback URL. Any app wakes the agent through it, and a project's own handlers are Rust programs.
  • Telegram. Talk to your agents from your phone, approve plans, get files back.
  • Conversations as files. Dump a conversation with its journal and maps to a .zip, and load it here or on another machine.

Agents on your subscriptions, through one daemon

The part I use most: a lead agent splits a feature between several sessions of the vendors' own CLIs. Two Claude Code sessions and a Codex session, say, each on my own subscription, all hosted by the one daemon of the machine.

lead (Claude Code)    writes the tasks into the journal, starts a session on each
  qa (S)       Claude Code   finds no format yet, asks the lead
  api (S)      Claude Code   decides the --json format, in the shared journal
  cli-docs (S) Codex         finds that decision in the journal, documents it
lead                  points qa at api's decision; checks each proof; closes each task

Every session reads and writes the same journal, so a decision made in one is known to all. The lead checks each slave's work against its task before it closes anything. Each CLI is the vendor's unmodified program, run in its documented headless mode, and signed in by its own flow. The harness never touches those credentials, and never pays for, resells or routes anyone's usage.

How messages reach an agent

Everything from outside reaches the model as its kind and its words, and is treated as data, never as instructions:

[telegram_message]: what you typed on your phone
[agent-to-agent:reviewer]: what another agent sent
[callback:ci]: what a script POSTed to the conversation's URL

An agent answers with its tools: telegram_send (with files), agent_send. A project's own callback type goes to its handler first, a Rust program in .harness/callbacks/, which you approve and turn on with Enter in Settings > Callbacks.

The project journal

Every project has one journal, owned by the daemon and shared by every agent and adapter. An entry is a decision, finding, bug, lesson or update, with tags, flags and links:

  • flags say how far to trust it (unverified, verified, deprecated) and what is still open (todo, question, wait-for-decision);
  • specifications and constraints are binding, and multitool docs check keeps the documentation and the journal in agreement;
  • a todo closes only once its branch holds a verified entry with its proof.

Mind maps hold where a long task stands; flowcharts hold the logic of what is built, and come alive as a pipeline's callbacks move them.

Install

curl --proto '=https' --tlsv1.2 -sSf https://harness-multitool.dev/install.sh | sh

It downloads the prebuilt multitool for your machine, checks its SHA-256, and installs it on your PATH with its daemon as a user service. No Rust is needed. Or build it from source: git clone https://github.com/codefather-labs/harness-multitool && cd harness-multitool && ./run.sh.

Under the hood: Rust, ratatui for the terminal interface, the same interface compiled to WebAssembly for the site, SQLite for the journal, and a daemon on a local socket. Local-first: no hosted service in the loop.

→ harness-multitool.dev · github.com/codefather-labs/harness-multitool

Comments