# 10 agentes, 30 GB de RAM y una cola: cómo conviven sin pisarse

> Cómo Sluice hace que hasta 10 agentes de IA compartan un equipo Linux de 30 GB sin pisarse: una cola, techos de memoria del kernel y Chromium en su sitio.

- URL: https://josegarrido.dev/es/10-agentes-30-gb-de-ram-y-una-cola-como-conviven-sin-pisarse/
- Author: José Antonio Garrido
- Published: 2026-11-13
- Language: es
- Project: [sluice](https://github.com/josegarridodigio/sluice) v0.12.2
- Tags: rust, claude-code, ai-agents, developer-tools
- English version: https://josegarrido.dev/en/10-agents-30-gb-of-ram-and-a-queue/

Durante las dos semanas siguientes a publicar Sluice 0.8.0, lo usé a diario en mis dos máquinas, las dos con 30 GiB de RAM, con hasta 10 agentes de IA trabajando a la vez en una de ellas. [Sluice](https://github.com/josegarridodigio/sluice) pone en una sola cola los tests, builds y comandos pesados de todos los agentes de IA de una máquina Linux, con un presupuesto común de CPU y memoria, y ejecuta cada comprobación una sola vez por árbol de git; te conté cómo empezó en el [primer artículo](https://josegarrido.dev/es/sluice-una-cola-compartida-para-que-tus-agentes-no-repitan-los-tests/). Aun con esa cola, los tests de mis agentes seguían pudiendo dejar una máquina sin memoria. Cómo conviven ahora, en resumen: la cola decide quién corre, los techos del kernel mantienen cada trabajo dentro de su parte y la protección del escritorio deja libre la del escritorio. Esto es lo que aprendí, y cada lección se convirtió en una versión, de la 0.9.0 a la 0.12.2:

- **Un reintento sigue siendo la misma suite** (0.9.0). La admisión por memoria pasa la estimación de un *gate* a sus variantes y espera tras cada muerte por memoria.
- **Cuando la máquina pagina, solo el kernel llega a tiempo** (0.10.0). Cada trabajo de *gate* (tests, linters, *type checks*) corre bajo un techo de memoria que impone el kernel, aunque todo lo demás esté bloqueado.
- **Un navegador no se queda donde lo lanzas** (0.11.0). Chromium, y por tanto cualquier navegador de Playwright, se sale de su trabajo; Sluice lo devuelve, así que su memoria cuenta, tiene límite y muere con el trabajo.
- **El escritorio tiene que poder opinar** (0.11.0). Cada trabajo tiene también un techo de swap, y ninguno arranca mientras tu sesión de escritorio se atasca por falta de memoria.
- **El entorno también es parte de lo que pruebas** (0.11.0). Variables como `NODE_OPTIONS` entran en la clave de caché.
- **Un daemon no debe heredar a quien lo arranca** (0.12.0). El entorno de la sesión de un agente, token incluido, ya no llega a los trabajos de todos.

## Un reintento sigue siendo la misma suite

Una semana después de publicar la 0.8.0 revisé lo que había pasado en mi segunda máquina: 12 hilos, 30 GiB de RAM, 8 GiB de swap y entre 4 y 10 agentes trabajando a la vez. En 37 horas hubo 11 OOM globales, 7 procesos matados por `systemd-oomd`, 16 trabajos de tests matados por memoria y una sesión de agente que cayó con ellos. La swap estaba llena en todos.

Había cuatro causas:

- Tras una muerte, los agentes reintentaban con `--filter` o `--test-concurrency=1`. Para Sluice era un comando nuevo, sin historial, así que estimaba 1,3–1,7 GiB para una suite que necesita 11–14 GiB.
- El margen de seguridad tras una muerte se acumulaba hasta 1,5×.
- La memoria fuera de la cola (agentes, builds, navegadores) crecía mientras corría una suite.
- La ventana de `systemd-oomd` de los agentes era de 5 s, y se llevó por delante a un agente 6 s después de que mataran un trabajo de tests.

La 0.9.0 cambió la admisión por memoria:

- Una variante de un comando con otros argumentos hereda la estimación de su *gate* en vez de una suposición.
- Solo una suposición puede arrancar como sonda.
- El margen tras una muerte es de 1,25×.
- Tras cualquier muerte por memoria, no arranca nada durante 10 s, ni hasta que baja la presión.
- La reserva de memoria crece hasta lo que creció el resto de la máquina mientras corrían trabajos pesados (el percentil 90, como mucho una cuarta parte de la RAM).
- La ventana de `systemd-oomd` de los agentes es de 15 s y la de los trabajos de 8 s, así que el trabajo siempre cae antes.

`sluice status` dice ahora de dónde sale la reserva y marca el trabajo que ha arrancado solo por encima de su estimación. No hay que tocar la configuración.

## Cuando la máquina pagina, solo el kernel llega a tiempo

Con la 0.9.0, la misma máquina se topó con el siguiente muro. Entre el 30 de octubre y el 1 de noviembre una misma suite corrió 61 veces, siempre sola en la máquina y por encima de su estimación: 46 pasaron, 9 fallaron sus tests y 6 murieron por memoria. Cada una de esas seis muertes fue un OOM global, y antes de cada una el journal del sistema se quedó callado 22, 30, 37, 67, 72 y unos 150 segundos. La máquina entera estaba paginando, y `systemd-oomd` y la protección del propio Sluice estaban bloqueados con todo lo demás: lo que corre en espacio de usuario llega tarde.

La 0.10.0 le pasa ese trabajo al kernel. Cada segundo, el daemon escribe el `memory.max` del cgroup de cada trabajo para que, entre todos, nunca dejen la máquina por debajo de un suelo. El kernel lo aplica aunque el daemon esté congelado. Viene activado por defecto con la contención completa:

```toml
# ~/.config/sluice/config.toml
[admission]
memory_reserve = "auto"   # una décima parte de la RAM: 3 GiB de 30 GiB
memory_ceiling = true
memory_floor = "auto"     # la mitad de la reserva: 1,5 GiB de 30 GiB
```

`sluice status` muestra el techo de cada trabajo en marcha. Desde el 2 de noviembre, los 387 trabajos siguientes en esa máquina corrieron sin ningún OOM ni muerte por memoria, y la swap no pasó del 36 %.

El precio es a propósito: una ejecución que antes pasaba empujando al resto de la máquina a la swap ahora muere dentro de su propio trabajo. La máquina sigue usable, y el mensaje le dice al agente que lo reintente cuando haya memoria libre o que te avise de que el *gate* no cabe.

## Un navegador no se queda donde lo lanzas

El 5 de noviembre le tocó a mi equipo de desarrollo: 20 hilos, 30 GiB de RAM, 8 GiB de swap, GNOME en Wayland y Sluice 0.10.0. Entre las 18:40 y las 19:20, una suite de tests de frontend de unos 14,5–15 GiB arrancó con el triple de su estimación, los trabajos de Playwright ocupaban 7,7–9,4 GiB cada uno, y a la vez corría un build de producción fuera de Sluice. La máquina llegó a 21 GiB usados (66 %), la swap pasó de 3,6 a 5,2 GiB, la escritura a swap llegó a 1.759 páginas por segundo, la carga a 32 y el retardo de entrada de GNOME Shell a 61–80 ms. No hubo OOM ni se mató nada: el techo de la 0.10.0 no llegó a actuar. El shell acabó sin responder, y a las 20:37 reinicié con SysRq.

Todavía no sé qué colgó el shell: siguió colgado cuando la memoria ya se había recuperado. Pero investigándolo encontré otra cosa. Ese día systemd había creado 385 *scopes* de Chromium en la máquina, y ahí habían ido a parar los navegadores que lanzaban los tests: fuera de sus trabajos.

Esto es lo que pasa. Al arrancar, cada proceso de navegador de Chromium, también en modo *headless*, prepara la conexión con el portal de escritorio XDG. El portal necesita un identificador de aplicación, y Chromium lo consigue pidiéndole al gestor de usuario de systemd, por el bus de sesión, un *scope* nuevo con su propio pid: `StartTransientUnit`. El proceso acaba en `app.slice/app-org.chromium.Chromium-<pid>.scope`. No hay ninguna opción para desactivarlo.

Para quien ejecuta trabajos, eso significa que la memoria del navegador sale de la cuenta del trabajo, de su pico aprendido, de su `memory.max` y de su muerte. Y Playwright lanza los navegadores en un grupo de procesos propio, así que matar el grupo de procesos tampoco los alcanza.

Lo comprobé el 6 de noviembre con una sonda: un *headless shell* de 6 a 8 segundos y unos 200 MB. El proceso del navegador se fue a su propio *scope*; los *renderers* que ya había creado se quedaron en el trabajo.

Los arreglos baratos no aguantaban:

- Quitar `DBUS_SESSION_BUS_ADDRESS` solo sirve para Chromium, y rompe los tests que necesitan el bus de sesión.
- El truco de `FLATPAK_SANDBOX_DIR`, que se salta el movimiento, dejó de funcionar en Chromium el 14 de octubre.
- Un *namespace* de cgroup no ayuda: systemd hace el movimiento desde el *namespace* raíz.

Lo que funciona es una propiedad de cgroup v2. Para mover un proceso, el kernel solo pide permiso de escritura en el `cgroup.procs` del ancestro común de los dos cgroups, y ese ancestro es `user@UID.service`, que es tuyo. Así que desde la 0.11.0, cada segundo el daemon recorre el árbol de procesos de cada trabajo y devuelve a su cgroup a cualquier descendiente que encuentre fuera. Este es un trabajo en la 0.12.1 que lanza directamente el Chromium *headless* de Playwright (156). El navegador se sale de su cgroup 265 ms después de arrancar el trabajo, y vuelve en el mismo ciclo:

![Log del daemon de Sluice en la 0.12.1: chrome-headless sale del cgroup del trabajo a su scope de Chromium y vuelve en el mismo ciclo](https://josegarrido.dev/articles/10-agentes-30-gb-de-ram-y-una-cola-como-conviven-sin-pisarse/8121c36880ac33aa.png)

```text
INFO sluice_gate_daemon::server: moved a process of the job back into its cgroup job=1794597479890-504544-15a79e pid=643155 comm=chrome-headless from=/user.slice/user-$UID.slice/user@$UID.service/app.slice/app-org.chromium.Chromium-643155.scope
```

Cuando el trabajo termina, lo que quede de él muere, dentro de su cgroup o fuera: los fugados, a través de un pidfd y después de comprobar la hora de inicio del proceso, para no mandar nunca la señal a un pid reutilizado. Un test de integración reproduce la fuga con la misma llamada a `StartTransientUnit`.

Viene activado por defecto (`[containment] reclaim_escaped = true`) y vale para todos los trabajos: el ajuste está en tu configuración de usuario, no en cada *gate*. Si tus tests lanzan algo a propósito con `systemd-run --user --scope`, o dejan un proceso en segundo plano que tiene que sobrevivir al trabajo, el daemon también los devolverá; para ese caso, ponlo a `false` y Sluice solo avisará de las fugas. Lo que coloca el propio Sluice, en su *scope* de agentes o en cualquier *slice* por debajo del suyo (como cuando un test ejecuta Sluice dentro de un trabajo), no cuenta como fuga. Todo lo demás, los *scopes* de Chromium incluidos, vuelve a su trabajo.

## El escritorio tiene que poder opinar

La misma 0.11.0 añade dos límites más:

```toml
[admission]
swap_ceiling = true
swap_floor = "auto"     # una cuarta parte de la swap
desktop_guard = true
```

- **Techo de swap.** Cada segundo el daemon escribe también el `memory.swap.max` de cada trabajo, para que entre todos no dejen la swap libre por debajo del suelo. Un trabajo que llega a su techo de memoria muere en su propio cgroup en vez de mandar la máquina entera a la swap.
- **Protección del escritorio.** Sluice lee la presión de memoria de tu sesión de escritorio (`session.slice` del gestor de usuario de systemd). Mientras está en el 10 % o más (`some avg10`, hasta que baja del 5 %), no arranca ningún trabajo, ni siquiera solo en la máquina, y los techos dejan libre la reserva entera.

Tus trabajos esperarán mientras el escritorio esté bajo presión; esa es la idea. `sluice status` muestra el techo de cada trabajo en marcha y la presión de la sesión en su línea `memory:`. Aquí, con un solo trabajo ligero en una máquina tranquila, así que no salen la swap, la presión ni las fugas, que solo aparecen cuando no son cero:

![sluice status en la 0.12.1 con un trabajo ligero en marcha: su techo de 22,1 GiB y la línea memory: con la presión del escritorio al 0,0 %](https://josegarrido.dev/articles/10-agentes-30-gb-de-ram-y-una-cola-como-conviven-sin-pisarse/8ca98541d1a27f88.png)

## El entorno también es parte de lo que pruebas

También en la 0.11.0: una variable como `NODE_OPTIONS` o `RUSTFLAGS` cambia lo que comprueba un test sin cambiar el árbol. Con `key_env` su valor entra en la clave de caché, y las peticiones con otros valores nunca comparten un resultado. `sluice init` las escribe según la *toolchain*, junto con el fichero que el gestor de paquetes reescribe en cada instalación. En un proyecto npm de usar y tirar:

```toml
[gates.test]
cmd = "npm test"
weight = "auto"
timeout = "30m"
hooks = ["pre-push"]
key_inputs = ["node --version", "npm --version"]
key_env = ["NODE_OPTIONS", "NODE_ENV"]
key_files = ["node_modules/.package-lock.json"]
env = { CI = "1" }
```

`sluice doctor` avisa cuando un *gate* se las deja fuera:

```text
[warn] key-env        gate 'test': key_env leaves out RUSTFLAGS, RUSTDOCFLAGS, CARGO_BUILD_TARGET (a change to them reuses a pass made with other values); needs sluice >= 0.11.0 to read key_env
```

Añadir `key_env` cambia la clave de cada *gate* una vez, así que cada uno vuelve a ejecutarse una vez.

## Un daemon no debe heredar a quien lo arranca

Todos los trabajos descienden del daemon, y la sesión de un agente puede arrancarlo por su cuenta. Desde la 0.12.0, el daemon no se queda con el entorno de quien lo arranca, así que el id, la dirección de la API y el token de portador de la sesión de un agente nunca llegan a los trabajos de los demás. Una comprobación del tipo "¿estoy debajo de un agente?" que suba por el árbol de procesos ya no confunde tus ejecuciones con las de un agente, y los *merge trains*, que ejecutan sus *gates*, su `prepare` y sus `key_inputs` con el entorno del daemon, nunca ven el token.

El daemon solo conserva una lista permitida (`PATH`, `HOME`, el idioma, `XDG_*`, el bus de sesión, `SLUICE_*` y pocas más), y un `sluice daemon` lanzado a mano se vuelve a ejecutar limpio. El log nombra las variables descartadas que parecen credenciales, sin enseñar su valor. Los *gates* que lanzan `run`, `verify` o un hook siguen recibiendo el entorno de quien los pide. Las claves de API que exporta el perfil de tu shell ya no llegan al daemon: los *merge trains* las sacan de tu shell de inicio de sesión (el `tool_env` por defecto), y con `[queue] tool_env = "daemon"` tienes que poner las que necesiten, como un proxy, en `pass_env`.

```toml
# ~/.config/sluice/config.toml
[daemon]
pass_env = ["HTTPS_PROXY"]
```

Y un *gate* puede quitar variables de su propio entorno con `env_remove`, para marcadores que `env` no puede borrar.

## Actualiza a la 0.12.2

```bash
sluice update
```

Comprueba el *checksum* y solo para el daemon si está inactivo; uno que está ejecutando *gates* sigue hasta su próximo reinicio. Si usas el plugin de Claude Code, actualízalo también, y después reinicia las sesiones de tus agentes, que siguen con el `sluice mcp` antiguo hasta que se reconectan:

```bash
claude plugin marketplace update sluice
claude plugin update sluice@sluice
```

Después, compruébalo:

```bash
sluice doctor   # daemon-version y plugin dicen 0.12.2, más los avisos de key_env si los hay
sluice status   # la versión del daemon, y la línea memory: con la presión del escritorio
```

La 0.12.1 corrige la detección de fugas de la 0.11.0 y la 0.12.0. Si estás en alguna de las dos y todavía no puedes actualizar, desactiva el manejo de fugas en tu configuración de usuario:

```toml
# ~/.config/sluice/config.toml
[containment]
reclaim_escaped = false
```

y reinicia el daemon cuando esté inactivo con `sluice daemon stop` (descarta los trabajos en cola). Con `false`, Sluice ni devuelve procesos ni mata lo que quede al acabar un trabajo; la detección sigue funcionando, así que puedes ver una ráfaga de líneas `WARN`. Cuando hayas actualizado, quita la línea para recuperar la contención, salvo que la necesiten tus propios tests.

Ninguna de estas versiones rompe una configuración existente. Las claves nuevas van en un solo sentido: un `.sluice.toml` compartido que use `key_env` necesita la 0.11.0 o posterior en todas las máquinas, y uno que use `env_remove`, la 0.12.0.

## Pruébalo

Necesitas Linux. La contención necesita cgroup v2 y un gestor de usuario de systemd, y la política de memoria, `systemd-oomd` con systemd 257 o posterior; en un contenedor o con cgroup v1, Sluice corre sin contención y `sluice doctor` te dice por qué. Todo el trabajo de memoria de este artículo sale de máquinas con Ubuntu 26.04 y kernel 7.0.

Si llegas nuevo: en un *runner* de GitHub de 4 CPU, con la 0.9.0 (mediana de 3 rondas), Sluice bajó el tiempo hasta que todos los agentes habían hecho su commit de 103 a 72 s con 4 agentes (−30 %) y de 213 a 119 s con 8 (−44 %).

```bash
curl -fsSL https://raw.githubusercontent.com/josegarridodigio/sluice/main/scripts/install.sh | sh
sluice doctor
sluice init --dry-run
sluice init
```

El código, el CHANGELOG y la decisión detrás de cada cambio (de la ADR-0026 a la ADR-0030) están en [github.com/josegarridodigio/sluice](https://github.com/josegarridodigio/sluice). Si te resulta útil, una estrella ahí ayuda a que otros lo encuentren. Y si quieres enterarte de la próxima versión cuando salga, con lo que voy aprendiendo al usarlo, tienes la newsletter justo debajo.
