====== Agentless ======

**Agentless** is a lightweight approach to autonomous software engineering that solves development problems **without** persistent agent loops.(("Agentless: Demystifying LLM-based Software Engineering Agents." [[https://arxiv.org/abs/2407.01489|arXiv:2407.01489]])) Developed by researchers from the University of Illinois Urbana-Champaign, it follows a simple three-phase "localize-then-repair" methodology. With over **2,000 GitHub stars**, Agentless achieved 40.7% on SWE-bench Lite and 50.8% on SWE-bench Verified when integrated with Claude 3.5 Sonnet — proving that simpler approaches can rival complex agent systems.

GitHub: [[https://github.com/OpenAutoCoder/Agentless|OpenAutoCoder/Agentless]](([[https://github.com/OpenAutoCoder/Agentless|GitHub Repository]]))(([[https://openautocoder.github.io/|Project Website]]))

===== Key Features =====

  * **No Agent Loop** — Unlike most AI coding tools, Agentless uses a fixed three-phase pipeline rather than an iterative agent loop
  * **Localize-Then-Repair** — Hierarchical fault localization followed by targeted patch generation
  * **Cost Efficient** — Significantly cheaper per task than agent-based approaches due to fewer LLM calls
  * **SWE-bench Performance** — 40.7% on SWE-bench Lite, 50.8% on SWE-bench Verified (with Claude 3.5 Sonnet)
  * **Best Open-Source Approach** — Achieved top open-source results on SWE-bench Lite at time of release
  * **Multi-Model Support** — Works with GPT-4, Claude 3.5 Sonnet, and other LLMs
  * **Reproducible** — Deterministic pipeline with published artifacts for all benchmark runs

===== Architecture =====

Agentless follows a deliberate anti-pattern to traditional agent design:

  * **Phase 1: Localization** — Hierarchical narrowing from repository level to file, class, method, and finally specific code lines
  * **Phase 2: Repair** — Generate candidate patches using the localized context
  * **Phase 3: Selection** — Rank and select the best patch using test execution and heuristics
  * **No Iterative Loop** — Each phase runs once; no backtracking or multi-turn agent conversation
  * **Minimal Tool Use** — Only needs file reading and test execution, no complex tool orchestration

===== Usage Example =====

<code bash>
# Clone and set up
git clone https://github.com/OpenAutoCoder/Agentless.git
cd Agentless

# Create conda environment
conda create -n agentless python=3.11
conda activate agentless
pip install -r requirements.txt

# Set API key
export OPENAI_API_KEY="your-key-here"

# Run localization phase
python3 agentless/localize.py \
    --instance django__django-16379 \
    --model gpt-4

# Run repair phase
python3 agentless/repair.py \
    --instance django__django-16379 \
    --localization results/localization.json

# Run patch selection
python3 agentless/select.py \
    --candidates results/patches/
</code>

===== How It Works =====

<mermaid>
graph TD
    A[Bug Report / Issue] --> B[Phase 1: Localization]
    B --> C[Repository-Level Analysis]
    C --> D[File-Level Narrowing]
    D --> E[Class/Method-Level Narrowing]
    E --> F[Line-Level Localization]
    F --> G[Phase 2: Repair]
    G --> H[Context Extraction]
    H --> I[LLM Patch Generation]
    I --> J[Multiple Candidate Patches]
    J --> K[Phase 3: Selection]
    K --> L[Test Execution]
    L --> M[Patch Ranking]
    M --> N[Best Patch Output]
    
    style B fill:#e1f5fe
    style G fill:#fff3e0
    style K fill:#e8f5e9
</mermaid>

===== Philosophy: Why Agentless? =====

The Agentless approach challenges the assumption that autonomous software engineering requires complex agent architectures:

  * **Simplicity** — A fixed pipeline is easier to understand, debug, and improve than an open-ended agent loop
  * **Predictability** — Deterministic phases produce more consistent results than stochastic agent exploration
  * **Cost** — Fewer LLM calls mean significantly lower API costs per task
  * **Reproducibility** — Fixed pipeline enables fair comparisons and scientific evaluation
  * **Baseline Value** — Provides a strong baseline against which agent-based approaches should be measured

The authors argue that if a simple three-phase pipeline can match or exceed agent-based systems, the field should question whether agent complexity is always justified. (([[https://arxiv.org/abs/2407.01489|Research Paper]]))

===== See Also =====

  * [[autocoderover|AutoCodeRover]] — Agent-based autonomous program improvement
  * [[trae_agent|Trae Agent]] — ByteDance's research-friendly CLI agent
  * [[smol_developer|Smol Developer]] — Generates entire codebases from a prompt
  * [[devon|Devon]] — Open-source pair programmer
  * [[cline|Cline]] — Model-agnostic autonomous coding agent

===== References =====