Learn how AI coding tools like Cursor are increasing pull request volumes and how Harness helps teams manage build queues, speed up testing, optimize CI execution, and simplify Jenkins migration.

TL;DR
- Scale builds with Harness managed cloud, self-managed, or Kubernetes-based infrastructure without maintaining every build machine.
- Accelerate builds with Cache Intelligence, Build Intelligence, and Docker Layer Caching.
- Reduce CI feedback time with Test Intelligence, parallel execution, and matrix strategies.
- Connect AI coding assistants such as Cursor, Windsurf, and Claude Code to create, trigger, and troubleshoot CI pipelines in Harness MCP.
A developer using agents such as Cursor can raise several pull requests before lunch. Each one triggers compilation, unit tests, integration tests, and security checks. If your Jenkins pipelines are sized for last year’s pull request volume, those jobs wait in the queue before a single build step runs.
Developers can now write code in minutes and still wait far longer for CI to validate it. If CI can’t keep pace, the productivity gains from AI-driven development get lost in build queues and delayed feedback.
The Hidden CI Bottleneck: When More Code Means More Waiting
For teams running self-hosted Jenkins environments, increasing CI workloads introduces infrastructure and operational challenges. Jenkins relies on a controller-agent architecture, where build workloads are distributed across configured agents. As pipeline activity increases, teams typically provision or auto-scale additional agents, allocate more compute resources, and manage concurrency to prevent jobs from piling up in queues.
Increasing the number of Jenkins build machines can help address capacity constraints, but it also introduces infrastructure costs and additional administration. Teams still need to maintain the Jenkins controller, manage agent availability, handle plugin dependencies, and keep pipeline configurations consistent. There is also the work of maintaining Groovy-based Jenkinsfiles, shared libraries, and custom scripts. As pipelines evolve across multiple teams, troubleshooting dependencies and standardizing configurations gets harder.
More infrastructure improves throughput, but you still maintain the controller, the agents, and the redundant work in every pipeline.

Why Teams Are Rethinking Jenkins for Modern CI
The Harness Software Delivery Agent combines managed build infrastructure, build optimizations, and centralized pipeline management to help engineering teams scale their CI workloads.
The Software Delivery Agent doesn’t just run your Jenkinsfile elsewhere. It changes how you provision builders, pick tests, cache work, and govern pipelines.
How Harness Software Delivery Agent Helps Teams Keep Up With AI-Driven Development
The Software Delivery Agent provides several capabilities that address increasing build and test workloads.
1. Scale Build Execution Without Managing Every Build Machine
With Jenkins, teams provision and maintain their own controllers and build agents, or use additional infrastructure integrations to manage execution capacity.
The Software Delivery Agent runs builds on managed, isolated infrastructure (Harness Cloud), so teams can run builds without provisioning and maintaining their own build machines. For organizations with specific infrastructure or compliance requirements, the Software Delivery Agent also supports self-managed and Kubernetes-based execution. This lets teams choose where their workloads execute while keeping a consistent CI pipeline experience.
2. Reduce Repeated Build Work With Intelligent Caching
A common source of unnecessary CI execution time is rebuilding or downloading components that have not changed. For example, a Java application may repeatedly download the same Maven dependencies, compile unchanged modules, and rebuild Docker image layers across multiple pipeline executions.
Jenkins supports caching through plugins and custom configurations, but teams must implement and maintain these mechanisms themselves.
The Harness Software Delivery Agent provides Cache Intelligence, Build Intelligence, and Docker Layer Caching to reduce repeated work.
- Cache Intelligence: Caches and restores dependencies across builds, reducing repeated downloads
- Build Intelligence: Reuses outputs from unchanged build targets, avoiding unnecessary compilation
- Docker Layer Caching: Reuses unchanged Docker image layers rather than rebuilding the entire image every time
These optimizations help reduce build execution time and improve infrastructure utilization, particularly for repositories with frequent code changes and repeated builds.
3. Run Relevant Tests Instead of Repeatedly Running Everything
As application codebases grow, test suites become increasingly expensive to execute. A small code change might trigger hundreds or thousands of unit tests, even when only a limited subset is relevant to the changes.
The Software Delivery Agent’s Test Intelligence analyzes code changes and test dependencies to identify the relevant unit tests that need to run. Instead of executing the entire unit test suite on every change, it selects tests associated with the modified code.
The Harness Software Delivery Agent also supports parallel test execution, so teams can distribute workloads across multiple execution nodes. This reduces unnecessary test execution while keeping meaningful validation of code changes.

4. Parallelize Workloads Without Increasing Pipeline Complexity
Jenkins supports parallel execution through its declarative and scripted pipeline capabilities. However, teams still need to configure execution environments, agent availability, and workload distribution.
The Harness Software Delivery Agent provides parallel stages and steps, as well as matrix strategies, to distribute workloads across different execution environments and configurations.
For example, a team validating an application across multiple runtime versions can use a matrix strategy to run the same test workflow against each version without duplicating the entire pipeline definition. This reduces the time developers spend waiting for build and test results.
5. Standardize Pipelines Across Teams
As engineering organizations grow, consistent pipeline configurations become increasingly important. Different teams may introduce their own Jenkinsfiles, shared libraries, plugin dependencies, and custom scripts. Over time, this leads to configuration drift and makes it harder to enforce common engineering standards.
The Harness Software Delivery Agent provides reusable pipeline templates, centralized secrets and connector management, role-based access controls, and governance policies. Teams can establish standardized templates and allow individual projects to reuse them, rather than maintaining separate configurations.
This helps platform engineering teams maintain consistency, improve visibility, and establish governance without taking away developer autonomy.
6. Bring CI/CD Directly Into AI Coding Tools With Harness MCP
The Harness Software Delivery Agent goes further through the Harness Model Context Protocol (MCP) server. It connects AI assistants to the Harness agent, enabling them to work with CI/CD pipelines and other Harness resources via natural-language instructions. With the appropriate MCP integration and permissions configured, developers can use the Software Delivery Agent directly from supported AI coding environments, including Cursor, Windsurf, and Claude Code.
For example, a developer working on an application in Cursor could ask:
- "Create a Harness pipeline for this application that builds the project and runs its unit tests."
- "Trigger the CI pipeline for my current branch."
- "Check the latest pipeline execution and explain why the build failed."
- "Inspect the execution logs and suggest changes to fix the failure."
- "Update the pipeline to run unit tests in parallel."
The AI assistant uses the Harness MCP tools to execute supported operations, retrieve pipeline execution details, and help investigate failures. The Harness Software Delivery Agent also provides AI skills that extend these workflows with predefined, multi-step operations for tasks such as pipeline creation, execution, and debugging
This complements traditional CI triggers. Teams can configure pull-request events to automatically trigger Harness pipelines, while developers use AI assistants to create, execute, inspect, and troubleshoot pipelines when needed. The result is a more connected workflow: developers write code, run pipelines, and investigate failures without constantly switching between tools.
What Does the Difference Look Like in Real Engineering Environments?
The benefits of modernizing CI infrastructure become easier to see in actual engineering workloads.
Consider Qrvey, an embedded analytics software provider that previously used Jenkins for its CI workloads. Its builds took anywhere from 90 minutes to several hours. The Jenkins infrastructure was limited to 8 threads, making it difficult to increase build capacity without additional investment.
After migrating to the Harness Software Delivery Agent with Harness Cloud, Qrvey reduced its average build time to approximately 12 minutes while using more than 30 parallel threads. The migration took approximately three months.
Read the Qrvey customer story.
If your team hits similar limits, measure queue time, p90 build time, and cache hit rate before making any changes.
From Jenkins to Harness: Modernizing Without Rebuilding Everything
One common concern for organizations considering a move away from Jenkins is the migration effort. Existing Jenkins environments may contain years of pipeline configurations, shared Groovy libraries, custom scripts, plugins, credentials, and integrations. Recreating all of this manually can look like a significant undertaking.
Migrating to the Software Delivery Agent does not necessarily mean rebuilding every pipeline from scratch. The Harness agent includes Jenkins migration guidance and tooling to help teams transition their existing CI workflows. The process involves understanding existing configurations, mapping dependencies, and adapting workflows to the Harness pipeline model.
For detailed Jenkins-to-Harness migration instructions, follow the steps outlined in the Harness Jenkins migration guide. You can use Harness AI to convert your existing Jenkins pipelines or bring your own LLM model to assist with the migration.

Consider a simplified Jenkins pipeline:
pipeline {
agent any
stages {
stage('Build') {
steps {
sh 'make build'
}
}
stage('Test') {
steps {
sh 'make test'
}
}
}
}The same workflow in the Harness Software Delivery Agent is expressed as Harness pipeline YAML with configured steps:
pipeline:
name: Build and Test
identifier: build_and_test
projectIdentifier: your_project
orgIdentifier: your_org
properties:
ci:
codebase:
connectorRef: your_github_connector
repoName: your_repo
build: <+input>
stages:
- stage:
name: CI
identifier: ci
type: CI
spec:
cloneCodebase: true
platform:
os: Linux
arch: Amd64
runtime:
type: Cloud
spec: {}
execution:
steps:
- step:
type: Run
name: Build
identifier: build
spec:
shell: Bash
command: make build
- step:
type: Run
name: Test
identifier: test
spec:
shell: Bash
command: make testThe Bigger Shift: AI-Native Development Needs Modern CI Infrastructure
AI-assisted development makes it possible to generate, review, and revise code faster than ever. But faster code generation does not automatically translate into faster software delivery. Every change still depends on reliable builds, tests, security checks, and timely feedback. If CI becomes a bottleneck, much of the productivity gains from AI coding assistants are lost as developers wait for validation.
Jenkins has served engineering teams well and remains a capable automation platform. But as organizations scale their development workflows, maintaining infrastructure, optimizing execution, managing plugins, and standardizing pipelines gets increasingly demanding.
For teams with growing build queues, lengthy test cycles, increasing infrastructure overhead, or inconsistent pipeline configurations, the Software Delivery Agent is worth evaluating.
As AI coding agents become a standard part of software development, the ability to interact with CI/CD directly from those tools becomes a valuable part of the developer experience. When AI can produce a pull request in minutes, CI feedback should not take hours. Explore the Harness Jenkins migration guide above to begin optimizing your pipelines.
Get started with Harness and run a pipeline of your own.
