A few months ago, a platform team at one of our customers realized it had a problem: a flood of AI-generated pull requests had suddenly filled up one of its merge queues. The team had set up an AI agent to perform routine code maintenance, like dependency updates and config changes, and that had worked — but it'd worked a little too well. Behind all those automated PRs was a backlog of high-priority feature work that hadn’t been merged, leading to a delayed release and developers who couldn’t get much done that morning.
Fortunately the team had the tools it needed to make the necessary adjustments. But it was one of many similar stories we’ve heard over the course of the year about the new pressures on CI. AI coding tools have become entirely mainstream, with 90% of developers using AI according to the 2025 DORA report. And while much of the conversation focuses on how AI is reshaping development workflows, far less attention has been paid to what this shift means for the teams responsible for keeping those workflows running: platform teams.
What the last 12–18 months have taught us
Across hundreds of conversations with platform engineering teams, we’ve seen the same themes emerge again and again:
Scale has suddenly become everyone’s problem.
Thanks to AI coding tools, the CI throughput challenges that once existed only at companies with hundreds of engineers are now showing up for much smaller teams. When a coding assistant can generate three weeks of work before lunch, suddenly every team has a scale problem, and it’s a problem that can’t be kicked down the road. When CI throughput maxes out, software delivery grinds to a halt.
AI expands what’s possible, and changes what CI must support.
AI has gone from the inner loop of local coding assistants running in a developer’s IDE to playing a role in the outer loop of the software delivery lifecycle. Teams are realizing the potential of AI-driven workflows (that can, for instance, find the optimal build path, or fix flaky tests dynamically), and they’re also discovering that bringing intelligence into CI comes with new challenges. An agent’s decisions are inherently unpredictable and may take very different paths depending on the context, making them hard to manage with static, script-based CI.
There's no one-size-fits-all approach to AI.
One of the clearest patterns from the past 12–18 months is just how differently teams apply AI. Even within the same company, two groups may use completely different models, workflows, or levels of autonomy based on their architecture, tooling, and risk posture. The use case also largely dictates how AI should be applied: high stakes changes require humans in the loop, while some workflows, like code maintenance, are more suitable for handing off to AI end-to-end. There’s a full spectrum of automation emerging, and CI needs to support all of it.
The five requirements for CI today
Across everything we’ve seen over the past 12–18 months, one principle keeps coming up: teams want to use AI on their terms. They’re looking for systems that let them apply AI where it genuinely helps, keeping humans in control of intent and outcomes, and maintaining delivery velocity even as machine-generated work accelerates.
AI has raised the bar for CI. CI must now scale to match machine-paced development, adapt in real time when AI proposes different paths, and support a wider spectrum of workflows. The teams who succeed are the ones whose CI systems amplify what AI can do without replacing human judgment.
Reflecting on the past year, we believe five requirements now define whether a CI platform can actually support AI-accelerated development:
1. Scalability
The first impact of AI is sheer volume. CI must be able to instantly scale up the number of build agents, without limits, so that the inner loop of development never stalls under AI-generated load. Otherwise, teams lose the fast feedback cycle that makes AI useful in the first place.
2. Composability
After capacity is handled, CI must help teams control the outer loop of how AI and human work is organized, validated, and prioritized. AI introduces a wide range of use cases, and no two teams use it the same way. CI needs composable primitives so platform engineers can build workflows that reflect their specific requirements, inserting AI where it makes sense and setting human-in-the-loop checkpoints.
3. Adaptability
The next step is truly bringing value into the outer loop with AI-assisted CI. An agent may be able to determine that certain codepaths don’t need to run, or that a flaky test can be remediated and retried immediately. The problem is, static YAML-based pipelines can’t take advantage of this intelligence — so CI must support pipelines that can adapt dynamically at runtime.
4. Programmability
As workflows become both composable and adaptive, the complexity grows, and teams need to reason about that complexity using real software practices. CI must be programmable in general-purpose languages, with reusable abstractions that make the system maintainable as AI-driven paths multiply. This also unlocks another advantage: the ability for agents to generate or modify pipelines programmatically.
5. Governability
Once CI is scalable, composable, adaptive, and programmable, the final requirement is controlling how all of that power is used. CI must provide strong governance: clear permission boundaries, workload controls, audit trails, approval rules, and mechanisms to prioritize human-authored work when agents are generating high volume. This is what keeps AI acceleration aligned with organizational intent instead of creating new operational risk.
The path forward with Buildkite
These five requirements reflect what platform teams are demanding from CI, and they’re the same capabilities that have shaped Buildkite’s architecture for years: machine-scale concurrency, pipelines that adapt at runtime, fully composable primitives, CI expressible as real software, and a governance model that keeps source code and decisions under your control.
The next step is helping teams apply that foundation to AI workflows themselves. Today, we’re announcing five new agentic workflow components that give you the building blocks to easily integrate AI into your CI/CD pipelines:
- A flexible, remote-friendly MCP server: Give AI agents access to Buildkite’s MCP server tools, without needing to install anything or configure an API token. Read more in the docs.
- Model providers: Easily connect your pipelines to the LLM of your choice. You can use your own credentials (e.g. your Claude API key), or use a Buildkite-managed key; we'll handle authentication everywhere your Buildkite agents need it.
- Universal pipeline triggers: Trigger pipelines to run from any external event, including webhooks, with GitHub and Linear events supported as first-class citizens. This lets you build automated workflows that react to real-time signals in your system.
- The Buildkite SDK: Generate pipeline steps for dynamic pipelines in general-purpose programming languages like JavaScript, TypeScript, Python, Go, and Ruby.
- AI plugins: Use a set of Buildkite plugins powered by Claude, Codex, Bedrock, and others to instantly summarize builds and diagnose build errors.
With these components, it’s easier than ever for platform teams to leverage AI however they see fit. A Linear issue can trigger a pipeline step that gathers the issue’s details, hands that context to an AI model, and opens a draft pull request based on the model’s proposed changes. A GitHub PR can automatically invoke an AI reviewer that summarizes changes and highlights potential issues. And when a build fails, an agent can analyze the logs, diagnose the root cause, and push a proposed fix.
In fact, we've built and open-sourced a set of fully functioning reference examples designed to handle these very use cases. You'll find them at github.com/buildkite-agentic-examples, and you can read all about them in the blog post.
Happy building. 🪁
