Agents come and go. Your factory stays.
An open-source, self-hosted AI software factory that runs on your machine. Work comes in from your trackers, nothing runs until you press Start, and each task runs with as much process as its risk needs, up to a pull request.
The work in your tracker, grouped by state. A form reply pushed by a custom runner was filed as GAR-2 and waits for Start.
One tracker item in, one pull request out.
A normal day, as the acceptance suite drives it in the real window. Work arrives and is filed once. You start it. The factory plans it by rules, runs it in its own worktree, lets you step in, opens the pull request and decides from measured risk whether it can merge. It only comes to you for what needs a person.
A form reply is filed once, in your tracker.
Signals come from GitHub issues, Sentry, PostHog, Slack, Discord or a runner of your own. A match is linked to the item it belongs to, noise is held back with the reason, and an unsure match becomes one question.
Everything lands in one tracker, filed once.
Each project has one primary tracker, YouTrack or GitHub Issues. Sources send signals that are filed there once, and when the item is done the loop closes at every source it came from.
Quick, standard or careful, by the rules you can read.
Quick is one step and a pull request. Standard adds an independent review. Careful adds a spec, architecture, verification and a plan you approve. Sensitive areas such as auth add their own steps.
Hold any step and work with the agent yourself.
The agent's own session opens in an in-app terminal, in the same checkout. Continue resumes the pipeline from the work as it now stands. Release ends the hold and keeps what you did.
Merged by measured risk, never by an agent's word.
The decision uses CI state, lines changed, areas touched, whether a person committed and branch protection. Auto-merge is off by default, and migrations, CI files, secrets, auth and payments always ask.
The project learns, not the agent.
A git repository per project holds the factory's rules and a ledger of lessons. A run loads only the lessons relevant to its step. Sharing is git pull and git push, and secrets never go in it.
The desktop app, as of v0.10.0.
Board. The work in your tracker, grouped by state. A form reply pushed by a custom runner was filed as GAR-2 and waits for Start.
“If Claude Code disappeared tomorrow, the factory should survive.”
The test this codebase is built to pass. Your tracker, your plans, your lessons and your history stay intact. Only an adapter changes.
Adapters, not integrations
Runtimes are routed by capability. Replacing an agent CLI changes one adapter, never the factory.
Rules decide, not models
The daemon decides from stored facts and fixed rules. No model output decides whether work is done, planned or stuck.
Gates, not assurances
Progress depends on measured facts like checks.typecheck == PASS && review.blocking_findings == 0.
Artifacts, not chat
A reviewer reads the diff and the spec, never the implementer's transcript.
Default deny
No tool, path or domain is reachable without a grant scoped to one assignment.
Your machine, your logins
Agents run under your own subscriptions. State lives in ~/.tandemise. There is no Tandemise cloud.
Work in progress, built in the open.
Tandemise runs real work end to end against real repositories every day. The APIs, data formats and UI still change from release to release, so expect rough edges. There is no Tandemise cloud service and no sign-up.
Known limitations, plainly written: docs/KNOWN_LIMITATIONS.md.
- Mission engine, plans across roles, measured gatesv0.2
- Claude Code, Codex and generic CLI runtimesv0.2
- Backlog with a WIP limit, routines, spend and time limitsv0.5
- Per-step models, your own skills, GitHub issues in and outv0.6
- Hand work in and back, pinned as a snapshotv0.7
- Evals for every run and setupv0.8
- Intake from any source into one primary trackerv0.9
- Planner lanes and merge by measured riskv0.9
- Hold a step and work with its agent in the terminalv0.9
- A brain repository per projectv0.9
- Optional self-hosted relay for teamsv0.9
- Installers for macOS, Linux and Windowsv0.10
- Design system package, WCAG 2.1 AA desktop appv0.10
- Signed macOS and Windows installersplanned
- OS credential store on Linux and Windowsplanned
- Hold for runtimes other than Claude Codeplanned
- Cleaning up finished missions' worktreesplanned
Recent releases.
- Installers for macOS, Linux and Windows on every release
- The desktop app meets WCAG 2.1 AA
- Accessible sizes, tooltips, tokens and components for the design system, with a Storybook
- Readable status colours in light mode, and dialog autofocus
- Intake from any source into the primary tracker
- Plan each task's steps, models and gates, and merge by risk
- Hold a task and work with its agent in the terminal
- A brain repo per project for memory and the factory
- An optional, slim, self-hosted relay
- Score every run and try a setup on evals before it goes live
- Hand work in and back, pinned as a snapshot
- Turn labelled GitHub issues into missions and report back on them
- Route each step to the right model and escalate on retry
- Bring your own skills and pin them to the roles that use them
How is Tandemise different from Claude Code or Codex?
It runs them. Tandemise is the factory around your agents: it takes work from your tracker, plans it, runs each step on the agent you staffed for it, opens the pull request and decides whether it can merge. The agents do the work, under your own logins.
Is there a hosted version?
No. There is no Tandemise cloud service and no sign-up. Solo needs no server. A team can run an optional relay with Docker Compose that shares who is working on what; it runs no agents and stores no work.
Will it merge pull requests on its own?
Not unless you turn it on. Auto-merge is off by default, and only a person can turn it on, in the app, for a project with a brain, after a backtest of past decisions. Migrations, CI and infrastructure files, secrets, auth and payments code, and the careful lane always ask.
Can I step in on a task?
Yes. Hold any running or waiting step and the agent's own session opens in a terminal in the same checkout. Continue hands it back; Release keeps what you did without resuming. Hold needs Claude Code today.
Where does my data live?
On your machine, in ~/.tandemise. The daemon listens on 127.0.0.1. Tokens go in the macOS Keychain; on Linux and Windows they are kept in ~/.tandemise/secrets.json with mode 0600 until OS credential stores are supported.
What does it cost to run?
Tandemise is free and Apache-2.0. The agents run on your own subscriptions, and spend and time limits stop work at the limit you set and ask before going further.
Which platforms are supported?
macOS (Apple Silicon and Intel), Linux (AppImage and .deb) and Windows, with installers on every release. They are not signed yet, so the system warns on first open. The app carries its own daemon and Node; you need git and the agent CLIs you want to use.
Install it.
The app brings its own daemon and Node; you need git, the agent CLIs you want to use (Claude Code, Codex, …) and, for pull requests and GitHub Issues, a signed-in gh.
- macOS · Apple silicon (.dmg)
131 MB - macOS · Intel (.dmg)
137 MB - Linux · x64 AppImage
127 MB - Linux · x64 .deb, Debian and Ubuntu
100 MB - Windows · x64 installer (.exe)
122 MB
The installers are not signed yet: on macOS, right-click the app and choose Open the first time; on Windows, choose More info → Run anyway.
$ git clone https://github.com/tandemise/tandemise.git $ cd tandemise && nvm use $ npm install && npm run build $ npm run dev # starts tandemd, then the app
Then add a repository, give the project a tracker in Settings → Intake, and press Start on a ready item on the Board.
Built for one product, opened up for everyone.
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. Most of its shape is borrowed, not invented.
Agents as persistent teammates that come back only when something needs your approval.
Paperclip ↗An organization with roles, goals, budgets and governance above whatever agents you already run.
Buzz ↗People and agents in one workspace, every agent with a person who answers for its work.
Hermes Agent ↗What a project learns should outlive any single agent or session.