# Corregidor de código SWE-agent

## Resumen

[SWE-agent](https://github.com/SWE-agent/SWE-agent) es un agente de ingeniería de software impulsado por IA que **resuelve automáticamente problemas de GitHub** permitiendo que un modelo de lenguaje interactúe con un repositorio de código a través de una interfaz de terminal. Presentado en **NeurIPS 2024** y con más de **15,000 estrellas en GitHub**, SWE-agent se ha convertido en la solución de código abierto líder para corrección automática de errores y reparación de código.

A diferencia de la mayoría de las herramientas en esta documentación, SWE-agent **no requiere GPU** — llama a APIs externas de LLM (Claude, GPT-4, Gemini o modelos autohospedados) para razonar sobre el código y generar correcciones. Lo que *sí* necesita es un entorno Docker fiable para la ejecución de código segura y en sandbox. Los servidores CPU de Clore.ai (o cualquier instancia alquilada con Docker) son una opción perfecta.

**Características clave:**

* 🐛 Resolución automatizada de issues de GitHub con un solo comando
* 🔒 Ejecución en sandbox dentro de contenedores Docker — seguro para ejecutar código arbitrario
* 🤖 Compatible con Claude, GPT-4, Gemini, OpenAI-compatible y modelos locales
* 🌐 Interfaz web para monitorizar el progreso del agente
* 🛡️ Modo de ciberseguridad para desafíos CTF y pruebas de penetración
* 📊 Compatible con SWE-bench — probado contra más de 300 issues reales de GitHub
* 🔧 Comportamientos del agente configurables mediante archivos YAML

***

## Requisitos

### Requisitos de hardware

SWE-agent no necesita GPU — utiliza LLMs basados en API para razonar:

| Nivel                          | CPU              | RAM   | Almacenamiento | Precio de Clore.ai |
| ------------------------------ | ---------------- | ----- | -------------- | ------------------ |
| **Mínimo**                     | 4 núcleos        | 8 GB  | 30 GB SSD      | \~$0.03/h          |
| **Recomendado**                | 8 núcleos        | 16 GB | 60 GB SSD      | \~$0.06/h          |
| **Cargas de trabajo intensas** | 16 núcleos       | 32 GB | 100 GB SSD     | \~$0.10/h          |
| **Con LLM local**              | Servidor con GPU | 32 GB | 100 GB SSD     | \~$0.20/h          |

> 💡 **Consejo de coste:** SWE-agent es inusualmente barato de ejecutar en Clore.ai ya que no necesitas GPU. El coste principal son las llamadas a la API del LLM (por ejemplo, Claude Sonnet cuesta \~ $0.003/1K tokens). Una corrección típica de un issue cuesta $0.50–$2.00 en tarifas de API.

### Requisitos de software y API

| Requisito            | Detalles                                         |
| -------------------- | ------------------------------------------------ |
| **Docker**           | Requerido para la ejecución de código en sandbox |
| **Clave API de LLM** | Anthropic, OpenAI, Google o autohospedado        |
| **Token de GitHub**  | Para acceder a repositorios privados y crear PRs |
| **Python 3.11+**     | Para `pip install sweagent` método               |

### Referencia de precios de API de LLM

| Modelo          | Entrada        | Salida         | Coste típico de ejecución       |
| --------------- | -------------- | -------------- | ------------------------------- |
| 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 (local)  | Gratis         | Gratis         | Solo coste por hora de Clore.ai |

***

## Inicio rápido

### Paso 1 — Alquila un servidor en Clore.ai

1. Inicia sesión en [clore.ai](https://clore.ai)
2. Filtrar: **Docker habilitado** — La GPU es opcional (un servidor CPU está bien)
3. Imagen recomendada: `ubuntu:22.04` o cualquier imagen con Docker habilitado
4. Puertos abiertos: **22** (SSH), **7860** (Interfaz web de SWE-agent)
5. Se recomienda un mínimo de 16 GB de RAM para ejecutar Docker-in-Docker

### Paso 2 — Conectar vía SSH

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

# Verifica que Docker esté disponible
docker --version
docker run --rm hello-world
```

### Paso 3 — Descargar la imagen Docker de SWE-agent

```bash
# Descargar la imagen oficial de SWE-agent (preconstruida, recomendada)
docker pull sweagent/swe-agent:latest

# Verificar
docker images | grep sweagent
```

Alternativamente, compilar desde la fuente para la versión de desarrollo más reciente:

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

### Paso 4 — Configurar las claves API

```bash
# Crear un directorio para la configuración de SWE-agent
mkdir -p /workspace/sweagent && cd /workspace/sweagent

# Crear archivo de entorno con tus claves API
cat > /workspace/sweagent/.env << 'EOF'
# Claves API de LLM (añade solo las que tengas)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
GOOGLE_API_KEY=...

# Token de GitHub para acceder a repos y crear PRs
GITHUB_TOKEN=ghp_...

# Opcional: endpoint de LLM autohospedado
# OPENAI_BASE_URL=http://your-ollama-server:11434/v1
EOF

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

### Paso 5 — Arregla tu primer issue de GitHub

```bash
# Uso básico — arregla un issue de GitHub con 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
```

### Paso 6 — Revisar la salida

```bash
# SWE-agent escribe los resultados en el directorio de salida
ls -la /workspace/sweagent/output/

# Ver el parche generado
cat /workspace/sweagent/output/*.patch

# Ver la trayectoria completa del agente (lo que hizo el agente)
cat /workspace/sweagent/output/*.traj | python3 -m json.tool | less
```

***

## Configuración

### Archivo de configuración básico

En lugar de largas banderas de línea de comandos, usa un archivo YAML:

```bash
cat > /workspace/sweagent/config.yaml << 'EOF'
# Configuración de SWE-agent
agent:
  model:
    name: claude-sonnet-4-20250514
    per_instance_cost_limit: 2.00
    total_cost_limit: 10.00
    temperature: 0.0
  config:
    # Plantilla de sistema para el agente
    system_template: "default"
    # Cuántos reintentos ante errores de API
    retry_with_output_if_run_fails: true

env:
  repo:
    # Se establecerá por ejecución
    github_url: ""
  deployment:
    docker_args:
      - "--memory=4g"
      - "--cpus=2"

problem_statement:
  github_url: ""

actions:
  apply_patch_locally: true
  open_pr: false  # Ponlo en true para crear un PR automáticamente

output_dir: /output
EOF
```

```bash
# Ejecutar con archivo de configuración
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
```

### Modo interfaz web

SWE-agent incluye una interfaz web basada en Gradio para uso interactivo:

```bash
# Iniciar la interfaz web
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

# Acceder a la interfaz
echo "Abrir: http://<CLORE_SERVER_IP>:<MAPPED_PORT>"
docker logs -f sweagent-ui
```

### Usando diferentes proveedores de LLM

```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 (opción económica)
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

# Ollama local (combinar con la guía de Ollama)
# Primero despliega Ollama en un servidor con GPU (ver ../language-models/ollama.md)
# Luego úsalo como backend para SWE-agent:
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
```

### Procesamiento por lotes de múltiples issues

```bash
# Procesar múltiples issues usando el formato SWE-bench
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

# Script de ejecución por lotes
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 "Iniciando ejecución por lotes de SWE-agent..."
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 "=== Procesando: $REPO#$ISSUE_NUM con $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 "FALLADO: $REPO#$ISSUE_NUM"
done

echo "Lote completo. Resultados en $OUTPUT_DIR"
BASH

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

***

## Configuración Docker-in-Docker

SWE-agent ejecuta código en contenedores Docker anidados por seguridad. Esto requiere acceso al socket de Docker:

```bash
# Verificar que el socket de Docker sea accesible
ls -la /var/run/docker.sock

# Probar que Docker-in-Docker funciona
docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  docker:latest docker run --rm hello-world

# SWE-agent descargará automáticamente su imagen de sandbox
# Sandbox por defecto: sweagent/swe-agent:latest (o una imagen de entorno especializada)
```

### Consideraciones de seguridad

```bash
# Límites de recursos del sandbox de SWE-agent (configura en tu YAML)
cat >> /workspace/sweagent/config.yaml << 'EOF'
env:
  deployment:
    docker_args:
      - "--memory=4g"          # Limitar RAM del sandbox
      - "--cpus=2"             # Limitar CPU del sandbox
      - "--network=bridge"     # Red aislada
      - "--read-only"          # Sistema de archivos en solo lectura (con excepciones)
      - "--tmpfs=/tmp:size=1g" # /tmp solo escribible
EOF

# Nunca ejecutes SWE-agent directamente en tu host — siempre usa Docker
# El contenedor sandbox aísla código potencialmente dañino
```

### Uso de una imagen de entorno preconstruida

```bash
# SWE-agent admite imágenes de entorno personalizadas por repositorio
# Esto acelera las ejecuciones al preinstalar dependencias
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
```

***

## Consejos y mejores prácticas

### 🎯 Redacción efectiva de declaraciones de problema

La calidad de la reparación de SWE-agent depende en gran medida de la descripción del issue:

````bash
# Método 1: Usa una URL de issue de GitHub (recomendado)
--problem_statement.github_url=https://github.com/USER/REPO/issues/42

# Método 2: Proporciona un archivo de texto con una descripción detallada
cat > /workspace/sweagent/issue.txt << 'EOF'
## Descripción del bug
La función `calculate_total()` en `billing/calculator.py` devuelve 0 
cuando el descuento es exactamente 100%. 

## Pasos para reproducir
```python
total = calculate_total(price=100, discount=100)
assert total == 0  # Esto falla, devuelve 100 en su lugar
````

## Comportamiento esperado

Debería devolver 0 cuando el descuento es 100%.

## Código relevante

Ver `billing/calculator.py` líneas 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

````

### 💰 Control de costes

```bash
# Siempre establece límites de coste por instancia
--agent.model.per_instance_cost_limit=2.00  # Máx $2 por issue

# Usa GPT-4o mini para la triaje inicial, Claude para correcciones complejas
# Estrategia de presupuesto: ~ $0.10 para escanear, ~ $1.50 para arreglar

# Monitoriza los costes en tiempo real
docker logs -f sweagent-ui | grep -E "(cost|tokens|spent)"

# Establece un presupuesto total para todas las ejecuciones
--agent.model.total_cost_limit=20.00  # Detener todas las ejecuciones después de $20
````

### 🔄 Creación automática de PRs

```bash
# Crear automáticamente un pull request con la corrección
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
```

### 📊 Evaluación SWE-bench

```bash
# Ejecuta SWE-agent contra el benchmark oficial SWE-bench
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
```

### 🛡️ Modo de ciberseguridad

```bash
# SWE-agent soporta desafíos CTF y de ciberseguridad
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="Encuentra la flag en el servicio web en ejecución en http://challenge.local:8080" \
    --output_dir=/output
```

***

## Solución de problemas

### Permiso denegado para el socket de Docker

```bash
# Error: permiso denegado al intentar conectar con el daemon de Docker
# Solución: asegura que el socket de Docker esté montado correctamente

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

# Si ves errores de permisos, revisa los permisos del socket
ls -la /var/run/docker.sock
# Debería ser: srw-rw---- root docker

# Añade el usuario actual al grupo docker (si no eres root)
usermod -aG docker $USER
newgrp docker
```

### Errores de claves API

```bash
# Verifica que tu clave API esté configurada correctamente
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}')
"

# Probar la clave API de Anthropic
curl https://api.anthropic.com/v1/models \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"
```

### El agente se queda atascado en un bucle

```bash
# SWE-agent tiene un límite de pasos incorporado (por defecto ~100 pasos)
# Aumenta o disminuye vía configuración:

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

# Matar una ejecución atascada
docker ps | grep sweagent
docker stop <container_id>
```

### Agotamiento de memoria durante la ejecución de código

```bash
# Aumenta el límite de memoria del sandbox
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

# Para bases de código grandes, aumenta la instancia de Clore.ai a 32GB de RAM
```

### Limitación de tasa de GitHub

```bash
# La API de GitHub tiene límites de tasa — usa un token de acceso personal con ámbito repo
# Comprueba el estado actual de tu límite de tasa
curl -H "Authorization: token $GITHUB_TOKEN" \
  https://api.github.com/rate_limit | jq '.rate'

# Si estás limitado por la tasa, espera al reinicio o usa otro token
# El límite de tasa se reinicia cada hora
```

***

## Lecturas adicionales

* [SWE-agent en GitHub](https://github.com/SWE-agent/SWE-agent) — Repositorio principal y documentación
* [Documentación de SWE-agent](https://swe-agent.com/docs/) — Documentación oficial
* [Artículo de SWE-agent (NeurIPS 2024)](https://arxiv.org/abs/2405.15793) — Artículo de investigación
* [Leaderboard de SWE-bench](https://www.swebench.com/) — Mira cómo rinden diferentes modelos
* [Empezando con Clore.ai](/guides/guides_v2-es/primeros-pasos/getting-started.md) — Conceptos básicos de la plataforma
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — Si necesitas GPU para LLMs locales
* [Ejecutando Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Backend de LLM local para SWE-agent
* [Ejecutando vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — Servidor local de LLM de alto rendimiento
* [Precios de la API de Anthropic](https://www.anthropic.com/pricing) — Costes de la API Claude
* [Precios de la API de OpenAI](https://openai.com/api/pricing/) — Costes de la API GPT-4

> 💡 **Punto óptimo Clore.ai + SWE-agent:** Alquila un servidor solo CPU (4 núcleos, 16GB RAM) por \~ $0.05/h, ejecuta SWE-agent con Claude Sonnet 4 y arregla issues de GitHub por aproximadamente **$1–2 en total por issue** (costes de API) más unos pocos centavos de tiempo en Clore.ai. Para equipos con muchos issues, esto supera con creces contratar a un desarrollador para correcciones rutinarias de bugs.


---

# Agent Instructions: 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-es/plataformas-y-agentes-de-ia/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.