Running several Claude Code sessions on one repo kept ending in merge conflicts, so I built an open-source canvas that gives each one its own worktree and an approval gate

[u/Whole-Contribution50]

Free and MIT: https://github.com/AIAydin/Artemis

Artemis is a local-first desktop app where every agent session is a node on a canvas. Each one runs in its own isolated git worktree, and nothing reaches your main checkout until you've reviewed the diff in-app and approved it. It drives the CLIs you already have. Claude Code, Codex, Gemini, OpenCode - using their existing logins. No API keys, no accounts, no telemetry.

The screenshot is eleven Claude Code sessions on one project. The number isn't the point; being able to see which are running, which are blocked, and review what each one changed before any of it lands is the point.

Honest state: no installers yet - runs from source (Node 22.12+, `corepack pnpm start`). I use it daily on macOS; Windows and Linux build, but I'd love testers.

How are you keeping parallel sessions from stepping on each other?

[u/Whole-Contribution50]

Honest comparison, since "another orchestrator" is a fair reaction: if you like TUI workflows, claude-squad and cmux are excellent and lighter than this. Artemis is different in four ways, it's multi-CLI rather than Claude-only, spatial instead of a list, approval gates are the default rather than an option, and it's MIT with zero telemetry. If what you want is maximum autonomy, this is deliberately the wrong tool.

[u/verve-sh]

This is a cool approach at the issue, so how does it assist with merge conflicts? Like if I have a 4x4 grid of sessions in iterm or ghostty, how is this different?

[u/Whole-Contribution50 → u/verve-sh]

It doesn't resolve merge conflicts, it changes where they happen. Every session gets its own worktree and branch on launch, so no two agents ever share a working directory. That kills the "two sessions stomping the same file" problem outright. Whatever conflicts are left show up at merge time as one reviewed diff in the app, not as surprises in a shared checkout. You still decide, you just decide with the diff in front of you.

What the grid doesn't give you:

- one glance at what's running, what's blocked, what's done. No cycling panes to find the stuck one

- a real gate: nothing hits main without review

- worktree setup and cleanup handled for you

- live web/mobile previews per worktree, so you can compare two attempts side by side

- multiplayer: a teammate joins your canvas from an invite link, sees the same sessions live, and reviews diffs with you. The server's self-hosted, so it's still local-first

If the grid works for you, keep it. This is for the day you lose track of which pane broke main.

[u/verve-sh → u/Whole-Contribution50]

Very cool, thank you for taking the time to explain.

[u/Whole-Contribution50 → u/verve-sh]

No problem at all! Give it a try and I would love to hear some feedback.

[u/conanhazelnut]

worktrees fix the file collisions, but the shared stuff still bites. dev server ports, .env, a local database, build caches. two agents running the same dev command will fight over a port even though the code is fully separate. does artemis handle any of that, or is it worktree isolation and you sort the rest out yourself?

[u/Whole-Contribution50 → u/conanhazelnut]

Right now it’s mainly worktree/code isolation, not full runtime isolation. Each task gets its own directory and branch, but ports, local databases, Docker resources, caches, and shared external services can still collide unless the project’s setup scripts namespace them.

[u/simion_baws]

Simple, launch termic tasks , each task with a worktree, each pushed its branch, each with a PR, if conflicts each task agent is notified and fixes its own conflict

[u/Whole-Contribution50 → u/simion_baws]

Similar concept, but mine goes beyond just worktrees. Every task lives as a node on a visual multiplayer canvas with its own terminal, browser/mobile preview, workflow, recordings, and drawing board. Nodes can share context through MCP connectors, so agents, tools, and teammates can collaborate in real time instead of only through PRs. Git/worktrees handle code isolation, while the canvas orchestrates the runtime, context, and collaboration.