<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Fastmcp on lo0 — Blog Técnico</title><link>https://blog.lo0.es/tags/fastmcp/</link><description>Recent content in Fastmcp on lo0 — Blog Técnico</description><generator>Hugo -- gohugo.io</generator><language>es</language><lastBuildDate>Sun, 14 Jun 2026 04:00:00 +0200</lastBuildDate><atom:link href="https://blog.lo0.es/tags/fastmcp/index.xml" rel="self" type="application/rss+xml"/><item><title>El segundo vector de coste de los agentes IA: durable execution con Temporal</title><link>https://blog.lo0.es/posts/temporal-durable-execution-coste-agentes/</link><pubDate>Sun, 14 Jun 2026 04:00:00 +0200</pubDate><guid>https://blog.lo0.es/posts/temporal-durable-execution-coste-agentes/</guid><description>&lt;blockquote>
&lt;p>Notación: importes en &lt;strong>euros (N €)&lt;/strong>, decimales con coma. No se usa el símbolo de dólar
(en este sitio es delimitador de fórmula).&lt;/p>
&lt;/blockquote>
&lt;h2 id="la-tesis-los-agentes-tienen-dos-vectores-de-coste-no-uno">La tesis: los agentes tienen dos vectores de coste, no uno&lt;/h2>
&lt;p>Casi todo el discurso de coste de la IA agéntica se centra en un solo vector: el &lt;strong>coste de
inferencia&lt;/strong> (los tokens). Y es resoluble: &lt;strong>FastMCP + vLLM en local elimina el coste de
inferencia&lt;/strong> —sirves los modelos en tu hierro, el coste por token cae a tu coste amortizado, sin
factura de API—. Pero hay un &lt;strong>segundo vector&lt;/strong> que casi nadie mide y que mata más proyectos: el
&lt;strong>coste de la ejecución defectuosa&lt;/strong>. Un agente no es una llamada, es una &lt;strong>secuencia&lt;/strong> de pasos
(razonar, llamar a una herramienta, razonar, llamar a otra…), y cuando esa secuencia falla a la
mitad sin estado persistido, el coste no es lineal: &lt;strong>se duplica, se dispara con los reintentos y
se infla en cada recuperación&lt;/strong>. Este artículo trata ese segundo vector, cómo lo ataca la
&lt;strong>durable execution&lt;/strong> (con Temporal como referencia), qué dice el estado del arte y los papers, y
por qué es la causa real de tanta cancelación.&lt;/p>
&lt;p>El marco que respalda la urgencia es el de &lt;strong>Gartner&lt;/strong>: predice que &lt;strong>más del 40 % de los
proyectos de IA agéntica serán cancelados antes de finales de 2027&lt;/strong>, por &lt;strong>costes crecientes,
valor de negocio poco claro o controles de riesgo inadecuados&lt;/strong> (&lt;a href="https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027">Gartner&lt;/a>).
&amp;ldquo;Costes crecientes&amp;rdquo; es exactamente este segundo vector: no el de servir el modelo, sino el de
ejecutarlo mal.&lt;/p>
&lt;hr>
&lt;h2 id="los-tres-gastos-de-un-agente-defectuoso">Los tres gastos de un agente defectuoso&lt;/h2>
&lt;p>El coste de la ejecución defectuosa se descompone en tres fuentes concretas, y conviene verlas con
números:&lt;/p>
&lt;div class="diagram" style="max-width:780px;margin:1rem auto;">
&lt;svg viewBox="0 0 780 220" role="img" aria-label="Los tres gastos de un agente defectuoso: fallos que cobran doble, retries sin control, y contexto inflado en recovery" xmlns="http://www.w3.org/2000/svg">
&lt;style>.bx{fill:none;stroke:currentColor;stroke-width:1.3}.tl{font:600 12px sans-serif;fill:currentColor}.ts{font:11px sans-serif;fill:currentColor}&lt;/style>
&lt;rect class="bx" x="20" y="50" width="230" height="100" rx="6"/>
&lt;text x="32" y="72" class="tl">1 · Fallos que cobran doble&lt;/text>
&lt;text x="32" y="92" class="ts">fallo en el paso 15 de 20&lt;/text>
&lt;text x="32" y="108" class="ts">→ se tiran los 14 anteriores&lt;/text>
&lt;text x="32" y="124" class="ts">+ reintento completo&lt;/text>
&lt;rect class="bx" x="275" y="50" width="230" height="100" rx="6"/>
&lt;text x="287" y="72" class="tl">2 · Retries sin control&lt;/text>
&lt;text x="287" y="92" class="ts">reintentos sin política&lt;/text>
&lt;text x="287" y="108" class="ts">→ factura de API/cómputo&lt;/text>
&lt;text x="287" y="124" class="ts">sin techo&lt;/text>
&lt;rect class="bx" x="530" y="50" width="230" height="100" rx="6"/>
&lt;text x="542" y="72" class="tl">3 · Contexto inflado&lt;/text>
&lt;text x="542" y="92" class="ts">recovery reconstruye&lt;/text>
&lt;text x="542" y="108" class="ts">el contexto completo&lt;/text>
&lt;text x="542" y="124" class="ts">→ tokens de más por paso&lt;/text>
&lt;text x="20" y="185" class="ts">Ninguno es el coste de inferencia "base": son los costes de ejecutar la secuencia MAL. Es el vector que vLLM local no toca.&lt;/text>
&lt;text x="20" y="205" class="ts">La durable execution ataca los tres a la vez con estado persistido por paso.&lt;/text>
&lt;/svg>
&lt;/div>
&lt;h3 id="vector-1-fallos-que-cobran-doble">Vector 1: fallos que cobran doble&lt;/h3>
&lt;p>Sin estado persistido, un fallo en el &lt;strong>paso 15 de 20&lt;/strong> te cuesta los tokens de los &lt;strong>14 pasos
anteriores&lt;/strong> (que ya pagaste) &lt;strong>más el reintento completo&lt;/strong> desde cero. El coste desperdiciado de
un agente sin checkpoint, por fallo, es:&lt;/p>
&lt;p>$$\text{coste desperdiciado} = \text{tokens de los pasos completados} \times \text{coste por token} \times (\text{reintentos})$$&lt;/p>
&lt;p>Cuanto más larga la secuencia y más tarde falle, más caro: un fallo al 75 % del trabajo tira el
75 % del coste. La &lt;strong>durable execution checkpointa cada paso&lt;/strong>: si el worker cae a la mitad, &lt;strong>otro
retoma el workflow exactamente donde se quedó&lt;/strong>, no desde cero (&lt;a href="https://temporal.io/">Temporal&lt;/a>).
Temporal usa su &lt;strong>Event History&lt;/strong> como registro de las decisiones pasadas; ante un fallo,
&lt;strong>reproduce&lt;/strong> el progreso hasta la fecha y reanuda en el punto exacto (&lt;a href="https://callsphere.ai/blog/temporal-ai-agent-workflows-durable-execution-workflow-as-code">CallSphere&lt;/a>).
El paso 15 falla → se reintenta el paso 15, no los 14 anteriores. El coste desperdiciado pasa de
&amp;ldquo;los 14 pasos&amp;rdquo; a &amp;ldquo;el paso que falló&amp;rdquo;.&lt;/p>
&lt;h3 id="vector-2-retries-sin-control">Vector 2: retries sin control&lt;/h3>
&lt;p>Los agentes que &lt;strong>reintentan sin política&lt;/strong> disparan la factura de API o de cómputo: un bucle de
reintentos ante un &lt;em>rate limit&lt;/em> puede generar decenas de llamadas facturables por una sola tarea.
La durable execution define &lt;strong>retry policies por activity&lt;/strong>: &lt;strong>límites duros&lt;/strong> de reintentos,
&lt;strong>backoff exponencial&lt;/strong> y &lt;strong>timeouts&lt;/strong> que &lt;strong>acotan el coste máximo posible&lt;/strong> de cada llamada. En
vez de &amp;ldquo;reintenta hasta que funcione&amp;rdquo; (coste ilimitado), defines &amp;ldquo;máximo N reintentos con backoff
y timeout de T&amp;rdquo; (coste acotado).&lt;/p>
&lt;p>El estado del arte lo respalda con datos: el benchmark &lt;strong>ReliabilityBench&lt;/strong> evalúa la fiabilidad de
agentes bajo fallos controlados y encuentra que &lt;strong>el rate limiting es el fallo más dañino&lt;/strong> de
todos (&lt;a href="https://arxiv.org/abs/2601.06112">arXiv 2601.06112&lt;/a>). Es decir, justo el fallo que un retry
sin política convierte en una espiral de coste. Acotar los reintentos no es higiene, es la defensa
contra el modo de fallo que la literatura señala como el peor.&lt;/p>
&lt;h3 id="vector-3-contexto-inflado-en-recovery">Vector 3: contexto inflado en recovery&lt;/h3>
&lt;p>Sin estado persistido, el agente &lt;strong>reconstruye el contexto completo en cada recuperación&lt;/strong>: vuelve
a cargar todo el historial de la conversación/tarea para &amp;ldquo;recordar&amp;rdquo; dónde estaba, pagando los
tokens de ese contexto enorme &lt;strong>en cada recovery&lt;/strong>. Con durable execution, el estado vive en el
historial del workflow, así que &lt;strong>el siguiente paso recibe solo el contexto necesario para ese
paso&lt;/strong>, no la conversación entera. El ahorro es directo: menos tokens de entrada por paso, y sin la
penalización de reconstruir el contexto tras cada fallo.&lt;/p>
&lt;hr>
&lt;h2 id="ejemplo-trabajado-el-coste-de-un-fallo">Ejemplo trabajado: el coste de un fallo&lt;/h2>
&lt;p>Pongamos números a los tres vectores. Un agente de 20 pasos que consume ~3.000 tokens por paso
(razonamiento + llamada a herramienta), sobre inferencia propia a ~1,09 €/1M tokens, con un fallo
al &lt;strong>paso 15&lt;/strong> y una tasa de fallo del 10 % de las ejecuciones:&lt;/p>
&lt;table>
&lt;thead>
&lt;tr>
&lt;th>Escenario&lt;/th>
&lt;th>Tokens recomputados por fallo&lt;/th>
&lt;th>Coste por fallo&lt;/th>
&lt;th>Sobre 10.000 ejecuciones (10 % fallan)&lt;/th>
&lt;/tr>
&lt;/thead>
&lt;tbody>
&lt;tr>
&lt;td>&lt;strong>Sin estado&lt;/strong> (reintento completo)&lt;/td>
&lt;td>14 pasos × 3.000 = 42.000&lt;/td>
&lt;td>~0,046 €&lt;/td>
&lt;td>~46 € desperdiciados&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Con checkpoint&lt;/strong> (reanuda en el 15)&lt;/td>
&lt;td>0 (solo reintenta el 15)&lt;/td>
&lt;td>~0,003 €&lt;/td>
&lt;td>~3 € desperdiciados&lt;/td>
&lt;/tr>
&lt;/tbody>
&lt;/table>
&lt;p>La cifra absoluta parece pequeña porque la inferencia es propia y barata; pero el &lt;strong>ratio&lt;/strong> es de
&lt;strong>~15×&lt;/strong> menos desperdicio por fallo, y escala con la longitud de la secuencia y con el coste por
token (si fuera una API externa a 10–30 €/1M, el desperdicio sin checkpoint se multiplicaría por
10–30). Y esto es solo el vector 1: súmale los retries sin control (vector 2), que pueden convertir
un fallo en decenas de llamadas, y el contexto reconstruido en cada recovery (vector 3). El coste
de la ejecución defectuosa &lt;strong>no es el coste de inferencia × algo pequeño&lt;/strong>; es un multiplicador que
crece con la complejidad del agente —y es exactamente lo que no aparece en la demo y sí en la
factura de producción—.&lt;/p>
&lt;hr>
&lt;h2 id="cómo-funciona-temporal-workflows-activities-y-determinismo">Cómo funciona Temporal: workflows, activities y determinismo&lt;/h2>
&lt;p>Para entender por qué Temporal logra esto, sus dos primitivas:&lt;/p>
&lt;ul>
&lt;li>&lt;strong>Workflow&lt;/strong>: la lógica de orquestación del agente (la secuencia de pasos, las decisiones). Tiene
que ser &lt;strong>determinista&lt;/strong>: ante el mismo Event History, produce las mismas decisiones. Eso es lo
que permite &lt;strong>reproducir&lt;/strong> la ejecución tras un fallo y llegar al mismo punto.&lt;/li>
&lt;li>&lt;strong>Activity&lt;/strong>: cada paso con efectos secundarios (una llamada al LLM, a una herramienta, a una
API). Las activities &lt;strong>no&lt;/strong> son deterministas (el LLM es probabilístico), así que su resultado se
&lt;strong>persiste&lt;/strong> en el Event History: al reproducir, no se vuelven a ejecutar, se leen del historial.&lt;/li>
&lt;/ul>
&lt;p>El truco es esa separación: la lógica determinista (workflow) se reproduce barata desde el
historial; los pasos caros y no deterministas (activities, las llamadas al modelo) se persisten y
&lt;strong>no se repiten&lt;/strong>. Por eso &amp;ldquo;el trabajo completado nunca se repite&amp;rdquo;: las activities completadas se
leen, no se recomputan. Y las &lt;strong>retry policies se definen por activity&lt;/strong>, así que cada llamada al
modelo o a una herramienta tiene su propio límite de reintentos, backoff y timeout —el control de
coste del vector 2, al nivel correcto—.&lt;/p>
&lt;hr>
&lt;h2 id="la-durable-execution-qué-es-y-el-panorama">La durable execution: qué es y el panorama&lt;/h2>
&lt;p>La &lt;strong>durable execution&lt;/strong> es un modelo de programación que &lt;strong>garantiza que el código se completa
pese a los fallos&lt;/strong>: cada paso se checkpointea automáticamente, y si un worker cae, otro retoma el
workflow donde se quedó (&lt;a href="https://temporal.io/">Temporal&lt;/a>). Cruzó a la &amp;ldquo;mayoría temprana&amp;rdquo; en 2025,
con ofertas de AWS, Cloudflare y Vercel, &lt;strong>impulsada precisamente por la infraestructura de agentes
IA&lt;/strong> (&lt;a href="https://www.inngest.com/blog/durable-execution-key-to-harnessing-ai-agents">Inngest&lt;/a>).&lt;/p>
&lt;div class="diagram" style="max-width:780px;margin:1rem auto;">
&lt;svg viewBox="0 0 780 200" role="img" aria-label="Durable execution: una secuencia de pasos checkpointeados; ante un fallo, se reanuda desde el ultimo checkpoint, no desde cero" xmlns="http://www.w3.org/2000/svg">
&lt;style>.bx{fill:none;stroke:currentColor;stroke-width:1.3}.cp{fill:none;stroke:currentColor;stroke-width:1.3;stroke-dasharray:3 2}.tl{font:600 12px sans-serif;fill:currentColor}.ts{font:11px sans-serif;fill:currentColor}.ar{fill:none;stroke:currentColor;stroke-width:1.3;marker-end:url(#dm)}&lt;/style>
&lt;defs>&lt;marker id="dm" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto">&lt;path d="M0,0 L10,5 L0,10 z" fill="currentColor"/>&lt;/marker>&lt;/defs>
&lt;rect class="bx" x="30" y="60" width="80" height="40" rx="5"/>&lt;text x="70" y="84" text-anchor="middle" class="ts">paso 1 ✓&lt;/text>
&lt;path class="ar" d="M110,80 L140,80"/>
&lt;rect class="bx" x="140" y="60" width="80" height="40" rx="5"/>&lt;text x="180" y="84" text-anchor="middle" class="ts">paso 2 ✓&lt;/text>
&lt;path class="ar" d="M220,80 L250,80"/>
&lt;text x="255" y="55" class="ts">… checkpoint por paso (Event History) …&lt;/text>
&lt;rect class="bx" x="430" y="60" width="80" height="40" rx="5"/>&lt;text x="470" y="84" text-anchor="middle" class="ts">paso 15 ✗&lt;/text>
&lt;text x="430" y="125" class="ts">fallo aquí&lt;/text>
&lt;path class="cp" d="M470,100 C470,140 400,140 400,108"/>
&lt;text x="300" y="155" class="ts">reanuda en el paso 15, no en el 1&lt;/text>
&lt;rect class="bx" x="360" y="60" width="60" height="40" rx="5"/>&lt;text x="390" y="84" text-anchor="middle" class="ts">14 ✓&lt;/text>
&lt;text x="30" y="185" class="ts">El trabajo completado nunca se repite: el coste de un fallo es el del paso que falló, no el de toda la secuencia.&lt;/text>
&lt;/svg>
&lt;/div>
&lt;p>El panorama de herramientas (la arquitectura de referencia de 2026 para agentes LLM durables):
&lt;strong>Temporal&lt;/strong>, &lt;strong>AWS Step Functions Express&lt;/strong>, &lt;strong>Restate&lt;/strong>, &lt;strong>DBOS&lt;/strong> e &lt;strong>Inngest&lt;/strong> como primitivas
de durable execution; y el modelo de &lt;em>checkpointer&lt;/em> de &lt;strong>LangGraph&lt;/strong> (PostgresSaver, RedisSaver,
DynamoDBSaver) en el lado de los frameworks de agentes (&lt;a href="https://render.com/articles/durable-workflow-platforms-ai-agents-llm-workloads">render.com&lt;/a>).
Temporal destaca por su modelo &lt;em>workflow-as-code&lt;/em> y su Event History como fuente de verdad.&lt;/p>
&lt;table>
&lt;thead>
&lt;tr>
&lt;th>Opción&lt;/th>
&lt;th>Modelo&lt;/th>
&lt;th>Self-hosted&lt;/th>
&lt;th>Nota para soberanía&lt;/th>
&lt;/tr>
&lt;/thead>
&lt;tbody>
&lt;tr>
&lt;td>&lt;strong>Temporal&lt;/strong>&lt;/td>
&lt;td>workflow-as-code, Event History&lt;/td>
&lt;td>sí (open source)&lt;/td>
&lt;td>el más maduro; on-prem completo&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Restate&lt;/strong>&lt;/td>
&lt;td>durable RPC/handlers&lt;/td>
&lt;td>sí&lt;/td>
&lt;td>ligero, moderno&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>DBOS&lt;/strong>&lt;/td>
&lt;td>durable sobre Postgres&lt;/td>
&lt;td>sí&lt;/td>
&lt;td>estado en tu Postgres&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Inngest&lt;/strong>&lt;/td>
&lt;td>event-driven, steps&lt;/td>
&lt;td>SaaS / self-host&lt;/td>
&lt;td>foco en DX&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>AWS Step Functions Express&lt;/strong>&lt;/td>
&lt;td>state machine&lt;/td>
&lt;td>no (SaaS AWS)&lt;/td>
&lt;td>atado a AWS, no soberano&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>LangGraph checkpointer&lt;/strong>&lt;/td>
&lt;td>checkpointer del framework&lt;/td>
&lt;td>sí (tu backend)&lt;/td>
&lt;td>a nivel de framework, no de plataforma&lt;/td>
&lt;/tr>
&lt;/tbody>
&lt;/table>
&lt;p>Para una plataforma soberana, los que se &lt;strong>self-hostean&lt;/strong> (Temporal, Restate, DBOS) mantienen el
estado en tu cluster; los SaaS (Step Functions) sacan la ejecución a una jurisdicción ajena. Temporal
es la elección por madurez y por su despliegue on-prem completo.&lt;/p>
&lt;hr>
&lt;h2 id="el-coste-de-la-propia-durable-execution">El coste de la propia durable execution&lt;/h2>
&lt;p>Honestidad de datos: la durable execution &lt;strong>no es gratis&lt;/strong>. Tiene dos costes a vigilar:&lt;/p>
&lt;ol>
&lt;li>&lt;strong>Overhead de ejecución&lt;/strong>: persistir el estado y reproducir el historial añade latencia y
cómputo. Las arquitecturas de referencia lo cifran en torno a un &lt;strong>5–20 % de overhead&lt;/strong> en una
carga de 100.000 ejecuciones/día (&lt;a href="https://render.com/articles/durable-workflow-platforms-ai-agents-llm-workloads">render.com&lt;/a>).&lt;/li>
&lt;li>&lt;strong>Precio por paso&lt;/strong>: en las ofertas con &lt;strong>precio por paso&lt;/strong>, orquestar muchas llamadas de modelo,
reintentos por &lt;em>rate limit&lt;/em> e interacciones complejas genera &lt;strong>numerosos pasos facturables&lt;/strong>, y
el coste puede dispararse (&lt;a href="https://render.com/articles/durable-workflow-platforms-ai-agents-llm-workloads">render.com&lt;/a>).&lt;/li>
&lt;/ol>
&lt;p>La conclusión para una plataforma soberana: &lt;strong>self-hostear el motor de durable execution&lt;/strong>
(Temporal es open source y se despliega on-prem) elimina el precio por paso del SaaS, dejando solo
el overhead de ejecución —un 5–20 % que se paga de sobra con lo que ahorra en los tres vectores
anteriores—. El cálculo: si un fallo a mitad de secuencia te ahorraba el 50–75 % del coste
recomputado, un 5–20 % de overhead es una ganga.&lt;/p>
&lt;hr>
&lt;h2 id="observabilidad-de-post-mortem-manual-a-trazabilidad-en-tiempo-real">Observabilidad: de post-mortem manual a trazabilidad en tiempo real&lt;/h2>
&lt;p>El cuarto elemento de la ecuación: la &lt;strong>capa de observabilidad&lt;/strong>. La integración con &lt;strong>Braintrust&lt;/strong>
y el &lt;strong>historial completo de cada ejecución&lt;/strong> (el Event History de Temporal) convierten el análisis
de coste de un &lt;strong>post-mortem manual&lt;/strong> —reconstruir a mano qué pasó y cuánto costó tras un fallo— en
&lt;strong>trazabilidad en tiempo real&lt;/strong>: cada ejecución queda registrada paso a paso, con sus tokens, sus
reintentos y su coste, lista para analizar. Esto cierra el bucle de FinOps del artículo de coste
por token, pero a nivel de &lt;strong>agente&lt;/strong>: no solo cuánto cuesta un token, sino cuánto cuesta una
&lt;strong>ejecución&lt;/strong> —y dónde se desperdicia—.&lt;/p>
&lt;hr>
&lt;h2 id="la-ecuación-completa">La ecuación completa&lt;/h2>
&lt;p>Juntando las piezas, la arquitectura de coste de un agente soberano:&lt;/p>
&lt;div class="diagram" style="max-width:780px;margin:1rem auto;">
&lt;svg viewBox="0 0 780 190" role="img" aria-label="La ecuación: FastMCP más vLLM local elimina el coste de inferencia; Temporal elimina el coste de ejecucion defectuosa; son complementarios" xmlns="http://www.w3.org/2000/svg">
&lt;style>.bx{fill:none;stroke:currentColor;stroke-width:1.3}.tl{font:600 12px sans-serif;fill:currentColor}.ts{font:11px sans-serif;fill:currentColor}.op{font:600 18px sans-serif;fill:currentColor}&lt;/style>
&lt;rect class="bx" x="20" y="50" width="230" height="70" rx="6"/>
&lt;text x="32" y="74" class="tl">FastMCP + vLLM local&lt;/text>
&lt;text x="32" y="94" class="ts">elimina el coste&lt;/text>
&lt;text x="32" y="110" class="ts">de INFERENCIA (tokens)&lt;/text>
&lt;text x="288" y="92" text-anchor="middle" class="op">+&lt;/text>
&lt;rect class="bx" x="320" y="50" width="230" height="70" rx="6"/>
&lt;text x="332" y="74" class="tl">Temporal (durable exec.)&lt;/text>
&lt;text x="332" y="94" class="ts">elimina el coste de&lt;/text>
&lt;text x="332" y="110" class="ts">EJECUCIÓN DEFECTUOSA&lt;/text>
&lt;text x="578" y="92" text-anchor="middle" class="op">=&lt;/text>
&lt;rect class="bx" x="600" y="50" width="160" height="70" rx="6"/>
&lt;text x="612" y="74" class="tl">Agente sostenible&lt;/text>
&lt;text x="612" y="94" class="ts">coste acotado,&lt;/text>
&lt;text x="612" y="110" class="ts">soberano, trazable&lt;/text>
&lt;text x="20" y="155" class="ts">Son COMPLEMENTARIOS: atacan vectores distintos. El 40% de proyectos que Gartner da por cancelados muere por ignorar el segundo.&lt;/text>
&lt;text x="20" y="175" class="ts">+ observabilidad (Braintrust / Event History) = trazabilidad de coste en tiempo real.&lt;/text>
&lt;/svg>
&lt;/div>
&lt;p>&lt;strong>FastMCP + vLLM en local elimina el coste de inferencia. Temporal elimina el coste de la ejecución
defectuosa. Son complementarios&lt;/strong> —atacan vectores distintos del mismo problema—. Quien resuelve
solo el primero (sirve barato pero ejecuta mal) sigue sangrando por el segundo; quien resuelve solo
el segundo (ejecuta robusto pero paga API) sigue sangrando por el primero. La plataforma sostenible
necesita los dos.&lt;/p>
&lt;hr>
&lt;h2 id="estado-del-arte-y-papers">Estado del arte y papers&lt;/h2>
&lt;p>El usuario pedía papers, y los hay: la fiabilidad y el coste de los agentes es un área de
investigación activa en 2026.&lt;/p>
&lt;table>
&lt;thead>
&lt;tr>
&lt;th>Paper&lt;/th>
&lt;th>Aporta&lt;/th>
&lt;/tr>
&lt;/thead>
&lt;tbody>
&lt;tr>
&lt;td>&lt;strong>ReliabilityBench&lt;/strong> (&lt;a href="https://arxiv.org/abs/2601.06112">2601.06112&lt;/a>)&lt;/td>
&lt;td>benchmark de fiabilidad de agentes: consistencia, robustez y tolerancia a fallos de herramientas/API; &lt;strong>el rate limiting es el fallo más dañino&lt;/strong>; ReAct más robusto que Reflexion bajo estrés&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Cost-Efficient LLM Agents&lt;/strong> (&lt;a href="https://arxiv.org/pdf/2603.01548">arXiv&lt;/a>)&lt;/td>
&lt;td>el &lt;strong>trade-off fiabilidad–coste&lt;/strong>: enrutar cada decisión por el LLM mejora el acierto pero dispara el coste; los grafos pre-codificados abaratan pero son frágiles ante fallos compuestos&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Byzantine Fault Tolerance multi-agente&lt;/strong> (&lt;a href="https://arxiv.org/abs/2511.10400">2511.10400&lt;/a>)&lt;/td>
&lt;td>consenso BFT (CP-WBFT) para estabilizar sistemas multi-agente bajo tasas de fallo extremas (85,7 %)&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>ACRFence&lt;/strong> (&lt;a href="https://arxiv.org/pdf/2603.20625">2603.20625&lt;/a>)&lt;/td>
&lt;td>seguridad del &lt;strong>checkpoint-restore&lt;/strong> de agentes: prevenir ataques de &lt;em>rollback&lt;/em> semántico&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>The Six Sigma Agent&lt;/strong> (&lt;a href="https://arxiv.org/html/2601.22290">2601.22290&lt;/a>)&lt;/td>
&lt;td>fiabilidad enterprise vía ejecución descompuesta dirigida por consenso&lt;/td>
&lt;/tr>
&lt;/tbody>
&lt;/table>
&lt;p>Dos lecturas para la propuesta. Primero, &lt;strong>el trade-off fiabilidad–coste es real y está
caracterizado&lt;/strong>: no se puede maximizar acierto ignorando coste ni al revés; la durable execution
desplaza la frontera al &lt;strong>abaratar la fiabilidad&lt;/strong> (checkpoint + retry acotado en vez de recomputar).
Segundo, &lt;strong>el checkpoint-restore de agentes tiene su propia superficie de seguridad&lt;/strong> (ACRFence):
persistir estado introduce riesgos de &lt;em>rollback&lt;/em> que hay que controlar —la durabilidad no es solo
una decisión de coste, también de seguridad—.&lt;/p>
&lt;hr>
&lt;h2 id="el-ángulo-soberano">El ángulo soberano&lt;/h2>
&lt;p>Para una plataforma soberana europea, la combinación encaja perfecto y &lt;strong>toda on-prem&lt;/strong>: &lt;strong>vLLM&lt;/strong>
sirve los modelos (sin coste de API ni soberanía cedida), &lt;strong>FastMCP&lt;/strong> expone las herramientas, y
&lt;strong>Temporal self-hosted&lt;/strong> orquesta con durabilidad (sin precio por paso de un SaaS ni datos de
ejecución saliendo a una jurisdicción ajena). El historial de ejecución —que describe en detalle qué
hace tu agente y con qué datos— &lt;strong>se queda en tu cluster&lt;/strong>, igual que las inferencias. Frente a una
pila de agentes sobre APIs externas + un orquestador SaaS estadounidense, la pila soberana elimina
los dos vectores de coste &lt;strong>y&lt;/strong> mantiene el dato bajo jurisdicción UE. Es el mismo argumento del
resto de la serie, aplicado a la capa de agentes: coste acotado, medido y soberano.&lt;/p>
&lt;hr>
&lt;h2 id="fastmcp-y-la-capa-de-herramientas">FastMCP y la capa de herramientas&lt;/h2>
&lt;p>El otro componente de la ecuación es &lt;strong>FastMCP&lt;/strong>, la capa que expone las herramientas al agente vía
&lt;strong>MCP&lt;/strong> (Model Context Protocol). El agente no llama a las APIs directamente: llama a &lt;strong>servidores
MCP&lt;/strong> que encapsulan cada herramienta (una base de datos, un buscador, un sistema interno), con un
contrato uniforme. La conexión con el coste y la durabilidad: cada llamada a una herramienta MCP es
una &lt;strong>activity&lt;/strong> de Temporal, así que hereda su retry policy, su timeout y su persistencia. Es
decir, FastMCP define &lt;strong>qué&lt;/strong> herramientas hay y Temporal gobierna &lt;strong>cómo&lt;/strong> se ejecutan con
durabilidad y coste acotado. Y al ser MCP servidores propios, las herramientas y los datos que tocan
&lt;strong>se quedan on-prem&lt;/strong> —no se exponen a un proveedor externo—. La tríada &lt;strong>vLLM (modelo) + FastMCP
(herramientas) + Temporal (orquestación)&lt;/strong> es una pila de agentes completamente soberana: el modelo,
las herramientas y la ejecución, todo bajo tu control y con el coste de los dos vectores acotado.&lt;/p>
&lt;hr>
&lt;h2 id="patrones-human-in-the-loop-y-secuencias-largas">Patrones: human-in-the-loop y secuencias largas&lt;/h2>
&lt;p>Dónde más brilla la durable execution, por patrón de agente:&lt;/p>
&lt;ul>
&lt;li>&lt;strong>Human-in-the-loop (HITL)&lt;/strong>: los patrones de aprobación humana —esenciales para la seguridad de
un agente— mapean directamente a las primitivas &lt;strong>suspend/resume&lt;/strong> de la durable execution,
permitiendo workflows que &lt;strong>pausan horas o días esperando una aprobación sin perder estado&lt;/strong>
(&lt;a href="https://www.inngest.com/blog/durable-execution-key-to-harnessing-ai-agents">Inngest&lt;/a>). Sin
durabilidad, mantener un agente &amp;ldquo;esperando&amp;rdquo; consume recursos o pierde el contexto; con ella, el
workflow duerme sin coste y despierta con todo su estado.&lt;/li>
&lt;li>&lt;strong>Secuencias largas&lt;/strong>: cuanto más larga la cadena de pasos, mayor el ahorro del checkpoint (un
fallo tardío tira más trabajo). Los agentes de varios pasos con herramientas son el caso de uso
canónico.&lt;/li>
&lt;li>&lt;strong>Multi-agente&lt;/strong>: cuando varios agentes colaboran, la fiabilidad se complica (los papers de BFT lo
estudian); la durable execution da el sustrato de estado consistente sobre el que construir esa
coordinación.&lt;/li>
&lt;/ul>
&lt;p>El patrón que &lt;strong>no&lt;/strong> la necesita: una llamada de un solo paso sin estado (un clasificador, una
extracción simple). Ahí el overhead de la durabilidad no compra nada. La regla: durable execution
para &lt;strong>secuencias con estado que fallan a la mitad&lt;/strong>; para lo demás, una llamada directa.&lt;/p>
&lt;hr>
&lt;h2 id="cómo-medir-el-segundo-vector">Cómo medir el segundo vector&lt;/h2>
&lt;p>Para gestionar el coste de la ejecución defectuosa hay que medirlo, y con el Event History y la
observabilidad (Braintrust) los KPIs están al alcance:&lt;/p>
&lt;table>
&lt;thead>
&lt;tr>
&lt;th>KPI&lt;/th>
&lt;th>Qué indica&lt;/th>
&lt;th>De dónde sale&lt;/th>
&lt;/tr>
&lt;/thead>
&lt;tbody>
&lt;tr>
&lt;td>&lt;strong>Tokens desperdiciados por fallo&lt;/strong>&lt;/td>
&lt;td>el coste del vector 1&lt;/td>
&lt;td>tokens recomputados tras un fallo&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Reintentos por activity&lt;/strong>&lt;/td>
&lt;td>el coste del vector 2&lt;/td>
&lt;td>retry count del Event History&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Tamaño del contexto en recovery&lt;/strong>&lt;/td>
&lt;td>el coste del vector 3&lt;/td>
&lt;td>tokens de entrada tras una recuperación&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Tasa de fallo por workflow&lt;/strong>&lt;/td>
&lt;td>la frecuencia del problema&lt;/td>
&lt;td>ejecuciones fallidas / totales&lt;/td>
&lt;/tr>
&lt;tr>
&lt;td>&lt;strong>Coste por ejecución completa&lt;/strong>&lt;/td>
&lt;td>el dato de negocio&lt;/td>
&lt;td>suma de tokens × coste/token por run&lt;/td>
&lt;/tr>
&lt;/tbody>
&lt;/table>
&lt;p>El último es el que cierra el círculo con el coste por token: no solo &amp;ldquo;cuánto cuesta un token&amp;rdquo;, sino
&amp;ldquo;cuánto cuesta una &lt;strong>ejecución de agente&lt;/strong>, y cuánto de eso fue trabajo útil frente a desperdicio&amp;rdquo;.
Sin estos KPIs, el segundo vector es invisible —y lo invisible no se optimiza, se cancela cuando la
factura sorprende—. Con ellos, el coste de cada ejecución es un dato en tiempo real, y la decisión
de durabilizar (o no) cada workflow se toma con números.&lt;/p>
&lt;hr>
&lt;h2 id="límites-y-trampas-data-driven">Límites y trampas (data-driven)&lt;/h2>
&lt;ol>
&lt;li>&lt;strong>La durabilidad no es gratis.&lt;/strong> 5–20 % de overhead; en SaaS con precio por paso, puede
dispararse. Self-hostea Temporal para quitar ese precio.&lt;/li>
&lt;li>&lt;strong>No todo agente la necesita.&lt;/strong> Una tarea de un solo paso sin estado no gana nada con durable
execution; el valor está en las &lt;strong>secuencias largas&lt;/strong> que fallan a la mitad.&lt;/li>
&lt;li>&lt;strong>El retry acotado puede ocultar fallos reales.&lt;/strong> Un límite de reintentos evita la espiral de
coste, pero hay que &lt;strong>alertar&lt;/strong> cuando se agota, no tragarse el fallo en silencio.&lt;/li>
&lt;li>&lt;strong>Checkpoint = superficie de seguridad.&lt;/strong> Persistir estado abre la puerta a ataques de rollback
(ACRFence); protégelo.&lt;/li>
&lt;li>&lt;strong>El primer vector sigue existiendo.&lt;/strong> Temporal no baja el coste de inferencia; necesitas vLLM
local para eso. Son complementarios, no sustitutos.&lt;/li>
&lt;/ol>
&lt;p>La conclusión que sostienen los datos y los papers: el coste de la IA agéntica tiene &lt;strong>dos
vectores&lt;/strong>, y el sector se ha obsesionado con el primero (inferencia) ignorando el segundo
(ejecución defectuosa) —que es justo donde Gartner sitúa la causa del 40 % de cancelaciones—.
&lt;strong>FastMCP + vLLM&lt;/strong> resuelve el primero; &lt;strong>Temporal&lt;/strong> el segundo. Una plataforma de agentes soberana
y sostenible necesita atacar los dos, con observabilidad que convierta el coste de cada ejecución en
un dato en tiempo real, no en una autopsia.&lt;/p>
&lt;h2 id="cierre">Cierre&lt;/h2>
&lt;p>El relato dominante sobre el coste de los agentes está medio cojo: trata el coste de inferencia como
si fuera el único, cuando es solo el que se ve en la demo. El que mata proyectos —el que Gartner
mete en &amp;ldquo;costes crecientes&amp;rdquo; dentro de su 40 % de cancelaciones— es el &lt;strong>coste de la ejecución
defectuosa&lt;/strong>: los fallos que cobran doble, los retries sin techo y el contexto que se reconstruye en
cada recuperación. La ingeniería que lo ataca no es un truco de prompt ni un modelo mejor, es un
&lt;strong>modelo de ejecución&lt;/strong>: la durable execution, que checkpointea cada paso, acota cada reintento y
pasa solo el contexto necesario. Temporal —open source, self-hosted— lo hace manteniendo el estado
en tu cluster, y combinado con vLLM (modelo) y FastMCP (herramientas) compone una pila de agentes
&lt;strong>completamente soberana&lt;/strong> donde los dos vectores de coste están acotados y el dato no sale de la UE.
El estado del arte y los papers confirman que el problema es real y caracterizable —el trade-off
fiabilidad-coste, el rate-limiting como peor fallo, el checkpoint-restore como nueva superficie de
seguridad—. Para quien quiera estar en el 60 % de proyectos agénticos que &lt;strong>no&lt;/strong> se cancelan, la
receta es la de este artículo: resolver los dos vectores, no uno, y medir el segundo con la misma
seriedad que el primero.&lt;/p>
&lt;h2 id="fuentes">Fuentes&lt;/h2>
&lt;ul>
&lt;li>Gartner · más del 40 % de proyectos de IA agéntica cancelados antes de 2027 — &lt;a href="https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027">https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027&lt;/a>&lt;/li>
&lt;li>Temporal · durable execution — &lt;a href="https://temporal.io/">https://temporal.io/&lt;/a>&lt;/li>
&lt;li>CallSphere · Temporal para workflows de agentes (Event History, replay) — &lt;a href="https://callsphere.ai/blog/temporal-ai-agent-workflows-durable-execution-workflow-as-code">https://callsphere.ai/blog/temporal-ai-agent-workflows-durable-execution-workflow-as-code&lt;/a>&lt;/li>
&lt;li>Inngest · durable execution, clave para agentes en producción — &lt;a href="https://www.inngest.com/blog/durable-execution-key-to-harnessing-ai-agents">https://www.inngest.com/blog/durable-execution-key-to-harnessing-ai-agents&lt;/a>&lt;/li>
&lt;li>render.com · plataformas de workflow durables para agentes/LLM (overhead, precio por paso) — &lt;a href="https://render.com/articles/durable-workflow-platforms-ai-agents-llm-workloads">https://render.com/articles/durable-workflow-platforms-ai-agents-llm-workloads&lt;/a>&lt;/li>
&lt;li>ReliabilityBench (arXiv 2601.06112) — &lt;a href="https://arxiv.org/abs/2601.06112">https://arxiv.org/abs/2601.06112&lt;/a>&lt;/li>
&lt;li>Cost-Efficient LLM Agents (arXiv 2603.01548) — &lt;a href="https://arxiv.org/pdf/2603.01548">https://arxiv.org/pdf/2603.01548&lt;/a>&lt;/li>
&lt;li>Byzantine Fault Tolerance multi-agente (arXiv 2511.10400) — &lt;a href="https://arxiv.org/abs/2511.10400">https://arxiv.org/abs/2511.10400&lt;/a>&lt;/li>
&lt;li>ACRFence · checkpoint-restore de agentes (arXiv 2603.20625) — &lt;a href="https://arxiv.org/pdf/2603.20625">https://arxiv.org/pdf/2603.20625&lt;/a>&lt;/li>
&lt;li>The Six Sigma Agent (arXiv 2601.22290) — &lt;a href="https://arxiv.org/html/2601.22290">https://arxiv.org/html/2601.22290&lt;/a>&lt;/li>
&lt;/ul></description></item></channel></rss>