Towards Structured, State-Aware, and Execution-Grounded Reasoning for Software Engineering Agents

Software Engineering (SE) agents have shown promising abilities in supporting various SE tasks. Current SE agents remain fundamentally reactive, making decisions mainly based on conversation history and the most recent response. However, this reactive design provides no explicit structure or persistent state within the agent’s memory, making long-horizon reasoning challenging. As a result, SE agents struggle to maintain a coherent understanding across reasoning steps, adapt their hypotheses as new evidence emerges, or incorporate execution feedback into the mental reasoning model of the system state. In this position paper, we argue that, to further advance SE agents, we need to move beyond reactive behavior toward a structured, state-aware, and execution-grounded reasoning. We outline how explicit structure, persistent and evolving state, and the integration of execution-grounded feedback can help SE agents perform more coherent and reliable reasoning in long-horizon tasks. We also provide an initial roadmap for developing next-generation SE agents that can more effectively perform real-world tasks.

💡 Research Summary

The paper “Towards Structured, State‑Aware, and Execution‑Grounded Reasoning for Software Engineering Agents” diagnoses a fundamental limitation of today’s large‑language‑model (LLM) based software‑engineering (SE) agents: they operate in a purely reactive fashion, relying only on the most recent prompt and the raw conversation history. This design lacks any explicit, persistent representation of the agent’s internal understanding of the software system, making long‑horizon reasoning brittle. The authors argue that to advance SE agents we must move beyond this reactive paradigm and adopt three complementary capabilities: (1) an explicit, structured representation of the agent’s current knowledge (code elements, dependencies, invariants, hypotheses, pre‑ and post‑conditions); (2) a persistent, evolving “agent state” that can be incrementally updated after each tool invocation or reasoning step; and (3) a systematic integration of execution feedback (test results, compiler errors, runtime logs) as structured evidence that directly updates the agent state.

The paper first clarifies terminology. “State” refers to the agent’s structured model of the target software, while “hypothesis” denotes provisional assumptions made during reasoning. “Structure” describes how these entities are stored, related, and revised (e.g., as a graph or finite‑state machine). The authors then enumerate three failure patterns observed in existing reactive agents: (a) inconsistent reconstructions of reasoning when the conversation grows long, leading to contradictory decisions; (b) loss of intermediate hypotheses, causing agents to forget or re‑introduce previously resolved issues; and (c) isolated handling of execution feedback, which prevents agents from linking new evidence to existing beliefs. Empirical references to studies on SWE‑bench, bug‑localization, and input‑order bias support these claims.

To remedy these issues, the authors propose a “structured, state‑aware, execution‑grounded” reasoning model. The core idea is to replace the monolithic prompt with an explicit intermediate representation that captures (i) the current understanding of code and its dependencies, (ii) all active hypotheses and invariants, (iii) expected pre‑ and post‑conditions for each planned action, and (iv) alternative or tentative hypotheses that may be explored later. Their recent work (Agent‑SAMA) demonstrates that modeling agent actions as a finite‑state machine with explicit pre/post conditions yields more stable multi‑step reasoning.

In this new model, each reasoning step is treated as a state transition rather than a fresh reconstruction. After invoking a tool (e.g., a compiler, test runner, or debugger), the agent parses the structured feedback, maps it to the relevant hypothesis or invariant, and updates the internal state accordingly. This eliminates the need to re‑process the entire conversation, reduces noise, and enables precise self‑reflection: the agent can pinpoint exactly which hypothesis was invalidated and retry only the affected sub‑graph.

The paper outlines a four‑stage roadmap: (1) design a domain‑specific schema and storage engine for the structured state (graph databases, constraint solvers, or specialized knowledge bases); (2) define standardized interfaces that translate raw execution artifacts into structured evidence (e.g., mapping a failing test case to a violated invariant node); (3) implement state‑based self‑verification and localized retry mechanisms that can roll back or revise only the erroneous portion of the reasoning trace; and (4) integrate the architecture with existing SE platforms (GitHub Copilot, GPT‑5.1‑Codex, TRAE) and evaluate on benchmarks such as SWE‑bench, Bug‑Localisation, and large‑scale code bases.

The anticipated benefits are substantial. Structured state ensures historical coherence, so agents maintain consistent reasoning across dozens of steps. Execution‑grounded updates turn noisy logs into actionable knowledge, improving bug‑localization and automated fixing accuracy. Localized retries cut computational overhead and avoid the “reset‑and‑retry” pitfall that often reproduces the same failure. Moreover, a persistent, queryable state can be shared across sessions or team members, facilitating knowledge transfer and collaborative debugging.

In conclusion, the authors make a compelling case that the next generation of SE agents must emulate the human developer’s mental model: a continuously refined, structured representation of the software system that evolves with each piece of evidence. By embedding explicit structure, persistent state, and execution‑grounded feedback into the reasoning loop, SE agents can achieve reliable long‑horizon performance, opening the door to truly autonomous software development assistants.