Software Engineering 3.0: Intent-Driven Paradigm

• Software Engineering 3.0 is defined by formal specifications, agent autonomy, and intent-driven processes that transform traditional development into continuous self-evolving systems.
• It integrates rigorous engineering theory with advanced AI, using multi-agent orchestration, declarative pipelines, and search-based synthesis to optimize quality and productivity.
• Empirical evidence shows enhanced productivity and rapid issue resolution, while also highlighting challenges in trust calibration, code maintainability, and human-agent collaboration.

Software Engineering 3.0 (SE 3.0) denotes a fundamental shift in software engineering, characterized by the convergence of formalized engineering theory, agentic autonomy, and intent-driven development processes shaped by advanced AI and Foundation Model (FM) technology. Distinct from previous eras—hand-coded classical SE (SE 1.0), and AI-assisted paradigms (SE 2.0)—SE 3.0 redefines software artifacts, workflows, and team structures through precise formalization, multi-agent orchestration, search-based synthesis, and continuous self-evolution. This article provides a comprehensive treatment of SE 3.0, integrating foundations, technical frameworks, agent modalities, empirical findings, and open research directions.

1. Historical Progression and Conceptual Foundations

SE 3.0 is best understood in the context of the discipline’s three main evolutionary waves:

• SE 1.0: Manual, plan-driven, code-centric engineering; processes such as Waterfall dominate, code serves as the primary deliverable, and design is sequential (Meyer, 24 Feb 2025, Sirotin, 2018, Mastropaolo et al., 2024).
• SE 2.0: Agile, DevOps-centric, task-level AI assistance; integration of CI/CD, DSLs, and code generators, but humans remain central in orchestration (Sirotin, 2018, Mastropaolo et al., 2024, Li et al., 20 Jul 2025).
• SE 3.0: Model-centric, agentic, and intent-driven; software systems evolve via formal specification of artifacts, autonomous agents assume planning, testing, repair, and code generation, and intent (rather than code fragments) becomes the “source” (Meyer, 24 Feb 2025, Li et al., 20 Jul 2025, Hassan et al., 2024, Hassan et al., 7 Sep 2025, Cogo et al., 27 Oct 2025).

The RPSE paradigm situates SE 3.0 as a chain of mental and material model transformations: stakeholder ideas (mental models) are systematically reified via formal intermediate representations down to executable code (Sirotin, 2018). In SE 3.0, each phase—including requirements, design, implementation, and testing—is rigorously formalized and the relationships between artifacts (e.g., milestones, code modules, tests) are governed by mathematical contracts and invariants (Meyer, 24 Feb 2025).

2. Formal Ontology and Engineering Theory

SE 3.0 advances a formal theory of software engineering, where engineering activities and artifacts are modeled as first-class mathematical objects. Core entities include:

• Project: Represented as $P = (\mathrm{Targets}(P),\,\mathrm{Milestones}(P))$, with milestone sequence and deliverables.
• Milestone: Defined by $$\mathrm{Elements}(M) \subseteq \mathit{PRODUCT\_INCREMENT}$$, enforcing project consistency via the invariant $$inc.\mathrm{product} \in \mathrm{Targets}(\mathrm{Project}(M))$$.
• CodeModule, TestCase: Linked by $\mathrm{Tests}(t, c)$ and $\mathrm{Passed}(t)$ predicates; milestone completion requires all associated tests to pass:

$$\mathrm{Completed}(M) \iff \forall inc,\forall c,\left(\forall t,\mathrm{Tests}(t,c)\Rightarrow\mathrm{Passed}(t)\right).$$

• Process: Modeled as sets of constraints (PROCESS_RULEs), rendering lifecycles amenable to conformance checking (e.g., Waterfall phase ordering).

This rigorous modeling delivers automated conformance, defined “done” states, process extensibility, and machine-verifiable compliance in CI/CD pipelines (Meyer, 24 Feb 2025). The RPSE view enables quantitative optimization of model chains for cost and quality (Sirotin, 2018).

3. Agentic Modality and Duality: SE for Agents and Humans

SE 3.0 is driven by autonomous, goal-oriented agents—AI teammates capable of planning, code synthesis, testing, repair, and architectural reasoning (Li et al., 20 Jul 2025, Roychoudhury, 24 Aug 2025, Hassan et al., 7 Sep 2025). Distinct modalities include:

Modality	Key Actors	Artifacts
SE for Humans	Agent Coaches, Leads	BriefingScript, MentorScript
SE for Agents	Coding agents, Subagents	Internal plans, Agent memory

• Agent Command Environment (ACE): Human-coaching interface handling BriefingScripts (goals, constraints, strategies), Merge-Readiness Packs (MRP: code diffs, test results, audit trails), and Consultation Request Packs (CRP: ambiguity resolutions).
• Agent Execution Environment (AEE): High-throughput agent workspace for parallel plan decomposition, performance monitoring, and proactive maintenance (Hassan et al., 7 Sep 2025).

Agents operate via agentic loops—decomposing mission briefs, executing multi-step plans, raising CRPs for ambiguities, and assembling MRPs for human review. The duality ensures human oversight for strategic decisions and agent autonomy for routine engineering tasks. MentorScripts embody formal rulebooks for style and process guidance, with agents capable of learning and sharing mentorship protocols.

4. FM Engineering and Intent-Driven, Search-Based Compilation

In SE 3.0, Foundation Model Engineering (FM engineering) treats both data and models as first-class artifacts, mirroring traditional DevOps in modularity, versioning, and automated orchestration (Ran et al., 2024, Cogo et al., 27 Oct 2025, Hassan et al., 2024). Key characteristics include:

• Declarative Pipelines: Specification of data transformation and labeling tasks via high-level DSLs; data-centric testing, bias audits.
• Unified Model Interface: API for model selection, training, adapter merging, and deployment—e.g.,

$$\mathtt{defineModel}: \{\texttt{arch}, \texttt{data},\texttt{objective}\} \to \texttt{ModelID}$$

• Continuous Compilation: Compiler.next exemplifies search-based intent compilers that optimize configurations over accuracy, cost, and latency;

$$P = \{ s \in S \mid \nexists s': A(s') \geq A(s)\wedge C(s') \leq C(s)\wedge L(s') \leq L(s), \text{ at least one strict}\}$$

employing NSGA-II multi-objective optimization, semantic caching, prompt mutation/crossover, and dynamic adaptation. Human intent—natural language, test cases—serves as source, and the compiler explores cognitive architectures to output working FMware (Cogo et al., 27 Oct 2025).

FM engineering brings the full machinery of software engineering—version control (git-theta), automated pipeline orchestration, multi-agent collaboration—to the era of FMs. Reproducibility is maintained via pinned FM versions and intermediate representations, and open benchmarks/traces are encouraged (Ran et al., 2024, Cogo et al., 27 Oct 2025).

5. Autonomous System Evolution and Multi-Objective Optimization

EvoGraph is emblematic of SE 3.0 self-evolving systems. Software estates are modeled as typed directed graphs over code, docs, builds, tests, and tickets. Specialized small LLMs (SLMs) drive learned mutation operators—code patching, weight merging, doc synchronization, build weaving, and language transmutation (Costa et al., 7 Aug 2025). Evolution proceeds via multi-objective fitness:

$$f(G) = \left(U(G), 1-P_{norm}(G), S(G), B(G), D(G), C(G)\right)^T$$

Selection applies Pareto front plus novelty to ensure continuous, closed-loop adaptation, subject to explicit safety gates (performance, security, drift control). Empirical results include >80% security vulnerability repair, cross-language modernization with 80-96% semantic equivalence, and 90% reduction in computational cost vs. large LLMs.

Autonomous evolution is tightly coupled to contract-based specification, empirical safety monitoring, and business KPI optimization, enabling systems to adapt while remaining under quantifiable control.

6. Empirical Evidence, Trust, Collaboration, and Governance

Large-scale empirical datasets (e.g., AIDev: 456K agent-initiated PRs) underpin software agent integration. Key findings include:

• Productivity: Agentic PRs vastly outpace human submission rates; agents resolve issues 10-100× faster than humans.
• Trust/Utility Gap: Agentic PRs are less frequently merged (acceptance rates: human ≈77%, Codex ≈64%, Copilot ≈35%) (Li et al., 20 Jul 2025). Agents favor minimal edits, contributing largely boilerplate code, with significant reviewer trust deficit.
• Review dynamics: Agents introduce code rapidly, but quality, style, and maintainability concerns prompt supplementary human oversight.

Statistical analysis (Mann–Whitney U, Cliff’s δ) confirms faster resolution but lower merge rates. Causes include limitations in complex reasoning, stylistic divergence, and unclear attribution.

Governance frameworks—attribution standards, accountability protocols, agent readiness metrics—are required, alongside living leaderboards and long-term quality tracking. Hybrid teams necessitate re-imagined Agile/DevOps, with new metrics, triage, and collaboration methods for human-agent interaction (Li et al., 20 Jul 2025, Hassan et al., 7 Sep 2025, Hassan et al., 2024).

7. Research Directions, Challenges, and Educational Implications

SE 3.0 presents substantial open questions and future work:

• Specification inference: Continuous intent extraction and formalization, trust calibration, robust handling of specification drift (Roychoudhury, 24 Aug 2025).
• Benchmarking and reproducibility: Gold-label dataset curation, community-shared compilation traces, standards for FMware interoperability, quality range estimation.
• Process engineering: Formal languages for BriefingScript/LoopScript/MentorScript, agentic guidance engineering, multi-agent collaboration protocols (Hassan et al., 7 Sep 2025).
• Tooling: Integration of agent-native IDEs, conversational debugging, SLA-aware runtime clusters, edge-cloud optimization (Hassan et al., 2024).
• Education: Curriculum renewal—shifting from “coding first” to “specify-and-coach”; training “Agent Coaches” for formal intent specification and multi-agent orchestration (Hassan et al., 7 Sep 2025, Ran et al., 2024).

A plausible implication is the future professionalization of agentic software engineering, with explicit formal artifacts for every process phase, and new roles spanning agent mentorship, evidence review, and specification management.

Citations correspond to arXiv identifiers:

• (Meyer, 24 Feb 2025) Software Engineering as a Domain to Formalize
• (Li et al., 20 Jul 2025) The Rise of AI Teammates in Software Engineering (SE) 3.0
• (Costa et al., 7 Aug 2025) EvoGraph: Hybrid Directed Graph Evolution toward Software 3.0
• (Roychoudhury, 24 Aug 2025) Agentic AI for Software: thoughts from Software Engineering community
• (Ran et al., 2024) Foundation Model Engineering: Engineering Foundation Models Just as Engineering Software
• (Mastropaolo et al., 2024) The Rise and Fall(?) of Software Engineering
• (Hassan et al., 7 Sep 2025) Agentic Software Engineering: Foundational Pillars and a Research Roadmap
• (Sirotin, 2018) RPSE: Reification as Paradigm of Software Engineering
• (Hassan et al., 2024) Towards AI-Native Software Engineering (SE 3.0): A Vision and a Challenge Roadmap
• (Cogo et al., 27 Oct 2025) Compiler.next: A Search-Based Compiler to Power the AI-Native Future of Software Engineering