Skip to content

Towards Iterative End-to-End Software Development: A Feature-Driven Multi-Agent Framework

🕒 Published (v1): 2025-11-04 09:27 UTC · Source: Arxiv · link

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

EvoDev is a multi-agent software development framework inspired by Feature-Driven Development (FDD) that replaces linear waterfall pipelines with a dependency-aware DAG called a Feature Map. Each node in the DAG propagates multi-layer context (business logic, UI/data design, implementation state) across iterative development cycles. On Android development benchmarks, EvoDev outperforms Claude Code by 57.3% and improves single-agent baselines by 16.0%–58.5%.

Problem

Existing LLM-based end-to-end software development systems (MetaGPT, ChatDev, AgileCoder) use linear, waterfall-style pipelines that fail to model the iterative, dependency-rich nature of real-world software development. They also rely on base LLMs to implicitly locate modification points in growing codebases—a task that degrades rapidly with repository scale. No prior work evaluated LLM agents on Android development, which adds complexity via application lifecycles, asynchronous tasks, and low-resource languages (Kotlin).

Method

EvoDev operates in three stages implemented on LangGraph:

  1. Overall Design Construction: A Business Analyst agent restructures informal requirements into a structured document (app description + business workflows). An Architect agent then produces a coarse-grained UI design (pages + top-level components) and a data entity schema, which serves as a shared vocabulary and blueprint for all subsequent agents.

  2. Feature Map Generation: A Feature Extractor agent decomposes requirements into features defined by a Feature Specification Schema (business workflow, business rules, UI flow, data flow, referenced component IDs). A Feature Planner agent then (a) infers inter-feature dependencies from business and technical perspectives, (b) groups features into cohesive sets sized to fit LLM context capacity, and (c) builds a DAG over feature sets—the Feature Map. Each DAG node stores three context layers: business-layer (feature specs + interfaces to successors), design-layer (relevant UI components and data entities from the global design), and implementation-layer (development status and modified files).

  3. Iterative Features Development: For each feature set in topological order, a Chief Programmer agent reads business- and design-layer context from the current node and all predecessors, extends the global design incrementally, and produces a fine-grained development plan. A Programmer agent then implements the plan using file read/write/edit tools. A file_contents memory cache replaces raw tool_calls history with natural-language summaries + updated file snapshots, controlling context bloat. Build errors are fed back in a coding→debugging loop until the build succeeds. After each set, EvoDev commits the result and updates the implementation-layer context for downstream nodes.

Key Contributions

  • First FDD-inspired multi-agent framework for end-to-end software development, with a DAG Feature Map carrying business, design, and implementation context across iterations.
  • APPDev: a manually constructed Android development benchmark of 15 apps, 172 average features per app, 3,656 average LoC, with feature-level quality scoring (1–4 scale)—significantly more complex than prior Python/web datasets.
  • A file_contents memory mechanism that removes fragmented tool_calls from dialogue history, keeping context compact and file versions current.
  • Empirical analysis of failure modes per agent role and practical implications for model training for iterative development.

Results

  • EvoDev (Claude 3.5 Sonnet backbone) outperforms the best baseline, Claude Code, by 57.3% on APPDev feature completion ratio.
  • EvoDev improves single-agent baselines by 16.0%–58.5% across different base LLMs (relative improvement).
  • Ablation (implied by RQ3): each stage—Overall Design Construction, Feature Map Generation, Iterative Development—contributes positively; Feature Map context propagation is a primary driver.
  • Task generalizability confirmed across tasks of varying difficulty (RQ2.b).
  • Model generalizability confirmed across multiple base LLMs (RQ2.a).

(Full ablation and per-baseline numbers are in sections not provided in the excerpt.)

Limitations

  • Dataset size is small (15 Android apps), raising concerns about statistical generalizability.
  • Feature set count is capped at ≤4 by design to balance cost/effectiveness; this may limit scalability to very large applications.
  • Relies on a scaffold project generated by Android Studio as input, adding a manual bootstrapping step not present in fully automated pipelines.
  • Performance depends on LLM ability to follow structured schemas (Feature Specification Schema, JSON outputs); low-resource or weaker models may violate schema constraints.
  • Evaluation is restricted to Android/Kotlin; generalization to other platforms or languages is asserted but not demonstrated.
  • The file_contents cache strategy is heuristic; correctness of substitution may degrade on complex diffs (the same risk noted for Claude Code's search–substitute strategy).

Relevance to Harnesses / Meta-Harnesses

EvoDev is a concrete meta-harness: it orchestrates multiple specialized sub-agents (Business Analyst, Architect, Feature Extractor, Feature Planner, Chief Programmer, Programmer) through a structured DAG control flow, managing inter-agent context passing via typed, multi-layer node payloads rather than unstructured prompt chaining. The Feature Map is functionally analogous to a harness's task graph—it determines execution order, gates which context each agent receives, and accumulates persistent state (implementation-layer context) that feeds forward. The file_contents memory mechanism directly addresses a harness-level concern: controlling context window growth in long-running, tool-heavy agentic loops. For researchers designing harnesses, EvoDev demonstrates that structured dependency graphs with multi-granularity context propagation significantly outperform flat sequential pipelines on complex, stateful tasks.