DEV Community

Cover image for Intentando trabajar con la IA de manera minimalista
Daniel M.
Daniel M.

Posted on Edited on

Intentando trabajar con la IA de manera minimalista

Abres un proyecto, lanzas un agente de IA y empiezas a trabajar. Después abres otro, pruebas un modelo distinto y dejas una conversación pendiente. Al volver al día siguiente, toca recordar en qué sesión estabas, qué habías pedido y con qué modelo estabas trabajando. Luego alguien te recomienda otra herramienta que no sabes si se solapa con la que estás usando o es complementaria.

Una parte de lo que estoy intentando resolver con las herramientas de IA es precisamente eso: organizar el trabajo y reducir las decisiones repetitivas. Para ello estoy usando, básicamente, T3 Code y Pi. En Pi, además, he añadido extensiones para elegir modelos según la petición y definir alternativas cuando un proveedor falla.

Vamos por partes.

¿Qué aporta cada herramienta?

Aunque ambas sirven para trabajar con agentes de programación, me interesan por motivos distintos:

Herramienta Qué busco con ella
T3 Code Una interfaz para organizar proyectos y conversaciones, y revisar el trabajo del agente.
Pi Un agente extensible que puedo usar desde el terminal y adaptar mediante configuración.
Autorouter de Pi Asignar cada petición a un nivel y utilizar el modelo configurado para ese nivel.
Proveedor de fallback de Pi Definir una cadena de modelos de respaldo para determinados errores.

T3 Code me resulta interesante por la organización de las sesiones. Cuando tienes varios trabajos abiertos, poder localizarlos y retomarlos forma parte de la utilidad de la herramienta. También permite trabajar con worktrees de Git: directorios de trabajo separados para avanzar en ramas distintas.

Con Pi, el atractivo está en poder ajustar cómo funciona el agente. Es lo que suele llamarse un harness: el entorno que conecta el modelo con herramientas para leer archivos, editarlos o ejecutar comandos, y que mantiene la conversación durante el trabajo.

Conviene distinguir estas capas. La interfaz, el agente y el modelo que responde tienen funciones diferentes. Las reglas que explico a continuación pertenecen a mi configuración de Pi; no son una configuración global que se aplique por sí sola a T3 Code.

¿Qué proveedores y modelos estoy usando?

A la hora de redactar este artículo, estoy usando GitHub Copilot, Codex y modelos disponibles a través de la API de NVIDIA.

Aquí hay un pequeño matiz: Copilot y Codex son productos, y NVIDIA ofrece acceso a un catálogo de modelos. Por ello, para saber qué intenta utilizar realmente una configuración hay que mirar el identificador del proveedor y del modelo.

En mi repositorio de configuración aparecen actualmente estas referencias:

Archivo Identificadores configurados
.pi/agent/autorouter.json openai/gpt-6.1-terra y openai/gpt-6.1-sol, además de la ruta fallback/simple.
.pi/fallback-chains.json deepseek-ai/deepseek-v4.1-flash, github-copilot/gpt-6-luna y nvidia/nvidia/nemotron-3-ultra-550b-a55b.

La cadena incluye también una referencia a DeepSeek. Estos son los valores guardados en los archivos cuando escribo el artículo; su presencia en el JSON no acredita que todos estén disponibles o autenticados en una instalación concreta.

En Pi, los identificadores tienen el formato proveedor/modelo. Mi configuración utiliza openai/. Este proveedor admite tanto una clave de API como el inicio de sesión con una suscripción de ChatGPT. La otra integración, openai-codex/, corresponde a la vía que algunas versiones muestran como «OpenAI Codex (legacy)». Son dos formas de conexión distintas, no dos modelos: el modelo es la parte que aparece después de la barra. Para adaptar estos archivos, hay que utilizar el proveedor con el que nos hemos autenticado y los modelos disponibles en /model. Puede consultarse la implementación del proveedor OpenAI de Pi.

Las extensiones de Pi

Pi permite añadir extensiones, instrucciones reutilizables, plantillas de prompts y temas. En este caso, las dos piezas que recoge mi repositorio son:

El autorouter decide qué ruta corresponde a una petición y el proveedor de fallback, configurado para el tier "Simple", intenta continuar con otra alternativa cuando se produce un error de los que admite.

Por ejemplo, pedir una explicación breve de un comando y solicitar una refactorización profunda pueden tener necesidades distintas. Ese reparto es lo que quiero con el autorouter. Si después el proveedor elegido devuelve un error temporal o un límite de peticiones, entra en juego la estrategia de respaldo cuando sea compatible con la ruta utilizada.

El autorouter: dejar las decisiones en un archivo

El archivo principal es .pi/agent/autorouter.json. En mi equipo, corresponde a la configuración global situada en ~/.pi/agent/autorouter.json.

La configuración usa cuatro niveles:

Nivel Destino configurado Razonamiento solicitado
SIMPLE fallback/simple off
MEDIUM openai/gpt-6.1-terra medium
COMPLEX openai/gpt-6.1-sol high
REASONING openai/gpt-6.1-sol max

La idea es reservar más capacidad de razonamiento para las peticiones que la necesitan. Los dos últimos niveles utilizan el mismo modelo, pero solicitan un esfuerzo diferente. El nivel efectivo dependerá de lo que soporte el modelo y de cómo lo gestione Pi.

¿Cómo clasifica la petición?

En el archivo tengo lo siguiente:

{
  "classifierType": "heuristic"
}
Enter fullscreen mode Exit fullscreen mode

Es un fragmento del archivo, no la configuración completa. Indica que la clasificación se hace mediante heurísticas locales: señales como la longitud del texto, la presencia de código o términos asociados al razonamiento. No necesita llamar a otro modelo para decidir el nivel.

Esto tampoco significa que mida perfectamente la dificultad. Una petición breve puede esconder un problema complejo. Por eso me interesa poder intervenir con reglas explícitas.

Palabras clave para orientar el nivel

El archivo incluye keywordTierRules. Por ejemplo, estas reglas forman parte de mi configuración:

{
  "keywordTierRules": [
    {
      "keywords": ["usa terra", "gpt-6.1-terra", "razonamiento medio", "medium"],
      "tier": "MEDIUM"
    },
    {
      "keywords": ["refactorización profunda"],
      "tier": "COMPLEX"
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Así, puedo escribir una petición como:

Usa terra para revisar este script y explicar qué cambiarías.
Enter fullscreen mode Exit fullscreen mode

Y expresar la preferencia desde el propio mensaje. En el archivo completo también hay reglas para peticiones simples y para las que quiero llevar al nivel de razonamiento máximo.

Hay que elegir bien las palabras: términos amplios como simple, high o max pueden aparecer en el texto que estamos analizando. Conviene revisar qué decisión ha tomado el router y ajustar las reglas si producen resultados inesperados.

Otra opción que tengo activada es:

{
  "questionReply": {
    "enabled": true
  }
}
Enter fullscreen mode Exit fullscreen mode

Su finalidad es mantener el modelo cuando el siguiente turno es una respuesta a una pregunta realizada mediante una herramienta de preguntas compatible. Responder brevemente a una aclaración no debería hacer que una tarea compleja se reclasifique sólo por la longitud de esa respuesta.

Instalar y revisar el autorouter

Según la documentación actual de la extensión, se instala con:

pi install npm:@coresofthq/pi-litellm-autorouter
Enter fullscreen mode Exit fullscreen mode

En una instalación nueva, dentro de Pi se puede generar una configuración inicial con:

/autorouter init
Enter fullscreen mode Exit fullscreen mode

Después hay que revisar los modelos y adaptar los niveles. Para activar el enrutamiento en la versión actual se selecciona autorouter/tiered mediante /model, o se inicia Pi con:

pi --model autorouter/tiered
Enter fullscreen mode Exit fullscreen mode

Para inspeccionar la última decisión:

/autorouter explain
Enter fullscreen mode Exit fullscreen mode

Esto permite comprobar el motivo de la selección, en lugar de asumir que el router ha elegido lo que teníamos en mente.

¿Qué ocurre si falla un proveedor?

La otra pieza está en .pi/fallback-chains.json. Su contenido define una cadena llamada simple:

{
  "simple": [
    "deepseek-ai/deepseek-v4.1-flash",
    "github-copilot/gpt-6-luna",
    "nvidia/nvidia/nemotron-3-ultra-550b-a55b"
  ]
}
Enter fullscreen mode Exit fullscreen mode

El orden declarado empieza por DeepSeek, continúa con el modelo servido a través de Copilot y termina con NVIDIA. El proveedor de fallback también puede recordar el último modelo que funcionó, por lo que ese orden no implica empezar siempre desde el primero declarado (en este caso, DeepSeek).

Su utilidad está en los errores recuperables, como determinados límites de peticiones, fallos de red o errores del servidor. Una credencial incorrecta o un identificador de modelo inválido requieren corregir la configuración.

Hay un detalle de compatibilidad que conviene revisar. Mi archivo del autorouter apunta SIMPLE a fallback/simple, pero la documentación actual de pi-litellm-autorouter indica que los destinos deben ser modelos físicos y que omite los modelos virtuales. Por tanto, estos archivos reflejan la combinación que quiero configurar, pero no bastan para garantizar que ambas extensiones se encadenen en cualquier versión. Con la versión actual, hay que utilizar un modelo físico admitido en ese nivel y verificar por separado el mecanismo de respaldo.

Ollama: pruebas con modelos en local

Además de los servicios anteriores, en un proyecto alojado en un repositorio privado estoy probando Ollama, cargando y ejecutando modelos en local. Me interesa comprobar qué puedo resolver con mi propio equipo y cómo se comportan los modelos en esas condiciones.

A la hora de redactar este artículo, el equipo tiene un Intel Core i7-12700H de 12.ª generación, 31 GiB de RAM reconocidos por el sistema y una Intel Iris Xe integrada (Alder Lake-P GT2), que comparte la memoria del equipo. El procesador sigue siendo capaz para uso general, pero la parte gráfica es modesta para estas cargas de IA. En conjunto, cumple su función básica para experimentar con modelos locales, ajustando el tamaño del modelo y el contexto a la memoria disponible, y aceptando tiempos de respuesta más largos cuando sea necesario.

No tengo medidas de rendimiento que permitan hacer una comparación rigurosa. De momento, me sirve para experimentar con el funcionamiento local y valorar si las respuestas resultan útiles para el proyecto.

En mi caso, Ollama se ejecuta en un contenedor de Docker. A la hora de redactar este artículo, tengo descargados los siguientes modelos:

Modelo Tamaño mostrado por Ollama Uso
abogatic-legal:9b 5,6 GB Modelo que estoy probando para consultas del proyecto privado.
nomic-embed-text:latest 274 MB Generación de embeddings: representaciones numéricas de textos para búsquedas por similitud.
qwen2.5:7b 4,7 GB Modelo de lenguaje de propósito general, de unos 7.600 millones de parámetros.
qwen2.5:3b 1,9 GB Variante de unos 3.100 millones de parámetros para probar una opción más pequeña.

Los tamaños de la tabla corresponden a los archivos que muestra Ollama, no a la memoria total necesaria durante la ejecución. Tampoco implican que tenga todos los modelos cargados al mismo tiempo.

El modelo de embeddings tiene una función distinta a los modelos que generan respuestas: permite representar y comparar textos para recuperar información relacionada con una consulta.

Para comprobar los modelos descargados, ejecuto el comando dentro del contenedor llamado ollama:

docker exec ollama ollama list
Enter fullscreen mode Exit fullscreen mode

Y para consultar cuáles están cargados y si se ejecutan en CPU, GPU o repartidos entre ambas:

docker exec ollama ollama ps
Enter fullscreen mode Exit fullscreen mode

La documentación de Ollama explica cómo interpretar la columna PROCESSOR. Es una comprobación útil antes de atribuir el rendimiento a la gráfica: tener una GPU instalada no demuestra que el modelo la esté utilizando.

En una prueba con qwen2.5:3b, este comando mostró 100% CPU, un contexto de 4096 tokens y un tamaño cargado de 2,2 GB. Por tanto, en esa ejecución el modelo estaba funcionando en CPU, sin utilizar la Iris Xe para la inferencia. Es una comprobación concreta del funcionamiento local; no permite sacar conclusiones sobre la velocidad sin medir los tiempos de respuesta.

La prueba también dejó un detalle mejorable: ante una pregunta escrita en castellano, el modelo respondió en portugués. Para repetirla, puedo indicar el idioma de manera explícita:

docker exec ollama ollama run qwen2.5:3b "Responde exclusivamente en español de España. Explica qué es Docker en tres frases."
Enter fullscreen mode Exit fullscreen mode

Esto orienta la respuesta, aunque no garantiza que el modelo siga siempre la instrucción. También forma parte de las pruebas: comprobar la calidad y el seguimiento de instrucciones, además de conseguir que el modelo arranque.

Guardar la configuración para poder recuperarla

Además de los JSON, el repositorio incluye un script de sincronización, sync.sh. Copia los archivos seleccionados desde sus ubicaciones locales al repositorio y crea un commit cuando detecta cambios. El envío a GitHub se hace aparte.

Esto permite conservar el historial de ajustes: qué modelo había asignado a cada nivel, qué reglas cambié o cómo estaba ordenada la cadena de respaldo.

El script filtra algunas variables sensibles antes de copiar la configuración de la shell. Ese filtro cubre nombres concretos; no sustituye la revisión de lo que vamos a subir. Para compartir estas reglas basta con los identificadores de los modelos y los parámetros de enrutamiento. Las credenciales deben quedarse fuera.

Con T3 Code busco tener los trabajos localizados y poder retomarlos con comodidad. Con Pi y sus extensiones, dejar por escrito cómo quiero repartir las peticiones entre modelos. Si mañana cambio de proveedor, puedo empezar revisando esos archivos y mantener el resto de mi forma de trabajar.

Foto: "Autómata" by pschube is licensed with CC BY-NC-ND 2.0

Top comments (0)