The Commit Graph is where your development and agentic workflows come together. 

Visualize branches and commits, manage parallel work and agents, and run your entire Git workflow from one view.

AI changed how code gets written. It also changed what developers spend their time doing.

Today, developers are reviewing AI-generated changes, coordinating parallel work across branches and worktrees, cleaning up commit history, resolving conflicts, and getting everything ready to merge.

That work is often scattered across terminals, Git views, browser tabs, staging tools, agent sessions, and conflict editors.

With GitLens 19, we’re bringing those workflows together.

The Commit Graph is now the workbench for modern development workflows. It gives developers one Git-aware surface for understanding repository activity, tracking parallel work, monitoring supported coding agent sessions, reviewing generated changes, comparing revisions, composing clean commits, automating rebases, and resolving conflicts with AI.

Agents can generate the code. GitLens gives you the context and control to review it, shape it, and ship it.

The Commit Graph Is No Longer Just History

The Commit Graph has always helped developers understand how a repository evolved.

But modern development requires more than looking backward.

Today, you might have several active branches and worktrees at once. You may be coding in one while an agent works in another. Incoming changes are waiting upstream. A review needs attention. A conflict may be developing between two parallel streams of work.

Git history is still important, but you also need to understand what is happening right now.

Every stream of development eventually connects back to Git. Branches, worktrees, coding agents, incoming changes, pull requests, and merge history all have Git context behind them. The Commit Graph brings that context together so you can understand the work and decide what happens next.

That’s why the Commit Graph has been reimagined from a place where you visualize what happened into a workbench where you can see what’s happening now and move the work forward.

Review. Compose. Compare. Rebase. Resolve. Manage parallel branches, worktrees, and agent sessions. 

All from the Commit Graph.

In GitLens 19, that evolution becomes the default experience. When you open GitLens, you start directly in the Commit Graph, where you can see the state of your repository and move immediately into the workflow that needs your attention.

It’s no longer another Git view you navigate to.

It’s your control center for parallel development.

Now You Can Start With the Full Picture

Opening GitLens should answer the most important questions about your repository before you start making changes:

• Where am I?
• What is actively changing?
• What is ahead or behind?
• What is coming from upstream?
• Which worktrees have uncommitted work?
• Is an agent still working or waiting for input?
• Where is this branch expected to merge?

GitLens 19 makes those answers easier to find directly in the Commit Graph.

The working-changes overview is now always visible, even when you have a single clean worktree. It keeps your current worktree, HEAD, upstream, merge target, and ahead or behind status within reach, alongside working changes from other worktrees.

New row markers and reference pills make HEAD, upstream, and merge targets easier to identify. Commits available upstream but not yet pulled into your branch now receive their own visible indicator, complementing the existing indication for unpushed commits.

The result is a Commit Graph that does more than show history. It continuously orients you within the repository.

You can see where your work began, where it’s headed, what’s arriving, and what still needs attention.

Less time reconstructing repository state. More time acting on what needs you.

Focus When the Repository Gets Noisy

A complete repository view is powerful until it becomes overwhelming.

That’s especially true in larger repositories or parallel workflows where several branches, worktrees, and agents may be active at once.

GitLens 19 turns the Graph header’s previous jump-to-reference action into a dedicated Focus Branch control. With one action, you can scope the Graph to the current branch and its relevant history.

That gives you two useful perspectives:

• Zoom out to understand everything happening across the repository.
• Focus in when you need to review or finish one specific stream of work.

The Graph’s sidebar now floats over the repository by default and collapses when it loses focus, giving the commit history more room without removing access to the contextual information and actions around it. If you prefer the previous shared-space layout, you can pin it again.

Together, these changes make the Graph feel less like a dense reporting surface and more like a workbench that adapts to the task in front of you.

Keep Parallel Agent Work Connected to Git Context

Coding agents make it possible to have more work happening at the same time.

They also create a new coordination problem.

An agent may be working in one worktree while you’re coding in another. Another session may be waiting for input. Changes may be accumulating across multiple branches. And when you return to a session later, you need to know not only what the agent was doing, but where that work lives in the repository.

GitLens connects those pieces.

For Claude Code sessions, live status can appear directly alongside the associated Git work, showing whether the agent is working, idle, or needs input. Session details remain connected to the branch and worktree where the work is actually happening.

GitLens 19 adds another important step: Resume Agent Session from a working-changes row.

Right-click a WIP row and choose from the AI agent sessions associated with that worktree. You can reopen a live session or resume an earlier one, even when no agent is currently active on the row.

Instead of asking, “Which terminal was that in?” you can return to the work from the same place you understand its Git state.

GitLens brings these workflows into VS Code and supported AI-native IDEs including Cursor, Windsurf, Trae, and Kiro.

Live agent monitoring currently applies to Claude Code through GitKraken’s Claude Code hooks. GitLens can also send work to supported IDE chats, the Claude Code extension, and detected CLI agents, but dispatch and live monitoring are distinct capabilities.

Take Work From Change to Merge Without Leaving the Graph

The value of the reimagined Commit Graph isn’t any single feature.

It’s what happens when those features work together.

Consider you’re coordinating an agent-built checkout improvement in a separate worktree.

1. See the Work in Progress

The Commit Graph shows a working-changes row for the worktree, along with the files changing and the associated Claude Code session status.

You can continue working elsewhere without losing visibility into the agent’s progress.

2. Review What the Agent Produced

When the work is ready, you can select the worktree and start an AI-assisted review directly in the Graph.

The review returns an overview, focus areas, and severity-tagged findings tied to specific file and line locations. Instead of burying the you in style noise, the workflow is designed to prioritize a smaller number of meaningful findings.

3. Send a Finding Back for Another Pass

A finding reveals a problem in retry handling.

Rather than copying the finding into another tool, you can send it back to an agent from the review. The handoff can include the entire review, one focus area, or an individual finding.

The review becomes an action loop, not a report that sits unread.

4. Compose the Result Into Clean Commits

The issue is fixed, but the changes still span several concerns.

Agent-generated changes aren’t necessarily organized for human review. Compose helps turn that raw output into intentional Git history.

Instead of creating one large commit, you’re able to now organize the work into logical, reviewable commits with AI-generated messages. Move files between commits, reorder them, preview synthesized diffs, and shape a history that explains the change instead of simply recording it.

When everything looks right, Compose writes the commits with built-in safeguards including content-hash verification, automatic stashing, and undo support.

5. Compare Before Moving Forward

Before preparing the branch for merge, you can use Compare directly from the Commit Graph to understand exactly what changed.

Compare commits, branches, revisions, and working changes without moving into another workflow or rebuilding repository context.

That gives you another opportunity to validate the work before changing history or bringing the branch up to date.

6. Rebase With AI

The code may be ready, but the branch isn’t.

While the agent was working, main moved forward.

Instead of stepping through a traditional interactive rebase one commit at a time, GitLens can intelligently automate much of the rebasing process directly from the Commit Graph.

AI helps propose a cleaner history while you stay in control of the final result, reducing the manual busywork required to prepare a branch for review and merge.

7. Resolve the Conflict

Parallel work sometimes collides.

If the branch conflicts during integration, the workflow stays connected to the same repository context.

GitLens Resolve, currently labeled Preview, can process conflicted files in parallel and provide streamed progress, confidence indicators, and a rationale explaining each proposed resolution.

Nothing is applied until you review the result.

For conflicts AI shouldn’t guess at, GitLens provides clear explanations and manual fallbacks such as Take Current, Take Incoming, or Delete File.

A Better Starting Point for Every Developer

Making the Commit Graph home also means it has to work before there’s anything to graph.

When no repository is open, the Commit Graph now provides actions to open a folder, clone a repository, or start a new project. In web and virtual environments, GitLens can instead offer an option to open a remote repository.

Signed-out users also receive a dedicated getting-started experience directly in the Graph, with options to create a free account or sign in.

These changes reinforce the larger shift: the Commit Graph isn’t simply where experienced users inspect repository history.

It’s where the GitLens workflow begins.

We’ve Been Building Toward This

GitLens 19 is the clearest expression of the Graph-as-home vision, but this transformation didn’t happen overnight.

GitLens 18 turned the Graph into a workbench. The embedded details panel brought Compare, Review, and Compose into the Commit Graph while working changes, additional worktrees, agent status, and contextual side panels became part of the same repository surface.

GitLens 18.1 made parallel work more visible. The working-changes bar provided a clearer view across worktrees, including per-worktree agent status and actions around active changes.

GitLens 18.2 brought AI conflict resolution into the workflow. Resolve arrived in Preview for merge, rebase, and cherry-pick conflicts, helping developers work through one of the most disruptive parts of parallel development without losing repository context.

GitLens 18.3 made the workbench a daily driver. Compose gained clearer commit and recompose workflows, Review added follow-up conversations, and Resolve gained conflict details, confidence indicators, rationales, and manual fallback actions.

At the same time, older and disconnected workflows continued moving into the Graph.

GitLens 19 completes that direction by making the Commit Graph the main experience from the moment GitLens opens.

The Bottleneck Moved

Coding agents can generate more code than ever before.

But generating code is only the beginning.

Developers still need to understand what changed. They need to keep parallel work organized, validate AI-generated changes, send issues back for another pass, shape work into clean history, compare the result, prepare branches for merge, and resolve conflicts when parallel work collides.

That’s where the work has moved.

GitLens 19 is built around that reality.

The reimagined Commit Graph brings repository understanding, parallel agent work, Review, Compose, Compare, AI-powered Rebase, and conflict resolution together into one development workbench.

Coding agents changed how quickly software can be created.

GitLens 19 is built for what comes next.

See the work. Understand it. Shape it. Ship it.

From Chaos to Control You Can See.

Learn more details about GitLens 19 latest features and changes in our release notes.