Several coding agents. One workspace that shows what each is doing.

Every coding agent runs its own session with its own picture of the repository. Point two at the same codebase and they edit the same file from different assumptions. The engineer ends up as the messenger between chat windows.

Context dies when a session ends, so the next run starts by re-explaining the codebase. Every additional agent makes this worse, not better.

Running one coding agent is a workflow. An engineer can now install several from different vendors on the same machine, Claude Code, Codex, Cursor, Grok, Gemini among them, and each will hold a task long enough that starting another one while the first works is the obvious move.

That is what changed. Once there are two, the missing product is not a better model. It is the place the two of them meet: one task board, a handoff that survives a restart, and one view of who is doing what.

Harmony connects the coding agents engineers already pay for and runs them as one fleet: one task board, durable sessions, explicit approvals.

Close the app. Reopen. Your agents are still working. Quit Harmony with sessions running in the background. Open it again and land where you left off: agents still running, tabs and terminal history still there.

Work is broken into tasks an agent claims, so a claimed task is visibly owned and claimed tasks reduce double-starts when the roster is authoritative.

Agents hand off through durable messages that survive a restart, acknowledged end to end. Parallel work uses separate git worktrees so edits do not collide on one shared index.

No agent spawns another without your signature, and every approval is single use.

The beachhead is engineers already paying for two or three coding agents and losing hours reconciling them. They do not need convincing that agents work. They need the layer that makes agents work together.

From there the surface widens: any team that adopts agents inherits the same coordination problem, and the orchestration layer sits above every model provider at once.

Bring-your-own keys travel from your machine straight to the provider: never stored, never proxied, never logged, never in a support bundle.

We do not sign in to providers for you, and a provider subscription cannot be routed through us. That is an architectural line, not a policy promise.

The desktop app and terminal agent are free and stay free. Harmony does not resell inference, so the free product never has to be crippled to survive.

For engineers who would rather not manage keys, a metered gateway is built and deliberately switched off until the economics and the terms have been checked. Distribution first, monetization second.

A Windows build is published and downloadable now, through a one-line installer that verifies the exact SHA-256 before anything runs. Builds are currently unsigned, so the OS warns on first install; the checksum is published with each release.

The orchestration layer is shipping code: task claiming, durable handoffs, single-use approvals, an MCP harness with 30+ tools, and 40+ built-in agent roles.

Next is macOS and Linux through the same digest-verified pipeline Windows already uses, plus code signing so installs stop triggering OS warnings.

Then depth in the orchestration layer: richer departments, longer-running work, tighter cost control. Hosted workspaces stay research until the credential and spend questions have real answers.