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:
- pi-litellm-autorouter, para el enrutamiento por niveles.
- pi-fallback-provider, para las cadenas de respaldo.
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"
}
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"
}
]
}
Así, puedo escribir una petición como:
Usa terra para revisar este script y explicar qué cambiarías.
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
}
}
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
En una instalación nueva, dentro de Pi se puede generar una configuración inicial con:
/autorouter init
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
Para inspeccionar la última decisión:
/autorouter explain
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"
]
}
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
Y para consultar cuáles están cargados y si se ejecutan en CPU, GPU o repartidos entre ambas:
docker exec ollama ollama ps
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."
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)