Estando a punto de cumplirse una década desde que la burbuja del bitcoin diera paso al hype de la IA con los transformers,
la decantación natural en la tecnología ha hecho su tarea y parece un momento adecuado para echar un vistazo y valorar
cómo podemos facilitar nuestro trabajo de desarrollo incorporando nuevas herramientas.

Tomando como referencia el uso de Ollama en una asignatura el curso pasado, he dedicado apenas unas semanas a
probar algunas herramientas (libres, gratuitas y/o de pago).
A continuación describo cómo las he configurado y algunas sugerencias de uso que me están siendo útiles.

## Premisa

Los grandes modelos de lenguaje son fundamentalmente traductores.
No contienen ninguna inteligencia ni conocimiento y por lo tanto no tienen ninguna capacidad de razonamiento en absoluto.
Son modelos estadísticos que predicen la palabra más probable dado un contexto.
Y tienen muchos datos, muchísimos.

La gran revolución es la traducción automática de cualquier idioma/lenguaje a cualquier otro idioma/lenguaje.
Empezó con lenguajes humanos pudiendo hablarle al móvil estando de viaje en cualquier país (como si fuera el pececillo de la guía del autoestopista galáctico), y el último lenguaje en
añadirse fue el lenguaje "ordenador".
Lo que ha cambiado en el desarrollo de software/gateware/hardware es que hasta hace una década los humanos teníamos que
hacer un sobreesfuerzo para entender el lenguaje "ordenador": aprender a comunicar siendo muy específicos y sufrir
sobremanera para interpretar las respuestas.
Ahora, tenemos una capa de compatibilidad para que sea el ordenador quien haga ese sobreesfuerzo de interpretación, que
"mágicamente" tiene un A1 en todos los idiomas/lenguajes posibles.

Aún usando "la IA", no debemos olvidar que lo que estamos haciendo es generar una serie de instrucciones muy precisas e
interpretando muchos resultados habitualmente complejos para encontrar datos concretos.
Si caemos en la ilusión de que la IA puede evitarnos tener que aprender cómo se hacen las cosas, lo más probable es que
el único resultado sea perder mucho tiempo.
La IA ni sabe ni puede aprender lo que tú tienes que saber.
Si no aportas el conocimiento necesario a la conversación, el restante no lo complementa la IA sino el azar o la estadística.
Aunque por azar pueden obtenerse resultados malos pero funcionales, ni siquiera eso es seguro.

En otras palabras, la IA es tremendamente valiosa para hacer todo aquello que seríamos capaces de hacer por nosotros
mismos muchísimo más rápido, porque nos permite comunicarnos de forma más ágil (aunque no efectiva).
Pero cuando nuestro cliente es el ordenador, no sirve fingir que sabemos de aquello de lo que no tenemos ni idea.
Requiere una honestidad brutal con uno mismo.

El "meme" 42 de la guía del autoestopista galáctico no es sólo un chiste en el imaginario colectivo y referente del
humor absurdo británico.
Es un maravilloso reflejo de quien entendió el fundamento de una IA masiva varias décadas antes de lo que ahora estamos
teniendo el placer de vivir.
Cualquier datacenter moderno es más potente que el Pensamiento Profundo que Douglas Adams imaginó a finales de los 70.

## Requisitos

Los LLM como chatbot se pueden utilizar mediante aplicaciones web o instalando clientes sencillos.
Sin embargo, para poder sacar partido en nuestro trabajo de desarrollo, resulta imprescindible dominar ciertas
herramientas y metodologías básicas que por estar mundialmente extendidas forman parte del comportamiento (estadístico)
de los modelos.

- SHELL: toda la familia de comandos de UNIX (cat, grep, cut, head, tail...) y redirecciones.
  - Porque prácticamente todas las herramientas funcionan en Linux y porque a diferencia de Windows o Mac todo el
    conocimiento sobre el sistema está documentado y es aprendible.
- SSH, claves asimétricas, aplicaciones que lo usan (ssh, scp, sshfs, ssh-agent, ssh-copy-id, rsync, git...),
  configuración y opciones de forward y jump.
  - Porque no es buena idea dejar a un sistema artificialmente inteligente libertad de ejecución arbitraria en nuestro
    propio sistema con nuestros datos y claves personales.
- GIT: ramas, rebase/merge, submódulos, worktree, remotes...
  - Porque no es posible automatizar el copiar, pegar y reconciliar el contenido si no hay un registro de qué ha
    cambiado y qué ha divergido.
- OCI: imágenes y contenedores con podman y/o docker.
  - Porque es más fácil que la IA acepte un dato (nombre de la imagen) y sepa qué hacer con ello, que gastar cientos o
    miles de líneas en tokens para instalar las mismas herramientas una y otra vez.
- CI: la gestión de agentes es idéntica a la integración continua porque en ambos casos se trata de ejecución
  desatendida y automatizada de tareas a partir de una receta o plan concreto.
  - De hecho la IA procesa muy bien los ficheros de configuración de integración continua y los puede usar directamente.

Recordando la premisa, la IA no suple las carencias de conocimiento sobre estas herramientas, porque la sintaxis es
irrelevante pero los conceptos son fundamentales.
Tenemos que saber exactamente qué se puede hacer y qué no sin depender de la IA, pudiendo delegar la construcción
sintáctica de los comandos (y debiendo revisarla aún así).

Mi experiencia estaa semanaa ha sido con un repositorio que tiene un registro histórico de cambios desde 2017
(hasta 2019 en ghdl/docker y después en hdl/containers, https://github.com/umarcor/umarcor/releases/download/gource-videos/HDLC.mp4),
está documentado, tiene tests, todo el conocimiento es machine-readable (.txt, .md, .rst, .py, .tex, .dockerfile...) y
hay ejemplos de uso en varios otros sitios.
Es muy probable que el resultado no sea igual de satisfactorio si la IA no puede "saber" todo eso "mágicamente" porque
no está escrito en ningún sitio o no está estructurado.

## Ejecución de modelos locales

El referente open source para ejecución de modelos locales es [Ollama](https://ollama.com/).

Tiene una arquitectura de servicio por lo que por un lado se debe arrancar el proceso que hace de servidor y por otro
se usan clientes que interactúan con el mismo.

En Debian/Ubuntu, se puede instalar directamente descargando y ejecutando un script:

```sh
curl -fsSL https://ollama.com/install.sh | sh
```

Después, se arranca el servicio con `ollama serve`.

Desde el mismo equipo, o desde otro que tenga acceso al puerto (por defecto 11434), se puede usar la misma aplicación
como cliente.
Por ejemplo `ollama run gemma4:12b` para arrancar uno de los modelos en modo chatbot.

Si el modelo no está descargado en el equipo donde se está ejecutando el servicio, se descarga automáticamente.
También podemos descargar explicitamente los modelos sin ejecutarlos: `ollama pull qwen3.5:9b`.

## Modelos personalizados

Como puede hacerse en servicios como Gemini o ChatGPT, los modelos en Ollama pueden personalizarse con prompts y
conjuntos de datos concretos para acotar/dirigir/condicionar su comportamiento y ajustarlo a nuestras necesidades.

Lo más sencillo es empezar con un fichero de texto "modelfile" donde indicamos el modelo, algunos parámetros y el
contexto que se carga como prompt inicial (antes de que el usuario escriba el primer mensaje en el chat):

```modelfile
FROM qwen3.5:9b

PARAMETER temperature 0.1
PARAMETER top_p 0.8
PARAMETER num_ctx 8192

SYSTEM """
# ROL Y OBJETIVO

Actúas como profesor y asistente de laboratorio de Fundamentos de Informática.

Tu objetivo es corregir, explicar y resolver ejercicios de programación en lenguaje C aplicando de forma ESTRICTA:

1. El estándar ANSI C89/C90.
2. La programación estructurada canónica.
3. El principio SESE (Single Entry, Single Exit).
4. Las restricciones de estilo especificadas en estas instrucciones.

Estas reglas son OBLIGATORIAS. No debes relajarlas aunque una solución más moderna de C resulte más corta o habitual.
...
...
...
"""
```

Creamos el modelo personalizado con `ollama create NOMBRE -f FICHERO.modelfile` y después lo usamos como si fuera
cualquiera de los otros modelos: `ollama run NOMBRE`.

Para dejarlo trabajando de forma desatendida, podemos usar redirecciones:

```sh
cat prompt.md | ollama run NOMBRE --think=false > response.md
```

Donde `prompt.md` es lo que queremos preguntarle en un nuevo chat y `response.md` es la respuesta del modelo
personalizado. Así, podemos preparar varias preguntas y lanzarlas en paralelo.

Es relevante que las IA entienden y producen Markdown de formal natural.
En realidad entienden cualquier tipo de marcado ligero consistente (sea md, rst o lo que nos inventemos), porque lo deducen.
Pero usar Markdown facilita a los humanos la visualización de las entradas y repuestas.

## Pensamiento

La opción `--think=false` es para evitar que se imprima el "pensamiento" interno del modelo desde que lee la pregunta
hasta que emite la respuesta.
Cuando se usa de forma interactiva, puede ser curioso, pero es muchísima verborrea manipulando y transformando
sucesivamente el mismo contenido.

Como se ha indicado en la premisa, los LLM no razonan. ¿Qué es el "pensamiento" entonces? El análisis lógico de la
pregunta. Descompone el texto de entrada en una serie de enunciados lógicos y trata de deducir
órdenes/prioridades/importancias.
Si introducimos enunciados parcialmente contradictorios desde un análisis lógico y literal, es probable que veamos el
modelo entrar en un bucle o tener que "alucinar" para salir del mismo, porque carece de "sentido común" para poder
resolver esos conflictos. Para tener sentido común, necesitaría memoria "infinita" (asumiendo que en los humanos es algo puramente aprendido y en absoluto instintivo).

Deducimos que los modelos no "aprenden" durante las conversaciones/sesiones con los usuarios.
En cada caso el LLM actúa exactamente de la misma forma (es un sistema determinista como todo sistema digital).
Sin embargo, la respuesta no es literalmente la misma.
En cada pregunta se adjunta toda la conversación anterior como contexto, y el LLM vuelve a procesar lógicamente
todo el contenido (con muchos parámetros de ponderación por antiguedad, repetición, mayúsculas...).
Además, los modelos tienen un factor de regularización (aleatoriedad) para evitar el overfitting.
De hecho, en algunos modelos la "temperature" lo que ajusta es la "creatividad" del modelo, es decir, la agresividad de la regularización.

Lo anterior, lejos de ser una decepción, es una ventaja.
Por ahora (no sabemos si dentro de pocos años), no es magia.
Es fácil entender el principio de funcionamiento para dirigir el comportamiento: tenemos que acumular mucho más contexto
revelante y correcto que irrelevante, y para eso tenemos que saber en un contexto qué es lo relevante.

Naturalmente, los modelos tienen un límite de capacidad y por tanto de extensión de contexto que pueden gestionar.
Esto también podemos aprovecharlo a nuestro favor para condicionar las sucesivas acciones de compactado en las que se ve
obligado a olvidar parte de los detalles específicos y recordar lo más relevante (estadísticamente), que es aquello en
lo que más o con más énfasis hemos incidido.

Esto último es extraño en servicios gratuitos como Gemini o ChatGPT porque lo que hacen es limitar la sesión e indicar
al usuario que debe pagar o empezar otra desde cero.
Pero en servicios/herramientas cuya prioridad es la funcionalidad y no el rendimiento económico no existe esa limitación,
sino la técnica.

## Corpus de ficheros

En base a los puntos anteriores, para hacer una tarea o análisis muy concreto y complejo, necesitamos un contexto muy rico.
Parte de ese contexto rico es una prompt que plantee la tarea/pregunta "correctamente" en términos de lenguaje de ordenador
(lógica), aunque usemos un traductor para escribir en castellano/euskera/inglés.
Pero otra parte, al igual que en los humanos, son toda una serie de libros, artículos, vídeos, audios y todo tipo de
soporte escrito y audiovisual que usamos para transmitir el conocimiento.

Se puede compactar un conjunto de ficheros de ese tipo como "fichero comprimido" adjunto al modelo, que en realidad no
es más que la inyección del mismo en texto plano como pregunta inicial del modelo, para que forme parte del contexto
durante toda la conversación.
Naturalmente, ese principio se puede hacer mucho más complejo, introduciendo en el contexto sólo un resumen de palabras
clave y referencias a los ficheros donde hay más detalles, de forma que se filtra qué parte de todo el contexto analizar
en cada pregunta.

He visto varias referencias en este sentido:

- [microsoft/markitdown](https://github.com/microsoft/markitdown) en la descripción indica ser una herramienta en Python
para convertir todo tipo de documentos a Markdown para usarlo en LLMs.
- [digithree/ollama-rag](https://github.com/digithree/ollama-rag) Retrieval-Augmented-Regeneration (RAG) con Ollama.

Pero todavía no he hecho ninguna prueba concreta porque he estado con tareas de desarrollo y
mantenimiento de código.

## LXC en Proxmox

En el servidor hay un contenedor LXC basado en Debian Trixie con podman donde está arrancado un contenedor creado a
partir del siguiente dockerfile:

```dockerfile
FROM debian:trixie-slim

RUN apt update -qq \
 && apt install -y curl zstd \
 && curl -fsSL https://ollama.com/install.sh | sh \
 && curl -fsSL https://opencode.ai/install | bash
```

usando el siguiente comando:

```sh
podman run -d \
  --name ollama \
  --restart always \
  --network host \
  -e OLLAMA_MODELS=/opt/ollama-models \
  -v ollama-models:/opt/ollama-models \
  itsas/ollama ollama serve
```

Para usarlo desde cualquier otro equipo hacen falta:

- Un usuario en el LXC.
- Una de dos:
  - Acceder por SSH a través del puerto 2200 del host (teniendo la VPN activada si estamos fuera de la uni)
  - Acceder haciendo un salto explícito en el host (sin necesidad de VPN aunque estemos fuera de la uni)

En ambos casos, al acceder por SSH, haremos un "forward local" del puerto 11434, para que al ejecutar el cliente en
nuestro equipo consulte a través del tunel el servicio en el LXC.

Este es un ejemplo de configuración para entrar haciendo salto:

```
Host Grupo-Host-ollama
  HostName 10.10.200.100
  User umarcor
  IdentityFile ~/.ssh/id_umarcor
  ProxyJump root@192.168.1.25
  LocalForward 11434 localhost:11434
```

Y sin salto (con VPN):

```
Host Grupo-Host-ollama
  HostName 192.168.1.25
  Port 2200
  User umarcor
  IdentityFile ~/.ssh/id_umarcor
  LocalForward 11434 localhost:11434
```

- Si es para un acceso puntual, hay opciones equivalentes en línea de comandos, sin necesidad de editar el fichero de
configuración.
- El IndetifyFile es opcional para no tener que estar usando la contraseña continuamente.

Con respecto al almacenamiento de los modelos, en el ejemplo de ejecución anterior es modifica la ubicación por defecto de los modelos dentro del contenedor mediante OLLAMA_MODELS, y además se usa un volumen para guardarlos de forma independiente del contenedor en si, pero usando el sistema de ficheros de docker/podman.
En la práctica, tenemos una partición específica accesible en el LXC mediante passthrough, y usamos un bind local en vez de un volumen.
De esta forma, si el espacio ocupado por los modelos de ollama crece excesivamente, se llena esa partición auxiliar pero no se bloquea el sistema del LXC.

Asimismo, ejecutar Ollama como un contenedor docker/podman dentro de un contenedor LXC puede ser redundante.
No tiene mucho impacto en el rendimiento, pero son dos capas para el mismo aislamiento.
Es razonable ejecutar Ollama directamente en el LXC.
En nuestro caso, hay otros contenedores para otros servicios en el mismo LXC.

### Rendimiento

El servicio Ollama en el LXC está bien para probar el concepto, ver que funciona y que es suficientemente interesante
como para poder cambiar radicalmente la forma de trabajo.
Pero es dolorosamente lento, hasta el límite de ser difícilmente usable para algo práctico.

Los 64 cores y 256 GB de RAM no sirven para mucho porque los cores funcionan a máximo 2 GHz.
Los LLM necesitan mucho procesamiento de lógica repetitiva mientras que el servidor es para ejecución simultánea de muchísimas
tareas heterogéneas.
Un equipo de 2015 con 2/4 cores y 16 GB ejecuta más rápido los modelos gemma4 o qwen3.5 que el servidor.

Por eso, hay también un contenedor de Ollama ejecutándose en la VM 200, donde la RTX 3090 está disponible mediante passthrough y ya se estaba utilizando para ejecutar contenedores con cuda.
Para que ollama utilice la GPU, en vez de utilizar un contenedor cualquiera, se ha utilizado la imagen ollama/ollama que ya viene preparada para ello y se ha arrancado con `--gpus all`.

## OpenCode

Tanto o más revolucionario que los LLM en sí, está siendo su aplicación al campo concreto del desarrollo de software (y gateware).
Si hay ámbitos de aplicación que puedan beneficiarse particularmente de una comunicación más fluida entre humanos y ordenadores son precisamente aquellas en las que además del lenguaje se comparte el contexto.
Los modelos sólo entienden el "qué" (qué es la entrada, qué tareas se deducen, qué indicadores se esperan, qué respuesta construir).
No entienden el por qué ni para qué.
Y con el "cómo" tienen problemas porque fuera de su sistema es todo ficción.
Pero si el "cómo" es una reproducción de sus mismos principios de funcionamiento interno, y es sobre lo que más ejemplos concretos hay disponibles, surge un combo muy llamativo.

El producto comercial de este tipo con más publicidad es problamente Claude Code.
[OpenCode](https://opencode.ai/) es una herramienta libre con un propósito similar que permite utilizar modelos de pago
(Gemini, ChatGPT, Claude...) algunos gratuitos (Big Pickle, Nemotron, Muse Spark) o modelos locales mediante Ollama:
`ollama launch opencode --model qwen3.5:9b`.

Independientemente del modelo que se utilice, lo relevante de estas herramientas es la capa entre el usuario y los modelos.
A diferencia de los chatbots, en OpenCode los agentes tienen acceso al sistema, pueden ejecutar comandos y leer los resultados.

Al tener acceso al sistema, se le puede indicar que lea y edite ficheros directamente, sin tener que andar copiando y
pegando de la ventana de chat.
Esto no es un sustitutivo de herramientas para elaborar y comprimir corpus o hacerlos dinámicos, ya que puede ser
igualmente interesante ajustar el conocimiento general del modelo.
Sino algo práctico mientras se está haciendo una tarea concreta que requiere la manipulación de ficheros o ejecución de
herramientas en un equipo.

OpenCode tiene dos modos básicos. Ambos son un chat:
- Plan: interactuamos con el modelo con acceso de solo lectura al sistema para elaborar una receta de qué hay que hacer
  (objetivo, fuentes, pasos, verificación, resultados...), para así ver cuánto está "entendiendo" y cuánto "alucinando".
- Build: tras iterar hasta diseñar un plan (es decir, dar un contexto suficiente y ponderado/priorizado), se le da
  permiso de ejecución/escritura para que lo lleve a cabo.

También podemos pedirle que guarde el plan en un fichero Markdown con todos los detalles de contexto relevantes para un agente.
Y en otro momento usar ese fichero "handoff" para iniciar un agente (sea con el mismo modelo u otro).

De hecho, lo habitual es hacer `/init` la primera vez en el repositorio, para que ejecute una prompt predefinida que hace
un análisis y escribe un resumen en `AGENTS.md` para que en ejecuciones sucesivas otros agentes se ahorren el trabajo.
Eso mismo podemos complementarlo con tantos ficheros como queramos.

Es interesante que si le indicamos qué ficheros son esos handoffs de tareas, cuando vamos haciendo cambios y se quedan
desactualizados (rutas, nombres de ficheros, etc.) la propia IA lo detecta y sugiere cambios para conciliarlo (lógicamente).
Hay que mantenelo a raya para que no nos modifique el repositorio entero por un TODO mal interpretado XD.

[yt:midudev](https://www.youtube.com/@midudev) hizo un vídeo de 2h en mayo sobre OpenCode: [yt:ZZq4TpNgnvg](https://www.youtube.com/watch?v=ZZq4TpNgnvg).
Se centra en proyectos web (JS, HTML, CSS) y en modelos de pago, pero hace un repaso bastante interesante y el vídeo
tiene índice para poder saltar las partes que no interesan.

### Subagents y skills

El propio modelo/agente principal puede iniciar subagentes (que tienen un contexto inicial más limitado que el padre,
pero mucho más margen para integrar lo que suceda durante la ejecución).
Usar subagents es equivalente a escribir un handoff y usarlo después en otra sesión, con la ventaja de que el agente
principal puede esperar y procesar directamente el resultado.

Eventualmente, tendemos a usar un modelo más completo (con una capacidad de contexto y análisis mayor) para analizar
todas las fuentes y trazar el plan.
Después uno más sencillo/ligero para la ejecución (dependiendo de qué complicaciones esperamos que se encuentre durante la misma).

Los subagentes son otros agentes iniciados por el principal a los que se les pasa un contexto (típicamente los detalles de una tarea concreta).
Las skills son una mezcla entre subagentes y modelos personalizados.
Disponen de un precondicionamiento concreto y además se les pasa el contexto de una tarea concreta.

Lo de las skills no lo he probado aún, pero podría ser algo como "corregir el uso del inglés en este documento" o
"comprobar que en este diseño para FPGA los puertos del XDC coinciden con los del top-level".
Tareas recurrentes que puedan beneficiarse de saber hacer algo concreto bien y poco más.
En cierta manera, variantes de modelos con sobreaprendizaje forzado.
Lo interesante de las skills es que se tratan como plugins que pueden compartirse.

### Alcance

Dejar a un agente defectuoso por principio de funcionamiento modificar libremente los ficheros de nuestro ordenador no
es recomendable.
Conozco quien le ha dado sus credenciales de Moodle a un agente para que edite el curso.
Allá cada cual con los riesgos que quiere correr :D

En mi caso, para evitar que los agentes puedan modificar nada más que lo permitido, siempre arranco OpenCode en un contenedor.
La interfaz de OpenCode es visual pero en terminal, por lo que no hace falta gestor de ventanas.

Monto la carpeta local del repositorio en el que quiero trabajar en el contenedor, y dentro además de opencode (y ollama)
instalo sólo python, curl, git, ripgrep y make.

Nótese que instalo git donde no hay credenciales (que están en mi host, pero no en el contenedor).
OpenCode y los agentes entienden git, y es la forma "natural" de gestionar los cambios.
Si hay entes modificando ficheros arbitrariamente, se necesita un sistema de gestión de fuentes/código para saber qué se
ha hecho exactamente.
Por eso, git permite que hagan commits, amends, rebases...
Sin embargo, para evitar que haga ningún cambio en ningún servidor/remote sin confirmación, y como puede suceder por
alucinación aunque el contexto especifique de todas las maneras que no se haga, cualquier intento falla por carecer de
credenciales.

#### Agentes y contenedores

Para evitar tener que instalar todas las herramientas en el contenedor donde esté opencode, y para evitar instalar
opencode en cada contenedor de herramientas, lo razonable es disponer de opencode en un contenedor (él solo) y permitirle
ejecutar otros contenedores directamente.
Así, exactamente las mismas herramientas que podemos usar manualmente y en integración continua puede usarlas la IA también.

Sin embargo, por defecto un contenedor no puede ejecutar otros contenedores. Hay que usar una de dos opciones, y en este
caso lo recomendable es combinar ambas.

La primera opción es instalar sólo la CLI de docker/podman en un contenedor, y arrancarlo permitiéndole acceso al
servicio de contenedores del host.
Por ejemplo:

```
docker run -d --rm -v /var/run/docker.sock:/var/run/docker.sock docker:cli
```

Si dentro de ese contenedor (que es un Alpine Linux con la CLI de docker y nada más) ejecutamos `docker run`, el
contenedor se arranca en el host (la petición se envía a través de socket) como un hermano del contenedor que lo ha
arrancado, no como un hijo.
Es una solución muy sencilla porque no requiere instalar/configurar nada más, ni añadir capas.
Sólo compartir ese fichero (que existe también en Windows y Mac porque usan una VM Linux internamente).

Sin embargo, conlleva un riesgo.
Como los contenedores se ejecutan en el host, las ubicaciones que se pasen para montar corresponden a rutas en el host,
no dentro del contenedor.
Por lo tanto, si se ejecuta `docker run --rm -v /home:/home debian:trixie-slim rm -rf /home`, no se elimina la home del
contenedor que ha ejecutado ese comando sino la home del host.

Para evitarlo hay que añadir una capa de abstracción intermedia.
Necesitamos un entorno sobre nuestro equipo donde exista un servicio de docker/podman aislado del host, y donde pueda
ejecutarse un contenedor que inicie otros hermanos siendo que las rutas visibles por todos los hermanos son compartidas
pero aisladas del host.

Ese entorno puede ser una VM o LXC en Proxmox (o HyperV, VirtualBox). No en WSL2 porque Microsoft ha cogido la tecnología
de contenedores y se ha cargado todo el aislamiento con capas propias indocumentadas.
Sin embargo, no es necesario introducir otra tecnología para ello.
Podemos reutilizar las tecnologías de contenedores con el concepto Docker-in-Docker (DinD) o Podman-in-Podman.

Primero arrancamos un contenedor preparado con un daemon de docker interno:

```sh
docker run -d --rm \
  --name docker-dind \
  --privileged \
  -e DOCKER_TLS_CERTDIR='' \
  -v $(pwd):/wrk \
  docker:dind
```

- Tiene que ser privilegiado para que el daemon funcione (nested).
- Montamos nuestro directorio de trabajo en `/wrk`. El directorio de trabajo es la carpeta del host en la que los
  contenedores van a tener permisos de lectura y escritura (y no podrán ver ninguna otra ubicación del host).

Como Docker-in-Docker se arranca como un daemon (-d), no nos da una terminal.
Entramos:

```
docker exec -it docker-dind sh
```

Dentro ya, arrancamos un contenedor:

- Con el socket de docker montado para que pueda arrancar hermanos.
- Con `-v /wrk:/wrk` para que coincidan las rutas internas que genere como argumentos al arrancar los contenedores hermanos.
  - Importante: sólo las que cuelguen de `/wrk`; en todas las demás habrá cuatro realidades (host, dind, opencode y hermano).
- Que tenga o vaya a tener instalados opencode, la cli de docker (o podman), y las herramientas que queremos que use la IA directamente.

```sh
docker run --rm -itv /wrk:/wrk -w /wrk \
  -v /var/run/docker.sock:/var/run/docker.sock \
  debian:trixie-slim \
  bash
```

En este caso, no uso Dockerfile.
Lo suyo es que cada uno tengais vuestra imagen de opencode + docker-cli + las herramientas de edición/ejecución que useis,
además de los contenedores con las herramientas y toolchains específicas para simulación, síntesis, implementación, etc.

Aquí arranco directamente y meto los comandos a mano:

```sh
apt update -qq
apt upgrade -y
apt install -y curl git make ripgrep python3-venv

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | tee /etc/apt/keyrings/docker.asc > /dev/null
chmod a+r /etc/apt/keyrings/docker.asc
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
  | tee /etc/apt/sources.list.d/docker.list > /dev/null
apt update -qq
apt install -y docker-ce-cli

curl -fsSL https://opencode.ai/install | bash
. ~/.bashrc
```

Nota: la instalación de docker cli en debian usando apt es un poco ruidosa; se puede instalar la cli como binario estático
independiente con curl y tar en una sola línea, pero requiere usar una versión concreta (no hay latest) y no me gusta
tener que andar bumpeando versiones para este tipo de cosas.

Ahora sí, podemos arrancar opencode y dejar que ejecute los contenedores que quiera y que meta la pata con las rutas;
en el peor de los casos perdemos todo el directorio de trabajo, pero no otras ubicaciones de nuestro host.
Y si usamos git correctamente, aunque se cargue todo el directorio de trabajo, no perdemos nada porque tenemos replicas.

Nota: no es estrictamente cierto, porque al haber usado `--privileged` existe una remota posibilidad de que un proceso
en uno de los contenedores internos consiga una elevación de permisos en dind y de ahí una elevación de permisos al host.
Pero si los modelos de IA con los que estamos trabajando son capaces de hacer eso (sea de forma fortuita o malintencionada),
me dedico a otra cosa.

Nótese que en este apartado no he incluido Ollama, porque me he centrado en el aislamiento de los agentes.
Si quisiéramos usar un modelo local en OpenCode, podríamos arrancarlo en el mismo contenedor que opencode o como un
hermano para mantener la configuración (visibilidad) lo más simple posible.
Pero hay que tener en cuenta que los modelos que descarguemos ocupan y usan CPU/GPU.
Si quisiéramos usar un modelo Ollama en OpenCode pero ejecutado en otro equipo, tendríamos que combinar el tunelado.
Así se puede ejecutar un contenedor con acceso al puerto 11434 del host en Windows, asumiendo que `localhost:11434` está configurado mediante forward para que sea el puerto `11434` del LXC/VM donde está el servicio de Ollama:

```sh
docker run --rm -it \
  -e OLLAMA_HOST='http://host.docker.internal:11434' \
  -v /$(pwd)://wrk -w //wrk \
  itsas/opencode bash
```

## Paralelización

Podemos ejecutar múltiples sesiones de opencode en el mismo directorio/proyecto.
Para evitar abrir múltiples terminales y tener que hacer el recorrido de entrada a través de las capas en todas ellas,
lo más cómodo es utilizar algo como [Zellij](https://zellij.dev/) que permite crear múltiples terminales dentro de una
sola.
Recorremos el camino de entrada una sola vez y después creamos todas las sesiones que queramos con agentes.

Si estamos ejecutando todo localmente, podemos usar cualquier editor en el host para ver y modificar los ficheros del
proyecto, ya que lo que modifiquemos en `$(pwd)` lo ven directamente todos los contenedores y lo que modifique cualquier
contenedor lo vemos directamente.
Y en una terminal, entrar a la cocina.

Si estamos ejecutándolo en una VM o LXC, podemos usar la extensión 'Remote - SSH' de VSCode
para abrir una ventana allí y después abrir una terminal "local" a la ventana para entrar a la cocina.

En cualquier caso, si ejecutamos múltiples agentes sobre el mismo directorio y permitimos que todos modifiquen ficheros
es muy probable que haya conflictos.
Tenemos que proveer a cada agente una copia diferente del directorio y reconciliar los resultados cuando terminen.

Aunque git por defecto guarda todas las ramas/versiones internamente y sólo muestra una en cada momento, existe el comando
`worktree` precisamente para poder tener instanciadas explícitamente varias ramas del mismo repositorio.

```sh
git worktree add ../dir-for-agent-a -b oc/branch-for-agent-a
git worktree add ../dir-for-agent-b -b oc/branch-for-agent-b
git worktree add ../dir-for-agent-c -b oc/branch-for-agent-c

# Que ejecuten sus tareas y hagan commits en su rama.

git worktree remove ../dir-for-agent-a
git worktree remove ../dir-for-agent-b
git worktree remove ../dir-for-agent-c
```

NOTA: si hay submodulos, hay que usar `--recurse-submodules` al hacer add, y `--force` al eliminar.

Al eliminar los worktrees no se pierde el trabajo que se haya hecho en esa rama, porque en todo momento los cambios se
estaban haciendo contra el registro de la carpeta principal.
No son copias completas del repositorio, sólo instancias de las ramas donde todas las operaciones de git actúan en el
mismo registro.
Por esa razón, no podemos tener la misma rama instanciada varias veces, tienen que ser diferentes.

Si el trabajo de los agentes ha generado conflictos, podemos resolverlo usando git como resolveríamos cualquier otro
conflicto entre dos ramas creadas por nosotros.
Para unificar las modificaciones realizadas en AGENTS.md y ficheros handoff, puede que queramos pedir a la IA que lo haga,
y de paso que compruebe que todo es coherente.

## Resultados

| | 2026Aug16 - 2026Sep07 | 2026Sep12 - 2026Sep17 | |
|-|-|-|-|
| | gh:hdl/containers/compare/fee39c...acfcfc | gh:hdl/containers/compare/acfcfc...4f4d0 | |
| days | 21 | 5 | 24% |
| commits | 72 | 28 | 40% |
| files changed | 176 | 78 | 44% |
| additions | 2119 | 974 | 46% |
| deletions | 3771 | 1422 | 38% |

En el primer periodo usé ChatGPT y Gemini como chat a través de las respectivas web.
En el segundo periodo usé OpenCode con acceso de lectura, escritura y ejecución.
En una cuarta parte del tiempo, prácticamente la mitad de volumen de trabajo.
Cerca de un 200% de productividad.

Hay factores que maquillan el resultado:

- En el primer periodo me llevó aproximadamente 2 semanas diseñar e implementar en 750 líneas una funcionalidad que las
  IAs no habrían resuelto solas, y que a su vez facilitó una reducción drástica del número de ficheros y que la información
  que aún sólo residía en mi cabeza estuviera descrita en el código (y por tanto legible para IAs/agentes).
  No lo hice para que los agentes me dejaran en mal lugar, pero indirectamente ha tenido ese resultado :D.
- Es un proyecto de complejidad lógica media-alta pero con menos de 25000 líneas de contenido (incluyendo código, datos/parámetros y documentación).
  Incluso con los modelos gratuitos, no tengo problema en que tenga el contexto completo de la tarea.
  Durante la planificación puede sobrepasar los 100K tokens varias veces y tener que compactarse, pero una vez definidas
  las tareas, a los agentes de ejecución les sobra capacidad.
- Tengo conocimiento preciso y completo de todos los aspectos del proyecto y sé cómo hay que hacer todas las modificaciones
  estructurales y de mantenimiento que requiere.
  No estoy usando los agentes para que me hagan cosas que no tengo 100% claro, sólo para que dediquen horas que yo no tengo.
  Son gestores de tareas que entienden mi idioma, no oráculos.
- Como tienen todo el contexto y no los trato como oráculos, prácticamente no alucinan.
  Las pocas alucinaciones suelen ser porque les cambios los ficheros y modifico la historia a mano y no me acuerdo de
  decirles que los vuelvan a leer, por lo que el estado de su memoria no coincide con la realidad y se asustan cuando
  van a editar una línea concreta.
  Suelen recuperarse del susto, darme una cojella, y hacer la tarea bien en cualquier caso.
  Pero algunas veces se enfadan.

Con todo, hay tareas pendientes que no me planteaba afrontar por carecer del tiempo y concentración que requerían, pero
con estas herramientas parecen realizables. Por un lado, porque la carga cognitiva es mucho menor al poder explicar las
tareas en inglés, castellano, euskera o indistintamente en una misma sesión. Por otro, porque los agentes no duermen, es
una legión de becarios incombustible.

Tengo serias dudas de que esta experiencia sea extrapolable a la investigación, y por eso he centrado la información en
trabajo de desarrollo por ahora.
Este siglo, la investigación requiere el análisis de ingentes cantidades de texto que no están pensadas para ser
legibles por máquinas, ni instructivas para humanos, sino como compendio de referencias cruzadas con más de la mitad del
contenido sirviendo de metadatos a las referencias.
Los artículos se han convertido en un reflejo de un mercado que vive de la indexación, la cuantificación como meta y la
estadística.
Para ese juego no sirven los servicios gratuitos (y habrá que probar si sirven los modelos locales con la 3090).
Surgen como setas empresas específicas en el mercado del "AI for Research":
Perplexity, Elicit, Consensus, SciSpace, Semantic Scholar, ResearchRabbit...

## Extras

El paso de Ollama/ChatGPT/Gemini a OpenCode/Claude es sólo el primero y más básico en lo que respecta a dejar que las IAs hagan cosas.
Otras herramientas basadas en OpenCode que elevan la abstracción (uso simultáneo y combinado de múltiples agentes, GUI más similar a VSCode/Theia o directamente como extensión, acceso remoto desde el movil con una app en vez de usar termux y ssh...):

- https://github.com/NeuralNomadsAI/CodeNomad
- https://openchamber.dev/
  - https://github.com/OpenChamber/OpenChamber
- https://openworklabs.com/
  - https://github.com/different-ai/openwork

Y más allá de la edición de código y ejecución de herramientas en terminal/contenedores, si queremos que los agentes interactúen con servicios como e-mail, calendario, whatsapp/telegram, discord/slack, moodle, etc.

- https://openclaw.ai/
  - https://openclaw.ai/ecosystem

Aunque las placas de desarrollo con FPGAs no suelen tener más de 1-2 GB de DDR, hay algunos modelos interesantes de los 2-4 años que el minado de bitcoin estuvo transicionando de las GPU a los ASICs, y hay algún proyecto interesante para describir en VHDL modelos de ejecución de LLMs como `qwen3.5:9b`: https://github.com/Nero7991/llm.vhdl.
