For teams of humans & agents

Agentile

Agile, with agency.

A deliberately light methodology for small teams who build software with AI agents. It keeps the agile spirit — short loops, working software, responding to change — and adapts it for a team where humans and agents work side by side.

We replaced the standup with a digest, so you can stand down.

The Manifesto

We are building software in an age where agents write much of the code. Agile taught us to favour short loops, working software, and responding to change. That spirit still holds — but the team has changed. Now humans and agents build together. Whether you are a person or an agent reading this, the loop is yours to run.

We have come to value

Shaped intent over hopeful prompts
Determinism over instruction
Verification over trust
Flow over output

That is, while there is value in the items on the right, we value the items on the left more.

The principles behind it

  1. 1

    One trunk, small batches. Humans and agents integrate continuously. Small diffs are reviewable; large ones are not.

  2. 2

    Capture is free; building is earned. Every idea enters in a single line. Nothing is built from an unshaped one.

  3. 3

    Capture and shaping are yours to define. Agentile insists they exist — not what they contain. Lay your own process on top.

  4. 4

    Context is infrastructure. Decisions, conventions, and domain rules live where every agent reads them, versioned with the code.

  5. 5

    Reduce agency with determinism. Anything you would repeat — build, test, scan, deploy — is a gate, not a hope.

  6. 6

    A fresh reviewer beats a confident author. Agents find others' mistakes better than their own. Nothing merges unverified.

  7. 7

    The loop learns. Each turn encodes its lessons, so the next turn is cheaper.

First be agile, then agentic. Agentile amplifies a healthy loop — and amplifies a broken one.

The Loop

Eight stages, one trunk

Work flows around a single loop — hours to a day per turn, not a two-week sprint. Each turn ends by teaching the next one.

Capture
Shape
Spec
Plan
Build
Verify
Ship
Learn

Light by design

Capture and shaping exist — how you run them is yours. Drop your own questions, gates, and rituals on top.

Deterministic gates

Build, test, scan, and deploy are commands the agents run — never hopeful sentences in a prompt.

Trust, but verify

A fresh-context reviewer critiques every diff before it merges. Accountability stays human.

Install

Run Agentile in Claude Code

Agentile ships as a Claude Code plugin — seven /ag- commands, three agents, and the verify-gate hooks. Add the marketplace, install, and you are looping.

claude plugin marketplace add agenta-consulting/agentile
claude plugin install agentile@agentile

Then, in any project you want to run the loop in:

/ag-init     # scaffold inbox.md, .agentile/ config, docs/adr/
/ag-capture  # drop a one-line idea, mid-build
/ag-shape    # interview it into a ready spec
7

Skills — ag-init, ag-capture, ag-inbox, ag-shape, ag-spec, ag-plan, ag-retro

3

Agents — planner, builder, reviewer, each in fresh context

2

Hooks — auto-format on edit, block "done" until tests pass

Yours — tailor every gate and the shaping questions per project