Arma tu propio arnés: el sistema que corre en cualquier modelo, no solo en Claude

Todo el verano nos malacostumbraron: 50% más de uso, Fable incluido sin pensarlo, la cuenta que parecía rendir más. Y justo cuando te acostumbraste, se acaba. Fable dejó de venir gratis en tu plan y ahora se cobra por uso; el extra de límites del verano, según se reportó, también se está yendo.

Seamos claros con los datos. Que Fable pase a cobrarse por uso sí es oficial: Anthropic lo puso a 10 dólares por millón de tokens de entrada y 50 por millón de salida. Lo del «50% extra que expira tal día y todo vuelve a la normalidad» lo reportó la prensa, no una página oficial — tómalo como contexto, no como sentencia. Y lo de que «los tokens solo van a subir y a rendir menos» es mi lectura de hacia dónde va esto, no un anuncio.

Pero el punto no son las fechas. El error no fue no aprovechar el verano. El error fue volverte dependiente de una sola suscripción y de un solo modelo. Porque los agentes que todos arman suenan increíbles, pero cada vez que corren queman tokens — y tú no controlas ni el precio ni la disponibilidad de esos tokens.

Un modelo, solo, hace una cosa: entra texto, sale texto. No tiene memoria, no toca tus archivos, no manda correos. Es inteligencia en bruto, congelada. Puede decir «yo haría esto», pero no puede hacerlo.

El arnés (harness, en inglés) es todo lo que le pones alrededor para que actúe: un bucle que lo llama una y otra vez, unas herramientas que son sus manos, y el contexto que le recuerda en qué va. Eso convierte un modelo que responde en un agente que trabaja. La fórmula es simple: agente = modelo + arnés.

¿Y sabes qué es un arnés? Claude Code. Cursor. Codex. Cada uno es un arnés muy pulido montado sobre un modelo. Cuando usas Claude Code, el modelo decide qué hacer y el arnés ejecuta: lee archivos, corre comandos, busca en la web. La buena noticia es que puedes armar el tuyo, a tu medida, para lo que TÚ haces.

No te asustes con la palabra «arnés». Por dentro son siete piezas, y ninguna es un misterio. Van del corazón hacia afuera:

Suena a mucho, pero el arnés mínimo son las tres primeras piezas (bucle + herramientas + un prompt) más el enchufe. El resto lo agregas cuando lo necesitas, no antes.

Antes de construir nada: no arranques de una hoja en blanco. El Arquitecto es una skill que armé justo para esto. Le cuentas lo que haces —tu idea, tu app, tu agente, las tareas que repites cada semana—, te hace dos o tres preguntas, y te devuelve un plano completo de 16 secciones para que Claude Code lo construya sin que le estés dictando cada paso.

Es tu punto de arranque: en vez de adivinar cómo armar el sistema, describes lo que necesitas y sale el diseño. De ahí lo construyes con cualquiera de los dos caminos de abajo.

Tiene su propia guía a fondo en la bóveda: The Architect.

Si no programas, empieza aquí. En la app de Claude ya tienes con qué armar un arnés ligero: uno que no corre solo, pero que describes una vez y reutilizas cada vez que lo necesitas.

El primer paso, siempre, es contarle todo lo que haces para que él diseñe el sistema. Este prompt lo arranca:

Eres el arquitecto de mi sistema de trabajo. Tu meta es diseñar un sistema que yo pueda reutilizar cada semana, no darme una respuesta de una sola vez.

Esto es lo que hago:
- Mi trabajo / negocio: [descríbelo en una línea]
- Las tareas que repito cada semana: [lista 3–6, ej. escribir 3 correos de ventas, resumir reseñas, armar el reporte del lunes]
- Lo que más tiempo me come: [1–2]
- Las herramientas que ya uso: [Gmail, Notion, Sheets, etc.]

Con eso:
1. Detecta qué tareas se pueden convertir en un sistema reutilizable.
2. Para la más valiosa, dame: el rol que debe tomar Claude, las instrucciones exactas (system prompt), qué archivos de referencia subir, el formato de salida y cómo sé que quedó bien.
3. Dime qué conectores (Gmail, Calendar, Drive) le darían manos para actuar.
4. Entrégalo como algo que yo pueda pegar en un Proyecto de Claude y usar mañana.

Hazme 2–3 preguntas si algo no queda claro antes de diseñar.

¿Quieres el sistema que corre solo y en cualquier modelo? Aquí sí hay código —pero menos del que crees—. Hay dos formas.

La rápida: el Agent SDK

El Claude Agent SDK te da el mismo motor de Claude Code —el mismo bucle, las mismas herramientas, la misma gestión de contexto— pero programable en Python o TypeScript. En pocas líneas ya tienes un agente que lee, edita y corre comandos por ti.

from claude_agent_sdk import query, ClaudeAgentOptions

async for mensaje in query(
    prompt="Ordena mi carpeta de Descargas por tipo de archivo.",
    options=ClaudeAgentOptions(
        allowed_tools=["Read", "Write", "Bash"],
    ),
):
    print(mensaje)

La tuya: el arnés mínimo

Si quieres control total y agnosticismo desde el día uno, escribe tu propio bucle. Son sorprendentemente pocas líneas y casi todo es repetitivo: una lista de mensajes, dos o tres herramientas, y un while que llama al modelo, ejecuta lo que pide y repite hasta terminar. Así se ve la forma:

import os, json, subprocess
from litellm import completion            # habla con 100+ modelos en formato OpenAI

# Cambia esta línea y tu sistema corre en otro modelo. Ese es todo el truco.
MODELO = os.getenv("MODELO", "claude-opus-4-8")   # o "gpt-4o", "gemini/...", "ollama/llama3"

def correr_bash(comando):                # una herramienta = una "mano" del agente
    return subprocess.run(comando, shell=True, capture_output=True, text=True).stdout

HERRAMIENTAS = {"correr_bash": correr_bash}

mensajes = [{"role": "user", "content": "Ordena mi carpeta de Descargas por tipo."}]

while True:                              # el bucle: el corazón del arnés
    r = completion(model=MODELO, messages=mensajes, tools=ESQUEMA)  # ESQUEMA = JSON de tus herramientas
    msg = r.choices[0].message
    mensajes.append(msg)
    if not msg.tool_calls:              # ya no pide herramientas -> terminó
        print(msg.content)
        break
    for tc in msg.tool_calls:           # ejecuta lo que pidió y devuélveselo
        salida = HERRAMIENTAS[tc.function.name](**json.loads(tc.function.arguments))
        mensajes.append({"role": "tool", "tool_call_id": tc.id, "content": str(salida)})

No tienes que escribirlo a mano. Ábrele Claude Code y pásale este prompt para que te lo construya funcionando, con tus herramientas:

Construye un arnés mínimo en Python, en un solo archivo, con estas reglas:

1. Un bucle de agente: llama al modelo; si pide una herramienta, la ejecuta, le devuelve el resultado y repite hasta que ya no pida herramientas.
2. Usa LiteLLM como capa de modelo, para que yo pueda cambiar entre Claude, GPT y un modelo local de Ollama con solo cambiar una variable de entorno MODELO. No lo pegues al SDK de un solo proveedor.
3. Herramientas para empezar: leer_archivo, escribir_archivo y correr_bash, cada una con su JSON Schema.
4. Un system prompt claro y una condición de parada (máximo de iteraciones).
5. Coméntalo en español para que yo entienda cada pieza.

Al final, explícame en 3 pasos cómo correrlo y cómo cambiar de modelo.

Aquí está el truco que hace que tu sistema sobreviva. Casi todos los proveedores y todos los modelos locales hablan el mismo idioma: el formato de la API de OpenAI. Si construyes tu arnés contra ese formato, cambiar de modelo es cambiar una línea de configuración, no reescribir la app.

Tres formas de lograrlo, de la más simple a la más soberana: