Manifold — One app. Many repos. Even more agents.

Your tools. Unmodified.

Manifold doesn't wrap, proxy, or re-skin your agents. When you open Claude Code inside Manifold, it is Claude Code — the same binary, the same keybindings, the same output. Same for Codex. Same for Gemini CLI. Manifold gives each agent its own terminal, its own workspace, its own branch. You keep the experience you already know.

Claude Code

~ $ claude
Claude Code v1.0.12
Model: claude-opus-4-6

> refactor the auth module
I'll refactor the auth module to use
OAuth2 with PKCE flow...

  Updated: src/auth/middleware.ts
  Updated: src/auth/session.ts
~/project $ █

Gemini CLI

~ $ gemini
Gemini CLI v0.1.0
Model: gemini-2.5-pro

> write integration tests
I'll create integration tests for
the auth and API modules...

  Created: tests/auth/oauth2.test.ts
  Created: tests/api/routes.test.ts
~/project $ █

Codex

~ $ codex
Codex v0.1.0
Model: o3

> add cursor-based pagination
I'll add cursor-based pagination
to the API routes...

  Updated: src/api/routes.ts
  Updated: src/api/handlers.ts
~/project $ █

Same tools. Same output. Manifold just gives each one its own workspace.

Three agents. One repo. Zero conflicts.

Every agent works on its own isolated branch — a full copy of your codebase that stays in sync with main but never collides with another agent's work. Manifold creates, manages, and cleans up these branches automatically. You focus on what to build. Manifold handles where they build it.

▸

Isolated branches Each agent gets a dedicated workspace branched from your main codebase. No merge conflicts between agents.

▸

Automatic lifecycle Branches are created when you spawn an agent, removed when you're done. No manual git choreography.

▸

Live status See which agent is running, waiting, or finished. Watch file changes stream in real time.

▸

Conflict detection If two agents touch the same file, Manifold flags it immediately — before it becomes a merge nightmare.

main ----------------------------------------
  |
  +-- feature/auth-refactor
  |     Claude Code ................... running
  |
  +-- feature/api-pagination
  |     Codex ........................ running
  |
  +-- feature/test-coverage
        Gemini CLI ..................... done

One app. Every project. All your agents.

Register all your repositories in Manifold. Switch between them instantly. Spin up agents on any project with one click. Run a Claude Code agent refactoring your backend while a Gemini agent writes tests for your frontend — in two different repos, at the same time, from the same window.

  MANIFOLD -- Projects

  > manifold-api         3 agents running
    > manifold-web          1 agent running
    > manifold-cli          idle
    > design-system         2 agents running

  ----------------------------------------

  j/k navigate   enter select   n new project   q quit

Developers don't need dashboards. They need terminals.

Manifold's UI is a multi-pane terminal environment. Each agent gets a real PTY. You see raw output — streamed, unfiltered. Open a shell tab alongside your agents. Browse files and diffs without leaving the app. Everything is keyboard-navigable. No electron bloat. No loading spinners. Just your agents, working.

Resizable multi-pane layout (agent terminal + code viewer + file tree + shell)
Built-in diff viewer — compare agent branches against main
File browser with syntax highlighting
Shell tabs that persist across restarts
AI-generated branch names and commit messages

+------------------------+--------------------------+--------------------------+
| MANIFOLD  manifold-api | agents: 3   branch: main | cmd-K: commands          |
+------------------------+--------------------------+--------------------------+
| FILE TREE              | Claude Code              | DIFF VIEWER              |
|                        | feature/auth-refactor    |                          |
|  v src/                |                          |  src/auth/middleware.ts  |
|    v auth/             | $ Refactoring auth...    |                          |
|      * middleware.ts   |   Updated middleware.ts  |  - const auth = basic()  |
|      * session.ts      |   Updated session.ts     |  + const auth = oauth2() |
|        oauth2.ts       |   Created oauth2.ts      |  - secret: env.KEY       |
|    v api/              | + 3 files changed        |  + secret: vault.get()   |
|      routes.ts         | $ _                      |                          |
|      handlers.ts       |                          |                          |
+------------------------+--------------------------+--------------------------+
| AGENTS                 | Codex                    | Gemini CLI               |
|                        | feature/api-pagination   | feature/test-coverage    |
|                        |                          |                          |
|  * Claude  running     | $ Adding pagination...   | + 24 tests passed        |
|  * Codex   running     |   Updated routes.ts      | $ _                      |
|  o Gemini  done        | $ _                      |                          |
+------------------------+--------------------------+--------------------------+

How it works

Register a project

Point Manifold at any git repository on your machine.

Spawn agents

Pick an agent (Claude Code, Codex, or Gemini CLI), describe the task, and launch. Manifold creates an isolated branch and drops the agent in.

Ship the work

Review diffs, commit changes, and create pull requests — all from inside Manifold.