GitKraken shipped Kepler into public preview on July 31, 2026 — and it is the most significant mainstream entry into a product category that did not exist six months ago. Kepler is an Agentic Development Environment (ADE): a control surface for directing multiple AI coding agents across multiple repositories from a single place. It is free during preview, available on Windows, Mac, and Linux, and it works with every major agent via the Agent Client Protocol.

If you run one coding agent on one repo, this is not for you yet. If you have three Claude Code sessions and two Codex tasks running across a monorepo and a shared library, Kepler is the answer to the question you have been duct-taping together with terminal tabs.

What Kepler Actually Is

Kepler is not an IDE. It does not replace your editor. It sits between your backlog and your agents, providing three things that terminal sessions cannot: multi-repo task management, agent-agnostic session control, and a visual board for tracking what each agent is doing.

The core unit is a Task. A Task defines a piece of work, attaches one or more repositories, and launches agent sessions into isolated git worktrees. Every repo in a Task inherits the same shared instructions — no copy-pasting the same prompt into four separate Claude Code windows.

Kepler gives you three entry points for starting work:

• From scratch. Define a task, attach repos, add context by typing, pasting documents, or voice input.
• From an issue. Kepler connects to Jira, Trello, Linear, GitHub Issues, GitLab Issues, and Azure DevOps. It pulls issue context directly instead of making you retype requirements.
• From a pull request. Hand an agent a PR and have it address review feedback or pre-review changes before a teammate sees them.

Each Task runs in its own git worktree per repo. Agents edit code in isolation. No branch collisions, no stash-and-pray, no wondering which Claude Code session touched that file.

Choose Your Agent, Choose Your Mode

Kepler works with any agent that implements the Agent Client Protocol (ACP) — the open standard that lets editors and agents communicate over JSON-RPC. Today that includes Claude Code, Codex CLI, Cursor, Copilot CLI, OpenCode, Gemini, and Augment (Augie). If your agent speaks ACP, Kepler can drive it.

This is the important shift. Previous meta-harness tools like Omnigent and Agent Orchestrator built custom adapters for each agent CLI. Kepler bets on a standard protocol, which means new agents can plug in without Kepler shipping an update. The protocol is maintained at agentclientprotocol.com, backed by SDKs in Rust, Python, TypeScript, Kotlin, and Java, and currently at stable version 1.

Each Task also has a mode and an effort level:

• Plan mode makes the agent explain its approach before touching code. Useful for first passes on unfamiliar repos.
• Default mode prompts for permission before risky operations.
• Autonomous mode lets the agent move freely, with every change gated behind a commit before it goes anywhere.
• Effort level is a cost dial. Turn it down to keep token spend in check during routine edits. Turn it up when the task demands deeper reasoning.

A team rationing Claude Max credits can shift a task to Codex without changing tools. The agent-agnostic framing means Kepler becomes the place where cost and capability decisions happen, not the CLI flags in each agent.

See the Whole Board

Work in progress shows up in three views: a list, a Kanban board sorted by status (exploring, in development, needs review, done), and a console view for scanning everything at once. For teams running four or five agents across a monorepo, this is the difference between “I think Claude is still working on the auth refactor” and a live status board.

Kepler also supports remote access. Start a Task from your desktop, check it from your phone or another browser without leaving the session running unattended. The handoff to GitKraken Desktop is clean — open a worktree an agent is editing and GitKraken Desktop shows a live diff and shortcut for review.

The Broader ADE Landscape

Kepler is not alone. The Agentic Development Environment category crystallized in mid-2026 with several entrants:

The pattern across all of them: git worktrees for isolation, multi-agent support, and a control surface that sits above the individual agent terminal. The differentiator is entry point — Kepler starts from your issue tracker and project management tools, Orca starts from the terminal, Agent Orchestrator starts from CI feedback loops.

Who Should Try Kepler Now

Multi-repo teams are the obvious first audience. If your monorepo plus shared packages mean agents are constantly editing overlapping file trees, Kepler’s per-task worktree isolation solves a real problem.

Teams evaluating agents get a natural testing ground. Run the same task through Claude Code and Codex in separate Kepler sessions, compare outputs side by side on the Kanban board, and decide on evidence rather than benchmarks.

Solo developers running parallel tasks will find the board view useful even if they feel overkill. The ability to define a task once, attach multiple repos, and have shared context flow to every agent session saves real time.

The catch: Kepler is in public preview, which means the feature set is not locked and feedback shapes what ships next. It requires agents to support ACP, which currently covers the major players but may not include every niche tool. And the free pricing during preview comes with no guarantee about post-preview tiers — though GitKraken has a history of keeping individual developer tools accessible.

Getting Started

1. Download Kepler from gitkraken.com/kepler (Windows, Mac, Linux).
2. Connect an agent in Settings — Kepler auto-detects installed CLIs for Claude Code, Codex, Copilot, and others.
3. Create a Task, attach repos, add your prompt, pick an agent and mode, and launch.
4. Track progress on the board. Hand off to GitKraken Desktop for code review.

The coding agent space spent the first half of 2026 arguing about which model is best. The second half is about which tool manages the agents you already use. Kepler is GitKraken’s entry into that fight, and it is the first one backed by a company that knows how to ship Git tooling at scale.

Related articles

• The Meta-Harness Era: When Your Coding Agent Needs Its Own Tech Lead
• Orchestration Topology Is the New Bottleneck in Agentic Coding
• Coding Agents in 2026: Three Hard Lessons HN Developers Learned the Expensive Way