> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/swe-agent.md).

# SWE-agent Code-Fixer

## Überblick

[SWE-agent](https://github.com/SWE-agent/SWE-agent) ist ein KI-gestützter Software-Engineering-Agent, der **GitHub-Issues automatisch löst** indem er ein Sprachmodell über eine Terminal-Schnittstelle mit einem Code-Repository interagieren lässt. Vorgestellt auf **NeurIPS 2024** und mit über **15.000 GitHub-Sternen**, ist SWE-agent zur führenden Open-Source-Lösung für automatisierte Fehlerbehebung und Code-Reparatur geworden.

Im Gegensatz zu den meisten Tools in dieser Dokumentation benötigt SWE-agent **keine GPU** — es ruft externe LLM-APIs (Claude, GPT-4, Gemini oder selbst gehostete Modelle) auf, um über Code nachzudenken und Fixes zu generieren. Was es *braucht* ist eine zuverlässige Docker-Umgebung für sichere, sandboxed Code-Ausführung. Clore.ai's CPU-Server (oder jede gemietete Instanz mit Docker) passen perfekt.

**Hauptfunktionen:**

* 🐛 Automatisches Lösen von GitHub-Issues mit einem einzigen Befehl
* 🔒 Sandbox-Ausführung in Docker-Containern — sicher zum Ausführen beliebigen Codes
* 🤖 Unterstützt Claude, GPT-4, Gemini, OpenAI-kompatible und lokale Modelle
* 🌐 Web-UI zur Überwachung des Agentenfortschritts
* 🛡️ Cybersecurity-Modus für CTF-Herausforderungen und Penetrationstests
* 📊 SWE-bench-kompatibel — getestet an über 300 echten GitHub-Issues
* 🔧 Konfigurierbare Agentenverhalten über YAML-Konfigurationsdateien

***

## Anforderungen

### Hardware-Anforderungen

SWE-agent braucht keine GPU — es nutzt API-basierte LLMs zum Gründen:

| Tier                   | CPU        | RAM   | Speicher   | Clore.ai-Preis |
| ---------------------- | ---------- | ----- | ---------- | -------------- |
| **Minimum**            | 4 Kerne    | 8 GB  | 30 GB SSD  | \~0,03 $/Std.  |
| **Empfohlen**          | 8 Kerne    | 16 GB | 60 GB SSD  | \~0,06 $/Std.  |
| **Hohe Arbeitslasten** | 16 Kerne   | 32 GB | 100 GB SSD | \~0,10 $/Std.  |
| **Mit lokalem LLM**    | GPU-Server | 32 GB | 100 GB SSD | \~$0.20/Stunde |

> 💡 **Kosten-Tipp:** SWE-agent ist ungewöhnlich günstig auf Clore.ai zu betreiben, da keine GPU benötigt wird. Die Hauptkosten sind die LLM-API-Aufrufe (z. B. kostet Claude Sonnet \~0,003 $/1K Tokens). Ein typischer Issue-Fix kostet 0,50–2,00 $ an API-Gebühren.

### Software- & API-Anforderungen

| Anforderung           | Details                                                 |
| --------------------- | ------------------------------------------------------- |
| **Docker**            | Erforderlich für sandboxed Code-Ausführung              |
| **LLM-API-Schlüssel** | Anthropic, OpenAI, Google oder selbst gehostet          |
| **GitHub-Token**      | Zum Zugriff auf private Repos und zum Erstellen von PRs |
| **Python 3.11+**      | Für `pip install sweagent` Methode                      |

### LLM-API-Preisreferenz

| Modell          | Eingabe         | Ausgabe         | Typische Laufkosten       |
| --------------- | --------------- | --------------- | ------------------------- |
| Claude Sonnet 4 | 3 $/M Tokens    | 15 $/M Tokens   | \~1,00–2,00 $             |
| GPT-4o          | 5 $/M Tokens    | 15 $/M Tokens   | \~1,00–3,00 $             |
| GPT-4o mini     | 0,15 $/M Tokens | 0,60 $/M Tokens | \~0,05–0,20 $             |
| Ollama (lokal)  | Kostenlos       | Kostenlos       | Nur Clore.ai-Stundenpreis |

***

## Schnellstart

### Schritt 1 — Server auf Clore.ai mieten

1. Melde dich an bei [clore.ai](https://clore.ai)
2. Filtern: **Docker aktiviert** — GPU ist optional (CPU-Server ist ausreichend)
3. Empfohlenes Image: `ubuntu:22.04` oder jedes Docker-fähige Image
4. Offene Ports: **22** (SSH), **7860** (SWE-agent Web-UI)
5. Mindestens 16 GB RAM empfohlen für das Ausführen von Docker-in-Docker

### Schritt 2 — Verbindung per SSH herstellen

```bash
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Überprüfen, ob Docker verfügbar ist
docker --version
docker run --rm hello-world
```

### Schritt 3 — Das SWE-agent Docker-Image ziehen

```bash
# Ziehe das offizielle SWE-agent Image (vorgebaut, empfohlen)
docker pull sweagent/swe-agent:latest

# Verifizieren
docker images | grep sweagent
```

Alternativ aus dem Quellcode bauen für die neueste Entwicklungsvariante:

```bash
git clone https://github.com/SWE-agent/SWE-agent.git
cd SWE-agent
docker build -t sweagent/swe-agent:local .
```

### Schritt 4 — API-Schlüssel einrichten

```bash
# Erstelle ein Verzeichnis für SWE-agent-Konfiguration
mkdir -p /workspace/sweagent && cd /workspace/sweagent

# Erstelle Umgebungsdatei mit deinen API-Schlüsseln
cat > /workspace/sweagent/.env << 'EOF'
# LLM-API-Schlüssel (füge nur hinzu, was du hast)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
GOOGLE_API_KEY=...

# GitHub-Token zum Zugriff auf Repos und zum Erstellen von PRs
GITHUB_TOKEN=ghp_...

# Optional: selbst gehosteter LLM-Endpunkt
# OPENAI_BASE_URL=http://your-ollama-server:11434/v1
EOF

chmod 600 /workspace/sweagent/.env
```

### Schritt 5 — Dein erstes GitHub-Issue beheben

```bash
# Basisverwendung — behebe ein GitHub-Issue mit Claude Sonnet
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /workspace/sweagent/output:/output \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1 \
    --actions.apply_patch_locally=true \
    --output_dir=/output
```

### Schritt 6 — Die Ausgabe prüfen

```bash
# SWE-agent schreibt Ergebnisse in das Ausgabe-Verzeichnis
ls -la /workspace/sweagent/output/

# Den generierten Patch anzeigen
cat /workspace/sweagent/output/*.patch

# Die vollständige Agenten-Trajektorie anzeigen (was der Agent getan hat)
cat /workspace/sweagent/output/*.traj | python3 -m json.tool | less
```

***

## Konfiguration

### Basis-Konfigurationsdatei

Anstelle langer Kommandozeilen-Flags nutze eine YAML-Konfig:

```bash
cat > /workspace/sweagent/config.yaml << 'EOF'
# SWE-agent Konfiguration
agent:
  model:
    name: claude-sonnet-4-20250514
    per_instance_cost_limit: 2.00
    total_cost_limit: 10.00
    temperature: 0.0
  config:
    # System-Prompt für den Agenten
    system_template: "default"
    # Wie viele Wiederholungen bei API-Fehlern
    retry_with_output_if_run_fails: true

env:
  repo:
    # Wird pro Lauf gesetzt
    github_url: ""
  deployment:
    docker_args:
      - "--memory=4g"
      - "--cpus=2"

problem_statement:
  github_url: ""

actions:
  apply_patch_locally: true
  open_pr: false  # Auf true setzen, um automatisch einen PR zu erstellen

output_dir: /output
EOF
```

```bash
# Mit Konfigurationsdatei ausführen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /workspace/sweagent/output:/output \
  -v /workspace/sweagent/config.yaml:/config.yaml \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --config /config.yaml \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/42
```

### Web-UI-Modus

SWE-agent enthält eine Gradio-basierte Web-Oberfläche für interaktive Nutzung:

```bash
# Starte die Web-UI
docker run -d \
  --name sweagent-ui \
  --env-file /workspace/sweagent/.env \
  -p 7860:7860 \
  -v /workspace/sweagent/output:/output \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python app.py --port 7860 --host 0.0.0.0

# Auf die UI zugreifen
echo "Öffnen: http://<CLORE_SERVER_IP>:<MAPPED_PORT>"
docker logs -f sweagent-ui
```

### Verwendung verschiedener LLM-Anbieter

```bash
# GPT-4o (OpenAI)
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=gpt-4o-2024-11-20 \
    --agent.model.per_instance_cost_limit=3.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# GPT-4o Mini (Budget-Option)
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=gpt-4o-mini-2024-07-18 \
    --agent.model.per_instance_cost_limit=0.50 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Lokales Ollama (in Verbindung mit Ollama-Anleitung)
# Zuerst Ollama auf einem GPU-Server bereitstellen (siehe ../language-models/ollama.md)
# Dann als Backend für SWE-agent verwenden:
docker run --rm \
  -e OPENAI_API_KEY=dummy \
  -e OPENAI_BASE_URL=http://<OLLAMA_HOST>:11434/v1 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=qwen2.5-coder:32b \
    --agent.model.per_instance_cost_limit=0.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1
```

### Stapelverarbeitung mehrerer Issues

```bash
# Verarbeite mehrere Issues im SWE-bench-Format
cat > /workspace/sweagent/batch_issues.json << 'EOF'
[
  {
    "repo": "USER/REPO",
    "issue_number": 1,
    "model": "claude-sonnet-4-20250514"
  },
  {
    "repo": "USER/REPO",
    "issue_number": 2,
    "model": "claude-sonnet-4-20250514"
  }
]
EOF

# Batch-Run-Skript
cat > /workspace/sweagent/run_batch.sh << 'BASH'
#!/bin/bash
set -e

ISSUES_FILE="${1:-/workspace/sweagent/batch_issues.json}"
OUTPUT_DIR="/workspace/sweagent/output"
ENV_FILE="/workspace/sweagent/.env"

echo "Starte batch SWE-agent Lauf..."
python3 -c "
import json
issues = json.load(open('$ISSUES_FILE'))
for i, issue in enumerate(issues):
    print(f'Issue {i+1}/{len(issues)}: {issue[\"repo\"]}#{issue[\"issue_number\"]}')
" 

jq -c '.[]' "$ISSUES_FILE" | while read issue; do
    REPO=$(echo "$issue" | jq -r '.repo')
    ISSUE_NUM=$(echo "$issue" | jq -r '.issue_number')
    MODEL=$(echo "$issue" | jq -r '.model')

    echo "=== Verarbeite: $REPO#$ISSUE_NUM mit $MODEL ==="
    
    docker run --rm \
      --env-file "$ENV_FILE" \
      -v "$OUTPUT_DIR:/output" \
      -v /var/run/docker.sock:/var/run/docker.sock \
      sweagent/swe-agent:latest \
      python run.py \
        --agent.model.name="$MODEL" \
        --agent.model.per_instance_cost_limit=2.00 \
        --env.repo.github_url="https://github.com/$REPO" \
        --problem_statement.github_url="https://github.com/$REPO/issues/$ISSUE_NUM" \
        --output_dir=/output || echo "FEHLGESCHLAGEN: $REPO#$ISSUE_NUM"
done

echo "Batch abgeschlossen. Ergebnisse in $OUTPUT_DIR"
BASH

chmod +x /workspace/sweagent/run_batch.sh
/workspace/sweagent/run_batch.sh
```

***

## Docker-in-Docker Einrichtung

SWE-agent führt Code in verschachtelten Docker-Containern aus für Sicherheit. Dies erfordert Zugriff auf den Docker-Socket:

```bash
# Verifiziere, dass der Docker-Socket zugänglich ist
ls -la /var/run/docker.sock

# Teste, dass Docker-in-Docker funktioniert
docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  docker:latest docker run --rm hello-world

# SWE-agent wird automatisch sein Sandbox-Image ziehen
# Standard-Sandbox: sweagent/swe-agent:latest (oder ein spezialisiertes Env-Image)
```

### Sicherheitsüberlegungen

```bash
# SWE-agent Sandbox-Ressourcenlimits (in deiner YAML konfigurieren)
cat >> /workspace/sweagent/config.yaml << 'EOF'
env:
  deployment:
    docker_args:
      - "--memory=4g"          # Sandbox-RAM begrenzen
      - "--cpus=2"             # Sandbox-CPU begrenzen
      - "--network=bridge"     # Isoliertes Netzwerk
      - "--read-only"          # Nur-Lese-Dateisystem (mit Ausnahmen)
      - "--tmpfs=/tmp:size=1g" # Schreibbares /tmp nur
EOF

# Führe SWE-agent niemals direkt auf dem Host aus — immer Docker verwenden
# Der Sandbox-Container isoliert potenziell schädlichen Code
```

### Verwendung eines vorgefertigten Environment-Images

```bash
# SWE-agent unterstützt benutzerdefinierte Environment-Images pro Repository
# Das beschleunigt Läufe durch vorinstallierte Abhängigkeiten
cat > /workspace/sweagent/env-config.yaml << 'EOF'
env:
  deployment:
    image: sweagent/swe-agent:latest
    pre_install:
      - "pip install -e ."
      - "pip install pytest"
    post_clone:
      - "git config --global user.email 'agent@sweagent.ai'"
      - "git config --global user.name 'SWE-agent'"
EOF
```

***

## Tipps & bewährte Methoden

### 🎯 Effektive Problemstellungen schreiben

Die Qualität der Fixes von SWE-agent hängt stark von der Issue-Beschreibung ab:

````bash
# Methode 1: Verwende eine GitHub-Issue-URL (empfohlen)
--problem_statement.github_url=https://github.com/USER/REPO/issues/42

# Methode 2: Stelle eine Textdatei mit detaillierter Beschreibung bereit
cat > /workspace/sweagent/issue.txt << 'EOF'
## Fehlerbeschreibung
Die Funktion `calculate_total()` in `billing/calculator.py` gibt 0 zurück 
wenn der Rabatt genau 100% beträgt. 

## Schritte zum Reproduzieren
```python
total = calculate_total(price=100, discount=100)
assert total == 0  # Das schlägt fehl, gibt stattdessen 100 zurück
````

## Erwartetes Verhalten

Sollte 0 zurückgeben, wenn der Rabatt 100% beträgt.

## Relevanter Code

Siehe `billing/calculator.py` Zeilen 45-67. EOF

docker run --rm\
\--env-file /workspace/sweagent/.env\
-v /workspace/sweagent/output:/output\
-v /workspace/sweagent/issue.txt:/issue.txt\
-v /var/run/docker.sock:/var/run/docker.sock\
sweagent/swe-agent:latest\
python run.py\
\--agent.model.name=claude-sonnet-4-20250514\
\--env.repo.github\_url=<https://github.com/USER/REPO\\>
\--problem\_statement.text\_file=/issue.txt

````

### 💰 Kostenkontrolle

```bash
# Setze stets Per-Instance-Kostenlimits
--agent.model.per_instance_cost_limit=2.00  # Max. 2 $ pro Issue

# Verwende GPT-4o mini für erste Triage, Claude für komplexe Fixes
# Budgetstrategie: ~0,10 $ zum Scannen, ~1,50 $ zum Beheben

# Überwache Kosten in Echtzeit
docker logs -f sweagent-ui | grep -E "(cost|tokens|spent)"

# Setze ein Gesamtbudget für alle Läufe
--agent.model.total_cost_limit=20.00  # Stoppt alle Läufe nach 20 $
````

### 🔄 Auto-PR Erstellung

```bash
# Automatisch einen Pull Request mit dem Fix erstellen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/42 \
    --actions.open_pr=true \
    --actions.push_gh_repo_url=https://github.com/USER/REPO
```

### 📊 SWE-bench Bewertung

```bash
# Führe SWE-agent gegen das offizielle SWE-bench-Benchmark aus
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run_batch.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --instances.type=swe_bench \
    --instances.subset=lite \
    --instances.split=test \
    --output_dir=/output \
    --num_workers=4
```

### 🛡️ Cybersecurity-Modus

```bash
# SWE-agent unterstützt CTF- und Cybersecurity-Herausforderungen
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.config=config/default_from_url_ctf.yaml \
    --env.deployment.image=sweagent/ctf-env:latest \
    --problem_statement.text="Finde die Flagge im laufenden Webdienst unter http://challenge.local:8080" \
    --output_dir=/output
```

***

## Fehlerbehebung

### Docker-Socket: Zugriff verweigert

```bash
# Fehler: Zugriff verweigert beim Verbinden mit dem Docker-Daemon
# Lösung: Stelle sicher, dass der Docker-Socket korrekt gemountet ist

docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  docker ps

# Wenn du Berechtigungsfehler siehst, überprüfe die Socket-Berechtigungen
ls -la /var/run/docker.sock
# Sollte sein: srw-rw---- root docker

# Füge den aktuellen Benutzer zur docker-Gruppe hinzu (falls nicht root)
usermod -aG docker $USER
newgrp docker
```

### API-Schlüssel-Fehler

```bash
# Überprüfe, ob dein API-Schlüssel korrekt gesetzt ist
docker run --rm \
  --env-file /workspace/sweagent/.env \
  sweagent/swe-agent:latest \
  python -c "
import os
keys = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GITHUB_TOKEN']
for k in keys:
    val = os.environ.get(k, 'NOT SET')
    masked = val[:8] + '...' if len(val) > 8 else val
    print(f'{k}: {masked}')
"

# Anthropic-API-Schlüssel testen
curl https://api.anthropic.com/v1/models \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"
```

### Agent steckt in einer Schleife fest

```bash
# SWE-agent hat ein eingebautes Schritt-Limit (Standard ~100 Schritte)
# Erhöhe oder verringere es über die Konfiguration:

docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --agent.model.per_instance_cost_limit=2.00 \
    --agent.max_requeries=5 \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Einen feststeckenden Lauf beenden
docker ps | grep sweagent
docker stop <container_id>
```

### Speicher-Fehler während der Code-Ausführung

```bash
# Erhöhe das Sandbox-Speicherlimit
docker run --rm \
  --env-file /workspace/sweagent/.env \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /workspace/sweagent/output:/output \
  sweagent/swe-agent:latest \
  python run.py \
    --agent.model.name=claude-sonnet-4-20250514 \
    --env.deployment.docker_args='["--memory=8g", "--cpus=4"]' \
    --env.repo.github_url=https://github.com/USER/REPO \
    --problem_statement.github_url=https://github.com/USER/REPO/issues/1

# Für große Codebasen die Clore.ai-Instanz auf 32 GB RAM erhöhen
```

### GitHub-Ratenbegrenzung

```bash
# Die GitHub-API hat Ratenbegrenzungen — verwende ein Personal Access Token mit repo-Berechtigungen
# Überprüfe deinen aktuellen Ratenlimit-Status
curl -H "Authorization: token $GITHUB_TOKEN" \
  https://api.github.com/rate_limit | jq '.rate'

# Wenn du ratenbegrenzt bist, warte auf das Reset oder verwende ein anderes Token
# Das Ratenlimit setzt sich stündlich zurück
```

***

## Weiterführende Lektüre

* [SWE-agent GitHub](https://github.com/SWE-agent/SWE-agent) — Haupt-Repository und Docs
* [SWE-agent Dokumentation](https://swe-agent.com/docs/) — Offizielle Dokumentation
* [SWE-agent Paper (NeurIPS 2024)](https://arxiv.org/abs/2405.15793) — Forschungspapier
* [SWE-bench Bestenliste](https://www.swebench.com/) — Sieh, wie verschiedene Modelle abschneiden
* [Clore.ai Erste Schritte](/guides/guides_v2-de/erste-schritte/getting-started.md) — Plattform-Grundlagen
* [GPU-Vergleichsanleitung](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — Falls du eine GPU für lokale LLMs benötigst
* [Ollama auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/ollama.md) — Lokales LLM-Backend für SWE-agent
* [vLLM auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/vllm.md) — Hochdurchsatz lokaler LLM-Server
* [Anthropic API Preise](https://www.anthropic.com/pricing) — Claude API-Kosten
* [OpenAI API Preise](https://openai.com/api/pricing/) — GPT-4 API-Kosten

> 💡 **Clore.ai + SWE-agent Sweet Spot:** Miete einen CPU-only Server (4 Kerne, 16 GB RAM) für \~0,05 $/Std., betreibe SWE-agent mit Claude Sonnet 4 und behebe GitHub-Issues für ungefähr **1–2 $ insgesamt pro Issue** (API-Kosten) plus ein paar Cent Clore.ai-Zeit. Für Teams mit vielen Issues ist das gegenüber der Einstellung eines Entwicklers für routinemäßige Fehlerbehebungen um Größenordnungen günstiger.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/swe-agent.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.