AgentiLoopGo

🌐 English · Español · Français · Deutsch · 中文 (简体) · Русский · 한국어 · 日本語

🎉 ¡Hemos publicado la versión v0.0.7 para Mac, Windows y Linux!

¡Pruébalo! Lee el README y mira cuánto tardas en tener AgentiLoop funcionando. Si te encuentras con algún problema, avísanos. Nos encantaría conocer tu opinión.

Extra: También hay una versión en Rust: AgentiLoopCLI → https://github.com/AgentiLoop/AgentiLoopCLI

Prueba las dos y dinos cuál lo hace mejor: ¿Go o Rust? 🐹 vs 🦀

💖 Patrocina AgentiLoop

¿Te gusta lo que ves? Ayúdanos a que AgentiLoop siga siendo rápido y multiplataforma. Patrocínanos en GitHub Sponsors → AgentiLoop. Los niveles y las ventajas están en la guía de patrocinio.

AgentiLoop es un agente de programación con IA que se ejecuta en tu terminal, al estilo de Claude Code. Describes lo que quieres con tus propias palabras. El agente lee tus archivos, edita el código y ejecuta comandos para conseguirlo, y te pide permiso antes de cambiar nada.

Está escrito en Go y funciona en macOS, Linux y Windows. Es el gemelo en Go de AgentiLoopCLI (Rust): mismas funciones, mismas opciones, mismos archivos de configuración, de sesión y de MCP, así que puedes cambiar entre ellos libremente. Funciona con Claude (Anthropic), OpenAI, modelos locales a través de Ollama o LM Studio, y oMLX en Apple Silicon.

¡Creado con AgentiLoop Agent! Es nuestro bebé. Tienes binarios precompilados para macOS, Linux y Windows en la página de Releases, o puedes compilarlo desde el código fuente con Go.

⚡ Primera ejecución: el asistente de configuración lo hace todo

No hay nada que configurar a mano. La primera vez que ejecutas agentiloop, un asistente de configuración integrado arranca solo. Te pregunta qué proveedor quieres (Claude, OpenAI, Ollama / LM Studio u oMLX), toma tu clave de API (escrita de forma oculta), comprueba que la clave funciona, te deja elegir un modelo y lo guarda todo en ~/.agentiloop. Alrededor de un minuto, sin archivos de configuración, sin líneas export.

Vuelve a ejecutarlo cuando quieras con agentiloop --setup (añade --tui para la versión a pantalla completa, o escribe /setup dentro de una sesión). agentiloop --reset lo olvida todo y empieza de cero. ¿Nunca has instalado un programa de línea de comandos? Sigue ¿Nuevo aquí? más abajo, paso a paso.

🚀 ¿Nuevo aquí? En marcha en 5 minutos

Sin Rust, sin Go, sin compilar. Descargas un archivo, le das una clave de API y empiezas a chatear. Sigue los pasos en orden.

1. Descarga AgentiLoop

Primero averigua qué archivo necesitas:

Tu ordenador	Archivo que descargar
Mac con Apple Silicon (M1, M2, M3, M4…)	`agentiloop-macos-arm64.tar.gz`
Mac con chip Intel	`agentiloop-macos-x86_64.tar.gz`
Linux, PC de 64 bits	`agentiloop-linux-x86_64.tar.gz`
Linux en ARM (Raspberry Pi 4/5, servidores ARM)	`agentiloop-linux-arm64.tar.gz`
Windows 10/11	`agentiloop-windows-x86_64.zip`

¿No estás seguro? En Mac o Linux, ejecuta uname -m. arm64 o aarch64 significa arm64, y x86_64 significa x86_64.

macOS y Linux. Abre Terminal y pega estas líneas. Este ejemplo usa el archivo de Apple Silicon, así que cambia macos-arm64 en las tres primeras líneas si el tuyo es distinto:

curl -LO https://github.com/AgentiLoop/AgentiLoopGo/releases/download/v0.0.7/agentiloop-macos-arm64.tar.gz
tar xzf agentiloop-macos-arm64.tar.gz
mkdir -p ~/.local/bin && mv agentiloop-macos-arm64/agentiloop ~/.local/bin/

Eso coloca el programa en ~/.local/bin, una carpeta dentro de tu directorio personal. El asistente de configuración del paso 3 se ofrece a decirle a tu terminal que busque ahí.

Windows. Abre PowerShell (menú Inicio → escribe "PowerShell") y pega:

Invoke-WebRequest https://github.com/AgentiLoop/AgentiLoopGo/releases/download/v0.0.7/agentiloop-windows-x86_64.zip -OutFile agentiloop.zip
Expand-Archive agentiloop.zip -DestinationPath $HOME\agentiloop -Force
$p = [Environment]::GetEnvironmentVariable("Path", "User")
[Environment]::SetEnvironmentVariable("Path", "$p;$HOME\agentiloop\agentiloop-windows-x86_64", "User")

Las dos últimas líneas añaden AgentiLoop a tu PATH. Cierra PowerShell y abre una ventana nueva para que se aplique el cambio.

2. Consigue una clave de API

AgentiLoop es el agente. El "cerebro" es un modelo de IA al que lo conectas. Elige uno:

Opción	Dónde conseguirla	Coste
Claude (recomendado)	console.anthropic.com → Create Key. Empieza por `sk-ant-`	Pago por uso
OpenAI	platform.openai.com/api-keys. Empieza por `sk-`	Pago por uso
Ollama (se ejecuta en tu propio ordenador)	Instálalo desde ollama.com y luego ejecuta `ollama pull qwen2.5-coder`	Gratis, sin clave

Guarda la clave en un lugar seguro. La pegarás en el siguiente paso.

3. Ejecuta el asistente de configuración

No editas ningún archivo ni escribes ningún comando export. AgentiLoop tiene un asistente de configuración integrado que te hace unas pocas preguntas y guarda la clave por ti.

Como ~/.local/bin todavía no está en tu PATH, esta única vez arráncalo con su ruta completa (en Windows el paso 1 ya arregló el PATH, así que escribe simplemente agentiloop):

~/.local/bin/agentiloop

La primera vez, cuando todavía no hay ninguna clave configurada, el asistente arranca solo. Tarda alrededor de un minuto y pregunta cinco cosas:

Qué proveedor — Claude, OpenAI, un servidor local compatible con OpenAI (Ollama, LM Studio, …) u oMLX. Escribe un número.
Tu clave de API — se escribe de forma oculta, no se muestra nada en pantalla. Los servidores locales normalmente no necesitan ninguna; con oMLX en el mismo Mac, el asistente lee la clave de la propia configuración de oMLX, así que ni siquiera la pide.
Comprobación de conexión — el asistente habla con el proveedor al momento. Si la clave es incorrecta te lo dice y te ofrece intentarlo de nuevo; no se guarda nada hasta que funciona.
Qué modelo — elige uno de la lista que devuelve el proveedor, o pulsa Enter para el predeterminado. Puedes cambiarlo en cualquier momento más adelante con /model.
Dónde guardar la clave — pulsa Enter para la opción predeterminada, ~/.agentiloop/env, un archivo privado que solo lee AgentiLoop. (Las otras opciones, para quien también quiera la clave en su shell o en el Llavero de macOS, se explican en Avanzado: definir la clave a mano en el Inicio rápido.)

Por último, el asistente se da cuenta de que ~/.local/bin no está en tu PATH y se ofrece a añadirlo. Pulsa Enter (sí). Después dice All set y te deja en el prompt. Aquí tienes una ejecución completa en el terminal normal, eligiendo Claude y aceptando los valores predeterminados (tu lista de modelos será distinta):

$ ~/.local/bin/agentiloop
Welcome to AgentiLoop! Let's set things up (about a minute).
Settings are kept in /Users/you/.agentiloop. Run `agentiloop --setup` or `/setup` to redo this, `agentiloop --reset` to start over.

Which model provider do you want to use?
  1  Claude (Anthropic) — API key from console.anthropic.com
  2  OpenAI — API key from platform.openai.com
  3  Ollama, LM Studio or another OpenAI-compatible server (local, usually no key)
  4  oMLX (local Apple Silicon server; reads ~/.omlx/settings.json)
Provider [1-4, default 1]: 1
Anthropic API key (starts with sk-ant-, input hidden):
Checking the connection…
Connected (8 model(s) available).

Pick a model (change it any time with /model):
   1  claude-sonnet-5  (default)
   2  claude-…
   3  claude-…
   …
Model [1-8, an id, or Enter for claude-sonnet-5]:

Where should the credential be saved?
  1  /Users/you/.agentiloop/env (recommended; only agentiloop reads it, file mode 600)
  2  Also add it to /Users/you/.zshrc so other tools in your terminal see it
  3  macOS Keychain, with a line in /Users/you/.zshrc that reads it (nothing stored in plain text)
Save to [1-3, default 1]:
saved to /Users/you/.agentiloop/env

`/Users/you/.local/bin` is not on your PATH, so `agentiloop` only works with its full path.
Add it to PATH in /Users/you/.zshrc? [Y/n]
updated /Users/you/.zshrc (between `# >>> agentiloop >>>` and `# <<< agentiloop <<<`); it applies to new terminals

All set: anthropic / claude-sonnet-5. Type a request at the prompt, /help for commands, /exit to leave.

Puedes empezar a chatear aquí mismo, o escribir /exit y continuar con el paso 4. A partir de ahora, un simple agentiloop arranca directamente en el prompt.

Para Claude puedes pegar una clave de API normal (sk-ant-api…) o un token de Claude Code (sk-ant-oat01-…, de claude setup-token); AgentiLoop detecta de qué tipo es. Si elegiste la opción 3 (Ollama, LM Studio, …), el asistente también te pide la URL del servidor y ofrece http://localhost:11434/v1 como valor predeterminado, así que para un Ollama local basta con pulsar Enter.

El mismo asistente, a pantalla completa. El asistente funciona en la interfaz que uses. Arráncalo con --tui y las mismas preguntas aparecen dentro de la interfaz a pantalla completa; cuando termina ya estás en el prompt:

Vuelve a ejecutarlo o rehazlo cuando quieras:

agentiloop --setup          # asistente en el terminal normal
agentiloop --setup --tui    # asistente dentro de la TUI a pantalla completa (como en la captura)
/setup                      # desde dentro de una sesión en marcha (REPL o TUI)
agentiloop --reset          # olvidarlo todo y empezar de cero

🔒 Mantén tu clave en privado. ~/.agentiloop/env solo lo puedes leer tú. No pegues la clave en chats ni la subas a git. En un Mac, la opción 3 de la pregunta «Where should the credential be saved?» la guarda en el Llavero, así que nunca está en el disco en texto plano.

¿Prefieres gestionar la clave tú mismo con variables de entorno? También funciona, pero es la vía avanzada; consulta Avanzado: definir la clave a mano en el Inicio rápido.

4. Comprueba que funciona

Abre una ventana nueva de terminal para que recoja el cambio del PATH hecho por el asistente (Windows: una ventana nueva de PowerShell). Después:

agentiloop --version

Deberías ver agentiloop 0.0.7. Ahora ejecútalo sin opciones:

agentiloop

Debería ir directamente al prompt. Si en su lugar vuelve a arrancar el asistente, la clave no se guardó: repite el paso 3.

5. Tu primera sesión

Ve a una carpeta de proyecto y abre la interfaz a pantalla completa:

Empieza con una carpeta de prueba nueva y vacía para probarlo sin riesgos. Para un proyecto real, entra con cd en la carpeta de ese proyecto (por ejemplo cd ~/code/my-app).

mkdir -p ~/agentiloop-test
cd ~/agentiloop-test
agentiloop --tui

¿Usas Ollama? El asistente ya recordó el servidor y el modelo que elegiste. Para cambiar a otro modelo que hayas descargado, escribe /model dentro de la sesión.

Ahora simplemente escribe lo que quieres con tus propias palabras y pulsa Enter. Algunas buenas primeras peticiones:

explica qué hace este proyecto
lista los archivos de src y dime cuál es el punto de entrada
busca los comentarios TODO y resúmelos
añade una opción --verbose al analizador de la línea de comandos
ejecuta los tests y arregla lo que falle
crea un README.md para este proyecto

Antes de que el agente cambie un archivo o ejecute un comando, te pregunta. Pulsa y para sí, n para no, a para permitir siempre esa herramienta durante la sesión, o Esc para saltarte el paso. Pulsa Ctrl-C para salir. La próxima vez, un simple agentiloop arranca igual y retoma tu última conversación.

¿Solo quieres una respuesta sin chat? Pasa la pregunta como argumento:

agentiloop "explain what this project does"

¿Qué puede hacer? (herramientas)

El agente trabaja con diez herramientas integradas. No las llamas tú. Describes el objetivo y el agente elige la herramienta:

Herramienta	Qué hace	¿Pregunta antes?
`read_file`	Lee un archivo (con números de línea)	No
`list_dir`	Lista los archivos de una carpeta	No
`glob`	Busca archivos por patrón de nombre (`.rs`, `src//.go`)	No
`grep`	Busca dentro de los archivos con una expresión regular	No
`web_fetch`	Descarga una página web o respuesta de API como texto plano	Sí
`todo_write`	Mantiene la lista de tareas del propio modelo para trabajos de varios pasos	No
`write_file`	Crea un archivo nuevo o sobrescribe uno	Sí
`edit_file`	Cambia un fragmento exacto de texto en un archivo	Sí
`bash`	Ejecuta un comando de shell, como tests, compilaciones o `git` (`sh -c` en Mac/Linux, `cmd /C` en Windows)	Sí
`task`	Lanza un subagente con una conversación vacía para una tarea autocontenida (explorar, investigar) y devuelve solo su respuesta. Tiene las mismas herramientas y hace las mismas preguntas; no puede lanzar subagentes propios	No (sus propias llamadas a herramientas preguntan como siempre)

¿Quieres más herramientas, como búsqueda web, bases de datos o GitHub? Añade servidores MCP; consulta Añadir herramientas con MCP.

El comando de ayuda

agentiloop --help muestra todas las opciones:

$ agentiloop --help
AgentiLoop — a cross-platform agentic coding loop for your terminal.

Usage: agentiloop [OPTIONS] [PROMPT]...

Arguments:
  [PROMPT]...  One-shot prompt. If omitted, starts an interactive REPL. A lone `-` in it is replaced by
               what is piped on stdin: git diff | agentiloop "review this" -

Options:
  -p, --provider PROVIDER           Model backend (PROVIDER): anthropic, openai (OpenAI-compatible: OpenAI, Ollama,
                                    LM Studio, Groq, OpenRouter, … via OPENAI_BASE_URL), omlx (local
                                    oMLX server, http://localhost:8000/v1), or codex (ChatGPT plan via
                                    `codex login`). Defaults to the last one used, then auto-detected from
                                    which credentials are set. [env: AGENTILOOP_PROVIDER]
  -m, --model MODEL                 MODEL id to use. Defaults to the last model used with this provider
                                    (~/.agentiloop/settings.json), then the provider's default. [env: AGENTILOOP_MODEL]
      --yes                         Skip all permission prompts (dangerous; intended for CI). Never remembered. [env: AGENTILOOP_YES]
      --max-turns N                 Max provider round-trips (N) per prompt [default: last used, then 50]
      --max-retries N               Retries (N) of a provider call that fails transiently (rate limit, overloaded, 5xx,
                                    dropped connection) before the error is reported; 0 = never retry. [env: AGENTILOOP_MAX_RETRIES] (default 3)
      --compact-at TOKENS           Summarize the conversation once a request reaches this many input TOKENS (0 = never)
                                    [default: last used, then 80% of the model's context window] [env: AGENTILOOP_COMPACT_AT]
  -C, --cwd DIR                     Working directory (DIR) the agent operates in (defaults to cwd)
  -r, --resume ID                   Resume a saved session by ID (see /sessions)
  -c, --continue                    Resume the most recent session for this working directory
                                    (the default for interactive launches; kept for scripts)
      --new                         Start a new session instead of continuing the last one in this directory
      --tui                         Full-screen terminal UI instead of the line REPL. Remembered. [env: AGENTILOOP_TUI]
      --no-tui                      Use the line REPL even if the TUI was used last time
      --no-mcp                      Don't start MCP servers from ~/.agentiloop/mcp.json / ./.mcp.json. [env: AGENTILOOP_NO_MCP]
      --setup                       Run the first-time setup wizard (provider, key, model). Runs by itself on a
                                    machine with no credentials and no ~/.agentiloop.
      --reset                       Back to brand new: delete ~/.agentiloop (settings, env, history, sessions,
                                    mcp.json), the agentiloop block in your shell profile and Keychain items the
                                    wizard created. Asks first unless --yes.
      --allow-tool NAME             Run this tool without asking (repeatable or comma-separated; NAME* matches a prefix, e.g. mcp_*)
      --deny-tool NAME              Never run this tool NAME; the model is told it was denied (same name rules). Beats --allow-tool and --yes
      --plan                        Plan mode: tools that change something (write_file, edit_file, bash, task, mutating MCP
                                    tools) are switched off and the model is asked for a plan instead. Toggle with /plan. [env: AGENTILOOP_PLAN]
      --append-system-prompt TEXT   Extra TEXT added to the end of the system prompt for this run (never saved). [env: AGENTILOOP_APPEND_SYSTEM_PROMPT]
      --json                        One-shot only: print the answer as one JSON object on stdout (result, is_error, session_id,
                                    provider, model, usage) instead of streaming text. Tool activity still goes to stderr.
      --stream-json                 One-shot only: print every event as one JSON object per line on stdout as it happens
                                    (text_delta, text, tool_call, tool_result, turn, compacted, retry, done), then the same result
                                    object as --json with "type": "result". Nothing else is printed.
  -h, --help                        Print help
  -V, --version                     Print version

Dentro de una sesión, escribe /help para ver los comandos del chat (/model, /sessions, /resume, /clear, /compact, /mcp, /exit). La referencia completa está en Todas las opciones y Comandos dentro del chat.

¿Atascado? Soluciones rápidas

Ves	Solución
`command not found: agentiloop`	`~/.local/bin` no está en tu PATH. Abre primero una ventana nueva de terminal; si eso no ayuda, ejecuta `~/.local/bin/agentiloop --setup` y di que sí cuando ofrezca añadirlo al PATH. En Windows, abre una ventana nueva de PowerShell
`Error: no provider credentials found`	No hay ninguna clave guardada. Ejecuta `agentiloop --setup` (paso 3) y compruébalo con el paso 4
macOS: "agentiloop" cannot be opened / unidentified developer	Esto pasa si lo descargaste con un navegador en lugar de con `curl`. Ejecuta `xattr -d com.apple.quarantine ~/.local/bin/agentiloop`
Windows: Windows protected your PC	Haz clic en More info → Run anyway
`401` / `invalid x-api-key` / error de autenticación	La clave es incorrecta o se pegó con espacios o comillas. Cópiala de nuevo y ejecuta `agentiloop --setup` para introducirla otra vez
Ollama: modelo no encontrado	Ejecuta `ollama list` y pasa el nombre exacto con `-m`
Sigue usando un modelo o proveedor antiguo	Recuerda tus últimas elecciones. Pasa `-p` / `-m` para cambiarlas, o ejecuta `agentiloop --reset` para empezar de cero

¿Sigues atascado? Abre un issue y pega el comando y el error. Te ayudaremos.

Inicio rápido

Tres pasos: instálalo, dale un modelo y ejecútalo.

Paso 1: Instalar

Descarga: baja el archivo comprimido para tu plataforma desde Releases, descomprímelo y pon agentiloop (agentiloop.exe en Windows) en tu PATH.

O compílalo: si todavía no tienes Go (1.25 o posterior), instálalo desde go.dev/dl. Después:

go install github.com/AgentiLoop/AgentiLoopGo/cmd/agentiloop@latest

o desde un clon:

git clone https://github.com/AgentiLoop/AgentiLoopGo.git
cd AgentiLoopGo
go install ./cmd/agentiloop

Esto compila el programa y deja un comando agentiloop en tu PATH, en ~/go/bin (%USERPROFILE%\go\bin en Windows). No hace falta ningún compilador de C.

¿No quieres instalarlo? Todo lo de este README también funciona desde dentro de la carpeta del repositorio. Donde veas agentiloop <options>, escribe go run ./cmd/agentiloop <options> en su lugar.

Paso 2: Conecta un modelo

AgentiLoop necesita un modelo con el que hablar. No tienes que definir ninguna variable de entorno para esto: simplemente ejecuta agentiloop y el asistente de configuración integrado te hace unas pocas preguntas y lo guarda todo por ti. La guía paso a paso, con una ejecución completa, está más arriba en 3. Ejecuta el asistente de configuración.

Avanzado: definir la clave a mano (sáltate esto si el asistente te ha funcionado)

Si prefieres gestionar la clave tú mismo, o ejecutas AgentiLoop en un script o en CI donde nadie puede responder al asistente, define una de estas variables de entorno y AgentiLoop la usará sin preguntar:

Quiero usar…	Define esto
Claude (Anthropic)	`export ANTHROPIC_API_KEY=sk-ant-...`
OpenAI	`export OPENAI_API_KEY=sk-...`
Ollama, LM Studio o cualquier servidor compatible con OpenAI	`export OPENAI_BASE_URL=http://localhost:11434/v1` (la dirección de tu servidor; los servidores locales no necesitan clave)
oMLX (modelos locales en Apple Silicon)	Normalmente nada. Inicia oMLX y luego ejecuta AgentiLoop con `-p omlx`

Detalles de oMLX. Cuando oMLX se ejecuta en el mismo Mac, AgentiLoop lee el puerto del servidor y la clave de API del propio archivo de configuración de oMLX (~/.omlx/settings.json). Si oMLX se ejecuta en otra máquina, o quieres sobrescribir esa configuración:

export OMLX_BASE_URL=http://192.168.1.50:7777/v1   # la dirección del servidor oMLX (o OMLX_PORT=7777 para localhost)
export OMLX_API_KEY=...                            # la clave de API de la configuración de oMLX

Si oMLX tiene desactivada la verificación de la clave de API, no hace falta ninguna clave.

Un export solo dura en la pestaña de terminal donde lo escribiste. Para que sea permanente añadirías la línea a tu perfil de shell (~/.zshrc en macOS), que es exactamente lo que hace por ti la opción "Also add it to ~/.zshrc" del asistente. Del mismo modo, la opción "macOS Keychain" del asistente es la versión automática de esto:

# una sola vez: guarda la clave en tu Llavero
security add-generic-password -a "$USER" -s ANTHROPIC_API_KEY -w "sk-ant-..."

# en ~/.zshrc: cárgala en cada terminal nueva
export ANTHROPIC_API_KEY="$(security find-generic-password -a "$USER" -s ANTHROPIC_API_KEY -w 2>/dev/null)"

Paso 3: Ejecútalo

Ve al proyecto en el que quieres trabajar y arranca AgentiLoop:

cd ~/my-project
agentiloop --tui

--tui abre la interfaz a pantalla completa, que es la que te recomendamos. Escribe lo que quieres, por ejemplo "busca dónde se carga el archivo de configuración y añade una opción --verbose", y pulsa Enter.

Verás las respuestas del agente, cada herramienta que usa (🔧) y cada resultado (✓ o ✖). El recuadro de abajo muestra lo que está haciendo en ese momento, por ejemplo ✻ Thinking... 12s. Antes de escribir un archivo o ejecutar un comando, te pregunta:

y: sí, esta vez
n: no
a: permitir siempre esta herramienta durante el resto de la sesión
Esc: saltar este paso, pero seguir adelante

Tres formas de usarlo

Modo	Comando	Ideal para
TUI (pantalla completa)	`agentiloop --tui`	El día a día: historial con desplazamiento, estado en vivo, enlaces en los que se puede hacer clic
Chat (línea a línea)	`agentiloop`	Terminales sencillas, o si prefieres texto plano
Una sola vez	`agentiloop "explain this project"`	Una pregunta: responde y termina. Práctico en scripts
Con pipe	`git diff \| agentiloop "review this" -`	Envía texto por pipe y pon `-` en el prompt: se sustituye por lo enviado. Práctico para diffs y logs

Teclas en la TUI: Enter envía · ↑ / ↓ recorren las peticiones anteriores · PgUp / PgDn o la rueda del ratón desplazan · Ctrl-F muestra u oculta el panel de archivos modificados (la rueda sobre él desplaza el panel; arrastra su borde izquierdo para cambiar el ancho) · Esc detiene la petición en curso (la sesión se conserva) · Ctrl-U borra la línea · Ctrl-C sale.

Menciona archivos con @

Escribe @ seguido de una ruta en cualquier parte del prompt y AgentiLoop adjunta ese archivo a lo que recibe el modelo: explica @src/main.rs envía tu frase más el texto del archivo con números de línea. Una carpeta (@src) adjunta su listado. Las rutas son relativas a la carpeta del proyecto (o absolutas, o ~/…); una palabra que no nombra nada se deja tal cual, así que las direcciones de correo están a salvo. Los archivos se recortan a 64 KB, las carpetas a 200 entradas, y una línea 📎 muestra qué se adjuntó. Funciona en la TUI, el chat y los prompts de una sola vez.

Ejecuta un comando de shell con !

Empieza una línea con ! y AgentiLoop la ejecuta como comando de shell en vez de enviarla al modelo: !git status, !cargo test, !ls src. Ves la salida al instante y se añade a la conversación, así que puedes seguir con «arregla esos tests que fallan» y el modelo ya los tiene. El comando se ejecuta en la carpeta del proyecto con la misma shell, tiempo límite de 120 s y tope de salida de 30 KB que la herramienta bash del modelo. Funciona en la TUI y en el chat.

Recuerda algo con

Empieza una línea con `#` y AgentiLoop guarda el resto como una nota en el `AGENTS.md` del proyecto en vez de enviarlo al modelo: `# ejecuta cargo fmt antes de cada commit`, `# el cliente de la API está en src/net`. La nota se añade como un punto bajo un encabezado `## Notes` (si no existe el archivo, se crea a partir de la plantilla de `/init`; si hay un `CLAUDE.md`, se usa ese). Como `AGENTS.md` va al prompt del sistema, el modelo sigue la nota desde la siguiente petición y en todas las sesiones posteriores. Funciona en la TUI y en el chat.

Recuerda tu configuración

Solo escribes tus opciones una vez. AgentiLoop guarda cómo lo lanzaste, así que la próxima vez un simple agentiloop arranca igual:

agentiloop -p anthropic --tui    # la primera vez: elige proveedor y TUI
agentiloop                       # a partir de ahora: mismo proveedor, mismo modelo, TUI y tu última conversación

Lo que recuerda:

Proveedor (-p) y TUI activada/desactivada (--tui / --no-tui)
Modelo: el último que usaste, por separado para cada proveedor. Al volver a un proveedor, vuelve también su modelo.
Límites: --max-turns y --compact-at
Tu conversación: retoma la última conversación de la carpeta actual, si esa conversación usaba el mismo proveedor. Los mensajes anteriores se vuelven a mostrar en pantalla, así que puedes desplazarte hacia atrás y ver dónde lo dejaste

Para cambiar algo, pasa la nueva opción. Se aplica al momento y se recuerda desde entonces:

agentiloop -p omlx        # cambia a oMLX (también vuelve su último modelo usado)
agentiloop -m <model>     # cambia de modelo
agentiloop --no-tui       # vuelve al chat línea a línea
agentiloop --new          # empieza una conversación nueva (la anterior sigue guardada)

Algunas cosas nunca se recuerdan, a propósito:

--yes: saltarse las peticiones de permiso tiene que ser una decisión deliberada cada vez
--no-mcp, -C y las peticiones de una sola vez
Las claves de API: esas viven en ~/.agentiloop/env (escrito por el asistente) o en el entorno de tu shell, nunca en settings.json

Para olvidarlo todo, ejecuta agentiloop --reset.

Todas las opciones

Cada opción también se puede configurar con una variable de entorno, que aparece en la segunda columna. Una opción que escribes siempre tiene prioridad sobre un valor recordado.

Opción	Variable de entorno	Qué hace
`-p, --provider <name>`	`AGENTILOOP_PROVIDER`	`anthropic`, `openai` u `omlx`. Si no indicas ninguno, AgentiLoop usa el último, o lo detecta a partir de tus claves (primero Anthropic, luego OpenAI, luego oMLX)
`-m, --model <id>`	`AGENTILOOP_MODEL`	Qué modelo usar
`--tui` / `--no-tui`	`AGENTILOOP_TUI`	Interfaz a pantalla completa activada / desactivada
`--new`		Empieza una conversación nueva en lugar de continuar
`-c, --continue`		Continúa aquí la última conversación (ya es lo predeterminado)
`-r, --resume <id>`		Vuelve a abrir una conversación concreta (encuentra los ids con `/sessions`)
`-C, --cwd <folder>`		Trabaja en una carpeta distinta de la que estás
`--yes`	`AGENTILOOP_YES`	No pregunta antes de ejecutar herramientas. ⚠️ Solo para uso automatizado y de confianza
`--allow-tool <name>`		Ejecuta esta herramienta sin preguntar; repite la opción o usa comas. `mcp_*` coincide con un prefijo. Útil en CI sin `--yes`
`--deny-tool <name>`		Nunca ejecuta esta herramienta: se le dice al modelo que fue denegada. Tiene prioridad sobre `--allow-tool` y `--yes`
`--plan`	`AGENTILOOP_PLAN`	Modo plan: empieza con todas las herramientas que cambian algo desactivadas (`write_file`, `edit_file`, `bash`, `task`, herramientas MCP que no son de solo lectura). El modelo lee y busca, y luego responde con un plan numerado en vez de hacer el trabajo. `/plan` lo desactiva (o activa) durante una sesión
`--no-mcp`	`AGENTILOOP_NO_MCP`	No inicia servidores MCP (mira más abajo)
`--append-system-prompt <text>`	`AGENTILOOP_APPEND_SYSTEM_PROMPT`	Texto extra al final del prompt del sistema para esta ejecución (no se guarda)
`--json`		Con un prompt de una sola vez: imprime la respuesta como un objeto JSON (`result`, `is_error`, `session_id`, `provider`, `model`, `usage`) en stdout. La actividad de herramientas queda en stderr
`--stream-json`		Con un prompt de una sola vez: imprime cada evento como un objeto JSON por línea en stdout según ocurre (`text_delta`, `text`, `tool_call`, `tool_result`, `turn`, `compacted`, `retry`, `done`), y al final el mismo objeto de resultado que `--json` con `"type": "result"`. No se imprime nada más. Para editores y scripts que quieren ver el progreso
`--setup`		Vuelve a ejecutar el asistente de primera configuración (proveedor, clave, modelo). Combínalo con `--tui` para ejecutarlo dentro de la interfaz a pantalla completa
`--reset`		Como nuevo: borra `~/.agentiloop`, el bloque de agentiloop en tu perfil de shell y los elementos del Llavero que creó el asistente (en Windows: las variables de entorno de usuario que definió). Las líneas `export` escritas a mano solo se comentan, y solo si dices que sí. Añade `--yes` para saltarte las preguntas
`--max-turns <n>`		Máximo de pasos que puede dar el agente por petición (50 por defecto)
`--max-retries <n>`	`AGENTILOOP_MAX_RETRIES`	Cuántas veces se reenvía una petición que falla por un motivo pasajero (límite de peticiones, sobrecarga, error del servidor, conexión cortada) antes de mostrarte el error: tras 1 s, 2 s, 4 s… (3 por defecto, `0` = nunca). Una línea `⟳ retry 1/3` muestra cada intento. No se hace si la respuesta ya empezó a llegar
`--compact-at <tokens>`	`AGENTILOOP_COMPACT_AT`	Cuándo resumir una conversación larga (150000 por defecto, `0` = nunca)
`-h` / `-V`		Ayuda / versión

Algunos ejemplos:

agentiloop -p openai -m gpt-4o-mini "summarize this repo"    # una pregunta con un modelo concreto
agentiloop -C ../other-repo --tui                            # trabaja en otro proyecto
agentiloop --yes "run the tests and fix any failures"        # sin supervisión, sin preguntas

¿Qué modelo se usa? Gana el primero que se cumpla:

-m en la línea de comandos
el modelo de la conversación que estás continuando
el último modelo que usaste con este proveedor
el predeterminado del proveedor: claude-sonnet-5 para Anthropic, gpt-4o-mini para OpenAI, o el primer modelo que ofrezca oMLX

Comandos dentro del chat

Escríbelos en el prompt, en la TUI o en el chat:

Comando	Qué hace
`!<comando>`	Ejecuta un comando de shell aquí y añade su salida a la conversación (ver Ejecuta un comando de shell con !)
`# <nota>`	Guarda la nota en el `AGENTS.md` de este proyecto bajo `## Notes` (ver Recuerda algo con #)
`/model`	Muestra los modelos disponibles. `/model 3` o `/model <id>` cambia de modelo (y se recuerda)
`/sessions`	Lista tus conversaciones guardadas, de la más reciente a la más antigua
`/resume <n or id>`	Vuelve a abrir una de ellas
`/clear`	Borra la conversación y empieza una nueva
`/undo`	Revierte los cambios en archivos que hizo el agente para tu último mensaje (los cambios hechos con `bash` no se deshacen)
`/rewind [n]`	Lista tus mensajes o vuelve a antes del mensaje n: se deshacen los cambios en archivos que hizo el agente desde ese mensaje y la conversación se corta ahí (los cambios hechos con `bash` no se deshacen)
`/todos`	Muestra la lista de tareas actual del modelo
`/diff`	Muestra qué cambió en el árbol de trabajo de git (estado más diff, cortado a 200 líneas)
`/commands`	Tus propios comandos: cada `.agentiloop/commands/<name>.md` (proyecto) o `~/.agentiloop/commands/<name>.md` pasa a ser `/<name>` y envía el archivo como prompt (`$ARGUMENTS` se sustituye por lo que escribas después, `$1`–`$9` por sus palabras). Los lista
`/hooks`	Muestra los hooks cargados desde `.agentiloop/hooks.json` (ver Hooks)
`/plan [on\|off]`	Activa o desactiva el modo plan (sin argumento, alterna). Mientras está activo, las herramientas que cambian algo se niegan a ejecutarse y el modelo responde con un plan; la TUI muestra PLAN en la línea de estado
`/init`	Crea un `AGENTS.md` inicial para el proyecto actual (nunca sobrescribe)
`/export [file]`	Guarda la conversación como archivo Markdown (`/export notes.md`, o un nombre por defecto en la carpeta del proyecto)
`/compact`	Resume la conversación ahora para liberar espacio
`/usage`	Muestra los tokens usados desde el inicio y cuánto contexto está ocupado
`/status`	Dónde estás: carpeta, proveedor, modelo y sus límites, sesión, modo plan, herramientas (y cuántas vienen de MCP), hooks, archivos de instrucciones, ajustes y consumo de tokens
`/mcp`	Muestra los servidores MCP conectados y sus herramientas
`/help`	Lista estos comandos
`/exit`	Salir

Conversaciones largas

Los modelos solo pueden leer una cantidad limitada de una vez. Cuando una conversación crece mucho (por defecto, cuando una petición llega a 150.000 tokens), AgentiLoop le pide al modelo que la resuma hasta ese punto y continúa a partir del resumen. Verás una nota 📦 cuando eso ocurra. /compact lo hace cuando quieras, y --compact-at 0 lo desactiva.

Caché de prompts (Anthropic). Las peticiones a Anthropic marcan el prompt del sistema, las herramientas y el último mensaje como cacheables, así que la siguiente petición de la misma conversación reutiliza la mayor parte del prompt en vez de pagarlo otra vez (la parte cacheada cuesta cerca de una décima parte, y la respuesta empieza antes). No hay nada que configurar. /usage muestra cuántos tokens se leyeron y escribieron en la caché, y --json los informa como cache_read_tokens y cache_write_tokens.

Instrucciones del proyecto

Pon un archivo AGENTS.md (o CLAUDE.md) en tu proyecto y AgentiLoop lo lee al arrancar y lo sigue: comandos de compilación, estilo de código, cosas que evitar. Lo busca en la carpeta actual y luego en las carpetas superiores, hasta la raíz del proyecto (la carpeta con .git). Un ~/.agentiloop/AGENTS.md personal se aplica a todos los proyectos; el archivo del proyecto va después y tiene prioridad. Los archivos se recortan a 32 KB. Una línea instructions: <ruta> muestra qué archivos se cargaron. Una línea que sea solo @ruta (por ejemplo @docs/style.md) se sustituye por el texto de ese archivo, relativo al archivo que la menciona. Las importaciones pueden anidarse tres niveles; los archivos que faltan, los ciclos y las líneas dentro de bloques de código se dejan tal cual.

Hooks: ejecuta tus propios comandos alrededor de las herramientas

Un hook es un comando de shell que AgentiLoop ejecuta por ti en un punto fijo: antes de que se ejecute una herramienta (PreToolUse), después de ejecutarse (PostToolUse) o cuando el agente termina una petición (Stop). Ponlos en .agentiloop/hooks.json dentro de tu proyecto, o en ~/.agentiloop/hooks.json para todos los proyectos (se cargan ambos):

{
  "hooks": {
    "PreToolUse":  [{ "matcher": "bash", "command": "sh .agentiloop/check-command.sh" }],
    "PostToolUse": [{ "matcher": "write_file,edit_file", "command": "cargo fmt" }],
    "Stop":        [{ "command": "osascript -e 'display notification \"done\" with title \"AgentiLoop\"'" }]
  }
}

matcher indica a qué herramientas se aplica el hook, con las mismas reglas que --allow-tool (nombres, prefijos mcp_*, *). Omítelo para aplicarlo a todas. Los hooks Stop lo ignoran.
El comando se ejecuta con sh -c (cmd /C en Windows) en la carpeta del proyecto. Recibe un objeto JSON por stdin: event, cwd, tool e input; PostToolUse añade output e is_error, Stop añade stop_reason. AGENTILOOP_HOOK_EVENT y AGENTILOOP_TOOL se definen como variables de entorno.
El código de salida 2 habla con el modelo. Un hook PreToolUse que sale con 2 bloquea la llamada, y lo que imprimió en stderr se envía al modelo como error. A un hook PostToolUse que sale con 2 se le añade su stderr al resultado de la herramienta. Cualquier otro código se ignora (uno distinto de cero se registra). Un hook se mata a los 60 segundos.
/hooks lista lo que se cargó. Un archivo roto se informa al arrancar y se omite.

Por ejemplo, este hook PreToolUse impide que bash ejecute git push:

#!/bin/sh
# .agentiloop/check-command.sh — stdin es el JSON de la llamada
if grep -q 'git push' ; then echo "git push no está permitido desde el agente" >&2; exit 2; fi

Añadir herramientas con MCP (opcional)

Los servidores MCP le dan al agente herramientas extra, como acceso a bases de datos, búsqueda web o tus propios scripts. Enuméralos en un archivo JSON:

~/.agentiloop/mcp.json: disponible en todos los proyectos
.mcp.json en una carpeta de proyecto: solo en ese proyecto. Si un nombre aparece en ambos archivos, gana este.

El formato es el mismo que usan Claude Code, Claude Desktop y Agent!, así que puedes copiar configuraciones que ya tengas:

{ "mcpServers": {
    "Local":  { "command": "my-mcp-server", "args": ["--flag"], "env": { "API_KEY": "${MY_KEY}" } },
    "Remote": { "url": "https://example.com/mcp", "headers": { "Authorization": "Bearer ${TOKEN}" } }
} }

Cómo funciona:

Dos tipos de servidor. Un servidor con command es un programa local que AgentiLoop inicia por ti. A un servidor con url se accede por HTTP. Funcionan tanto los servidores más nuevos "Streamable HTTP" como los más antiguos "SSE"; una URL que termina en /sse (o "transport": "sse") selecciona el estilo antiguo.
Nombres de herramientas. Cada herramienta del servidor le aparece al agente como mcp_<server>_<tool>, por ejemplo mcp_Local_search.
Secretos. ${VAR} (o ${VAR:-default}) se rellena desde tu entorno, así que las claves no tienen que estar en el archivo.
Permisos. Las herramientas MCP piden permiso como cualquier otra herramienta, a menos que el servidor marque una herramienta como de solo lectura.
Prompts. Los prompts guardados de un servidor se convierten en comandos /mcp__<servidor>__<prompt>, p. ej. /mcp__Local__summarize algún texto. Las palabras tras el comando rellenan los argumentos del prompt en orden (o nombre=valor); el texto que devuelve el servidor se envía como tu prompt. /mcp los lista.
Desactivar servidores. Añade "disabled": true para saltarte un servidor, o ejecuta con --no-mcp para saltártelos todos.
Seguridad. http:// sin cifrar solo se permite para localhost; los servidores remotos necesitan https://.

Escribe /mcp para ver qué servidores se han conectado, sus herramientas y cualquier error.

Dónde se guardan las cosas

Todo vive en ~/.agentiloop/. Define AGENTILOOP_HOME para usar otra carpeta, por ejemplo un perfil de pruebas separado.

Archivo	Qué contiene
`settings.json`	El proveedor, los modelos y las opciones recordados, más lo que el asistente escribió en otros sitios
`env`	Tu clave, escrita por el asistente (`KEY=value`, modo de archivo 600). Se carga al arrancar; un `export` en tu shell tiene prioridad
`sessions/`	Tus conversaciones, un archivo por cada una
`mcp.json`	Tus servidores MCP
`hooks.json`	Hooks para todos los proyectos (el `.agentiloop/hooks.json` de un proyecto se suma)
`history.txt`	Las peticiones que has escrito (para ↑ / ↓)

Otras variables de entorno

Rara vez las necesitarás:

Variable	Uso
`ANTHROPIC_BASE_URL`	Envía las peticiones de Anthropic a un proxy o a un servidor compatible
`ANTHROPIC_OAUTH_TOKEN`	Alternativa a `ANTHROPIC_API_KEY` para un token de Claude Code
`OMLX_BASE_URL`, `OMLX_PORT`, `OMLX_API_KEY`	Dirección y clave del servidor oMLX. Tienen prioridad sobre `~/.omlx/settings.json`, que se lee por defecto (puerto 8000 si no se define ninguno)
`AGENTILOOP_LOG=debug` (o `RUST_LOG=debug`)	Muestra los registros de depuración, incluido el uso de tokens por petición

Para desarrolladores

Compilar y probar

go build -o agentiloop ./cmd/agentiloop   # → ./agentiloop
go test ./...                             # funciona sin conexión, no necesita claves de API

La compilación cruzada no necesita nada extra, por ejemplo GOOS=windows GOARCH=amd64 go build ./cmd/agentiloop.

Los tests no tocan la red. El bucle del agente se ejecuta contra un modelo falso con guion, y los analizadores de streaming contra un servidor de pruebas local. La TUI se dibuja en la pantalla simulada de tcell. El cliente MCP se prueba contra un servidor de ejemplo incluido, con los tres tipos de conexión (stdio, HTTP, SSE). Puedes ejecutar ese servidor tú mismo para probar MCP a mano:

go run ./examples/mcp-example-server --http 8791   # o --sse 8792, o --stdio

Cómo está organizado el código

El proyecto está dividido en cinco paquetes, y cada uno se apoya en los anteriores:

Paquete	Qué contiene
`core`	El corazón: el bucle del agente, los mensajes, las interfaces de herramientas y proveedores, los permisos, las sesiones, los resúmenes
`provider`	Habla con los modelos: Anthropic, servidores compatibles con OpenAI, oMLX
`tools`	Herramientas integradas: `read_file`, `write_file`, `edit_file`, `list_dir`, `glob`, `grep`, `web_fetch`, `todo_write`, `bash`
`mcp`	El cliente MCP, portado desde AgentMCP de Agent! en Swift
`cmd/agentiloop`	El programa `agentiloop`: opciones, chat, TUI, configuración

core, provider, tools y mcp usan solo la biblioteca estándar de Go, así que se pueden integrar en otros programas.

Dependencias

Todo lo que no es la TUI ni la línea de comandos usa la biblioteca estándar. El programa agentiloop añade:

Módulo	Para qué se usa
`github.com/spf13/pflag`	Opciones de la línea de comandos
`github.com/peterh/liner`	El chat línea a línea
`github.com/gdamore/tcell/v2`, `github.com/mattn/go-runewidth`	La TUI
`github.com/yuin/goldmark`, `github.com/alecthomas/chroma/v2`	Markdown y resaltado de código

Hoja de ruta

Licencia

PolyForm Noncommercial 1.0.0. Puedes usar, modificar y compartir este software con fines personales y no comerciales. El uso comercial, incluida la creación o venta de versiones comerciales, está reservado a AgentiLoop. Contacta con AgentiLoop para obtener una licencia comercial.

AgentiLoop: agentiloop.ai

Navigation Menu

Repository navigation

README_es.md

README_es.md

AgentiLoopGo

🎉 ¡Hemos publicado la versión v0.0.7 para Mac, Windows y Linux!

💖 Patrocina AgentiLoop

⚡ Primera ejecución: el asistente de configuración lo hace todo

🚀 ¿Nuevo aquí? En marcha en 5 minutos

1. Descarga AgentiLoop

2. Consigue una clave de API

3. Ejecuta el asistente de configuración

4. Comprueba que funciona

5. Tu primera sesión

¿Qué puede hacer? (herramientas)

El comando de ayuda

¿Atascado? Soluciones rápidas

Inicio rápido

Paso 1: Instalar

Paso 2: Conecta un modelo

Paso 3: Ejecútalo

Tres formas de usarlo

Menciona archivos con @

Ejecuta un comando de shell con !

Recuerda algo con

Recuerda tu configuración

Todas las opciones

Comandos dentro del chat

Conversaciones largas

Instrucciones del proyecto

Hooks: ejecuta tus propios comandos alrededor de las herramientas

Añadir herramientas con MCP (opcional)

Dónde se guardan las cosas

Otras variables de entorno

Para desarrolladores

Compilar y probar

Cómo está organizado el código

Dependencias

Hoja de ruta

Licencia

FilesExpand file tree

README_es.md

Latest commit

History

README_es.md

File metadata and controls

AgentiLoopGo

🎉 ¡Hemos publicado la versión v0.0.7 para Mac, Windows y Linux!

💖 Patrocina AgentiLoop

⚡ Primera ejecución: el asistente de configuración lo hace todo

🚀 ¿Nuevo aquí? En marcha en 5 minutos

1. Descarga AgentiLoop

2. Consigue una clave de API

3. Ejecuta el asistente de configuración

4. Comprueba que funciona

5. Tu primera sesión

¿Qué puede hacer? (herramientas)

El comando de ayuda

¿Atascado? Soluciones rápidas

Inicio rápido

Paso 1: Instalar

Paso 2: Conecta un modelo

Paso 3: Ejecútalo

Tres formas de usarlo

Menciona archivos con @

Ejecuta un comando de shell con !

Recuerda algo con

Recuerda tu configuración

Todas las opciones

Comandos dentro del chat

Conversaciones largas

Instrucciones del proyecto

Hooks: ejecuta tus propios comandos alrededor de las herramientas

Añadir herramientas con MCP (opcional)

Dónde se guardan las cosas

Otras variables de entorno

Para desarrolladores

Compilar y probar

Cómo está organizado el código

Dependencias

Hoja de ruta

Licencia