arxiv: 2605.07717 · v1 · submitted 2026-05-08 · 💻 cs.SE · cs.AI

Recognition: 2 theorem links

· Lean Theorem

The AI-Native Large-Scale Agile Software Development Manifesto

Ricardo Britto , Fredrik Palmgren , Nishrith Saini , Marcus Ohlin

Authors on Pith no claims yet

Pith reviewed 2026-05-11 01:49 UTC · model grok-4.3

classification 💻 cs.SE cs.AI

keywords AI-native agilelarge-scale software developmentagile manifestoAI in software engineeringagile principlessoftware development manifestoadaptive systemsagent workforces

0 comments

The pith

A manifesto redefines large-scale agile software development by treating AI as a first-class participant rather than a supporting tool.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper contends that current large-scale agile frameworks stay limited by human-centric coordination meetings, artifact synchronization, and role-based handoffs that prevent real-time adaptation. It introduces the AI-Native Large-Scale Agile Software Development Manifesto as a response to advances in large language models and similar technologies. The manifesto rests on six principles that aim to convert development into an intelligent, adaptive, continuously learning system. A reader would care because it targets the long-standing gap between agile ideals and actual practice at scale in complex projects. If the principles hold, organizations could move away from document-heavy and sequential workflows toward ones where AI handles orchestration and knowledge maintenance alongside people.

Core claim

We present the AI-Native Large-Scale Agile Software Development Manifesto: a set of values and principles that redefine how large-scale software development is organized when AI becomes a first-class participant rather than a peripheral tool. The manifesto is grounded in six principles—parallel processes, intent-driven teams, living knowledge, verification-first assurance, orchestrated agent workforces, and reusable blueprints—that together shift development from a meeting-driven, document-heavy, sequential process to an intelligent, adaptive, continuously learning system.

What carries the argument

The AI-Native Large-Scale Agile Software Development Manifesto, built on the six principles of parallel processes, intent-driven teams, living knowledge, verification-first assurance, orchestrated agent workforces, and reusable blueprints.

If this is right

Development moves from sequential handoffs to parallel processes that run simultaneously.
Teams shift to intent-driven work instead of role-based meetings and artifacts.
Knowledge becomes living and self-updating rather than static documentation.
Assurance starts with verification integrated at every step instead of end-stage checks.
Workforces combine humans with orchestrated AI agents that handle routine coordination.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Existing large-scale agile frameworks might need partial replacement rather than incremental extension when these principles are applied.
Human roles could evolve toward oversight of AI-orchestrated agents and blueprint reuse.
Verification-first assurance could reduce downstream defects if AI handles initial checks reliably.
The approach may scale better to very large projects by minimizing manual synchronization overhead.

Load-bearing premise

The six principles will produce an intelligent adaptive system without creating new coordination failures or reliability problems from current AI limitations.

What would settle it

Measure whether teams applying the manifesto show measurably fewer coordination meetings, faster requirement adaptation, and stable output quality compared with conventional large-scale agile setups, or whether AI integration instead increases error rates and delays.

Figures

Figures reproduced from arXiv: 2605.07717 by Fredrik Palmgren, Marcus Ohlin, Nishrith Saini, Ricardo Britto.

**Figure 2.** Figure 2: The relationship between humans, AI personas, agents, skills, MCP connectors, and the [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗

**Figure 3.** Figure 3: AI-native R&D blueprint: a cross-functional end-to-end team supported by a local agent [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

read the original abstract

Despite the widespread adoption of agile methods, achieving true agility at scale remains elusive. Large-scale agile frameworks remain largely human-centric and manual, relying on coordination meetings, artifact synchronization, and role-based handoffs that inhibit real-time adaptation. Meanwhile, rapid advances in AI, particularly large language models, have begun transforming software engineering, yet their potential for organizational-level agility remains underexplored. We present the AI-Native Large-Scale Agile Software Development Manifesto: a set of values and principles that redefine how large-scale software development is organized when AI becomes a first-class participant rather than a peripheral tool. The manifesto is grounded in six principles, parallel processes, intent-driven teams, living knowledge, verification-first assurance, orchestrated agent workforces, and reusable blueprints, that together shift development from a meeting-driven, document-heavy, sequential process to an intelligent, adaptive, continuously learning system.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

This is a conceptual manifesto with six principles for treating AI as a first-class actor in large-scale agile, but it offers no evidence or handling of AI's practical limits.

read the letter

The main point is that the paper defines an AI-Native Large-Scale Agile Software Development Manifesto built around six principles: parallel processes, intent-driven teams, living knowledge, verification-first assurance, orchestrated agent workforces, and reusable blueprints. It claims these will move large-scale development away from meetings and documents toward an adaptive, continuously learning system where AI participates directly rather than as a side tool. That specific packaging is new, even though the individual ideas draw from existing agile work and recent AI applications in software engineering. The structure is straightforward and gives readers a compact way to think about the organizational shift. It does a reasonable job of naming current coordination problems and sketching how AI could reduce them. The stress-test note is accurate here: the argument assumes AI can sustain real-time coordination, maintain consistent knowledge, and perform reliable verification without new failure modes, yet the text provides no mitigation strategies or even a clear acknowledgment of documented LLM weaknesses such as context limits, hallucination drift, or error propagation in multi-agent setups. Everything stays at the level of assertion. There is no data, no pilot, and no formal reasoning to show the principles would actually deliver the claimed agility. This work is aimed at software engineering researchers and practitioners who follow agile at scale and are curious about AI's longer-term organizational role. It could serve as a discussion starter in a reading group or workshop on future directions. I would not cite it for any concrete claim or method. It still deserves peer review because the framing is distinct enough to benefit from referee feedback on how to add grounding or test the ideas, even if heavy revision would be required to move beyond a position paper.

Referee Report

2 major / 0 minor

Summary. The manuscript presents the AI-Native Large-Scale Agile Software Development Manifesto, which introduces six principles—parallel processes, intent-driven teams, living knowledge, verification-first assurance, orchestrated agent workforces, and reusable blueprints—to reorganize large-scale software development by integrating AI as a first-class participant, shifting from traditional meeting-driven processes to an intelligent, adaptive system.

Significance. If the proposed principles could be operationalized and shown to mitigate coordination and reliability risks, the manifesto would offer a forward-looking conceptual framework for scaling agile practices with AI. As presented, however, the work remains a high-level vision without empirical grounding, implementation details, or analysis of feasibility, limiting its contribution to stimulating discussion in software engineering.

major comments (2)

[Abstract] Abstract: The central claim that the six principles 'together shift development from a meeting-driven, document-heavy, sequential process to an intelligent, adaptive, continuously learning system' is unsupported. The manuscript supplies no analysis of how the principles would accommodate or mitigate documented LLM limitations such as hallucination in living knowledge, inconsistent multi-step reasoning in orchestrated agent workforces, or context-window constraints in parallel processes.
[Description of the six principles] Description of the six principles: The feasibility of treating AI as a first-class participant is load-bearing for the manifesto's thesis, yet no mitigation strategies are offered for new failure modes (e.g., error propagation across agent teams or drift in reusable blueprints), leaving the claimed transition from human-centric to AI-native agility unexamined.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the detailed and constructive review of our manuscript on the AI-Native Large-Scale Agile Software Development Manifesto. The feedback correctly identifies the high-level nature of the work and the need to better qualify its claims. We address each major comment below and describe the revisions we will incorporate.

read point-by-point responses

Referee: [Abstract] Abstract: The central claim that the six principles 'together shift development from a meeting-driven, document-heavy, sequential process to an intelligent, adaptive, continuously learning system' is unsupported. The manuscript supplies no analysis of how the principles would accommodate or mitigate documented LLM limitations such as hallucination in living knowledge, inconsistent multi-step reasoning in orchestrated agent workforces, or context-window constraints in parallel processes.

Authors: We appreciate the referee noting that the abstract presents the shift as an outcome without explicit analysis of LLM limitations. The manuscript is a manifesto proposing a conceptual framework, not an empirical evaluation, so the claim reflects the intended collective effect of the principles rather than demonstrated results. We agree the language can be strengthened by qualification. In revision, we will update the abstract to describe the shift as a proposed outcome and add a short paragraph in the principles section outlining high-level accommodations (e.g., verification-first assurance to counter hallucination, human-in-the-loop orchestration for reasoning consistency, and scoped context management in parallel processes), referencing existing work on AI reliability in software engineering. revision: partial
Referee: [Description of the six principles] Description of the six principles: The feasibility of treating AI as a first-class participant is load-bearing for the manifesto's thesis, yet no mitigation strategies are offered for new failure modes (e.g., error propagation across agent teams or drift in reusable blueprints), leaving the claimed transition from human-centric to AI-native agility unexamined.

Authors: We agree that feasibility considerations and mitigation of AI-specific failure modes are important for the manifesto's thesis. The current text focuses on defining the six principles to articulate the vision, consistent with the style of prior manifestos that stimulated subsequent research. To address the gap, we will expand the principles description with concise subsections on risks and mitigations. Examples include using verification-first assurance and living knowledge to limit error propagation in agent teams, and versioned, continuously validated reusable blueprints to reduce drift. These additions will examine the human-to-AI-native transition more explicitly while preserving the paper's concise, visionary character. revision: yes

Circularity Check

0 steps flagged

No circularity: definitional manifesto with no derivations or self-citations

full rationale

The paper introduces a new manifesto with six principles (parallel processes, intent-driven teams, living knowledge, verification-first assurance, orchestrated agent workforces, reusable blueprints) as a conceptual redefinition of large-scale agile development when AI is treated as a first-class participant. It makes no claims of deriving quantities, predictions, or results from fitted parameters, equations, or prior self-citations. The text is self-contained as a position paper presenting values and principles without any load-bearing steps that reduce to inputs by construction. This is the expected outcome for a non-empirical, non-predictive manifesto.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 0 invented entities

The proposal rests on the domain assumption that current AI capabilities can serve as first-class participants in organizational processes; no free parameters or invented physical entities are introduced.

axioms (1)

domain assumption AI systems can function as first-class participants in large-scale agile development without introducing insurmountable coordination or verification problems.
This premise underpins the entire manifesto but receives no supporting evidence or justification within the abstract.

pith-pipeline@v0.9.0 · 5448 in / 1199 out tokens · 45601 ms · 2026-05-11T01:49:56.006133+00:00 · methodology

discussion (0)

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

IndisputableMonolith/Foundation/AbsoluteFloorClosure.lean reality_from_one_distinction unclear

?

unclear
Relation between the paper passage and the cited Recognition theorem.

The manifesto is grounded in six principles, parallel processes, intent-driven teams, living knowledge, verification-first assurance, orchestrated agent workforces, and reusable blueprints, that together shift development from a meeting-driven, document-heavy, sequential process to an intelligent, adaptive, continuously learning system.
IndisputableMonolith/Cost/FunctionalEquation.lean washburn_uniqueness_aczel unclear

?

unclear
Relation between the paper passage and the cited Recognition theorem.

Human intent and AI execution over manual handoffs across roles

What do these tags mean?

matches: The paper's claim is directly supported by a theorem in the formal canon.
supports: The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends: The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses: The paper appears to rely on the theorem as machinery.
contradicts: The paper's claim conflicts with a theorem or certificate in the canon.
unclear: Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Reference graph

Works this paper leans on

20 extracted references · 20 canonical work pages

[1]

2021 , issn =

Adapting Behavior Driven Development (BDD) for large-scale software systems , journal =. 2021 , issn =. doi:https://doi.org/10.1016/j.jss.2021.110944 , author =

work page doi:10.1016/j.jss.2021.110944 2021
[2]

Empirical Software Engineering , volume =

Dingsøyr, Torgeir and Moe, Nils Brede and Fægri, Tor Erlend and Seim, Eva Amdahl , title =. Empirical Software Engineering , volume =

work page
[3]

Journal of Systems and Software , volume =

Rolland, Colette and Prakash, Naveen and Ben Achour, Camille , title =. Journal of Systems and Software , volume =

work page
[4]

and Lines, Mark , title =

Ambler, Scott W. and Lines, Mark , title =

work page
[5]

Larman, Craig and Vodde, Bas , title =

work page
[6]

2020 , howpublished =

work page 2020
[7]

, title =

Guo, Philip J. , title =. Communications of the ACM , volume =

work page
[8]

IEEE Software , volume =

Zhang, Jie and Wang, Xin , title =. IEEE Software , volume =

work page
[9]

arXiv preprint , year =

Dingsøyr, Torgeir and Moe, Nils Brede and Seim, Eva Amdahl and Fægri, Tor Erlend , title =. arXiv preprint , year =

work page
[10]

Behavior-Driven Development , howpublished =

work page
[11]

2025 , howpublished =

Khomenko, Kateryna , title =. 2025 , howpublished =

work page 2025
[12]

Agent Skills , howpublished =

work page
[13]

Dingsøyr, N

T. Dingsøyr, N. B. Moe, T. E. Fægri, and E. A. Seim, ``Exploring software development at the very large scale: a revelatory case study and research agenda for agile method adaptation,'' Empirical Software Engineering, vol. 23, no. 1, pp. 490--520, 2018

work page 2018
[14]

Rolland, N

C. Rolland, N. Prakash, and C. Ben Achour, ``Challenges of large-scale agile: a systems perspective,'' Journal of Systems and Software, vol. 125, pp. 1--14, 2016

work page 2016
[15]

, `` SAFe 5.0 framework overview,'' https://scaledagileframework.com, 2020

Scaled Agile Inc. , `` SAFe 5.0 framework overview,'' https://scaledagileframework.com, 2020

work page 2020
[16]

Larman and B

C. Larman and B. Vodde, Large-Scale Scrum: More with LeSS. 1em plus 0.5em minus 0.4em Addison-Wesley, 2016

work page 2016
[17]

S. W. Ambler and M. Lines, Disciplined Agile Delivery: A Practitioner's Guide to Agile Software Delivery in the Enterprise. 1em plus 0.5em minus 0.4em IBM Press, 2012

work page 2012
[18]

P. J. Guo, ``The state of AI -assisted programming: emerging opportunities and challenges,'' Communications of the ACM, vol. 66, no. 11, pp. 68--77, 2023

work page 2023
[19]

Irshad, R

M. Irshad, R. Britto, and K. Petersen, ``Adapting behavior driven development (bdd) for large-scale software systems,'' Journal of Systems and Software, vol. 177, p. 110944, 2021

work page 2021
[20]

AgentSkills , ``Agent skills,'' https://agentskills.io/

work page