The Agile Agent Manifesto agileagentmanifesto.org

A manifesto for the agent era · October 2026

The Agile Agent Manifesto

Agents now write good code. Typing is no longer the bottleneck. The bottleneck is knowing what to build, and keeping the code right while more people change it.

Why a new manifesto

The work moved

For twenty years, agile teams were built around one scarce skill: writing code. Stories were written by the business, refined in meetings, and handed to developers who turned them into software.

Coding agents changed what is scarce. They write code that is good enough to ship after review. What remains hard is understanding what the business needs, and guaranteeing that the code base stays consistent when more people, and more agents, change it.

This manifesto describes how a team works when that is true. It is written for developers, business analysts, product owners and the people who lead them.

The manifesto

Seven principles

  1. Rules live in code, not in prompts

    If a rule can't break the build, it's a wish.

    AGENTS.md files and Copilot instructions help, but agents don't always follow them, and nobody notices when they drift from the code. A rule only counts when it can stop a change: a lint rule that fails the build, an architecture test that runs with the unit tests, a required review.

    $ npm run build
    ✖ src/booking/controller.ts:14:1  architecture/no-layer-skip
      Controllers must not import from db/. Use the repository layer.
    Build failed: 1 rule violation.
  2. Make the code boring

    Homogeneous code is what agents build on.

    Agents copy what they see. When there is one way to build an endpoint, one way to handle errors and one folder structure, agents write code that looks like the rest. Invest in consistency first; every other layer depends on it.

  3. Automate first, agents second

    Scripts for everything repeatable, agents for the rest.

    Use AI to write the scripts, generators and codemods that automate every repeatable task. A script does the same thing every time and costs almost nothing to run. Use agents for the work a script can't do.

  4. The business writes code

    Business analysts and product owners open merge requests for what they know best.

    With an agent and a platform that turns a prompt into a merge request, BAs and POs change texts, configuration, feature toggles and features that follow an existing pattern themselves, in the repositories they are allowed to change. Nobody waits for a sprint to fix a label.

  5. Refine by building

    Pair and build the story instead of only talking about it.

    A refinement meeting discusses work someone will do later. In an Agile Agent team, a developer and a BA pair online and build the story in that same time. The goal is a 3-point story built in the time refinement used to take.

  6. Developers fly the plane

    Agents are the autopilot. Responsibility never moves to the agent.

    A developer reviews and approves every merge request, with AI help, and takes the controls when the autopilot fails. Architecture, security, performance and data migrations stay with developers.

  7. Prove it, don't promise it

    Every change to how we work starts as a measured pilot.

    One team, six to eight weeks. Measure lead time, review time, change failure rate and production defects before and after, and decide with the data.

The foundation

Five layers that keep code right

Build from the bottom up. Each layer catches what the one below misses.

5 · Developer approvalEvery change, every time
4 · Enforced rulesLint and architecture tests fail the build
3 · AgentsFor everything scripts can't do
2 · ScriptsAI writes automation for repeatable work
1 · Homogeneous codeOne way to do each thing, everywhere

The new team

From handoffs to pairs

Today

DEV
DEV
DEV
DEV
BA
BA?

4 developers + 1–2 BAs. The BA writes the story, the team refines it, developers build it. Every step is a handoff.

Agile Agent team

DEVBA
Pair
DEVBA
Pair
DEVArchitecture and guardrails

3 developers + 2 BA/BEs (business analysts or business engineers). They pair online every day and build the story together.

A video call: a developer and a business analyst pair while an agent opens a merge request that passes lint and architecture tests and waits for the developer's approval.

Principle 5 in practice

What a pairing session looks like

The BA describes the change, the agent writes it and opens the merge request, the guardrails run in CI, and the developer approves what ships.

The people in this picture are AI-generated.

4 3DevelopersThe hypothesis: the same output with one developer fewer.
1–2 2BA / BEMore business input, every day. Developers can grow into this role.
~€900Per person, per monthBudget estimate for an agent subscription for each team member.

Who changes what

Three zones, one approver

Green zone A BA or PO with an agent
  • Texts and translations
  • Small UI changes
  • Configuration and feature toggles
  • Changes that follow an existing pattern
Yellow zone A BA and a developer in a pair
  • User stories up to 3 story points
  • New behavior inside the existing architecture
Red zone Developers
  • Architecture
  • Security
  • Performance
  • Data migrations

A developer approves every change. Code owners rules in the repository protect the red zone, and repository permissions decide who can open a merge request where.

Prove it

One team, six to eight weeks

Setup

  • 3 developers + 2 BA/BEs
  • Only the AI tools the company allows
  • Guardrails in CI from day one

Needs

  • A platform that turns a prompt into a merge request
  • Repository permissions per person
  • AI-assisted code review

Measure

  • Lead time per story
  • Review time
  • Change failure rate
  • Defects in production

Signatories

Add your name

If you want to build software this way, sign the manifesto. Comment "I sign" on the launch post on LinkedIn, with your name and role, and you will be added here.

  1. Andres SanchezAuthor · Engineering lead