Nobody Can Review AI Code Fast Enough. Three Products Shipped in 72 Hours.

Pull request review time is up 441% since AI coding agents went mainstream. Nearly a third more pull requests now merge with no human review at all. The bottleneck didn't disappear when agents got better at writing code. It moved downstream, to the part nobody built tools for: reviewing, coordinating, and merging what agents produce.

Three products shipped in the same 72-hour window to close that gap. GitKraken launched Kepler on June 15. OpenHands released Agent Canvas on June 16. GitHub made the Copilot App generally available on June 17. None of them are trying to make agents write better code. They are all building the infrastructure to handle what agents already produce.

The numbers behind the bottleneck

Google's DORA team surveyed nearly 5,000 developers for their 2025 report on AI-assisted software development. Their central finding: AI is an amplifier. It makes strong engineering teams faster and weak ones worse. Throughput is up. Stability is not.

The harder data comes from Faros, which measured actual repository behavior across 22,000 developers rather than relying on self-reporting. Their telemetry paints a sharper picture of what happens when code generation scales but review infrastructure doesn't:

• Median time in PR review increased 441% (up from 91% the prior year)
• Bugs per developer rose 54% (up from 9% the prior year)
• Incidents per pull request jumped 243%
• Pull request size grew 51%, creating cognitive overload during review
• 31% more pull requests merged with no review at all

GitKraken's own developer survey adds another data point: 78% of the 493 developers surveyed are already running AI coding agents, and 47% run them throughout the full working day. At that level of parallel usage, branch conflicts, stale branches, and context-switching between agent sessions become the dominant cost.

Their CEO, Matt Johnston, put it plainly: "Developers are spending less time writing code and more time managing the output of systems that generate it."

GitKraken Kepler: the merge coordination layer

GitKraken launched Kepler on June 15 as what they call an "Agentic Development Environment." The core concept is "Code Flow": how work moves between developers, agents, repos, branches, and production. Kepler manages that flow end to end.

The features target specific pain points that anyone running multiple agents has hit:

• Cross-repo Tasks treat a database migration, API change, and frontend update as one coordinated effort even when they span three repositories. Shared context, cross-repo conflict detection, and coordinated delivery happen underneath a single Task object.
• Commit Composer takes raw agent output (which tends to be messy) and restructures it into clean, reviewable commits. Developers stop rewriting git history by hand after every session.
• Conflict Resolver and Auto-Rebasing handle the branch collisions that parallel agents create. Kepler surfaces and resolves conflicts as part of the delivery pipeline, keeping branches current without manual intervention.
• Multi-Agent Oversight shows every agent in flight across every repo from one dashboard. What is running, what needs human input, what is ready to merge.

GitKraken's differentiator is a decade of Git-specific engineering. Their argument: anyone can build a worktree UI in a quarter, but branch graph awareness, conflict resolution, and merge readiness are problems they have been solving since 2014. Kepler runs on that foundation.

The pricing model matters here too. Kepler is a standalone commercial product with a current promotion of 70% off Pro. No usage-based token metering. You pay for the coordination layer, not for the agents themselves.

GitHub Copilot App: parallel execution and automated merge

GitHub made the Copilot App generally available on June 17 for macOS, Windows, and Linux. It is not another IDE extension. It is a standalone desktop application built for dispatching and managing multiple agent sessions.

The technical foundation is git worktrees. Each agent session gets its own isolated working directory linked to the repository. You can run ten agents against the same codebase simultaneously without conflicts, stashing, or branch-switching. The "My Work" dashboard tracks all active sessions, open issues, pull requests, and background automations in one view.

Three features define the delivery play:

Canvases are bidirectional work surfaces where plans, pull requests, terminal sessions, and release checklists become artifacts that both humans and agents can update. The agent shows its progress on the canvas as it works. You can redirect it mid-execution instead of waiting for the pull request to discover it went the wrong direction.

Cloud Automations let you schedule recurring agent work that runs on GitHub-hosted sandboxes. Nightly test runs, auto-labeling new issues, drafting release notes. Your laptop does not need to be open.

Agent Merge is the most consequential feature. It lets the agent respond to reviewer comments, drive CI back to green, and merge the pull request once conditions you define are met. You set the threshold: address feedback only, fix CI, or merge when all checks pass.

Agent Merge has a governance catch. If your team relies on informal review norms rather than enforced branch protection rules, the agent will merge without human sign-off. It follows the rules the GitHub API exposes. If those rules allow it, it merges. Audit your branch protection settings before turning this on.

The billing reality is also worth noting. GitHub moved all Copilot plans to usage-based AI Credits on June 1. A single frontier-model session consuming 30,000 tokens can cost 30 to 40 credits. Running five parallel agents on a complex refactor means five concurrent token streams. Pro subscribers at $10/month can exhaust their allowance in a single afternoon of heavy agentic work.

OpenHands Agent Canvas: event-driven delivery automation

OpenHands released Agent Canvas on June 16. The positioning is different from the other two. OpenHands is open source (MIT licensed), model-agnostic, and self-hostable. Agent Canvas is the new primary interface for the platform.

The core idea: most coding agent work is still manual. You open a terminal, start a session, paste context, wait, review, and repeat. Agent Canvas turns that into scheduled and event-triggered workflows.

First release focuses on practical automations:

• Slack message triggers that start an agent investigation
• GitHub pull request review automation
• Linear issue triage on a schedule
• Recurring tasks like dependency checks, repo summaries, docs drift detection

Agent Canvas runs the OpenHands agent out of the box, but it also supports Claude Code and OpenAI Codex through the Agent Client Protocol. You can start locally on your laptop, move workflows to a VM for always-on execution, or connect to OpenHands Cloud and Enterprise when you need shared infrastructure and governance controls.

The model-agnostic design solves a real cost problem. Background automations running on a schedule should not default to the most expensive model. LLM Profiles let you route routine tasks to cheaper models and reserve frontier models for complex debugging or architectural work. That matters when agents are running every hour, not just during interactive sessions.

OpenHands reports 77,000 GitHub stars and millions of downloads. NVIDIA and AMD are both partners, providing compute paths from local GPUs to cloud infrastructure. The open source positioning is deliberate: agent infrastructure should not be a black box, and if agents are running real engineering work, developers should be able to inspect how they operate.

What the convergence tells you

Three independent companies identified the same gap and shipped solutions in the same 72 hours. That is not coincidence. The market recognized that coding agents solved the generation problem, and the next bottleneck is what happens between code generated and code merged.

The three products attack different parts of the delivery pipeline:

1. Kepler owns branch and merge coordination. It treats Git as the delivery surface, not just plumbing where code eventually lands.
2. Copilot App owns parallel execution and the automated merge loop. It leverages GitHub's native integration with CI, issues, and pull requests to close the gap between generation and merge.
3. Agent Canvas owns event-driven automation. It connects agents to the systems where work starts (Slack, GitHub, Linear) and runs them on schedules.

The pricing divergence is structural. GitHub charges per AI Credit consumed (usage scales with agent activity). GitKraken charges a flat subscription for the coordination tool. OpenHands is free and open source, with Enterprise as the paid upgrade for governance and scale.

What to do about it

If you are running more than one coding agent in parallel, you already have the delivery problem. Here is what the three launches suggest:

Audit your review pipeline before adding more agents. The Faros data shows 31% more PRs merging with no review. If your team is rubber-stamping agent output because the volume is too high, adding faster agents makes the quality problem worse, not better.

Check branch protection rules before enabling automated merge. Agent Merge and similar features will merge what the API allows. If your review process is informal rather than enforced in GitHub settings, automate merge at your own risk.

Budget for delivery overhead. The agent license is not the total cost. Time spent managing branches, resolving conflicts, reviewing large diffs, and fixing bugs from untested merges is the hidden cost the DORA and Faros data quantifies.

Consider open source for infrastructure you want to control. OpenHands gives you the automation layer without platform lock-in. Kepler gives you Git-native coordination without token metering. GitHub gives you the tightest integration but at usage-based pricing that scales with every session.

The bottleneck will keep moving. Each layer that gets automated pushes the problem one step further along the pipeline. For now, the layer that needs attention is the one between generation and production. These three products are the first coordinated attempt to build it.

Sources: GitKraken, GitHub Copilot App GA, GitHub product blog, OpenHands, DORA 2025 (Google), Faros AI telemetry analysis, ByteIota analysis, InfoQ coverage, Sven Roth analysis