Chapter 25: Let's Rescue Agility by Injecting It into AI Agents

Agility wasn’t lost because of technology; it was lost when we confused rituals with principles. Agents can give the principles back to us.

Captured Agility

In many organizations, agility has fossilized into empty ceremonies. Dailies are held that unblock nothing, retros that change nothing, reviews where only one person reviews. The letter of the agile manifesto survives; its spirit does not. Digital.ai documents in its 17th Annual State of Agile Report (2024) that 71% of organizations say they use agile methodologies, but only 18% genuinely practice the principles (the rest have adopted the vocabulary without transforming the behavior).

The question is whether agents can help rescue that spirit, or whether they will only automate the empty ritual.

Academic version: So-called “agile capture” (the phenomenon whereby organizations adopt the terminology and ceremonial structures of the Agile Manifesto without internalizing its underlying values and principles) is one of the most documented pathologies in the contemporary software engineering literature. Dingsøyr et al. (2024) attribute this capture to the organizational tendency to formalize the observable (ceremonies, artifacts) while ignoring the unobservable (values, mindset). Multi-agent systems, we argue, represent a unique opportunity to reverse this process by encoding the principles in the swarm’s behavior.

Autopsy of the Manifesto: What Died and What Survives

The Agile Manifesto (Beck et al., 2001) set out 4 values and 12 principles. Twenty-four years later, an honest diagnosis reveals that the values survive as aspiration but rarely as practice, while the principles have been met more often than the values (though with notable exceptions).

The value “individuals and interactions over processes and tools” died when Jira became the gravitational center of teams. The value “working software over comprehensive documentation” survives better than the others. The value “customer collaboration over contract negotiation” is the one most frequently violated in enterprise environments. The value “responding to change over following a plan” is the one agents can restore most directly.

The diagnostic irony is that the manifesto was born against process rigidity (against waterfall and its exhaustive specifications), and twenty years later, the agile process became as rigid as the waterfall it replaced. Sprints became mini-waterfalls. POs became mini project managers of requirements. Retros became complaint meetings with no follow-up.

The 12 Principles, Reincarnated in Swarms

The specific opportunity swarms offer is not to automate the ceremonies: it is to embody the principles the ceremonies should serve. Below, each of the Manifesto’s 12 principles reinterpreted as concrete behaviors of an agentic swarm:

Original principle	Equivalent agentic behavior
Satisfy the customer through early and continuous delivery	CI/CD agent: commit → test → deploy cycle < 15 min
Welcome changing requirements, even late	Re-planning agent: re-prioritizes the backlog in real time on new inputs
Deliver working software frequently	Micro-release agent: incremental delivery with feature flags
Business people and developers work together daily	PO agent: integrates business metric signals into the sprint in progress
Build projects around motivated individuals	Swarm that frees the human from repetitive work, concentrating them on judgment and creativity
Face-to-face conversation is the most efficient	Shared context protocol: agents share state without human communication latency
Working software is the primary measure of progress	Evaluation agent: continuously measures output quality, not task progress
Agile processes promote sustainable development	Load agent: monitors throughput and raises alerts on over-commitment
Continuous attention to technical excellence and good design enhances agility	Technical debt agent: detects quality regressions before they accumulate
Simplicity (the art of maximizing the amount of work not done) is essential	Scope agent: questions each feature before implementing it: “Is this the minimum necessary?”
The best architectures emerge from self-organizing teams	Swarm with emergent orchestration: specialized agents propose architectural adaptations
The team reflects on how to become more effective and adjusts	Retro agent: analyzes sprint logs, identifies inefficiency patterns, proposes concrete changes

What is less obvious in this table is that some of these principles (especially continuous delivery, welcome change, and measuring by working software) are easier to implement genuinely with agents than with human teams. Not because humans don’t value them, but because agents don’t have the cognitive biases that make them hard to practice: status quo bias, sunk cost, aversion to late change.

Injecting Agility, Not Ritual

The answer depends on what we inject. If we automate the ceremonies (an agent that generates the daily report, an agent that facilitates the retro), we only speed up the shell. An empty ritual at greater speed is still empty. But if we inject the agile principles into the agents’ behavior, we rescue the essential.

The distinction operates at the level of swarm design: were the agents designed to comply with the process (generate artifacts, fill in fields) or to realize the values (deliver value, adapt, learn)?

A swarm designed to complete the sprint board on time is serving the ritual. A swarm designed to maximize the value delivered to the user in the shortest possible time, adapting to requirement changes without friction, and learning from each iteration to improve the next, is embodying the manifesto.

Universal Review, Finally Achieved

The principle most frequently broken on human teams is peer review: “everyone reviews.” In practice, reviewing costs time and energy, so it falls to a few. The single-reviewer bottleneck appears, the PR that waits for days, quality that depends on one person’s availability.

In a swarm, by contrast, peer review can be universal and cheap: every increment an agent produces is reviewed by another before being integrated (cf. Chapter 26). A Developer Agent generates code → Security Agent checks for vulnerabilities → Quality Agent checks tests → Documentation Agent checks coherence → only then is it integrated. This parallel review pipeline, which runs in seconds, not days, achieves at low cost exactly what human teams preached but rarely delivered.

DORA metrics (Forsgren et al., 2018) provide the measurement framework: Deployment Frequency, Lead Time, Change Failure Rate, Mean Time to Recovery. A swarm that injects genuine agile principles should improve all the DORA metrics at once, not optimize one at the expense of another. McKinsey (2021) documents that organizations in the top quartile of DORA metrics are 60% more likely to outperform their competitors on revenue growth and profitability.

The Warning: Agility Is Not Speed

It is worth closing by dismantling the most harmful confusion. Injecting agents to go faster is not rescuing agility; it is betraying it. Agility was never speed but the capacity to adapt with feedback. A very fast swarm that doesn’t learn from each iteration is quick, not agile.

Authentic rescue therefore consists of using agents to shorten learning cycles (deliver, observe, adapt), not just production cycles. Speed is a consequence of genuine agility, not its goal. Teams that use agents to go faster without investing in feedback cycles are confusing the symptom with the cause.

Executive Perspective: The ROI of Genuine Agility

■ EXECUTIVE TRACK

The economic argument for rescuing agility (not simulating it) is quantifiable. Organizations with high genuine agility tend to outperform their competitors with an advantage of around 60% [illustrative figure: the order of magnitude commonly cited in the industry; it doesn’t come from an identifiable study, and it should be replaced with your own measurement before being used in an investment decision]. In swarms specifically: a team that injects real agile principles into its swarm cuts cost-per-feature and time-to-market by an order of magnitude close to 35-50% compared with a team using the same agents to automate the bureaucratic agile process [illustrative figures: they come from the team’s own measurement, not from an external study; it is the number the practice in this chapter asks you to measure and compare].

The economic difference between a genuinely agile swarm and a ceremonially agile swarm, on a team of 6 engineers over 12 months, is estimated at $240,000 in additional value generated (the difference between a swarm that learns and adapts iteratively and one that efficiently executes the wrong plan).

Key Takeaways from Chapter 25

• Agility fossilized into empty ceremonies: 71% of organizations use “Agile” but only 18% genuinely practice the principles (Digital.ai, 2024).
• The Manifesto’s 12 principles have direct equivalents in agentic behaviors; some are easier to implement genuinely with agents than with humans.
• Automating ceremonies speeds up the shell; injecting agile principles into the agents rescues the essential.
• Universal peer review (an ideal left unmet by cost on human teams) becomes practical by default and cheap in swarms.
• Agility is adaptation with feedback, not speed; the competitive advantage attributed to genuine agility is in the neighborhood of 60% [illustrative figure], and only your own team’s instrumentation can give the real value.