# EnsoAI: running multiple AI coding agents across Git worktrees in parallel

> EnsoAI is a desktop application that maps each Git worktree to its own persistent AI terminal session, letting Claude, Gemini, Codex and others work simultaneously on separate branches. The README opens with a notice that EnsoCode is the project's own successor, which changes the calculus for anyone starting fresh.

**J3n5en/EnsoAI** — Multiple Agents, Parallel Flow

- Repository: https://github.com/J3n5en/EnsoAI
- Website: https://enso.j3.do
- Stars: 999 · Forks: 120
- Language: TypeScript
- License: MIT
- Published: 2026-10-11 · Updated: 2026-10-11 · Language: en
- Canonical page: https://hysenlabs.com/projects/j3n5en-ensoai

## Each Git worktree gets its own persistent AI terminal session

The central design choice in EnsoAI is to bind an AI agent's terminal session to a Git worktree rather than to a repository. A Git worktree is a checkout of a different branch in a separate directory, and most tools give it no special status. Here, the binding means the agent running on a feature branch never inherits the conversation history from the main branch.

The desktop application runs on Electron 39 or newer, with React 19 and TypeScript 5.9 in the front end. The terminal layer uses xterm.js and node-pty, which means the AI agent runs as a real CLI process rather than an embedded API call. Whatever the agent prints to standard output appears in the worktree's terminal. The app does not call an AI API directly. It launches an agent's CLI and lets that process own the session. If the agent requires its own API key or authentication, you configure that outside EnsoAI.

Sessions persist across switches, so the agent on a stalled branch keeps its conversation state while you work in another worktree. This is the design feature that makes parallel work across branches practical rather than just possible.

## Installing with Homebrew, Scoop, Winget, or downloading a platform binary

EnsoAI ships as a pre-built binary for macOS, Windows and Linux. On macOS, the quickest path is through Homebrew:

```bash
brew tap j3n5en/ensoai
brew install --cask ensoai
```

On Windows, both Scoop and Winget are supported. With Scoop:

```powershell
scoop bucket add ensoai https://github.com/J3n5en/scoop-ensoai
scoop install ensoai
```

With Winget:

```powershell
winget install J3n5en.EnsoAI
```

Manual downloads are listed on the GitHub Releases page. The macOS side distinguishes Apple Silicon (the arm64 DMG) from Intel (the plain DMG), and Linux gets both an AppImage and a deb package.

Building from source requires Node.js 20 or newer and pnpm 10 or newer. The package.json pinned packageManager field names pnpm 10.26.2 specifically. After cloning and running `pnpm install`, `pnpm dev` starts the development build and `pnpm build:mac`, `pnpm build:win` or `pnpm build:linux` produces a distributable. Code-signing for production macOS builds is not covered beyond the unsigned build variant flags exposed in the npm scripts.

## Six named agents and a custom CLI slot for anything else

The built-in agent list covers Claude, Codex, Gemini, Cursor Agent (cursor-agent), Droid and Auggie. Each occupies its own terminal session, isolated to the worktree it was started in.

Beyond those six, any CLI-based agent can be added in settings by entering its launch command. That single statement is the extent of what is documented about custom agents: a launch command is enough, and no further configuration format is given.

The practical limit is that the integration path is a CLI invocation. If an AI service has no CLI, or if its CLI requires an interactive setup flow that the terminal cannot automate, EnsoAI gives you no alternative integration point. There is no plugin API, no SDK and no webhook. The six built-in agents work because each has a CLI that the app knows how to launch; your own choice has to match that pattern to be usable.

The app also includes an AI code review feature listed as generating commit messages and performing code reviews using your chosen agent. The README does not specify which agents support the code review path and which do not.

## Monaco editor, visual Git diff and a 3-way merge editor built into the same window

The editing layer aims to reduce the need to switch to another tool for routine tasks. For text editing, EnsoAI embeds Monaco, the same editor at the core of VS Code, with language-specific highlighting across 50 or more file types. Keeping the editor inside the same window matters when working across multiple worktrees: you can review a file and keep the AI terminal visible at the same time.

Git operations stay in the same window rather than requiring a separate client. Staging and committing go through a file-oriented interface where the diff is visible alongside the commit form, which matters when you are reviewing code an AI agent wrote rather than code you wrote yourself. The interface is described as keyboard-centric in the README.

The 3-way merge editor is the feature most tied to the worktree use case. Conflicts that arise from two agents modifying the same file are the specific problem it addresses. Both the incoming and the current version are laid out side by side, with a live preview of the merged result updating as work proceeds. A command palette at Cmd+Shift+P exposes the IDE Bridge action, which hands the current worktree off to VS Code or Cursor when a task needs capabilities outside what the embedded editor provides.

## The README's opening block names a successor before describing the project

A reader skimming the feature list would miss the most consequential line. Before the logo, before the tagline and before the installation instructions, the README opens with a notice that EnsoCode is the successor, described as a local-first desktop workbench for orchestrating teams of autonomous coding agents, and states that anyone starting fresh should go there instead.

This is the project's own statement, and it reframes everything below it. The last push was on 2026-09-08 and the repository is not archived. The authors have, however, already named their next iteration and pointed new users elsewhere.

What the README does not provide is a migration guide. There is no section explaining what EnsoCode adds, what it changes in the configuration format, or whether a worktree layout or settings JSON from EnsoAI carries over. The link to the EnsoCode repository is the only handoff point between the two projects.

## No cloud layer, no browser interface, and no collaboration features

EnsoAI is a desktop application. Cloud sync, shared sessions, remote access and a web interface are all absent. Multi-window support covers opening multiple workspaces on the same machine simultaneously, not sharing a session with another user. Every AI session runs in a terminal on the local machine, with the AI agent's process attached to that terminal.

Colour scheme synchronisation with Ghostty is the closest the application comes to a network feature. Selecting a Ghostty theme changes the application's own colour scheme to match, and the README describes the available library as containing more than 400 options. It is a display preference with no network traffic involved.

For a team where one developer wants to hand off a worktree session to another, or where the build machine is remote and SSH is the only access, EnsoAI has nothing to offer. The IDE Bridge opens VS Code or Cursor on the same machine; it does not forward to a remote development environment. No plan to add remote access appears in either the FAQ or the project documentation.

## Electron, sqlite3 and pnpm at the centre of the dependency graph

Electron 39 wraps the application, with React 19 powering the interface and TypeScript 5.9 throughout. The terminal layer pairs xterm.js with node-pty, which is why agent output behaves like a real terminal session rather than a text box. Git operations run through simple-git, and sqlite3 holds session state, settings and commit history in a local database rather than in memory or a remote service.

The pnpm requirement is worth noting for teams with a standardised Node.js toolchain. The packageManager field in package.json pins pnpm at 10.26.2. A developer who tries to install dependencies with npm or yarn will encounter an error from corepack or from pnpm's postinstall script, which calls electron-builder install-app-deps and then runs a script named prepare-node-pty-conpty.mjs. That second step handles native module compilation for node-pty on Windows, and the README gives no further detail about what it does or whether it requires a Visual Studio build environment.

The repository includes AGENTS.md and CLAUDE.md at the top level alongside the standard README. Those files are not covered here, but their presence shows the project's own development uses the same agent tools the app is built to host.

## Conclusion

EnsoAI suits a developer who already works with multiple Git worktrees and wants to delegate separate branches to separate AI agents without context switching. It does not suit anyone who needs a browser-based or cloud-hosted setup, or who wants a stable foundation: the README directs new adopters to EnsoCode as the successor. Before adopting it, check that your AI agent of choice supports a CLI invocation, since that is the only integration path the app exposes, and read the EnsoCode repository to understand what the migration path looks like.

## FAQ

### What is EnsoAI?

EnsoAI is a desktop application that assigns each Git worktree its own persistent AI agent terminal session, allowing Claude, Codex, Gemini and other CLI-based agents to work on separate branches simultaneously. It runs on Electron and supports macOS, Windows and Linux.

### How do I install EnsoAI on macOS?

The recommended path is Homebrew: run `brew tap j3n5en/ensoai` followed by `brew install --cask ensoai`. A DMG download is also available on the GitHub Releases page, with separate files for Apple Silicon and Intel.

### Which AI agents does EnsoAI support?

Six agents ship with built-in configurations: Claude, Codex, Gemini, Cursor Agent (the cursor-agent CLI), Droid and Auggie. Any other CLI-based agent can be added in settings by entering its launch command.

### Does EnsoAI replace VS Code or Cursor?

EnsoAI is an orchestration layer for worktrees and agents rather than a full IDE. The README FAQ draws that distinction: the intent is to run agent sessions and manage worktrees, then open VS Code or Cursor for tasks that require a full development environment.

### What are the build requirements for EnsoAI?

Building from source requires Node.js 20 or newer and pnpm 10 or newer. After installing dependencies with `pnpm install`, use `pnpm dev` for development or a platform-specific build script for a distributable.

## Sources

- [J3n5en/EnsoAI on GitHub](https://github.com/J3n5en/EnsoAI)
- [License: MIT](https://github.com/J3n5en/EnsoAI/blob/main/LICENSE)
- [Project website](https://enso.j3.do)
- [README](https://github.com/J3n5en/EnsoAI/blob/main/README.md)
- [Releases](https://github.com/J3n5en/EnsoAI/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/j3n5en-ensoai