🎉 Update 5/22: Chunk sidecars are now available to all CircleCI users, including Free plans.

Local development and remote validation were always meant to work together: developers iterate on their machine, run a few manual checks, then push to CI to clear code for production. But AI development broke that balance, flooding CI with a volume of commits no developer has read, let alone tested.

Chunk sidecars restore the balance: lightweight, preconfigured environments that run alongside your local workflow and validate changes as they happen. Agents get actionable feedback while they work, and CI stays focused on the final-mile checks that let you ship with confidence.

Balancing the inner and outer loops

Software development consists of two loops. The inner loop is where code gets written and tested locally, and the outer loop is where CI validates it after the push.

AI speeds up the inner loop but increases the risk of incomplete changes making it into the outer loop. CI becomes the only safety net, often catching basic issues across an ever-growing volume of commits. And as the validation bottleneck grows, the gap between code generation and actual delivery widens. The 2026 State of Software Delivery found that the typical team increased feature branch activity by 15%, but main branch throughput declined nearly 7%. At the same time, main branch workflows failed more often than at any time in the past 5 years. Development activity is up, but deployments are trending down.

The technical cost of this is obvious. By the time a failure surfaces in CI, the agent has moved on, and the context needed to resolve it is gone. The developer has to reconstruct what happened, re-prompt the agent, and start another cycle. Multiply that across dozens or hundreds of changes a day and the lack of progress on main makes more sense.

The business cost is just as real. Every round-trip from CI back to the agent burns tokens and compute. Every cycle spent catching and fixing a broken unit test in the outer loop is a cycle that could have been resolved locally in seconds. The cost per shipped change is climbing, and the majority of that cost is going toward problems that should never have reached CI in the first place.

Lightweight checks belong in the inner loop, where the agent is actively working, so that feedback arrives while the change is still in motion. That keeps agents iterating on clean code locally and keeps CI focused on the integration, security, and release work that actually gets code to production.

Building this into a real workflow requires environments that boot in milliseconds, match your CI environment, and return results before the agent’s feedback window closes.

How sidecars work

A sidecar is a lightweight microVM environment that mirrors your project’s stack and runs within your local development workflow. It detects your tech stack, test commands, and build system automatically, so there’s no manual configuration to get started. Your agent syncs code to it, runs a scoped set of checks (we’re calling these microbuilds), and gets immediate feedback on whether the change works.

The process is hooks-driven. When your agent pauses to evaluate its work, the sidecar runs the microbuild automatically. If the build fails, the agent iterates until it passes, then hands control back to you. No push to CI is required at any point in the loop.

Sidecars are designed to return feedback within 60 seconds, keeping them within the built-in feedback windows that many agents operate within.

They’re also agent-agnostic, working exactly the same with Claude Code, Codex, Cursor, or something you built yourself. The sidecar doesn’t care where the code comes from, only that it works before it hits your shared repo.

Accelerate your inner loop with sidecars

Here’s a typical workflow with sidecars wired into an agent session.

1. Install the Chunk CLI:

brew install CircleCI-Public/circleci/chunk

2. Initialize and authenticate:

chunk init
chunk auth set circleci

chunk init detects your test commands, configures your validation hooks, and wires up your agent’s settings.

3. Run the chunk-sidecar skill in your agent:

In your AI agent of choice, invoke the chunk-sidecar skill. It syncs your repo to a sidecar and runs your validations there. The skill handles the full loop: sync local changes, run validation, interpret failures, fix locally, and repeat until everything passes. The developer doesn’t have to intervene, copy-paste logs, or manually trigger anything.

The inner loop stays fast with the help of a few key features:

• Snapshots: Capture a configured environment so future sidecars boot from a known-good state. No reinstalling dependencies on every run. You can share snapshots across your team so everyone validates against the same environment.

• Auto-detection: The CLI discovers your tech stack, build system, and test commands. It’s not always perfect on the first pass (if you’ve ever set up a CI pipeline, you know), but agent skills handle the refinement loop so you’re not manually debugging configuration.

• Environment parity: Because sidecars run in a remote environment that matches your CI stack, they catch things your laptop can’t. Tests that pass on macOS but fail on Linux. Dependencies that need cloud resources your local machine doesn’t have. When a sidecar says the code is good, you can trust that CI will agree.

When the agent hands the control back to you, all the basic checks are already done. Your CI pipeline can focus on system-level validation: how your changes integrate with the full codebase, how they behave in a shared environment, and whether they hold up against everything else your team is shipping.

What’s next

Chunk sidecars are available now for customers on any CircleCI plan, including free. Install the Chunk CLI, run chunk init in your project, and start a sidecar session from your agent to get started.

This is the first step toward rebalancing the inner and outer dev loops, but that’s only half the story. Once validated changes are coming out of the inner loop consistently, the next challenge is moving them through CI and into production faster. That requires smarter merge handling, earlier conflict detection, and precise coordination between what agents validate locally and what pipelines need to verify at scale.

That’s where we’re headed, and quickly: giving teams a complete validation path from first prompt all the way to production. We’ll be sharing more as this develops. In the meantime, try sidecars on your own projects and share your feedback on Discord.