
Cómo hacer tu agente de IA portable entre modelos (sin construir otro wrapper)
Corrí el mismo workflow en Ollama y OpenAI cambiando solo un YAML. Cero cambios en código. Pero validar que el swap era seguro requirió capas que ningún adapter te da.
Series: LLM Portability (4 articles)
- 1Cómo hacer tu agente de IA portable entre modelos (sin construir otro wrapper) This article
Hace unas semanas estaba corriendo un agente de análisis de incidentes con Ollama en mi laptop. Funcionaba. Tools, structured output, todo bien. Pero tardaba 9 segundos por request.
Entonces pensé: "voy a probar con GPT-4o-mini a ver qué tal la latencia."
Cambié un profile en YAML. Corrí el mismo workflow. 3.6 segundos. Mismo resultado. Misma estructura. Mismos tools invocados correctamente.
Pero había un caso, uno solo, donde ambos modelos se equivocaron de la misma forma. Un incidente con severidad ambigua que ambos escalaron a
high cuando debía ser medium . Mismo blind spot. Misma integración.Si no hubiera tenido el eval harness, hubiera hecho el swap y seguido adelante. Con él, además de validar que la calidad se mantiene, descubrí que tengo un problema de prompt en el caso ambiguo que ninguno de los dos modelos resuelve bien. Eso no es un problema de portabilidad. Es un problema de diseño que el eval hizo visible.
Y eso es lo que quiero mostrarte hoy: la arquitectura que hace posible swappear modelos con confianza, no con esperanza.
El consejo que todos repiten
Cada vez que sale un modelo nuevo, el timeline se llena de lo mismo: "no te cases con un provider", "usa un adapter", "mantén tu código agnostic".
Y sí, tiene sentido. Los ciclos de vida de los modelos se comprimen cada vez más. Nadie quiere reescribir su app por cada lanzamiento.
Pero la mayoría de los equipos interpretan ese consejo como "wrappea la llamada HTTP". Construyen un adapter, cambian el endpoint, y asumen que ya son portables.
Un adapter normaliza la invocación: mensajes, auth, reintentos, streaming. El cable entre tu código y el modelo.
Pero no te dice:
- ¿Qué modelo debería correr este workflow?
- ¿Qué pasa cuando el output del modelo no cumple el schema esperado?
- ¿Cómo comparo dos candidatos?
- ¿Cómo sé que el swap es seguro antes de producción?
Un adapter te da consistencia de transporte. Portabilidad necesita consistencia de comportamiento.

Y ahí es donde la mayoría de los equipos se quedan cortos.
Strands ya resuelve esa capa
Si estás usando Strands Agents SDK , ya tienes la abstracción de invocación resuelta. El SDK expone providers intercambiables (
OpenAIModel , OllamaModel , BedrockModel ) detrás de un agent loop común.En el proyecto que construí, el módulo
StrandsModelFactory es el único lugar que importa SDKs de providers. El resto del código nunca nombra un vendor:# src/providers/strands_factory.py# Este es el ÚNICO módulo que sabe de providers específicos
class StrandsModelFactory: """Crea instancias de modelo Strands según el profile seleccionado."""
def create(self, profile: ModelProfile) -> Model: match profile.provider: case "ollama": return OllamaModel( host=profile.endpoint, model_id=profile.model_id ) case "openai": return OpenAIModel( model_id=profile.model_id ) # ... otros providersFíjate: el business logic no sabe si detrás hay un Ollama en
localhost:11434 o un GPT-4o-mini en la nube. Usa el mismo Agent , los mismos tools, el mismo contrato.
Strands se encarga del agent loop, tool integration y message orchestration. Esa capa ya está resuelta.
No construyas otra encima
Un wrapper HTTP custom sobre Strands duplica responsabilidad. Es como poner un intermediario entre dos personas que ya se entienden.
Cuando intenté usar
gpt-5 en una comparación, me dieron 429 (rate limit). Pero en vez de pelear con eso, me pregunté: ¿realmente necesito el último modelo para este workflow? Cambié a gpt-4o-mini , cero cambios en business logic, solo el YAML y una variable de entorno. Y el resultado fue el mismo. No siempre necesitas el modelo más grande para resolver tu problema.Si tu adapter no te da eso, el problema no es la capa de transporte. El problema es que te faltan las capas de arriba.
Lo que sí necesitas construir (y Strands no te da)
Acá está el mapa completo de lo que vive encima del SDK:

Voy capa por capa.
Capability Registry -¿qué puede hacer cada modelo?
models: ollama-local: provider: ollama model_id: llama3.2 capabilities: - tool-use - structured-output latency_class: high cost_class: free enabled: true
openai-gpt4o-mini: provider: openai model_id: gpt-4o-mini capabilities: - tool-use - structured-output latency_class: low cost_class: low enabled: trueEl registro declara capacidades, clase de latencia y clase de costo por cada profile. No almacena secretos. No afirma capacidades que no hayas verificado.
Policy Engine - ¿qué necesita este workflow?
workflows: incident_analysis: requires: - tool-use - structured-output optimize_for: reliability max_cost_class: medium fallback: - fast-general - deep-reasoningFíjate: el workflow pide
tool-use y structured-output . No pide "GPT-4o" ni "Claude". Pide capacidades. La política filtra modelos incompatibles y ordena los que quedan.Capability Router - ¿cuál modelo corre este request?
El router toma la política, consulta el registry, y devuelve una selección determinista con fallback chain. Si el primero falla, viene el siguiente. Sin intervención manual.
Structured Contracts - ¿el output es correcto?
from pydantic import BaseModel
class IncidentAnalysis(BaseModel): """Contrato de output — si el modelo no produce esto, falla.""" severity: str affected_service: str root_cause: str recommended_actions: list[str]Si el modelo produce algo que no valida contra este schema, el sistema lo detecta inmediatamente. No tres días después en producción.
Evaluation Harness - ¿el swap es seguro?
Esta capa separa "creo que funciona" de "medí que funciona". Corre un dataset de casos conocidos y valida schema, tools, task score y latencia. Más adelante te muestro los resultados reales.
Observability - ¿qué decidió el sistema y por qué?
JSON logs estructurados, correlation IDs, routing reason. Cuando algo falla a las 3am, no quieres adivinar qué modelo se eligió ni por qué.
La prueba: mismo workflow, dos providers
Corrí
incident_analysis con dos profiles. Mismo agente. Mismos tools simulados ( get_service_status , get_runbook ). Mismo contrato Pydantic. Solo cambié el profile en YAML.
Modelo | Provider | Schema | Tools | Task Score | P95 Latencia |
|---|---|---|---|---|---|
ollama-local | Ollama / llama3.2 | 100% | 100% | 0.90 | 9303 ms |
openai-gpt4o-mini | OpenAI / gpt-4o-mini | 100% | 100% | 0.90 | 3610 ms |
Ambos pasaron schema y tools al 100%. Mismo task score global.
Pero hay un caso que los delata.
En
ambiguous-severity (un incidente donde la severidad no es clara), ambos sobre-escalaron a high cuando el esperado era low o medium . Task score para ese caso: 0.6.Un adapter no detecta eso. El eval harness sí. Y lo que te dice no es solo "cuidado con el swap", sino "tu prompt tiene un gap que necesitas resolver independientemente del modelo".
El comando:
python evaluate.py --workflow incident_analysis \ --profiles ollama-local,openai-gpt4o-miniGenera un reporte Markdown con todo: schema compliance, tool success rate, task score por caso, y latencia P95.
Swappeé providers editando YAML. Confié en el swap solo después de que el eval harness me dijo que podía.
Lo que quiero que te lleves
- Provider abstraction no es portabilidad. Strands te da lo primero. Lo segundo lo construyes tú.
- No dupliques trabajo. Si tu SDK de agentes ya abstrae providers, otro wrapper HTTP es código que vas a mantener sin beneficio.
- Lo que sí necesitas: un registry de capacidades, un policy engine, un router, contratos validados, evaluación automatizada y observabilidad.
- Ninguna migración sin medición. El eval no solo valida el swap, expone problemas de diseño que de otra forma serían invisibles.
- Local y cloud coexisten bajo la misma arquitectura. Latencia y costo son inputs de política, no forks de código.
Qué sigue
Este es el primer artículo de la serie LLM Portability Lab.
Hoy viste que la abstracción del provider ya está resuelta y que el trabajo real está en las capas de arriba. En el próximo artículo me meto en la pregunta incómoda: ¿"swappable" significa "portable"?
Spoiler: no.
Vamos a ver por qué dos modelos que pasan los mismos tests pueden dar resultados de negocio diferentes, y cómo el eval harness te protege de migraciones silenciosamente rotas.
¿Te resultó útil este artículo? Compártelo con tu equipo o déjame saber en los comentarios qué capa de la arquitectura te gustaría que cubriera con más detalle.
Y si ya estás construyendo agentes multi-provider, me encantaría escuchar cómo estás manejando la portabilidad hoy.
Series: LLM Portability (4 articles)
- 1Cómo hacer tu agente de IA portable entre modelos (sin construir otro wrapper) This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article