Skip to content
Tandemise

Open source · Local-first · Work in progress

Agents come and go.
Your company stays.

Tandemise is a local-first operating system for running a software company with interchangeable AI workers, tools, and machines. It owns the missions, roles, permissions, artifacts, and approvals, and hands the actual work to whichever runtime you choose.

Not a model. Not a coding agent. Not a chat client. The organization layer above them.

Your missions. Your roles. Your artifacts. Your machines. Your call.

View on GitHubSee it todayRead the spec

Status

Changelog →
Work in progressv0.7.0macOSNode 22Apache-2.0

Tandemise is being built in the open. It already runs missions end to end against a real repository: planning, isolated Git worktrees, typed artifacts, deterministic gates, and human approvals, pulled from a ranked backlog and stopped at the spend and time limits you set. Each step can run on its own model, GitHub issues can become missions, and your whole setup can live in your repository. You can hand in your own specs, designs, and pull requests, or take over a step and hand it back. The APIs, data formats, and UI still change week to week, so expect rough edges. There's no hosted version and no sign-up. Follow along, or pull it down and try it.

  • ✓Mission engine, DAG scheduling, gates
  • ✓Claude Code, Codex & generic CLI runtimes
  • ✓Desktop app, approvals inbox
  • ✓Ranked backlog, WIP limit, routines
  • ✓Spend & time limits, traced Done-when
  • ✓Per-step models, escalation on retry
  • ✓Your own skills, pinned per role
  • ✓GitHub issues in & out, setup as code
  • ✓Hand work in & back, pinned as snapshots
  • ✓Native notifications
  • ◌Packaged installers
  • ◌Linux & Windows support

How it works

One sentence in, a verified release candidate out.

You describe an outcome and say what done means. Tandemise plans a DAG of tasks across specialized roles (product, design, architecture, developer, reviewer, QA, release) and runs each one in an isolated Git worktree on whichever runtime you've routed that role to. It collects typed artifacts at every stage and checks deterministic gates. It only comes to you for decisions that need human judgement.

  1. Intent
  2. Plan
  3. Approve
  4. Execute
  5. Review
  6. QA
  7. Release candidate
  8. Your call

“If Claude Code disappeared tomorrow, the organization should survive.”

The test this codebase is built to pass. Missions, roles, decisions, and history stay intact. Only an adapter changes.

What it looks like today

The desktop app, as of this week.

All screenshots →

Principles

Why it's shaped this way.

  • Adapters, not integrations

    Every runtime implements one contract. The scheduler asks who can do shell + git and is healthy, never whether Claude is available.

  • Artifacts, not chat

    Product specs, plans, change sets, and review reports are typed and validated. A reviewer reads the diff and the spec, not the implementer's transcript.

  • Gates, not assurances

    Progress depends on measured facts like review.blocking_findings == 0. “The developer says it's done” never counts.

  • Default deny

    No tool, path, domain, or app is reachable without an explicit grant scoped to one assignment. A QA worker can't even discover a production-write tool.

  • Crash recovery built in

    The daemon outlives the window. Runs are checkpointed and resumable, and every restart is recorded in the mission timeline.

  • Local-first

    Your repositories, your machine, your keys. The daemon listens on 127.0.0.1, and the organization's state lives in SQLite on your disk.

Quick start

Build it from source.

Full guide →
macOS · Node 22
$ git clone https://github.com/demogar/tandemise.git
$ cd tandemise && nvm use
$ npm install && npm run build

$ npm run daemon     # starts tandemd
$ npm run desktop    # starts the desktop app

Point it at a Git repository and connect a runtime. Claude Code is detected automatically, and any other CLI can be wired in through the generic adapter. Then create a mission and say what done means, or let a product agent propose it.

Origins

Built for one product, opened up for everyone.

Read more →

Tandemise started as a private tool with one job: helping build Beveloce, an AI cycling coach, with a team of agents instead of a single chat window. Once it was running real missions every day, it was cleaned up, stripped of everything specific to that product, and released as open source so any developer can use it and extend it.

Most of its shape is borrowed, not invented. The names and order of the phases, how work is split across roles and between people and agents, and the operating model around budgets, approvals, and standing work all come from the projects below. What Tandemise adds is mostly the assembly: those ideas in one local-first place, with typed artifacts and gates measured from facts.

  • Grok Bot

    Agents as persistent teammates that come back only when something needs your approval. The approvals, the inbox, and routines follow that model.

  • Paperclip

    An organization with roles, goals, budgets, and governance above whatever agents you already run. The organization layer, the roles, and the limits come from there.

  • Buzz

    People and agents working side by side in one workspace. Tandemise borrows its owned-agent model, owner-reviewed drafts, and runtimes as replaceable adapters.

  • Hermes Agent

    An agent that grows with you and remembers what it has done. The idea that missions, decisions, and history outlive any single agent comes from there.

Thank you to the people behind each of them.

Follow the build in the open.

Star the repository to follow progress, open an issue with ideas, or read the contributing guide if you'd like to help.

demogar/tandemiseContributing