Skip to content
/
Tier B A4 Markdown scaffold

agentic-agile-template (Microsoft)

agentic-agile-template-ms · microsoft/agentic-agile-template · ★ 60 · last commit 2026-05-20

A GitHub template providing the CLAUDE.md, Issue templates, manifesto, and measurement framework teams need to adopt wave-based parallel human-agent development.

Best whenThe specification is the program — agents fail due to coordination breakdown, not model capability; well-specified stories with file boundaries, acceptance c…
Skip ifOpen-ended prompts without specifications, One-directional delegation (human tells AI, doesn't partner)
vs seeds
claude-conductor(seed, Archetype 4: zero primitives, markdown scaffolding) but adds three innovations: (1) GitHub Issue template with fi…
Primitive shape
No installable primitives
00

Summary

agentic-agile-template (Microsoft) — Summary

Agentic-Agile Template is a Microsoft-published GitHub template repository providing a starter kit for teams adopting "Agentic-Agile Development" — the practice of producing production-ready software through structured human-agent partnerships. The repo ships a customizable CLAUDE.md (agent context template), an MANIFESTO.md (5 values + 13 principles), a STYLE.md (coding conventions template), .github/copilot-instructions.md, a GitHub Issue template for agentic stories (agentic-story.md), 3 methodology documentation files (agent surface selection, 8-dimension evaluation framework, epic decomposition example), and a reference mcp.json configuration. The framework's core insight: "agents fail not because of model capability, but because of coordination breakdown" — well-specified stories with acceptance criteria, file boundaries, and negative constraints produce production-quality code. 60 stars, 3 contributors, MIT license, last pushed May 2026.

differs_from_seeds: Closest to claude-conductor (seed, Archetype 4 "Markdown scaffold, zero primitives") — both are template repositories providing markdown scaffolding (CLAUDE.md, STYLE.md) with zero installable primitives. The Microsoft template adds a GitHub Issue template with the agentic-story format (file ownership, acceptance criteria, negative constraints), a manifesto document, and an 8-dimension evaluation framework — layers of governance and measurement not present in claude-conductor. Unlike kiro (Archetype 5 closed IDE), this is openly MIT-licensed and tool-agnostic.

01

Overview

agentic-agile-template (Microsoft) — Overview

Origin

Published by Microsoft (github.com/microsoft/agentic-agile-template). MIT license. 60 stars, 11 forks, 3 contributors. Last pushed May 2026 — actively maintained.

The manifesto credits: "The Agentic-Agile Team and Minthe (GitHub Copilot with Claude), 2026" — indicating the manifesto was co-written with an AI agent named "Minthe."

Core Insight

The README states:

"The core insight: agents fail not because of model capability, but because of coordination breakdown. When you give an agent a vague prompt, you get vague output. When you give it a well-specified story with acceptance criteria, file boundaries, and negative constraints, you get production-quality code. The specification is the program."

Manifesto: 5 Values + 13 Principles

Values:

  1. Specifications and contracts over open-ended prompts
  2. Human-agent partnership over one-directional delegation
  3. Parallel independence over sequential handoffs
  4. Built-in governance over bolted-on compliance
  5. Continuous measurement over post-hoc assessment

Selected principles:

  • "Specs are the primary control surface... In Software 3.0, the spec is the program."
  • "Humans design, agents execute, both review."
  • "Governance is architecture, not afterthought."
  • "Agent autonomy is earned through evidence."
  • "Budget for the full cycle [review, rework, integration]."

Lineage

The manifesto explicitly acknowledges two foundations:

  1. Agile Manifesto (2001) — carries forward the 4 Agile values
  2. Andrej Karpathy's Software 3.0 framework — "model weights are the CPU, context window is RAM, specification is the program"

Wave-Based Parallel Execution

The methodology's operational model: work executes in parallel "waves" of independent stories. Each wave = stories that can execute simultaneously without file-level conflicts. Review gates separate waves.

02

Architecture

agentic-agile-template (Microsoft) — Architecture

Distribution

  • Type: template-bundle (GitHub template repository)
  • Install: "Use this template" button on GitHub
  • Runtime: None
  • License: MIT

Repository Structure

agentic-agile-template/
├── CLAUDE.md                     # Agent context template (fill in project details)
├── MANIFESTO.md                  # Agentic-Agile Manifesto (5 values + 13 principles)
├── STYLE.md                      # Code conventions and style guide template
├── CONTRIBUTING.md               # Contribution guidelines (Agentic-Agile workflow)
├── SECURITY.md                   # Security policy
├── LICENSE                       # MIT License
├── mcp.json                      # Example MCP server configuration
├── .github/
│   ├── copilot-instructions.md   # GitHub Copilot instruction file (shorter CLAUDE.md)
│   └── ISSUE_TEMPLATE/
│       └── agentic-story.md      # GitHub Issue template for agentic stories
└── docs/
    ├── agent-surface-selection.md  # Guide to CLI vs IDE vs Chat vs API agent choice
    ├── evaluation-framework.md     # 8-dimension partnership measurement framework
    └── epic-decomposition-example.md  # Worked example: epic → stories → waves

No Installable Components

Zero commands, zero skills, zero hooks, zero scripts, zero CLI. This is a template repository — you copy it, then customize.

mcp.json Configuration (Reference Only)

Three example MCP server entries:

  • github — GitHub API access (read issues, create PRs, search code)
  • filesystem — File system access to a specified directory
  • memory — Persistent memory store across sessions

These are documentation examples; no bundled servers.

GitHub Issue Template

.github/ISSUE_TEMPLATE/agentic-story.md is the key operational artifact. It enforces the agentic-story format with required fields:

  • Originating Prompt (the human intent)
  • Scope (what to build)
  • File Ownership (explicit list of files the agent will touch)
  • Acceptance Criteria (passing conditions)
  • Negative Constraints (what the agent must NOT do)
  • Wave Assignment (which parallel batch)
03

Components

agentic-agile-template (Microsoft) — Components

Template Files

File Purpose
CLAUDE.md Agent context template — fill with project purpose, structure, conventions, testing, commands
MANIFESTO.md Agentic-Agile values and 13 principles
STYLE.md Code conventions, naming, documentation, commit, PR format templates
CONTRIBUTING.md Contribution guidelines following Agentic-Agile workflow
.github/copilot-instructions.md Copilot-specific shorter version of CLAUDE.md

Issue Template

.github/ISSUE_TEMPLATE/agentic-story.md — GitHub Issue template with sections:

  • Epic (parent epic)
  • Originating Prompt (human intent verbatim)
  • Scope (what to build)
  • File Ownership (explicit file list)
  • Acceptance Criteria
  • Negative Constraints (must NOT do)
  • Wave Assignment (parallel batch number)
  • Dependencies (blockers)

Documentation Files

File Purpose
docs/agent-surface-selection.md Decision guide: CLI vs IDE vs Chat vs API vs Cloud agent
docs/evaluation-framework.md 8 dimensions for measuring human-agent partnership
docs/epic-decomposition-example.md Worked example: epic → stories → waves → file ownership

MCP Configuration Example

mcp.json — reference configuration for 3 MCP servers (github, filesystem, memory).

No Active Components

  • Commands: 0
  • Skills: 0
  • Hooks: 0
  • Scripts: 0
  • CLI: none
  • MCP servers: 0 (config example only)

8-Dimension Evaluation Framework

From docs/evaluation-framework.md:

  1. Merge conflicts (should be zero)
  2. First-pass acceptance rate
  3. Escaped defects
  4. Rework rate
  5. Spec quality score
  6. Agent autonomy evolution
  7. Retrospective action completion
  8. Wave velocity
05

Prompts

agentic-agile-template (Microsoft) — Prompts

Excerpt 1 — CLAUDE.md Template Structure

From CLAUDE.md (the customizable template):

# Agent Context — [Your Project Name]

## Project Purpose

[Describe your project here]

**Primary language:** [e.g., TypeScript, Python, Go]
**Framework:** [e.g., Express, FastAPI, Gin]
**Key dependencies:** [e.g., PostgreSQL, Redis, RabbitMQ]

---

## Repository Structure

project-root/
├── src/                    # Application source code
│   ├── api/                # HTTP handlers / route definitions
│   ├── services/           # Business logic layer
│   ├── models/             # Data models / types
│   ├── repositories/       # Data access layer
│   └── utils/              # Shared utilities
├── tests/                  # Test files (mirrors src/ structure)

Prompting technique: Fill-in-the-blank template — all placeholders marked with [brackets] or <!-- comments -->. This forces the team to make explicit decisions about architecture before any agent starts. The comment block explains: "Think of it as onboarding documentation, but optimized for agents: structured, explicit, and maintained alongside your code."

Excerpt 2 — Manifesto Value Statement

From MANIFESTO.md:

We are discovering better ways of developing software through human-agent partnership 
and helping others do the same.

Through this work we have come to value:

**Specifications and contracts** over open-ended prompts
**Human-agent partnership** over one-directional delegation
**Parallel independence** over sequential handoffs
**Built-in governance** over bolted-on compliance
**Continuous measurement** over post-hoc assessment

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

Prompting technique: Agile Manifesto format — left column (valued more) vs right column (still valued). Mirrors agilemanifesto.org formatting as an intentional lineage signal.

Excerpt 3 — Principle on Autonomous Agents

**10. Agent autonomy is earned through evidence.**
Early work is more human-directed. Over time, agents take on broader scope, including 
coordination across parallel work streams, but only within constraints validated by 
measured outcomes, not assumed capability. In multi-agent teams, orchestrator autonomy 
follows the same principle: expand scope only where results justify trust.

Prompting technique: Risk-graduated principle — autonomy expansion is conditional on measured evidence, not assumed capability. This is a governance principle that functions as a human-behavior constraint (the human must not over-trust the agent without evidence).

09

Uniqueness

agentic-agile-template (Microsoft) — Uniqueness & Positioning

differs_from_seeds

Most similar to claude-conductor (seed, Archetype 4: zero primitives, markdown scaffolding) but with three important additions: (1) a GitHub Issue template for agentic stories with explicit file ownership and negative constraints — a coordination mechanism not present in claude-conductor; (2) an 8-dimension quantitative measurement framework for assessing partnership quality; (3) a manifesto grounding the methodology in Agile + Software 3.0 lineage. Compared to agent-os (also Archetype 4), the Microsoft template adds the wave-based parallel execution model and file-ownership decomposition pattern. The kiro seed uses spec-first files (requirements.md, design.md, tasks.md) — this template uses GitHub Issues as the spec container. Neither Claude Flow nor BMAD-METHOD addresses team-level measurement of human-agent partnership effectiveness.

Key Positioning

  • Microsoft origin gives it credibility and longevity signals other template repos lack.
  • The wave-based parallel execution model (multiple human-agent pairs, file-ownership decomposition) is the most operationally specific contribution not found in other methodology documents.
  • The "Originating Prompt" field in the Issue template — capturing the human's raw intent verbatim — is a lightweight provenance mechanism that other frameworks ignore.
  • Co-authored with an AI agent ("Minthe") and published under MIT — signals openness to reproduction and extension.

Observable Failure Modes

  1. Template fatigue: 5 files to customize before starting any work (CLAUDE.md, STYLE.md, CONTRIBUTING.md, copilot-instructions.md, mcp.json). Teams may skip customization and use blank defaults.
  2. Wave decomposition is manual and hard: Identifying truly independent stories with zero file overlap requires architectural judgment most teams lack.
  3. No enforcement mechanism: File ownership is declared in the Issue template, but nothing prevents an agent from touching files outside its declared scope.
  4. MCP configuration is example-only: Teams must provision their own GitHub/filesystem/memory MCP servers — the config doesn't ship working servers.
  5. Measurement requires discipline: The 8-dimension framework requires consistent tracking after each wave — most teams won't sustain this.
04

Workflow

agentic-agile-template (Microsoft) — Workflow

Wave-Based Parallel Execution Model

Step Activity Artifact Gate
1 Define epic GitHub Epic Issue Human review
2 Decompose epic → stories Individual story issues (agentic-story template) File-ownership verification
3 Map dependencies Story dependency graph Independence check
4 Assign to waves Wave N story groups Zero file overlap per wave
5 Create feature branches One branch per story (automated)
6 Assign to agents CLI / IDE / Chat / API surface per story Human assignment
7 Execute wave in parallel Code changes (per-story branch) (parallel)
8 Wave review gate All PRs reviewed All accepted or revised
9 Merge + launch next wave Clean main branch (repeat)

Spec-First Story Format

The agentic-story.md Issue template enforces:

  • File Ownership: Every story has explicit file list — prevents merge conflicts
  • Negative Constraints: What the agent must NOT do — prevents scope creep
  • Acceptance Criteria: Passing conditions — defines "done"
  • Wave Assignment: Which parallel batch — enables wave planning

Approval Gates

  1. Epic decomposition review: Human verifies file-level independence before assigning waves.
  2. Wave review gate: All PRs in the wave reviewed before merging and launching next wave.
  3. Retrospective: Post-wave analysis of escapes, rework, spec quality.

Agent Surface Selection (docs/agent-surface-selection.md)

Task Type Recommended Surface
Complex, interactive IDE agent (SYNC pair programming)
Well-defined, automated CLI agent (ASYNC delegation)
Exploratory Chat agent
High-volume batch API/Cloud agent

Measurement Loop

After each wave: measure merge conflicts, first-pass acceptance, escaped defects. Use retrospectives to improve spec quality and agent autonomy level.

06

Memory Context

agentic-agile-template (Microsoft) — Memory & Context

CLAUDE.md as Active Memory

The template's primary memory mechanism is the customized CLAUDE.md:

  • Provides agent context that persists across all sessions in the project
  • Updated by the team alongside code changes
  • "Think of it as onboarding documentation, but optimized for agents"

The template explicitly cautions: "An outdated context file is worse than none because agents will follow stale instructions confidently."

GitHub Issues as Memory

The agentic-story.md Issue template serves as structured memory for each work unit:

  • Originating Prompt (captures human intent even when the agent forgets it)
  • Acceptance Criteria (persists the "done" definition)
  • Retrospective action items tracked in issues

mcp.json Memory Server

The reference mcp.json includes a memory MCP server entry:

{
  "memory": {
    "purpose": "Gives the agent a persistent memory store across sessions for storing and retrieving facts.",
    "configuration": "No additional configuration required."
  }
}

This is a configuration template, not a bundled server — teams configure their own memory MCP.

Spec as Memory

Principle 1: "Specs are the primary control surface." The spec (CLAUDE.md + issue stories) IS the memory — it doesn't need a separate memory system if specs are maintained.

Evaluation Framework as Institutional Memory

docs/evaluation-framework.md — the 8 dimensions accumulate measurement data over time, creating a performance history for the human-agent partnership. Retrospectives feed findings back into spec improvements.

07

Orchestration

agentic-agile-template (Microsoft) — Orchestration

Multi-Agent / Parallel Wave Execution

Yes — the methodology is explicitly designed for multiple human-agent pairs working in parallel:

"Multiple humans, each collaborating with their own agentic partners, work simultaneously in the same codebase without collisions. Coordination comes from structural decomposition and shared architectural agreements, not from synchronous communication."

Pattern: parallel-fan-out within a wave. Each story in a wave is assigned to a separate agent working on its own branch. Stories are guaranteed non-overlapping (file-ownership enforcement prevents merge conflicts).

Subagent definition format: Not defined — the framework is tool-agnostic. Stories define work units; any agent surface can execute a story.

Isolation Mechanism

git-branch per story. File ownership enforcement ensures no two stories in the same wave touch the same file. No containers or worktrees specified.

Multi-Model

Not prescribed. docs/agent-surface-selection.md recommends different agent surfaces (CLI, IDE, Chat, API) for different task types, which may implicitly involve different models.

Execution Mode

one-shot per story (ASYNC) or interactive-loop (SYNC). The SYNC/ASYNC model is the methodology's key operational taxonomy.

Consensus

No automated consensus. Humans review all wave PRs at the review gate before merging.

Orchestration at Scale

Principle 3 describes eventual evolution:

"As the model matures, agentic teams of orchestrators and sub-agents take on broader coordination, with humans focusing on definition, review, and strategic direction."

But no concrete implementation is prescribed for this evolved state.

08

Ui Cli Surface

agentic-agile-template (Microsoft) — UI / CLI Surface

CLI Binary

None — template repository only.

Local UI

None.

IDE Integration

Tool-agnostic. The CLAUDE.md and .github/copilot-instructions.md files work across:

  • Claude Code (CLAUDE.md)
  • GitHub Copilot (.github/copilot-instructions.md)
  • Cursor
  • Any LLM-based development tool

GitHub Integration

The primary "UI" surface is GitHub:

  • ISSUE_TEMPLATE/agentic-story.md — structured story creation in GitHub Issues
  • CONTRIBUTING.md — contribution workflow with wave/wave-review pattern
  • .github/copilot-instructions.md — Copilot-specific context

Agent Surface Selection Guide

docs/agent-surface-selection.md classifies available agent surfaces:

  • CLI agent — well-defined tasks, batch execution
  • IDE agent — interactive, complex debugging
  • Chat agent — exploratory, clarification
  • API agent — high-volume automation
  • Cloud coding agent — asynchronous, larger scope

Cross-Tool Portability

High — tool-agnostic by design. The methodology works with any AI assistant; file templates work across Claude Code, Copilot, Cursor, etc.

Observability

The 8-dimension evaluation framework (docs/evaluation-framework.md) is the observability prescription — measure merge conflicts, first-pass acceptance, escaped defects, rework rate after each wave.

Related frameworks

same archetype · same primary tool · same memory type

BMAD-METHOD ★ 48k
A4 Markdown scaffold

Provides a full agile delivery lifecycle with named expert-persona AI collaborators that elicit the human's best thinking rather…

Agent OS ★ 4.6k
A4 Markdown scaffold

Extracts implicit codebase conventions into token-efficient markdown standards files and injects them selectively into AI agent…

Claude Conductor ★ 367
A4 Markdown scaffold

Gives Claude Code a persistent, cross-linked, auto-analyzed documentation system so it retains codebase context across sessions.

Spec-Driver (Greenfield Spec-Driven Development) ★ 25
A4 Markdown scaffold

Prevents spec rot in AI-assisted development by making implementation changes flow back into evergreen, authoritative specs via…

Anthropic Knowledge Work Plugins ★ 16k
A4 Markdown scaffold

Role-specialized plugin bundles with live MCP connectors that turn Claude into a domain expert for enterprise knowledge workers.

Codex Integration for Claude Code (skill-codex) ★ 1.3k
A4 Markdown scaffold

Single Claude Code skill that handles Codex CLI invocation correctly (stdin blocking, thinking token suppression, session resume)…