AI changed how code gets written.

It didn’t change how developers need to understand, review, and ship that code.

That’s the real shift happening inside engineering teams right now.

Developers are generating more code than ever with agents, AI IDEs, and autonomous workflows. But the workflow around that code is becoming fragmented:

• terminals everywhere
• disconnected worktrees
• scattered branches
• giant pull requests
• lost context
• constant switching between tools

Code generation got faster.

Managing it got harder.

That’s why GitLens 18 exists.

Not as another AI chat panel.

Not as another code generation tool.

But as a Git-aware workflow surface built for modern, parallel, agent-driven development.

Whether developers are working in VS Code, Cursor, Windsurf, Kiro, Trae, or other VS Code-based AI IDEs, the underlying Git workflows are becoming dramatically more complex.

GitLens 18 is designed to bring structure, visibility, and Git context back into those workflows.

What’s New in GitLens 18

GitLens 18 introduces major new workflows designed for modern agent-driven development:

• The Commit Graph becomes a true workbench for active development
• AI-powered Review + Commit Composer directly inside the Graph
• Deep Claude Code integration with live agent session visibility
• New Agent Sessions sidebar + experimental Agent Kanban workflows
• Multi-worktree WIP rows for managing parallel work
• Focused Graph mode + branch pinning
• Visual History + Treemap repository visualizations
• Detached Graph windows for multi-monitor workflows
• Conflict resolution directly inside the Graph
• Significant Graph performance and reliability improvements

The Workflow Around Git Changed

For years, Git workflows were mostly linear.

One developer.
One branch.
One active task at a time.

Most Git tooling was built around that assumption.

The Commit Graph primarily existed to help developers visualize history after work had already happened.

But agent-driven development fundamentally changes the shape of software workflows.

Developers are no longer just writing code sequentially. They’re coordinating multiple AI-powered tasks simultaneously, managing several worktrees in parallel, reviewing generated changes continuously, and iterating faster than traditional Git workflows were ever designed to support.

The repository becomes a living system of active work instead of a static timeline of completed work.

That shift introduces a completely new set of problems:

• fragmented worktrees
• disconnected agent sessions
• noisy repositories
• giant generated diffs
• parallel branches everywhere
• constant context reconstruction

And most tools still treat the Commit Graph like a passive history viewer.

GitLens 18 changes that.

The Commit Graph Is No Longer Just History

GitLens 18 transforms the Commit Graph into a workbench for understanding, reviewing, and managing active work as it happens.

The Commit Graph is no longer just a place to read history. It’s where both you and your agents work.

At the center of this transformation is a new embedded details panel that brings critical Git workflows directly into the Graph. Developers can inspect commits, review working changes, compare branches, conduct AI-powered reviews, compose commits, stage files, and resolve conflicts without switching views or losing context.

The revamped details panel also introduces richer file-tree actions, multi-diff support, and dedicated Compose, Review, and Compare modes, making it easier to move from understanding changes to acting on them.

Beyond the details panel, GitLens 18 expands the Commit Graph into a broader workspace for modern development. A new overview sidebar keeps active branches, work-in-progress, and agent sessions within easy reach, while integrated agent workflows surface live status and contextual actions directly within Git context. Multi-worktree visibility, focused Graph views, branch pinning, repository visualizations, and new ways to manage parallel work all help developers stay oriented as workflows become increasingly complex.

Instead of bouncing between Source Control, terminals, browser tabs, pull requests, worktrees, and AI tools, GitLens brings those workflows together into a single workbench inside your IDE.

The Commit Graph no longer exists just to visualize repository history.

It becomes the place where developers and their agents review, coordinate, and move work forward.

Review and Compose Directly in the Graph

Generated code is easy to create.

Structuring, validating, and understanding it before it reaches pull request review is the hard part.

GitLens 18 brings both Commit Composer and AI-powered Review directly into the Commit Graph.

Developers can now continuously organize and validate generated work without leaving Git context.

Inside the Graph, you can:

• review generated changes
• identify risky areas with severity indicators
• compare outputs across branches
• structure intentional commits
• preview changes with multi-diff support
• continuously validate work before massive PRs pile up downstream

That’s one of the biggest shifts in GitLens 18:

Review becomes continuous instead of delayed.

Generated work stays understandable before repository chaos compounds.

AI Agents, Deeply Integrated Into Git Workflows

Most agent tooling today treats coding agents as isolated terminal processes.

GitLens 18 approaches the workflow differently.

Agent sessions become deeply integrated into Git-aware surfaces across the IDE.

Agent status now appears directly throughout GitLens:

• Home view branch cards
• Commit Graph overview cards
• Commit Graph details panels
• Agent Sessions sidebars

Developers can instantly see:

• which sessions are active
• which are waiting for input
• which are idle
• which branches and worktrees are associated with each session

Git context stays attached to the workflow the entire time.

Instead of reconstructing context across disconnected terminals and tabs, developers can monitor, review, and act on agent workflows directly inside GitLens.

Agent Workflows Need Git Context

Agents are becoming incredibly effective at generating code, but code generation alone doesn’t solve the hardest parts of software development. Developers still need to understand what changed, why it changed, where the work belongs, and whether the output is actually safe to ship.

That’s where most modern agent workflows start to break down.

Without strong Git context, even simple workflows become difficult to track. Branches drift. Worktrees multiply. Sessions become disconnected from the actual repository state. Developers end up bouncing between terminals, AI chat windows, Source Control views, pull requests, and browser tabs just to piece together what’s happening.

GitLens 18 approaches the problem differently by integrating agent workflows directly into Git-aware surfaces inside the IDE.

Instead of treating agents as isolated tools running outside the development workflow, GitLens ties sessions directly to branches, work-in-progress states, commit history, and repository structure. Developers can connect sessions, monitor progress, review generated changes, compare outputs, and commit work from the same workflow surface without constantly reconstructing context.

The workflow stays connected.
The repository stays understandable.

Parallel Workflows Are The New Normal

One of the biggest changes happening across engineering teams right now is the shift from sequential development to parallel development.

Modern developers are no longer working through a single task from start to finish before moving to the next thing. They’re coordinating multiple active streams of work simultaneously.

An engineer might have one agent refactoring business logic, another updating analytics instrumentation, another generating tests, and another handling error recovery flows. All while reviewing pull requests and managing active branches in parallel.

Traditional Git tooling was never designed for that level of concurrency.

Most workflows still assume a simpler model: one developer, one task, one branch, one active change at a time. But agent-driven development completely breaks that assumption. Repositories become crowded with in-flight work, disconnected worktrees, temporary experiments, partially generated changes, and branches that constantly move.

GitLens 18 was built around the idea that modern Git workflows are inherently parallel.

One of the clearest examples is the new Multi-Worktree WIP experience. The Commit Graph now surfaces a work-in-progress row for every active worktree, not just the one you’re currently working in. Instead of constantly switching contexts to understand what is happening across your repository, developers can see, review, and act on changes across all active workstreams from a single view.

Alongside live worktree visibility, GitLens 18 introduces focused Graph views, branch pinning, integrated worktree awareness, agent session visibility, and workflow tools designed to help developers stay oriented inside rapidly changing repositories.

Instead of hiding parallel work, GitLens surfaces it clearly and keeps it actionable.

You can see what’s happening across your repository, understand which work requires attention, and move between active workflows without losing context.

Modern development isn’t becoming more linear.

It’s becoming more parallel.

GitLens 18 helps developers see, understand, and manage that complexity without drowning in noise.

Visual Agent Worfklows: A New Way To Manage Parallel AI Work

Visualizations in the Graph

GitLens 18 introduces powerful new ways to understand and manage your repository directly from the Commit Graph.

The new Visualizations mode helps you see where work is happening, how your repository is evolving, and where AI agents are actively contributing. Switch between the enhanced Visual History timeline and new experimental Treemap views to explore repository activity from entirely new perspectives.

GitLens 18 also introduces an experimental Agent Kanban view that transforms the Commit Graph into an operational dashboard for active AI workflows. Instead of tracking agent progress across terminals and disconnected tools, Agent Kanban provides a centralized view of every active session, automatically organized into workflow states like Needs Input, Working, Idle, and Inactive. Developers can approve or deny agent permissions, review proposed plans, jump directly to working changes, and keep parallel agent workflows moving without losing Git context.

Visual History

Visual History transforms your repository into an interactive timeline of development activity.

See how work evolves over time with rich filtering, zooming, and exploration tools. Scope activity to specific files or folders, focus on individual branches, and quickly identify patterns across your repository’s history. Whether you’re investigating a recent change or exploring long-term trends, Visual History helps you understand how your codebase evolves at a glance.

Treemap Visualizations (Experimental)

Treemap visualizations provide a spatial view of your repository, helping you quickly identify where work is concentrated and how activity is distributed across your codebase.

GitLens 18 includes three Treemap views:

• Files Treemap — Explore your repository structure through an interactive map of files and folders, sized by their relative footprint.
• Commits Treemap — Instantly identify hotspots of development activity by visualizing the areas of your codebase receiving the most changes.
• Agent Activity Treemap — See where AI agents are working in real time, including the files they’re reading and actively modifying.

Each Treemap supports hover details, click-to-zoom navigation, and breadcrumbs for exploring your repository from the highest level down to individual folders and files.

Together, Visual History, Treemap visualizations, and Agent Kanban give developers a richer understanding of both repository activity and active agent workflows, all from within the Commit Graph.

Git Workflows Need To Evolve

A lot of AI tooling today focuses almost entirely on generation speed.

How quickly can code be written?
How fast can changes be suggested?
How much work can be automated?

But software development has always been much larger than code generation alone.

Teams still need review workflows, commit history, repository awareness, branch management, pull requests, visibility into active work, and confidence in the structure surrounding the code itself.

None of those responsibilities disappear just because agents can generate code faster.

That’s why GitLens 18 isn’t trying to replace Git workflows.

It’s evolving them.

The Commit Graph becomes more than a visualization layer. It becomes a coordination surface where developers can manage active work, understand generated changes, monitor parallel workflows, review diffs continuously, and keep repositories structured as development accelerates.

That shift is critical because the future of software development isn’t just about generating more code.

It’s about maintaining clarity as the scale and speed of development continue to increase.

That’s the future modern teams actually need.

GitLens + GitKraken Code Review

GitLens 18 also pairs naturally with GitKraken Code Review.

GitLens helps developers:

• manage agent work
• structure changes
• review diffs
• create clean commits
• push organized pull requests

GitKraken Code Review then helps teams:

• reduce review noise
• highlight meaningful logic changes
• build context faster
• review agent-generated code confidently

Together, the workflow becomes:

Start → Track → Review → Commit → Push → Understand → Approve

That matters because the bottleneck in modern development is shifting.

It’s no longer:

“Can we generate code?”

It’s:

“Can we understand and trust what was generated?”

GitLens 18 Is Built For The Agent Era

Git workflows are changing.
Development workflows are changing.
The shape of repositories is changing.

And the tools developers use need to evolve with them.

GitLens 18 is built around a simple idea:

Modern development needs Git-aware workflows that can keep up with agents, parallel work, and AI-generated changes without sacrificing visibility or control.

That’s why GitLens 18 transforms the Commit Graph from a passive visualization into a working surface for modern software development.

Because in the agent era, understanding your workflow matters just as much as accelerating it.

GitLens for IDEs is available for:

• VS Code
• Cursor
• Windsurf
• Trae
• Kiro

Learn more about the GitLens 18 release and specific updates in the GitLens 18 Release Notes.