Mend
One harness-agnostic repo and context store, reachable from any of your devices — your phone included. First-class review for everything your agents write, on your own infra.
mend claude — and everything else stays the same.
Open source · Self-hosted · In development
$ codex → $ mend codex · the same agent
$ pwd/home/dev/code/billing-service $ mend codexnew project — adopting into the store, provisioning a worktreesession 01J8QK4M · recording [ Codex runs here, unchanged ]If you use coding agents heavily, some of this will be familiar.
Work scattered across machines
Every machine you code on collects its own clones, worktrees, and half-finished sessions. The session you need is always on the machine you're not at.
The harness owns the session
Claude Code and Codex each keep the conversation in their own format, on the machine that ran it. Worktree, process, and history are welded together — so when a session builds up genuinely good context, you keep it running for weeks, afraid to close the terminal, because there's no way to take it anywhere else.
There's no phone story
Checking what an agent is doing, answering its question, reading the diff — all of it means being at the machine that started it.
Port roulette
Three worktrees, three dev servers, ports 3000 / 3001 / 5173-and-counting. Which one belongs to which session — and now open the right one from another device.
No local review story
The agent writes to your disk, but reviewing still means pushing a branch and opening a PR. And the review tools that could help want their own cloud and their own inference bill, when you already pay for a subscription that could read the change.
MacBook · with you
Desktop · at home
Work laptop · office
Phone
One store for repos and sessions, on a machine you pick.
mend claude, mend codex, or mend run -- anything — the same TUI, shortcuts, and connected subscription you have today. Mend adds a durable worktree under the agent and a recorded workspace around it, all inside one central store instead of scattered checkouts.
One store, one worktree per session
mend adopt clones the repository into a central store on the Mend host. Each session runs in its own git worktree there, so parallel agents cannot collide and no client checkout becomes the source of truth.
Detach without stopping
The agent runs in a supervised workspace, not in the terminal window that displays it. Close the client and the process keeps running; reattach later from the CLI, the web app, or the phone with the scrollback intact. Good context follows the session, not the terminal — nothing to hoard.
Resume, or switch harnesses
A settled session reopens with the same harness and its native state. Reopening a Claude Code session in Codex — or the reverse — works in beta: same worktree, translated conversation history.
The same session, from your phone.
The development app connects to a real Mend host: see what is running, start or resume an agent, message a live session, open its terminal, read the local diff. A control and review surface — not an IDE on a small screen.
Now
3 sessions · 2 projects · this machine
Needs you
Keep the legacy callback or remove it?
Ready to review
4 files · +86 / −12 · 2 checks observed
Active
pnpm test · running 00:41
claude · billing-service
session 01J8QK4M · recording
⏺ I'll keep the DB-session path and remove
the legacy callback. Running the suite…
$ pnpm test auth
✓ 41 passed (3.2s)
? Keep legacy() exported for the
migration window? (y/n)
attached over your tailnet
Review
billing-service · worktree vs base
- Change
- 4 files · +86 / −12
- Record
- 212 events
- Mode
- read-only on mobile
- if (legacyCallback) return legacy(req)+ return dbSession(req)Inline comments and send-review are next
Illustrative data — capabilities available in the development app
The app reaches the Mend host over your LAN or tailnet with an operator token. Nothing is exposed publicly.
The dev server belongs to the session too.
Run three sessions and you get three dev servers on three ports nobody remembers. When a server starts listening inside a session's workspace, Mend will forward it and show it beside the session it belongs to — no port map in your head, no guessing which :3000 is whose.
Discovered, not configured
The workspace reports when something starts or stops listening. Mend forwards the port and labels it with the session that owns it; an explicit declaration is there for when detection isn't enough.
Another view of the session
The forwarded URL belongs to the session, like its terminal and its diff. Open it from the machine you're on — or your phone — and it goes away when the session does.
Never public
Forwards bind to your LAN or tailnet, on the same authenticated connection as everything else. No public port, no tunnel service, no accidental deployment.
Review the change before it's a commit.
Each session exposes one change: its worktree against its base. That is a first-class review object in Mend — a proper diff viewer, line-range comments, and a direct path back to the session that produced it. No branch to push, no PR to open — and the review runs where the session ran, on your own infra, not in a third-party review service.
src/invoice.ts +22 −4
@@ -38,7 +38,8 @@ export function totalWithDiscount
const subtotal = sumLines(invoice.lines); const discounted = subtotal - discount(subtotal);- return round(subtotal) - discount(subtotal);+ return round(discounted);Youdraft · src/invoice.ts:40
Half-cent capture path — is round-half-even applied here too?
@@ -52,3 +53,3 @@ export function round
export function round(amount: number) {- return Math.round(amount * 100) / 100;+ return roundHalfEven(amount * 100) / 100;Mend read the changedraft · not a verdict · planned
round() now rounds half-even, but nothing in this session exercised a half-cent amount.
suggested addition · src/invoice.test.ts
+ expect(round(2.005)).toBe(2.0);+ expect(round(2.015)).toBe(2.02);evidence: seq 0087–0198 · proposed check: pnpm test invoice-rounding
Accept suggestionEditDismiss
Comments become an editable follow-up
Mend assembles the open comments into one editable instruction and saves it to the same session. Today, mend continue delivers the bundle and reopens the work; one-click delivery from the review is next.
The change already belongs to one session
Every write happens in that session's supervised worktree, so the change-to-session link is structural rather than guessed. Hunk-level prompts, commands, and checks are the next layer of the review.
Landing is optional
Commit, merge, or open a PR when the review holds — or don't. Publication is one possible output of a change, not the price of getting a review.
The record is written by the runtime, not the model.
Every Mend session runs on Sealant, an open-source runtime that puts the harness in a workspace it doesn't control and records the session from underneath it: processes, exits, file changes, terminal output, network. The harness can't embellish a record it doesn't write.
Runtime events are observations
Processes, exits, file changes, and terminal bytes come from the runtime record. What the harness says remains conversation, not proof that something happened. Hunk-level provenance inside Mend's review is still in development.
The record outlives the terminal
A session is a durable event log, not a scrollback buffer. Replay it during review, or a month later when someone asks why the change was made.
Observations, not verdicts
Mend reports what happened and stops there. No confidence scores, no "safe to merge". You decide what lands — with the evidence in front of you.
const discounted = subtotal - discount(subtotal);- return round(subtotal) - discount(subtotal);+ return round(discounted);const workspace = await sealant.workspaces.create({ // the session's git worktree, owned by Mend's store source: { kind: "mount", path: worktree },}) const term = await workspace.sessions.open(["claude"]) // detach, reattach, replay — from any sequence, on any deviceconst attachment = await term.attach({ from: lastSeen })for await (const chunk of attachment.output) { terminal.write(chunk)}No private hooks.
This is Mend's whole integration with Sealant — the public @sealant/sdk from npm. Mount the session's worktree into a workspace, open the harness on a PTY, attach to the durable stream from any sequence.
Anything Mend does, your own tooling can do. If you'd rather build your own workflow than adopt this one, the runtime underneath is the part to take.
sealant.dev →What isn't built yet.
Everything above this line runs in the development build today, except the dev-server forwards — those are marked in development where they appear. The pieces below are designed but not shipped.
Context packs and handoffs
Named, versioned selections of files, docs, and decisions. Each session receives an immutable snapshot, so “what did the agent know?” has an exact answer — and a settled session drafts a handoff you can edit and pass to the next one.
Mend reads the change
A machine pass over the record, not just the patch: instruction drift, rewrites nothing exercised, context supplied but never read. Draft comments and proposed checks, each linked to the record or shipped with a runnable check. Never verdicts.
Scoped device access
QR pairing and revocable per-device tokens, replacing the single operator token before the remote setup is called finished.
Clone it and point it at a repository.
Mend is early and in development. The loop on this page — adopt, run your agent, detach, reattach, review, follow up — works today; the section above lists what doesn't yet.
$ git clone https://github.com/sealant-sh/mendOpen-source · local-first · built on @sealant/sdk
Open source
Apache-2.0, one repository. You can read every line of the thing that runs your agents, holds your repositories, and talks to your phone.
Local-first
The store is a directory on your Mend host; sessions run there under your control. No Mend cloud, no Mend account, no telemetry. The agent you bring still talks to its own provider, as it does today.
Private by construction
Remote access rides your own LAN or tailnet. Nothing requires a public port, a hosted relay, or a public repository.