PaperlayerView exact revision on arXiv

Source-linked AI summary

Agentic Software Engineering: Foundational Pillars and a Research Roadmap

Ahmed E. Hassan, Hao Li, Dayi Lin, Bram Adams, Tse-Hsun Chen, Yutaro Kashiwa, Dong Qiu

arXiv:2509.06216v3cs.SEcs.AI

TL;DR

Building and shipping complex, trustworthy software remains a challenge as autonomous agents pursue software-engineering objectives. This paper proposes Structured Agentic Software Engineering as a structured duality and conceptual scaffold, introducing evidence-oriented artifacts and processes while intentionally stopping short of a definitive solution.

  • Problem

    Building and shipping complex, trustworthy software remains a challenge for autonomous-agent efforts.

  • Method

    The paper proposes Structured Agentic Software Engineering, organized around a structured duality and evidence-oriented artifacts for bridging agent outputs with oversight.

  • Results

    The paper presents a vision and conceptual framework for reconsidering software engineering around agent work and evidence-based oversight.

  • Takeaways & Limitations

    SASE provides structured vocabulary intended to catalyze dialogue about trustworthy agentic software engineering.

  • Takeaways & Limitations

    SASE is intentionally visionary and is not offered as a definitive solution.

Abstract

from arXiv · show

Agentic Software Engineering (SE 3.0) represents a new era where intelligent agents are tasked not with simple code generation, but with achieving complex, goal-oriented SE objectives. To harness these new capabilities while ensuring trustworthiness, we must recognize a fundamental duality within the SE field in the Agentic SE era, comprising two symbiotic modalities: SE for Humans and SE for Agents. This duality demands a radical reimagining of the foundational pillars of SE (actors, processes, tools, and artifacts) which manifest differently across each modality. We propose two purpose-built workbenches to support this vision. The Agent Command Environment (ACE) serves as a command center where humans orchestrate and mentor agent teams, handling outputs such as Merge-Readiness Packs (MRPs) and Consultation Request Packs (CRPs). The Agent Execution Environment (AEE) is a digital workspace where agents perform tasks while invoking human expertise when facing ambiguity or complex trade-offs. This bi-directional partnership, which supports agent-initiated human callbacks and handovers, gives rise to new, structured engineering activities (i.e., processes) that redefine human-AI collaboration, elevating the practice from agentic coding to true agentic software engineering. This paper presents the Structured Agentic Software Engineering (SASE) vision, outlining several of the foundational pillars for the future of SE. The paper culminates in a research roadmap that identifies a few key challenges and opportunities while briefly discussing the resulting impact of this future on SE education. Our goal is not to offer a definitive solution, but to provide a conceptual scaffold with structured vocabulary to catalyze a community-wide dialogue, pushing the SE community to think beyond its classic, human-centric tenets toward a disciplined, scalable, and trustworthy agentic future.

1 Introduction

SASE frames Agentic Software Engineering as a structured duality serving both humans and agents, requiring a rethinking of SE’s actors, processes, tools, and artifacts. It proposes ACE and AEE workbenches connected through explicit, version-controlled artifacts to support scalable, trustworthy collaboration.

  • Motivation: Current agent efforts often fail to meet merge-readiness because they contain regressions, superficial fixes, or weak engineering hygiene, increasing human verification demands.The introduction describes this as a speed-versus-trust challenge at agentic scale.
  • Motivation: Informal prompting lacks reproducible processes, auditable artifacts, and durable collaboration mechanisms, limiting agentic work to 1-to-1 coding instead of N-to-N engineering.SASE positions structured artifacts and activities as the basis for larger-scale human-agent teams.
  • Foundational pillars: SASE rethinks SE’s four pillars: hybrid human-agent actors, repeatable processes, specialized tools, and machine-readable artifacts serving as contracts and institutional memory.Examples include BriefingScript and agent-generated Consultation Request Packs for human expertise.
  • Scope: The paper presents SASE as a conceptual scaffold and research roadmap for community dialogue, not as a definitive solution.It also identifies research challenges and opportunities and discusses implications for SE education.
  • Structured duality: Agentic SE introduces SE for Humans, where humans set intent, strategy, and mentorship as Agent Coaches, alongside SE for Agents, where agents execute within structured environments.The two modalities are intended to operate simultaneously rather than treating agents as mere coding assistants.
  • Purpose-built workbenches: ACE supports human orchestration, intent specification, workflow management, observability, and evidence-backed review, while AEE supports agents’ computation, parallelism, and repetitive execution.The environments separate human and agent strengths while preserving collaboration between them.
  • Structured collaboration: ACE and AEE exchange version-controlled BriefingScripts, LoopScripts, MentorScripts, Consultation Request Packs, and Merge-Readiness Packs in a structured dialogue.Agents can request human expertise through CRPs and present evidence-backed deliverables through MRPs.

2 From Agency to Autonomy: A Hierarchical Framework for AI in SE

The paper distinguishes agency from autonomy and uses that distinction to motivate a hierarchical framework for classifying AI capabilities in SE, from assistance to full automation. This framework situates the transition from AI-Augmented SE (SE 2.0) to Agentic SE (SE 3.0).

  • The framework adapts the staged logic of autonomous-driving levels to classify AI capabilities in SE from simple assistance to full automation.
  • Agency is the capacity to act and execute plans toward a given goal, whereas autonomy is the capacity to self-govern and formulate goals independently.
  • The framework is intended to clarify the transition from AI-Augmented SE (SE 2.0) to Agentic SE (SE 3.0).

Level 0: Manual Coding (No-AI SE) [SE 1.0]

Level 0 describes manual coding without AI assistance: humans translate ideas into tokens and perform all driving tasks in the corresponding autonomy analogy.

  • No-AI SE requires humans to manually translate ideas into tokens by typing.
  • Plain text editors such as Notepad, vi, and emacs exemplify Level 0 technology.
  • The SAE Level 0 parallel is no automation, with the human performing all driving tasks.

Level 1: Token Assistance (AI-Augmented Coding) [SE 1.5]

Level 1 provides token-level assistance that maps immediate editing intent to predicted tokens, while the human remains responsible for driving.

  • Token assistance maps a developer’s immediate editing intent to predicted tokens.
  • Standard auto-complete features in modern IDEs exemplify Level 1 technology.
  • The SAE Level 1 parallel is driver assistance, such as cruise control.

Level 2: Task-Agentic (AI-Augmented SE) [SE 2.0]

Level 2 maps planned code changes to complete generated blocks and extends similar automation to testing and code review, while requiring constant human supervision.

  • Task-agentic coding maps a planned code change, such as a function description, to a complete generated code block.
  • Comparable Level 2 automation exists for other SE tasks, including testing and code review.
  • GitHub Copilot and Amazon CodeWhisperer are example technology manifestations.
  • The SAE Level 2 parallel is partial automation: the vehicle controls steering and speed, but the human must constantly supervise and remains responsible.

Level 3: Goal-Agentic (Agentic SE) [SE 3.0]

Level 3, or Goal-Agentic SE, maps broad technical goals to detailed multi-step implementation plans executed by emerging agents. Its autonomy remains conditional, requiring human intervention under specified conditions.

  • Goal-Agentic SE translates a technical goal such as adding a caching layer into a detailed plan of code changes.
  • Agents at this level can execute multi-step plans across code, documentation, and other essential artifacts.
  • Emerging systems including Devin, Claude Code, Jules, and Codex aim to operate at this level through self-devised or human-guided plans.
  • Level 3 parallels SAE Level 3 conditional automation: the system drives itself under specific conditions, but a human must remain ready to intervene.

Level 4: Specialized Domain Autonomy [SE 4.0]

Level 4, or Specialized Domain Autonomy, combines high autonomy with restriction to a particular technical or quality-attribute domain. Specialization can target a technology stack, a quality attribute, or both.

  • Specialized Domain Autonomy maps a broad technical mandate to concrete goals within a particular domain.
  • Frontend specialization combines implementation abilities with Next.js and Tailwind CSS and an excellent baseline aesthetic taste.
  • A security agent applies deep security expertise across diverse technology stacks.
  • Level 4 agents can specialize in a technology stack, a quality attribute, or a fused combination of both.
  • Level 4 parallels SAE Level 4 high driving automation: autonomy is restricted to a limited operational domain.

Level 5: General Domain Autonomy [SE 5.0]

Level 5, or General Domain Autonomy, aims to apply high-autonomy capabilities to any technical challenge, but remains conceptual and does not yet exist. The paper therefore emphasizes disciplined practices for the nearer-term Agentic SE transition.

  • General Domain Autonomy would map a general technical mandate to domain-specific technical mandates across unfamiliar domains.
  • Level 5 requires deep, specialized expertise across technology domains and quality attributes, including backends, embedded systems, performance, reliability, accessibility, and security.
  • General domain autonomy is currently at the conceptual or research stage and does not yet exist.
  • The Level 5 parallel is full driving automation, applying high autonomy to any technical challenge under all conditions.
  • The immediate challenge is mastering Agentic SE, because moving from SE 2.0 to SE 3.0 increases complexity in orchestration, trust, and verification.
  • SASE focuses on artifacts, processes, and tools needed to engineer trustworthy software during the SE 3.0 era.

3 The Emergence of Agentic Software Engineering

Agentic Software Engineering is emerging amid strong industry incentives and a shift from workflow-based automation toward more autonomous, goal-oriented systems. Evidence shows rapid benchmark progress and widespread agent use, while also exposing persistent problems with merge readiness, evaluation, and software quality.

  • SE attracts Agentic SE investment because expensive engineering labor, rich software data, measurable outcomes, safety nets, and transferable benefits converge.
  • Automated testing and CI pipelines mitigate risks, while SE-trained foundation models can generalize to other business tasks lacking equivalent guardrails and data.
  • Competition among frontier companies has accelerated Agentic SE from a theoretical concept to a strategic imperative and produced specialized coding agents.
  • Workflow agents execute human-defined plans through hardcoded orchestration, whereas autonomous agents plan, reason, invoke tools, and formulate their own paths.
  • Autonomous agents can be guided in natural language, enabling English-based rewiring and a shift from explicitly coding logic to declaratively describing behavior.
  • Passing tests is insufficient for merge readiness because agents struggle to understand context, intent, and broader system behavior.
  • 29.6% of plausible fixes introduced regressions or were incorrect upon rigorous retesting, while GPT-4 true solve rates fell from 12.47% to 3.97% after manual audits.
  • Agents often produce superficial, single-file patches that pass unit tests but fail broader CI checks because of style problems or hidden regressions.

4 Motivational Example: The Anatomy of an Agentic SE Workflow

The example replaces ticket-by-ticket coding with specification, parallel agent execution, human evaluation, and iterative refinement. It exposes gaps in processes and artifacts, motivating structured, durable guidance and auditable outputs.

  • The New Workflow: The developer shifts from coder to specifier, evaluating candidate solutions and refining specifications when none is acceptable.Once an acceptable solution emerges, it proceeds toward review and eventual merge.
  • The New Workflow: Approximately 1.5 hours of specifications and guidance for seven tickets triggers 28 pull requests generated asynchronously by autonomous agents.The workflow produces four pull requests per ticket for parallel solution exploration.
  • The New Workflow: N-version programming supports trial-and-error inference-time compute and creative exploration through multiple agent-generated solutions.The developer compares candidate pull requests before selecting or revising the specification.
  • Process and Artifact Gaps: BriefingScripts replace vague tickets with structured work orders covering success criteria, architectural context, strategic advice, and potential gotchas.They are intended as first-class, machine-readable artifacts rather than informal prompts.
  • Process and Artifact Gaps: BriefingScripts evolve through dialogue, versioned updates, and feedback, creating a durable, auditable record of shared human-agent understanding.The paper characterizes this artifact as human-readable while remaining machine-readable and reviewable.
  • Process and Artifact Gaps: MentorScript codifies reusable mentorship, while LoopScript defines agent workflows and Readiness Packs organize evidence for merge decisions.Together, these artifacts address guidance, execution, and the gap between agent outputs and merge-ready contributions.
  • Workbenches: The Agent Command Environment supports one-to-many and many-to-many collaboration as a command center for orchestrating parallel agent work.It is proposed because current tools do not adequately support the new agentic workflow.

Appendix A.2.

The appendix describes complementary workbenches: ACE coordinates human oversight and agent collaboration, while AEE supplies agents with specialized tools and operational monitoring.

  • Agent Command Environment: ACE should let developers compare and combine multiple agent-generated solutions, inspect architectural impacts, and manage structured artifacts.Its proposed capabilities include versioning BriefingScript, MentorScript, and LoopScript and composing agent teams by capability and cost.
  • Agent Command Environment: ACE supports strategic intervention, including evaluating, retraining, demoting, or retiring underperforming agents and switching to direct implementation when efficient.Voice interaction is proposed as a complementary modality for orchestration and mentorship.
  • Agent Command Environment: Voice can capture commands, intent, and feedback without requiring developers to leave their current work context.The ASR layer passes transcribed intent to downstream ACE tools and agents rather than performing reasoning.
  • Agent Execution Environment: AEE is a workbench built for agents, whose tools may include hyper-debuggers, semantic search, and structural editors operating on symbolic representations.These tools are intended to exploit agent strengths rather than reduce human cognitive load.
  • Agent Execution Environment: AEE monitoring should handle operational issues such as vulnerabilities, excessive computational costs, and broken virtual environments before surfacing strategic problems to humans.The intended boundary is autonomous low-level maintenance with human attention reserved for significant intervention.

5 The Engineering Activities of SASE

SASE is framed as an initial scaffold of structured activities for governed, evidence-based collaboration among human coaches, AI teammates, and hybrid teams. It introduces artifacts and environments that make briefing, execution, mentorship, and consultation explicit.

  • SASE Activities: SASE distinguishes team-level agentic software engineering from solo agentic coding through governance, evidence-based review, consultation, and explicit merge-readiness.Consultation Request Packs make human consultation traceable as a team artifact.
  • Briefing Engineering: Briefing Engineering codifies intent and guidance in version-controlled, testable, machine-readable BriefingScripts that are as central as source code.BriefingScripts combine requirements specification, architectural design, implementation advice, and test planning, while remaining iterative rather than waterfall-style.
  • Briefing Engineering: BriefingScript formalization is more tractable because machines consume the briefs, tasks are granular, and AI assistants can help humans author them.The activity adapts principles from Requirements Engineering and Agile/Scrum to an agentic context.
  • Agentic Loop Engineering: Agentic Loop Engineering uses declarative LoopScripts to turn agent work into disciplined, auditable, reproducible workflows grounded in DevOps principles.The paper connects LoopScripts with declarative pipelines, infrastructure-as-code, observability, and a future evolution of CI/CD.
  • Mentorship: Mentorship-as-code captures review guidance in version-controlled MentorScripts, including explicit rules and principles inferred from contextual corrections.The stated goal is more predictable and reliable agent behavior by reducing the coach’s burden of inferring rule interactions.
  • Human-Agent Roles: Agent-centric SE casts humans as strategists, mentors, and conductors who arbitrate value and provide tacit knowledge while agents perform computational work.The proposed activities formalize human participation where expertise adds the greatest value, including agent escalations and callbacks.
  • Foundational Pillars: The roadmap emphasizes agent-native toolchains, engineered multi-agent teams, and persistent teammates to improve interpretability, specialization, reliability, and continuous maintenance.It also identifies Agent-Native MCP servers and AEE engineering as important infrastructure for robust, scalable, fault-tolerant agentic SE.

6 Discussion

The discussion argues that agentic software engineering needs structured, auditable foundations spanning human-agent collaboration, workbenches, artifacts, processes, and education. SASE presents these elements as a conceptual scaffold rather than a final solution.

  • Critical gaps: Current agentic tools lack robust traceability, observability, and unified archival for human-agent collaboration.Pull-request systems track suggestions and code changes but do not explicitly preserve the causal link between mentorship and implementation.
  • Structured collaboration: SASE replaces ephemeral agentic coding with structured, auditable records that support reproducible and trustworthy collaboration.The framework treats the collaboration journey, including intent evolution and decision trails, as part of software engineering.
  • Mentorship-as-Code: Mentorship-as-Code turns review guidance into version-controlled, testable MentorScript rules that can improve cumulatively across tasks and teams.This extends existing prompt-driven workflows into a team-level methodology rather than a solo-developer convenience.
  • Dual workbenches: SASE defines complementary workbenches: ACE supports human specification, orchestration, mentorship, and evidence-based review, while AEE supports agent strengths such as massive parallelism.The framework also identifies ATLE and ATIE for agent memory, lifecycle, observability, and agent-native tooling.
  • Artifacts and handovers: SASE makes Merge-Readiness Packs and Consultation Request Packs first-class artifacts for evidence-based completion and agent-initiated human consultation.MRPs bundle functional completeness, verification, SE hygiene, rationale, and auditability; CRPs support traceable handovers when agents encounter ambiguity.
  • Education and scope: The proposed shift elevates humans from direct implementers to agent coaches and orchestrators, requiring education that prepares students to manage fleets of agents.The paper explicitly frames SASE as a discussion scaffold and notes that its realization would not automatically create highly productive engineers.
Loading 2509.06216v3…