---
title: "Agentes de IA y MCP | Documentación de Kilobat"
url: "https://kilobat.app/es/docs/agents"
description: "El servidor MCP, los hooks de agentes, el registro de red de los agentes, las skills para agentes y cómo mantener el Mac despierto."
---

# Agentes de IA y MCP

El servidor MCP, los hooks de agentes, el registro de red de los agentes, las skills para agentes y cómo mantener el Mac despierto.

Encontrarás instrucciones paso a paso para [Claude Code](https://kilobat.app/agents/claude-code), [Codex](https://kilobat.app/agents/codex), [Cursor](https://kilobat.app/agents/cursor), [Gemini CLI](https://kilobat.app/agents/gemini-cli), [Claude Desktop](https://kilobat.app/agents/claude-desktop), [Windsurf](https://kilobat.app/agents/windsurf), [Cline](https://kilobat.app/agents/cline), [Zed](https://kilobat.app/agents/zed), [Hermes Agent](https://kilobat.app/agents/hermes), [OpenClaw](https://kilobat.app/agents/openclaw), [OpenCode](https://kilobat.app/agents/opencode), [GitHub Copilot CLI](https://kilobat.app/agents/copilot-cli) y [cualquier cliente MCP](https://kilobat.app/agents/mcp-client) en [Configurar Kilobat en tu agente de IA](https://kilobat.app/agents).

Dale a un agente como Claude Code, Codex o Cursor esta instrucción:

```
Install the Kilobat CLI with `brew install seifip/kilobat/kilobat`. Run `kilobat diagnose --json`, `kilobat status --json` and `kilobat scan --json`, then tell me what is slowing my connection and how to fix it. Ask me before changing DNS, profiles or rules.
```

## Servidor MCP

`kilobat mcp` habla el Model Context Protocol por stdio. Añádelo a Claude Code:

```
claude mcp add kilobat -- kilobat mcp
```

O añádelo a cualquier cliente que lea una configuración `mcpServers`:

```
{ "mcpServers": { "kilobat": { "command": "kilobat", "args": ["mcp"] } } }
```

Herramientas de solo lectura: `get_status`, `diagnose_network`, `diagnose_connection`, `get_conditions`, `get_updaters`, `get_uploads`, `get_data_pack`, `get_wifi`, `scan_wifi`, `suggest_wifi_channel`, `get_usage_report`, `compare_usage`, `get_app_bandwidth`, `get_access_policy`, `get_network_history`, `list_sessions`, `agent_network_log` (cada host al que se conectaron un agente y sus comandos), `benchmark_dns`, `check_url`, `list_connections`, `list_devices`, `trace_route`, `get_route_history`, `compare_speed_tests`, `get_exit_path` (consulta a Cloudflare tu IP pública solo cuando el agente pasa `public_ip`), `check_vpn_leaks` (la prueba de fugas, que consulta servicios externos), `list_networks`, `get_fastest_dns` (el DNS más rápido por red según las pruebas discretas de la app), `list_rules`, `list_approvals`, `list_blocked_connections`, `explain_verdict` (cada regla que coincide con un host o app y la que decide), `check_host_reputation` (si un host está en una lista de malware, phishing, estafas o rastreadores, comprobado en este Mac), `get_protection_status`, `run_stutter_test` y `get_game_ping` (solo envían pings), `get_nearby_radios`, `get_captive_portal` (una página de inicio de sesión Wi-Fi, igual que `kilobat portal --json`), `service_status` (consulta las páginas públicas de estado de los servicios indicados o de las apps activas) y `create_support_report` (el informe para tu proveedor, que el agente te entrega). Devuelven el mismo JSON que la CLI. `run_speedtest` usa datos, `run_lan_test` transfiere datos en tu propia red durante cinco segundos y pregunta primero, y `keep_awake` y `release_awake` impiden el reposo por inactividad durante un tiempo definido sin cambiar ajustes; `keep_awake` con `lid_closed` también mantiene el Mac activo con la tapa cerrada, una vez que lo has permitido, y pregunta primero. Las herramientas que realizan cambios (`set_profile`, `set_app_rule`, `set_new_app_mode`, `decide_approval`, `block_destination`, `set_budget`, `set_data_pack`, `set_app_quota`, `set_network_cost`, `set_updater_pause`, `set_kill_switch`, `set_protection`, que también indica al agente que nunca desactive Protección para completar su propia solicitud, `hold_upload`, que retiene la subida de otra app, `set_dns`, que también vacía la caché, `set_fastest_dns`, `set_dns_fallback` y `set_airdrop_visibility`, que abre los ajustes de AirDrop) están marcadas como cambios y sus descripciones indican al agente que te pregunte primero.

## Conectar agentes

Sin ayuda, Kilobat se guía por el tráfico y el uso de CPU de un agente, así que un agente en silencio puede haber terminado o estar esperándote. Sus hooks le dicen a Kilobat a qué proyecto pertenece una ejecución, cuándo te espera y cuándo ha terminado. Cada hook ejecuta `kilobat agent-event`, que no imprime nada, vuelve al instante y siempre sale con 0, así que no puede romper el agente. Si la app no está abierta, los eventos esperan en un pequeño archivo que lee al abrirse. Kilobat lee identificadores de sesión, carpetas y textos de estado breves, nunca instrucciones ni respuestas. Combínalos con los hooks que ya tengas.

**Claude Code**, en `~/.claude/settings.json`. Cada hook recibe por stdin un JSON con el identificador de sesión y la carpeta, que lee `--stdin-json`. Una solicitud de permiso o de entrada significa que espera; Stop significa terminado cuando acaban las tareas en segundo plano; un límite de uso significa que espera hasta que se restablezca.

```
{
  "hooks": {
    "SessionStart": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent claude --stdin-json" }] }],
    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent claude --stdin-json" }] }],
    "Notification": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent claude --stdin-json" }] }],
    "Stop": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent claude --stdin-json" }] }],
    "StopFailure": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent claude --stdin-json" }] }],
    "SessionEnd": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent claude --stdin-json" }] }]
  }
}
```

**Codex**, lo más sencillo: `notify` en `~/.codex/config.toml`. Codex pasa un argumento JSON después de cada turno, que lee `--json-arg`. Solo indica terminado, y Codex ejecuta un único programa `notify`.

```
notify = ["kilobat", "agent-event", "done", "--agent", "codex", "--json-arg"]
```

Para indicar también la espera, usa en su lugar los hooks de Codex en `~/.codex/hooks.json` y márcalos como de confianza con `/hooks`:

```
{
  "hooks": {
    "SessionStart": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent codex --stdin-json" }] }],
    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent codex --stdin-json" }] }],
    "PermissionRequest": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent codex --stdin-json" }] }],
    "Stop": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent codex --stdin-json" }] }]
  }
}
```

**Gemini CLI**, en `~/.gemini/settings.json`. Gemini CLI se ejecuta como `node`, así que Kilobat no puede asociar su tráfico a la ejecución, pero el estado sí llega.

```
{
  "hooks": {
    "SessionStart": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent gemini --stdin-json" }] }],
    "BeforeAgent": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent gemini --stdin-json" }] }],
    "Notification": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent gemini --stdin-json" }] }],
    "AfterAgent": [{ "hooks": [{ "type": "command", "command": "kilobat agent-event --agent gemini --stdin-json" }] }]
  }
}
```

**Cline** (CLI, SDK y Kanban): instala el plugin de Kilobat, que añade un archivo al almacén de plugins de Cline y no cambia ningún otro ajuste. `cline plugin uninstall kilobat` lo quita.

```
cline plugin install https://kilobat.app/agents/cline/kilobat.ts
```

Informa de una ejecución trabajando, terminada, fallida mientras Cline sigue abierto, cancelada, con límite de uso una vez agotados los reintentos de Cline, y en espera mientras Cline te hace una pregunta. Espera a los subagentes y compañeros antes de dar una ejecución por terminada. Las solicitudes de aprobación de Cline no son visibles para los plugins, así que esas las cubre la detección por tráfico y CPU.

Cualquier otro agente puede llamar a `kilobat agent-event start|working|waiting|done|failed --agent <name> --session <id> --cwd <folder>` desde sus propios hooks. Añade `--verbose` para ver qué ocurrió cuando lo pruebes a mano.

## Registro de red de agentes

Mientras se ejecuta Claude Code, Codex, Cursor, Gemini CLI, Aider, Windsurf, Claude Desktop, ChatGPT u otro agente, Kilobat registra cada host con el que contactaron él y los procesos que inicia: `npm`, `pip`, `uv`, `curl`, `git`, `brew`, servidores MCP, también cuando hay un shell de por medio. Cada sesión, desde que arranca el proceso del agente hasta que terminan él y todo lo que inició, muestra los hosts por el proceso que se conectó, ordenados de más a menos enviado, con el puerto y el protocolo, la primera y la última vez que se vieron, los bytes enviados y recibidos y el número de conexiones, además de la carpeta del proyecto en la que se ejecutó el agente. Está en Historial › Registro de red de agentes, y mientras un agente se ejecuta el menú muestra una línea como «Claude Code · 14 hosts · 2,1 MB enviados». Copiar como Markdown pone la tabla de una sesión en el portapapeles para una incidencia o una revisión.

Las marcas indican lo que merece una segunda mirada, nunca que algo vaya mal: *primera vez* (ningún agente de este Mac había contactado con ese host; los registros conocidos como registry.npmjs.org, pypi.org y github.com, y el servicio propio del agente, nunca se consideran nuevos), *HTTP sin cifrar* (puerto 80), *subida grande* (más de 10 MB a un host que no sea el servicio propio del agente, así que no se marca a Claude Code por enviar su contexto a Anthropic), *solo dirección* (sin nombre de host conocido) y *compartir o túnel* (una lista corta de sitios de pegado, servicios para compartir archivos como transfer.sh, túneles como ngrok y trycloudflare.com, y capturadores de solicitudes como webhook.site). Solo marcados muestra únicamente esos.

Cómo funciona: Kilobat ya lee cada segundo las estadísticas de red de macOS por conexión (las mismas que `nettop`), con el proceso de cada conexión. Reconoce a los agentes por su ejecutable, por el paquete que ejecuta un intérprete (`node …/@openai/codex`, `python3 -m aider`) o por el ejecutable propio de la app, y sigue el árbol de procesos de cada agente: el kernel le avisa en cuanto un proceso del árbol hace fork, así que un `curl` que dura una décima de segundo se asigna mientras se ejecuta, y los procesos que pasan a depender de launchd siguen siendo del agente. Gana el agente más cercano, así que Claude Code ejecutado en el terminal de Cursor cuenta como Claude Code. Los nombres de host vienen del filtro de red de Kilobat cuando está activado (el nombre que pidió una app), de buscar con el resolvedor de tu Mac los hosts de desarrollo conocidos y los hosts de las URL de `curl` o `git` de un agente y cotejar las direcciones, o del DNS inverso, que se marca porque es el nombre del servidor, no el que pidió la app. Sin nada de esto, la fila muestra la dirección.

Lo que no puede ver: el tráfico que los servicios de macOS generan para un proceso (las consultas DNS pasan por mDNSResponder y las descargas por `nsurlsessiond`), los contenedores Docker y las máquinas virtuales (su tráfico sale por el proceso de Docker o de la máquina virtual) y los agentes dentro de un editor que se ejecutan en su proceso de extensiones, como Cline o Copilot en VS Code, que no pueden distinguirse del editor. En Cursor y Windsurf, los comandos que escribes en su terminal cuentan como de la app. Una conexión que se abre y cierra entre dos muestras de un segundo sigue sumándose a los bytes de la sesión, sin host. Un proceso que se inicia y termina antes de que se gestione el aviso fork del kernel puede pasar inadvertido. El registro se guarda con Kilobat Pro, solo en este Mac, en `~/Library/Application Support/Kilobat/agent-network-log.json`, durante 30 días y nunca se envía a ningún sitio; Borrar permite elegir la última hora, hoy o todo.

Con la [Protección](https://kilobat.app/es/docs/blocking#protection) activada, las conexiones que Kilobat rechazó también aparecen en la sesión, marcadas como Bloqueadas con la lista o la regla del guardián de agentes, aunque no transportaran ningún byte.

En el terminal, `kilobat agent-log` muestra la última sesión, o la del propio agente cuando lo ejecuta un agente; `--all`, `--since 2h`, `--agent claude`, `--flagged` y `--json` la acotan. Leer es gratis, y `kilobat agent-log --watch` registra en directo en el terminal sin la app ni Pro, sin guardar nada. Los agentes llaman a la herramienta MCP de solo lectura `agent_network_log`, que sin argumentos devuelve su propia sesión, así que un agente puede comprobar con qué habló una instalación que ejecutó.

## Borrar historial u olvidar un sitio

En Ajustes › Datos y privacidad, *Olvidar un sitio* elimina un host de Intentos bloqueados, el registro de red de agentes, los destinos de ejecuciones de agentes y sesiones activas, y la memoria de notificaciones de Protección. Incluye subdominios para eliminar también nombres como www.example.com. Borrar historial de sitios elimina los mismos registros de la última hora, desde medianoche o por completo. Intentos bloqueados y el registro de red de agentes también tienen sus propios menús Borrar; el menú contextual de un host ofrece Olvidar. Al borrar el historial se conservan tus reglas y ajustes de protección. La actividad futura puede volver a registrarse.

En Terminal, usa `kilobat history forget example.com --subdomains --json` o `kilobat history clear --hour` (también están disponibles `--today` y `--all`). El comando pide a la app que borre sus registros activos cuando está abierta o edita los historiales guardados cuando está cerrada. MCP `clear_history` hace lo mismo, solo cuando pides al agente que borre el historial. La eliminación no se puede deshacer; el resultado cuenta las entradas eliminadas de cada historial.

## Mientras una app está en primer plano

Para leer o presentar, la opción «Mientras una app esté en primer plano» de la taza mantiene el Mac activo solo mientras la app que elijas sea la que está en primer plano, y lo deja entrar en reposo de nuevo en cuanto cambias a otra. «Mantener la pantalla encendida», en la taza, decide si la pantalla también se queda encendida, igual que para todo lo que Kilobat mantiene activo. Kilobat sigue los propios eventos de cambio de app de macOS: no hace sondeos, no mueve el puntero ni simula actividad, así que no puede hacerte parecer presente ante un software de vigilancia. Termina cuando la app se cierra, cuando lo desactivas o, con batería, al llegar al 20 % (o al mínimo que hayas fijado para las ejecuciones con la tapa cerrada), y nunca mantiene el Mac en marcha con la tapa cerrada. Tiene su propia retención, así que cambiar de app o cerrar la app nunca termina una sesión activa ni una ejecución de agente. Desde la línea de comandos: `kilobat awake --while-frontmost Keynote --display`.

## Con el adaptador conectado

Activa «Mantener activo con el adaptador conectado» (Ajustes › Activo y agentes), o «Con el adaptador conectado» en la taza, y al enchufar el adaptador de corriente el Mac se mantiene activo hasta que lo desenchufes, como indica «Activo con el adaptador conectado» en la franja de estado. «Mantener la pantalla encendida» decide si la pantalla también se queda encendida. Si lo desactivas, sigue desactivado hasta la próxima vez que enchufes el Mac, aunque Kilobat se reinicie. Kilobat detecta el cambio mediante la propia notificación de fuente de alimentación de macOS, sin sondeos. Al desenchufarlo solo termina la sesión que inició el enchufe: una que hayas iniciado tú, una descarga que estés esperando, una app en primer plano, una ejecución de agente o una retención desde la línea de comandos continúan. Nunca mantiene el Mac en marcha con la tapa cerrada. Desde la línea de comandos: `kilobat settings awake-on-power on`, y `kilobat settings keep-screen-on on` para la pantalla; `kilobat conditions --json` lo indica como `awakeOnPower`.

## Funcionar con la tapa cerrada

Al cerrar la tapa, el Mac entra en reposo aunque Kilobat lo esté manteniendo activo, salvo que permitas funcionar con la tapa cerrada en Ajustes › Activo y agentes. Eso instala un pequeño asistente que se ejecuta como root; macOS te pide que lo permitas en Ajustes del Sistema › General › Ítems de inicio. Con esto activado, una ejecución de agente en curso mantiene el Mac en marcha con la tapa cerrada, y lo mismo hace una sesión activa cuando marcas «También con la tapa cerrada» en el menú de la taza. Un agente que te está esperando solo lo mantiene si activas «Mantener activo mientras un agente espera», y como máximo 30 minutos.

Un Mac cerrado dentro de una mochila puede sobrecalentarse y agotar la batería, así que el propio asistente deja que el Mac entre en reposo al llegar a tu mínimo de batería (20 % de forma predeterminada), cuando se calienta, en cuanto se desenchufa si eliges solo con corriente, tras el tiempo máximo que fijes (8 horas como máximo) y un minuto después de que Kilobat se cierre. Si el asistente o el Mac se reinician durante una retención, primero restaura el ajuste. Kilobat muestra cómo terminó cada retención, por ejemplo «Mac en reposo: batería al 20 %».

Desde la línea de comandos, `kilobat awake --lid-closed` pide a la app la misma retención y explica por qué cuando no es posible; la retención termina con el comando. Los agentes usan `keep_awake` con `lid_closed`, cuya descripción les indica que te lo confirmen antes. `kilobat conditions --json` informa de `lidClosedAllowed` y del `lidHold` actual.

## Skills para agentes

Nueve Agent Skills enseñan a los agentes de programación a resolver problemas de red en el Mac y a mantener en marcha las ejecuciones largas con Kilobat. Interpretan sus mediciones, explican lo que no es seguro y preguntan antes de cambiar ajustes. Instálalas juntas; la skill `kilobat` envía al agente a la que corresponda.

```
npx skills add seifip/kilobat-skills
```

|  |  |
|---|---|
| [kilobat](https://github.com/seifip/kilobat-skills/tree/main/skills/kilobat) | Empieza aquí. Configuración, normas de seguridad y qué skill encaja con la pregunta. |
| [mac-network-troubleshooting](https://github.com/seifip/kilobat-skills/tree/main/skills/mac-network-troubleshooting) | Internet lento o inestable sin una causa clara: encuentra la capa que falla. |
| [mac-wifi-troubleshooting](https://github.com/seifip/kilobat-skills/tree/main/skills/mac-wifi-troubleshooting) | Wi-Fi débil o que se corta, canales saturados, el mejor sitio para el Mac o el router. |
| [mac-hotspot-data-saver](https://github.com/seifip/kilobat-skills/tree/main/skills/mac-hotspot-data-saver) | Puntos de acceso del teléfono y planes con tope de datos: qué consume datos, perfil Viaje, límites de datos. |
| [mac-dns-troubleshooting](https://github.com/seifip/kilobat-skills/tree/main/skills/mac-dns-troubleshooting) | Resoluciones lentas, pruebas de resolvedores, cambio de DNS, portales cautivos. |
| [video-call-network-check](https://github.com/seifip/kilobat-skills/tree/main/skills/video-call-network-check) | Llamadas y streaming de juegos con cortes: picos de latencia, jitter, pérdida, bufferbloat y subidas en segundo plano. |
| [mac-bandwidth-monitor](https://github.com/seifip/kilobat-skills/tree/main/skills/mac-bandwidth-monitor) | Qué apps usan la conexión, historial de uso y adónde se conectan. |
| [mac-app-firewall](https://github.com/seifip/kilobat-skills/tree/main/skills/mac-app-firewall) | Bloquea o permite apps, dominios e IP; pregunta por las apps nuevas y responde a sus solicitudes. |
| [mac-agent-runs](https://github.com/seifip/kilobat-skills/tree/main/skills/mac-agent-runs) | Ejecuciones largas de agentes: mantener el Mac activo, comprobar las condiciones, conectar los hooks del agente, ver cuándo terminó una ejecución, si te espera o si se atascó. |

Instala la CLI de Kilobat por separado con el comando de Homebrew de arriba, o conecta su servidor MCP. La CLI requiere macOS 14 o posterior; compilarla desde el código fuente con Homebrew requiere Xcode 16 o posterior. Consulta las [skills en skills.sh](https://skills.sh/seifip/kilobat-skills) o [lee su código y sus referencias](https://github.com/seifip/kilobat-skills).

## Siri y Atajos

Pregunta a Siri por tu conexión y Kilobat responderá a partir de sus propias comprobaciones, en una o dos frases y con una tarjeta de cifras. Di el nombre de la app en la pregunta, como requiere Siri: «¿Por qué va lento mi internet en Kilobat?» ejecuta una nueva comprobación e identifica la causa: «Tu Wi-Fi está bien; la línea de tu proveedor pierde el 4 % de los paquetes desde las 21:05. Está en tu informe para el proveedor». Las demás preguntas: «¿Está bien mi conexión en Kilobat?», «¿Por qué se congeló mi llamada en Kilobat?» (el informe de la última llamada), «¿Está caído Slack en Kilobat?» (cualquier servicio con una página de estado que Kilobat lea, o «¿Están caídas mis apps en Kilobat?» para las que usas), «¿Qué usa mi internet en Kilobat?», «¿Cuántos datos he usado en Kilobat?», «¿Estoy listo para mi llamada en Kilobat?», «¿Tiene fugas mi VPN en Kilobat?» y «Ejecutar una prueba de velocidad con Kilobat». Las mismas preguntas funcionan desde Spotlight y cada una es una acción en Atajos que pasa su respuesta al siguiente paso: el estado de la red con su estado general, causa, latencia y pérdida; el informe de llamada; los servicios y si informan de una interrupción; o los datos de hoy como tamaño. La acción Usar modelo de Atajos puede pasar esos resultados a Apple Intelligence. Sin Kilobat Pro, Siri indica qué falla y cómo se mide la línea, cuántas veces se congeló una llamada y si un servicio está caído; Pro añade por qué y qué hacer. Los [atajos preparados](https://kilobat.app/shortcuts) usan esas mismas acciones.