Paper deep dive
Towards Assurance Closure in AI-Native Large-Scale Agile Software Development
Ricardo Britto
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:The AI-Native Manifesto envisions large-scale agile software development in which humans increasingly govern intent, risk, and exceptions while agents execute more of the engineering process. Realizing that end-state requires more than better code generation: it requires assurance closure, meaning that the system can establish what must be true, determine and obtain appropriate evidence, judge the credibility of that evidence, preserve its validity through change, and use the resulting uncertainty to bound agent authority. Existing work already provides many of the necessary mechanisms across formal methods, testing, simulation, assurance cases, digital twins, and runtime assurance. We identify six residual gaps in making the surrounding assurance reasoning sufficiently machine-operable, propose a high-level architecture with six corresponding capabilities built on a shared semantic assurance layer, and formulate four research questions to turn that architecture into dependable, human-on-the-loop, AI-native R&D.
Tags
Links
- Source: https://arxiv.org/abs/2608.07317v1
- Canonical: https://arxiv.org/abs/2608.07317v1
Trouble viewing inline? Open PDF directly →
Full Text
23,506 characters extracted from source content.
Expand or collapse full text
Towards Assurance Closure in AI-Native Large-Scale Agile Software Development Ricardo Britto Ericsson, Sweden Blekinge Institute of Technology, Sweden ricardo.britto@ericsson.com August 2026 Abstract The AI-Native Manifesto envisions large-scale agile soft- ware development in which humans increasingly govern intent, risk, and exceptions while agents execute more of the engineering process. Realizing that end-state re- quires more than better code generation: it requires as- surance closure, meaning that the system can establish what must be true, determine and obtain appropriate ev- idence, judge the credibility of that evidence, preserve its validity through change, and use the resulting uncertainty to bound agent authority. Existing work already provides many of the necessary mechanisms across formal meth- ods, testing, simulation, assurance cases, digital twins, and runtime assurance. We identify six residual gaps in making the surrounding assurance reasoning sufficiently machine-operable, propose a high-level architecture with six corresponding capabilities built on a shared semantic assurance layer, and formulate four research questions to turn that architecture into dependable, human-on-the- loop, AI-native R&D. 1 Introduction The AI-Native Manifesto proposes a form of large-scale agile software development in which humans progressively shift from implementation work to supervisory control, while remaining responsible for intent, risk, policy, and exceptional decisions, as agents assume increasing engi- neering authority (Britto et al. 2026). Its verification-first assurance principle is a prerequisite for that transition: delegation is meaningful only if the system can provide adequate grounds for trusting what agents produce. We develop that unresolved requirement as assurance closure: the ability to establish what must be true, de- termine and obtain appropriate evidence, judge the cred- ibility of that evidence, preserve its validity as the sys- tem changes, and use the resulting uncertainty to bound agent authority. The individual techniques needed for these tasks already exist in many forms. The research challenge is to make the meta-assurance process that se- lects, connects, interprets, and maintains them sufficiently machine-operable for AI-native R&D. This paper is there- fore a position paper and research agenda rather than a proposal for a new verification method. The remainder of the paper is organized as follows: Section 2 reviews adjacent work and identifies six residual gaps that prevent assurance closure. Section 3 presents a high-level architecture whose six capabilities provide an integrated response to those gaps. Section 4 turns that architecture into four research questions that must be addressed before it can support dependable, human-on- the-loop delegation. Section 5 concludes by returning to the role of assurance in realizing the full AI-native vision. 2 Related Work Assurance closure builds on several mature areas rather than replacing them. Requirements engineering and for- mal specification provide ways to make expected behavior more precise; recent agentic work shows that models can increasingly generate and reason about formal specifi- cations, but also that accepted formalizations may still omit assumptions or admit incorrect behavior (Hamblin et al. 2026; Agarwal et al. 2026). Formal methods, static analysis, testing, and model-based techniques provide com- plementary forms of evidence. Industrial experience, such as Amazon’s ShardStore, shows the value of decomposing correctness into properties and applying different tech- niques where they are most useful (Bornholt et al. 2021). Other fields address how assurance evidence is orga- nized and maintained. Assurance cases structure claims, evidence, and reasons for doubt (Goodenough, Weinstock, and Klein 2012), while DARPA ARCOS targets greater automation in evidence evaluation and assurance-case con- struction (Defense Advanced Research Projects Agency, n.d.). Digital-twin research emphasizes that simulation evidence is useful only when the model is credible for its intended purpose (Shao, Hightower, and Schindel 2023). Continuous and runtime assurance, in turn, show how assurance arguments and safety constraints can remain active as systems operate and change (Sljivo et al. 2024; Slagel et al. 2024). These foundations are substantial. What is still missing is an integrated mechanism that enables an agentic R&D system to perform much of the assurance reasoning that expert engineers currently pro- 1 arXiv:2608.07317v1 [cs.SE] 7 Aug 2026 vide for them. From this landscape, we identify six gaps, ordered as a stepwise transformation toward greater delegated author- ity. GAP 1—Autonomous specification adequacy. Be- fore an agent is allowed to implement a change, the system needs to know whether the available description of the intended behavior is good enough to act on. This is more than translating prose into a formal language. Re- quirements may be incomplete, mutually inconsistent, too weak to distinguish correct from incorrect behavior, or based on assumptions that have never been made explicit. Recent benchmarks show that specification-level reason- ing remains difficult even when formal tools are available (Hamblin et al. 2026; Agarwal et al. 2026). The gap is therefore the ability to detect that the current specifi- cation is not yet adequate for delegation and to identify what is missing before implementation proceeds. GAP 2—Assurance strategy synthesis. Once the expected behavior is sufficiently clear, the next question is what evidence should justify a particular change. Different properties call for different techniques: a local invariant may be suited to formal proof, an API contract to static or property-based checks, a distributed failure scenario to simulation or fault injection, and an operational property to runtime monitoring. Risk-based V&V already makes such choices in practice, and heterogeneous assurance has proven valuable in industry (Bornholt et al. 2021; Shaw 2026). What remains largely human work is constructing a proportionate assurance plan for each change: deciding which claims matter, how strongly they must be sup- ported, which evidence can be reused, and where human judgment is still required. GAP 3—Scalable assurance evidence generation. An assurance plan is useful only if the required evidence can actually be produced at AI-native speed. Existing methods already provide many ways to generate evidence, including theorem proving, model checking, static anal- ysis, testing, fuzzing, simulation, emulation, executable reference models, digital twins, and runtime monitors. The unresolved issue is how an agentic system can instan- tiate these methods at the right scope and fidelity for the change at hand. For example, dynamic validation should not require reproducing the whole production system if only a small interaction is relevant. The system may instead need to construct a focused executable environ- ment that contains only the services, state, workloads, faults, and assumptions needed to challenge the affected behavior. Whatever environment is used must itself be credible for the claim being evaluated (Shao, Hightower, and Schindel 2023). The research problem is therefore scalable, change-focused generation of assurance evidence, not any single mechanism such as a digital twin. GAP 4—Evidence credibility and sufficiency. Producing evidence is not the same as having a good reason to believe a claim. Assurance cases and defeater- based reasoning already provide ways to relate claims to evidence and to ask what reasons for doubt remain (Goodenough, Weinstock, and Klein 2012). Agentic de- velopment adds a further complication: the code, specifi- cation, tests, simulations, and evaluations may share the same model family, retrieved context, or mistaken inter- pretation. Several apparently independent artifacts may therefore repeat the same error. The gap is the ability to assess whether a body of evidence is relevant, sufficiently strong, sufficiently independent, and free of unresolved defeaters for the decision being made. This should not be reduced prematurely to a single synthetic confidence score. GAP 5—Assurance validity under continuous change. Assurance is never permanent. A proof may de- pend on an interface assumption that later changes; a test may no longer represent production behavior; a simula- tion model may become stale; or new operational evidence may invalidate a previously accepted claim. Continuous and dynamic assurance already recognizes this lifecycle problem (Sljivo et al. 2024). AI-native R&D raises the required speed and granularity: each software or environ- ment change should automatically reveal which claims, assumptions, models, tests, proofs, and observations are affected, which evidence remains reusable, and what must be regenerated. Without this capability, faster generation simply creates an assurance bottleneck downstream. GAP 6—Assurance-governed delegation and su- pervisory control. Closing the preceding gaps still leaves a governance question: what should agents be allowed to do with the assurance available now? Runtime- assurance architectures already constrain autonomous components when safety conditions are threatened (Slagel et al. 2024). AI-native software development needs an analogous control loop over engineering authority. The ability to propose a change, edit code, merge, release, or deploy should depend on the current assurance state and the consequences of being wrong. At the same time, humans must retain enough visibility to understand un- resolved uncertainty, intervene in exceptional cases, and reduce or revoke authority. The gap is therefore not sim- ply about more automation, but about evidence-based, reversible delegation with meaningful human supervision. 3Assurance-Closure Architecture The six gaps suggest that assurance closure cannot be achieved by adding a single additional verification tool to the development pipeline. Figure 1 presents a high-level architecture in which assurance becomes a continuous control function around agentic R&D. C1–Specification Assurance addresses GAP 1. It turns human intent, requirements, constraints, and known system behavior into machine-actionable obligations, but its key responsibility is to challenge them rather than merely formalize them. It should identify ambiguity, miss- ing assumptions, conflicts, weak constraints, and impor- tant behavior that remains unspecified. Its output is 2 High-Level Assurance-Closure Architecture A continuous assurance loop for bounded, reversible delegation Human governance Intent objectives Risk policy Delegation limits Escalation revocation 1 Specification Assurance Make intent and obligations clear enough to proceed 2 Assurance Strategy Synthesis Decide what evidence is needed for this change 3 Assurance Execution Fabric Generate the planned evidence at the required scope 4 Evidence Adjudication Judge credibility, coverage, independence and uncertainty 5 Continuous Assurance State Track validity and restore assurance after change 6 Delegation Supervisory Control Bound agent authority and keep humans meaningfully on loop Bounded reversible agent authority continuous feedback Semantic Assurance Layer Shared machine-readable knowledge connecting intent, claims, assumptions, system structure, evidence, validity, runtime observations, and validated engineering experience Intent claimsAssumptions risksSystem dependenciesEvidence provenanceValidity observationsValidated experience Figure 1: High-level architecture for assurance closure. Human governance defines intent, risk, policy, and limits on delegation. Six assurance capabilities progressively transform that input into bounded, reversible agent authority, while a shared semantic assurance layer maintains the knowledge needed across the loop. therefore not “a formal specification” in a particular nota- tion, but a specification state that is sufficiently complete and explicit for the next level of delegation, together with any unresolved questions that still require human input. C2–Assurance Strategy Synthesis addresses GAP 2. Given the affected claims, architecture, risk, and uncer- tainty, it decides what evidence should be produced and at what depth. It may choose formal proof for some properties, testing or fuzzing for others, executable valida- tion environments for interaction-heavy behavior, runtime monitoring for properties that cannot be fully established before deployment, or human review when judgment can- not be delegated. The capability is deliberately method- neutral: its purpose is to construct and continuously adapt an assurance strategy rather than to privilege a specific technology. C3–Assurance Execution Fabric addresses GAP 3 by turning that strategy into evidence. It orchestrates het- erogeneous tools and agents, scopes them to the affected parts of the system, and constructs the validation context required by the selected methods. This is where conven- tional static and formal techniques, BDD and model-based testing, property-based testing and fuzzing, simulation and emulation, targeted digital twins, runtime verifica- tion, and expert review can all participate. A central research concern is efficiency: the fabric should generate enough evidence to challenge the relevant claims without reproducing or re-verifying the entire system for every change. C4–Evidence Adjudication addresses GAP 4. It in- terprets the evidence produced by C3 rather than treating tool success as proof of correctness. The capability must reason about relevance, coverage, provenance, method soundness, shared dependencies between evidence sources, uncertainty, and unresolved defeaters. It should also rec- ognize when more evidence is needed or when apparently diverse evidence is actually based on the same assump- tion. The result is a structured assurance judgment that explains why the available evidence is or is not adequate for the decision under consideration. C5—Continuous Assurance State addresses GAP 5. It maintains the dependencies between intent, claims, assumptions, system elements, assurance activities, ev- idence, and runtime observations. When something changes, C5 determines which assurances remain valid, which have become stale, and which parts of the assurance strategy must be rerun. The aim is incremental reassur- ance: preserve strong evidence when its assumptions still hold, while precisely invalidating the evidence that no longer applies. C6–Delegation and Supervisory Control addresses GAP 6. It maps the current assurance state to concrete engineering permissions and escalation rules. An agent might be allowed to explore or prepare a change while being prevented from merging it; stronger evidence may permit merging but still require human approval for de- ployment. If evidence becomes invalid, authority should contract automatically. C6 also exposes the remaining un- certainty and the reasons for restricting access to humans, enabling them to supervise intent, risk, and exceptions rather than re-performing all implementation work. A semantic assurance layer supports all six capa- bilities. It provides shared, machine-readable knowledge linking intent, claims, assumptions, risks, architecture, implementation, dependencies, assurance activities, ev- idence, provenance, defeaters, validity conditions, run- time observations, and validated engineering experience. Machine-readable assurance models and traceability are not new (Foster et al. 2021; Defense Advanced Research Projects Agency, n.d.); the role of this layer is to provide 3 the six capabilities with a common state on which auto- mated assurance decisions can be made. It also preserves useful experience, such as failed assumptions, counterex- amples, effective assurance strategies, and invalidated evidence, with explicit scope and provenance so that fu- ture assurance decisions can reuse knowledge without treating past experience as universally valid. 4 Research Agenda The architecture in Figure 1 is a hypothesis about the capabilities required for assurance closure, not an im- plemented solution. Realizing it requires advances in how those capabilities are automated, connected, and evaluated. We organize that work around four research questions. RQ1–Specification adequacy for delegation. How can an agentic system determine that a specification is sufficiently complete, correct, consistent, and discrimi- nating to justify a particular level of delegation? Re- search is needed to detect missing assumptions and weak constraints, generate counterexamples, compare indepen- dently derived interpretations, and decide when unre- solved ambiguity requires human clarification rather than further autonomous work. RQ2–Automated assurance strategy and evi- dence generation. Given a change, its affected claims, architecture, uncertainty, and consequence profile, how can the system construct a cost-effective portfolio of as- surance activities and then instantiate it at the appro- priate scope? This includes both selecting among proof, analysis, testing, fuzzing, simulation, targeted executable environments, runtime monitoring, and human review, and determining the minimum credible context in which each selected technique can provide useful evidence. RQ3–Evidence trustworthiness and sufficiency. How can evidence produced partly by agents be assessed for applicability, soundness, provenance, dependence on shared assumptions, coverage, and unresolved defeaters? Agent-written tests, for example, are not automatically strong evidence; recent results show that increasing their volume may provide little improvement in repository- level issue resolution (Chen et al. 2026). Research should therefore focus on when heterogeneous evidence genuinely corroborates a claim and when it merely reproduces the same interpretation through different artifacts. RQ4–Continuous assurance and dynamic dele- gation. How can assurance dependencies be maintained incrementally so that change automatically invalidates stale evidence, triggers proportionate re-assurance, and adjusts agent authority? Delegation should be reversible: weakened evidence or violated assumptions should reduce permissible actions, while restored evidence may expand them. This also requires studying the information humans need to supervise the loop effectively without becoming a manual verification bottleneck. Evaluation principle. A useful demonstrator should expose the same system to changes that differ in affected claims, uncertainty, and risk. A meaningful result would be an assurance system that derives materially different and defensible strategies, constructs the required vali- dation context, identifies remaining reasons for doubt, reuses evidence when justified, and grants different levels of authority. Evaluation should therefore consider not only task success but also false assurance, defect and defeater discovery, assurance cost, unnecessary human intervention, re-assurance latency after a change, and the calibration between the assurance state and delegated authority. 5 Conclusion The AI-native vision ultimately depends on a change in the human role: people should be able to govern intent, acceptable risk, and exceptional decisions without having to reproduce every engineering action that agents perform. Verification-first assurance is therefore not a peripheral quality activity; it is a condition for responsible delegation. Existing verification and validation techniques provide many of the necessary building blocks, but they do not yet provide assurance closure as an integrated, machine- operable capability. This paper has framed that missing capability through six gaps, a corresponding high-level architecture, and four research questions. The central research challenge is to make the assurance reasoning around existing methods, what must be assured, what evidence is needed, whether the evidence should be believed, when it ceases to ap- ply, and what authority it justifies, operate at the speed and scale of agentic development while preserving mean- ingful human control. Closing that gap is, in our view, necessary for the full AI-native large-scale agile software development vision to move from increasingly capable code generation to trustworthy, bounded delegation of R&D authority. References Agarwal, Anmol, Natalie Neamtu, Pranjal Aggarwal, Seungone Kim, Jannis Limperg, Cedric Flamant, Kanna Shimizu, Bryan Parno, and Sean Welleck. 2026. Verus-SpecGym: An Agentic Environment for Evaluating Specification Autoformalization. https://doi.org/10. 48550/arXiv.2605.26457. Bornholt, James, Rajeev Joshi, Vytautas Astrauskas, Brendan Cully, Bernhard Kragl, Seth Markle, Kyle Sauri, et al. 2021. “Using Lightweight Formal Methods to Validate a Key-Value Storage Node in Amazon S3.” In Proceedings of the ACM SIGOPS 28th Sym- posium on Operating Systems Principles, 836–850. ACM. https: //doi.org/10.1145/3477132.3483540. Britto, Ricardo, Fredrik Palmgren, Nishrith Saini, and Marcus Ohlin. 2026. The AI-Native Large-Scale Agile Software Development Man- ifesto. https://doi.org/10.48550/arXiv.2605.07717. Chen, Zhi, Zhensu Sun, Yuling Shi, Chao Peng, Xiaodong Gu, David Lo, and Lingxiao Jiang. 2026. Rethinking the Value of Agent-Generated Tests for LLM-Based Software Engineering Agents. https://doi. org/10.48550/arXiv.2602.07900. Defense Advanced Research Projects Agency. n.d. “Automated Rapid Certification of Software (ARCOS).” DARPA. Accessed August 7, 2026. https://w.darpa.mil/research/programs/automated-rapid- certification-of-software. 4 Foster, Simon, Yakoub Nemouchi, Mario Gleirscher, Ran Wei, and Tim Kelly. 2021. “Integration of Formal Proof into Unified Assurance Cases with Isabelle/SACM.” Formal Aspects of Computing 33:855– 884. https://doi.org/10.1007/s00165-021-00537-4. Goodenough, John B., Charles Weinstock, and Ari Z. Klein. 2012. Toward a Theory of Assurance Case Confidence. Technical report CMU/SEI-2012-TR-002. Software Engineering Institute, Carnegie Mellon University. https://doi.org/10.1184/R1/6585362.v1. Hamblin, Grant, Kevin Song, Zhanda Zhu, Anand Jayarajan, Sihang Liu, Nandita Vijaykumar, and Gennady Pekhimenko. 2026. SpecBench: Evaluating Specification-Level Reasoning for Software Engineering LLM Agents. https://doi.org/10.48550/arXiv.2605.30314. Shao, Guodong, Joe Hightower, and William Schindel. 2023. “Credibility Consideration for Digital Twins in Manufacturing.” Manufacturing Letters 35:24–28. https://doi.org/10.1016/j.mfglet.2022.11.009. Shaw, Mary. 2026. Correctness, Confidence, and Context: Framing Software Assurance in the AI Age. https://doi.org/10.48550/arXiv. 2607.04667. Slagel, J. Tanner, Lauren M. White, Aaron Dutle, Cesar A. Munoz, and Nicolas Crespo. 2024. “A Verification Framework for Runtime Assurance of Autonomous UAS.” In 43rd Digital Avionics Systems Conference (DASC). NASA Technical Reports Server document 20240007986. Accessed August 7, 2026. https://ntrs.nasa.gov/ citations/20240007986. Sljivo, Irfan, Anastasia Mavridou, Johann Schumann, Ivan Perez, Pavlo G. Vlastos, and Corey K. Carter. 2024. “Dynamic Assurance of Autonomous Systems through Ground Control Software.” In AIAA SciTech Forum and Exposition. NASA Technical Reports Server document 20230018233. Accessed August 7, 2026. https://ntrs.nasa. gov/citations/20230018233. 5