Token LabBuscar

JEV · AGENT SYSTEMS

Jev y el harness de agentes: decisiones, contexto, coste y control

Análisis técnico del modelo de decisiones y del PDF viral, con arquitectura propia, cálculos y un harness local reproducible.

JevHarnessRLCDContext engineering

Fuentes y versiones
En este artículo

Qué cambia Jev y qué conserva el software

Un agente de programación es un programa con estado que alterna inferencia y acciones. El harness construye contexto, presenta herramientas, limita recursos y registra resultados. El modelo propone un parche; el runtime decide qué versión del repositorio ve y qué puede ejecutar.

Jev es un modelo de decisiones de TypeSafe, no un generador de código sustituto. Devuelve juicios tipados a partir del estado [1]. Seguiremos un agente SRE que corrige la amplificación de reintentos de un cliente HTTP: el generador modifica código y el decisor ayuda a seleccionar evidencia. Autenticación, permisos y ejecución siguen siendo responsabilidades del software.

El objetivo es calcular el beneficio real del enrutamiento y construir un harness reproducible. JSON define contratos; la probabilidad representa incertidumbre; una caché sólo es válida para una identidad y versión concretas. El ejercicio requiere funciones Python y conceptos de timeout, sin modelo de pago.

Leer la promesa en el nivel correcto

El PDF de doce páginas se identifica como síntesis independiente de septiembre de 2026, sin respaldo de TypeSafe: propone estado explícito, contexto según consulta y rutas bajo política [2]. Almeida figura como coautor de InstructGPT [3], pero eso no demuestra la autoría del PDF.

El informe de TypeSafe atribuye 193,6× y 444,6× a workflows System One seleccionados, con probabilidades de modelos como referencia [4]. No prueba esa mejora en agentes completos. El mensaje aportado tampoco documenta una reproducción de la instalación en dos horas.

Una decisión, un workflow y una corrección aceptada son unidades distintas. Ahorrar por intento puede encarecer cada solución si aumentan los fallos. Aquí presentamos análisis propio y una simulación local, no una reconstrucción del modelo privado.

De texto generado a decisiones acotadas

La generación autorregresiva predice tokens sucesivos; una decisión acotada elige entre resultados ya definidos. TypeSafe describe salidas paralelas y denomina RLCD a su entrenamiento [4] [5]. Las fuentes revisadas no permiten reproducir arquitectura, pérdida y datos; no inventamos una implementación interna.

“Arregla el servicio” requiere investigación. “¿Qué subsistema debe recibir este paquete de evidencia?” tiene candidatos definidos. Sin embargo, una traza sin la política de reintentos puede inducir una respuesta formalmente válida y causalmente equivocada.

El esquema impide nombres de herramientas inexistentes, no la elección equivocada de una herramienta válida. Es como una función tipada que devuelve el entero incorrecto. Hay que comparar calidad, calibración y latencia contra un LLM con salida estructurada sobre la misma tarea.

En la notación, x es entrada, y₁:T la secuencia generada, s el estado, Q la pregunta y A las respuestas permitidas. La segunda expresión abstrae una interfaz, no el entrenamiento privado de Jev.

Diseñar la pregunta antes del modelo

Choice selecciona alternativas; Score expresa niveles ordenados; Noul devuelve la probabilidad de una proposición [6] [7] [8]. Una relevancia de 0,8 no significa 80% de correcciones válidas. Elegir un subsistema tampoco demuestra que el fallo esté entre los candidatos.

Nuestro paquete incluye objetivo, revisión, aserción fallida, fragmentos, IDs permitidos y evidencia ausente. Preguntamos por suficiencia y relevancia por separado. La insuficiencia provoca más búsqueda, no una elección obligatoria. Ausencia y contradicción se registran de forma distinta.

Agrupe preguntas independientes sobre una instantánea. Si B necesita la respuesta de A, ejecute otra etapa. Versione rúbrica y umbrales para que los registros históricos mantengan su significado.

Calibración, concentración y coste del error

Choice confidence reescala la probabilidad máxima respecto a la distribución uniforme [9]. Con tres opciones y máximo 0,8 resulta 0,7. No son dos confirmaciones independientes. Noul no lleva un campo confidence separado.

La calibración describe grupos: cerca de 0,8, el evento debería ocurrir aproximadamente el 80% de las veces. Un predictor constante puede estar calibrado y discriminar mal. La exactitud alta tampoco evita exceso de confianza en fallos raros. Analice repositorios, idiomas y clases de acciones por separado.

Ejemplo propio: un error cuesta 100 unidades y una revisión perfecta cuesta 2. Actuar cuesta en expectativa (1−p)×100; sólo gana si p>0,98. No es un umbral recomendado: la revisión también falla y las pérdidas cambian. La probabilidad nunca concede permisos.

Arquitectura para el incidente de reintentos

El controlador crea un ID, verifica acceso y fija un commit. El lector adjunta rutas, rangos y hashes a archivos autorizados. Los secretos se filtran antes de cualquier llamada externa, incluido el router. El almacén conserva observaciones inmutables; el controlador mantiene el estado activo y la política.

El constructor fija instrucciones y la aserción fallida, después añade evidencia dentro del presupuesto. La recomendación del decisor se intersecta con proveedores autorizados y recursos restantes. El generador propone un parche; el ejecutor verifica alcance y contenido antes de aplicarlo en un worktree aislado. Las salidas son datos, nunca autoridad.

Ante timeout se conserva una ruta prudente o revisión. Respuestas inválidas no ejecutan herramientas. Una versión obsoleta requiere releer. Cancelar evita nuevas acciones, no necesariamente cargos ya enviados. Tras un crash se reconcilian resultados desconocidos antes de repetir escrituras.

Arquitectura original de referencia: la recomendación pasa por política; sólo el ejecutor autorizado actúa. Líneas discontinuas: observaciones. No representa internals de TypeSafe. Abra para ampliar.
Arquitectura original de referencia: la recomendación pasa por política; sólo el ejecutor autorizado actúa. Líneas discontinuas: observaciones. No representa internals de TypeSafe. Abra para ampliar.
ComponenteEntrada → salidaNo demuestra
DecisorEvidencia y opciones → probabilidadesPermiso ni certeza
ConstructorFragmentos y presupuesto → paqueteIrrelevancia de lo omitido
PolíticaIdentidad y alcance → permitir/revisar/denegarCorrección del parche
EjecutorPropuesta autorizada → observaciónAusencia de efecto por timeout
VerificadorParche y comprobaciones → resultadoCorrección fuera de cobertura

El contexto como presupuesto de evidencia

Para reparar reintentos, la regla de conservar el límite, el código actual y la aserción fallida pesan más que una antigua conversación. Cada fragmento necesita ID, revisión, procedencia, tamaño, permisos y marca obligatoria. Un resumen conserva el enlace a la fuente.

El modelo didáctico elige una representación por fragmento bajo presupuesto. Las utilidades son estimaciones; las dependencias importan: definición y llamada pueden ser útiles sólo juntas. Fije contratos, reserve salida y rechace presupuestos que no permitan la evidencia obligatoria.

Separe prefijo estable de evidencia dinámica para no destruir reutilización. Invalide resúmenes cuando cambien hashes. FastContext investiga búsqueda de repositorios por separado [10]; no constituye una medición de Jev.

Contabilizar la ruta completa

Ejemplo sintético: 10.000 tokens de entrada a $2/millón y 1.000 de salida a $8/millón cuestan $0,028. No son precios actuales. Una ruta barata de $0,010 más $0,015 de transferencia/revisión y $0,001 de decisión cuesta $0,026: ahorra sólo 7,1%. Otros $0,004 de reintentos eliminan el ahorro.

Si las decisiones ocupan 20% del tiempo y se aceleran 200×, Amdahl limita la mejora total a aproximadamente 1,248×. En tareas paralelas importa el camino crítico, no sumar spans solapados.

Mida coste por corrección aceptada incluyendo fallos, búsqueda y revisión. Iguale versiones y cachés. La caché de prompts y la residencia KV no son el mismo contrato de facturación; no presuponga reutilización entre modelos.

nᵤ, n꜀ y nₒ cuentan entrada sin caché, con caché y salida; p son dólares por millón. C_d es el coste de decidir. En S, f es la fracción temporal original y s su aceleración, con trabajo restante invariable y composición serial.

Cálculo Amdahl original: decisiones 200× más rápidas. Eje horizontal: fracción temporal original; vertical: aceleración total. Ejemplo sintético, no medición de Jev.
Cálculo Amdahl original: decisiones 200× más rápidas. Eje horizontal: fracción temporal original; vertical: aceleración total. Ejemplo sintético, no medición de Jev.

Una recomendación no es un permiso

Preparar un parche no autoriza desplegarlo. Una recomendación segura de sí misma sigue fuera de alcance. Compruebe acciones y destinos antes del enrutamiento y justo antes de ejecutar; vincule aprobación a ID, digest, destino, vencimiento y revisión.

Buscar cadenas peligrosas no asegura un shell. Subprocesos, imports y enlaces simbólicos cambian el efecto real. Use operaciones estrechas, rutas canónicas, aislamiento, límites y ausencia de credenciales de producción. Los tests también ejecutan código no confiable.

Comentarios y logs pueden contener inyección. Su procedencia no les concede autoridad. Ante timeout de escritura, consulte el resultado antes de reintentar: SQLite no crea una transacción atómica con una API externa.

Integrar una decisión antes de reconstruir el agente

Hay tres niveles: una skill enseña a integrar; una herramienta ofrece el servicio; un harness nativo controla cada turno. Instalar la primera no concede el tercero. Verifique qué permite la versión concreta del agente.

Empiece por ranking de evidencia en modo sombra, sin cambiar ejecución. Revise discrepancias y active una cohorte pequeña con rollback inmediato. Añada rutas de modelos sólo si puede transferir contexto independiente y resultados compactos.

El adaptador necesita validación, versión resuelta, deadlines, concurrencia limitada y coste de fallos. La caché incluye versiones de modelo, pregunta, política y hash de estado, sin compartir entre clientes. API y skill oficiales están al final [11] [12]. El laboratorio usa fixtures locales; no llama servicios de pago.

Cuándo compensa y dónde falla

Use código para hechos deterministas, embeddings o rerankers para relevancia, un decisor para juicios acotados y generación para nuevos parches. No convierta cada rama en una llamada AI.

El comprador típico es plataforma de desarrollo o infraestructura de agentes. Compra tareas correctas bajo restricciones de coste y privacidad. El especialista compite en latencia y calibración; el proveedor general puede agrupar routing y caché; el harness controla workflow y auditoría; el modelo local añade operación propia. No es una clasificación de cuota ni una afirmación sobre adquisiciones.

Persisten calibración de eventos raros, candidatos ausentes, dependencias podadas y errores correlacionados. Más paralelismo puede subir la factura. Optimizar un router no demuestra mejora recursiva de inteligencia.

Práctica, validación y entrevistas

Ejecute python3 lab.py con Python 3.11+. No hay dependencias, credenciales ni red. Los fixtures son deterministas y no necesitan semilla. SQLite en memoria deja cinco decisiones distintas tras reproducir la misma solicitud; no demuestra recuperación entre procesos.

El flujo fija evidencia obligatoria, valida probabilidades, propone una ruta y aplica política. El hash identifica repeticiones. La selección voraz no es óptima y los tamaños son estimados. No se ejecuta shell ni se genera un parche.

Espere policy/assertion/implementation, rechazo por presupuesto insuficiente, review para respuestas ambiguas o inválidas y deny para deploy. Una revisión nueva crea otra identidad. Inyecte proveedor no autorizado, NaN, candidato ausente y versión de política nueva: revisión, rechazo de esquema, rechazo de esquema e identidad nueva. Añada concurrencia y recuperación antes de usar almacenamiento persistente.

Compare agente original, heurística, LLM estructurado y Jev sobre tareas reservadas con iguales permisos. Separe las ablaciones de contexto y routing. Mida éxito, coste por solución, p50/p95, caché, tiempo humano y violaciones. Repita por dificultad, conserve fallos y separe calibración del test final.

Brier es la media de (p−y)²: el ejemplo da 0,255, sin demostrar calibración real. Examine cobertura y errores según umbral: enviar todo a revisión no automatiza nada. Incluya evidencia ausente, inyección, caída del servicio, hashes obsoletos y escrituras inciertas.

Descargar laboratorio Python completo
"""Python 3.11+, standard library only. Offline harness simulation, NOT Jev.
No network, shell execution, real code edits, GPU or model benchmark.
Run: python3 lab.py
"""
from dataclasses import dataclass
from hashlib import sha256
import json
import math
import sqlite3

@dataclass(frozen=True)
class Chunk:
    id: str
    revision: str
    text: str
    tokens: int  # Synthetic fixture sizes, not a tokenizer measurement.
    utility: float
    mandatory: bool = False


def select(chunks, budget):
    if budget < 0 or len({c.id for c in chunks}) != len(chunks):
        raise ValueError("invalid budget or duplicate chunk")
    if any(c.tokens <= 0 or not math.isfinite(c.utility) for c in chunks):
        raise ValueError("invalid chunk")
    pinned = [c for c in chunks if c.mandatory]
    left = budget - sum(c.tokens for c in pinned)
    if left < 0:
        raise ValueError("mandatory evidence exceeds budget")
    result = pinned[:]
    # A transparent greedy heuristic; not an optimal dependency-aware solver.
    for c in sorted((c for c in chunks if not c.mandatory),
                    key=lambda c: (-c.utility / c.tokens, c.id)):
        if c.tokens <= left:
            result.append(c)
            left -= c.tokens
    return result


def validate_answer(answer):
    if not isinstance(answer, dict) or set(answer) != {"choice", "probabilities"}:
        raise ValueError("invalid answer schema")
    p = answer["probabilities"]
    if not isinstance(p, dict) or set(p) != {"local", "frontier", "review"}:
        raise ValueError("unknown candidates")
    if any(type(x) not in (int, float) or not math.isfinite(x) or not 0 <= x <= 1
           for x in p.values()) or not math.isclose(sum(p.values()), 1.0, abs_tol=1e-8):
        raise ValueError("invalid probabilities")
    if answer["choice"] not in p or p[answer["choice"]] != max(p.values()):
        raise ValueError("choice does not match maximum")
    return p


def choose_route(answer, action, policy):
    # These are typed fixture actions. No shell-string safety claims.
    if action not in policy["allowed_actions"]:
        return "deny"
    try:
        p = validate_answer(answer)
    except ValueError:
        return "review"
    target = answer["choice"]
    if target not in policy["eligible_routes"] or p[target] < policy["threshold"]:
        return "review"
    return target


def record(db, state, action, policy, answer):
    # Identity includes all decision inputs, not just an action name.
    payload = json.dumps([state, action, policy, answer], sort_keys=True,
                         separators=(",", ":"), allow_nan=False)
    key = sha256(payload.encode()).hexdigest()
    existing = db.execute("SELECT result FROM events WHERE id=?", (key,)).fetchone()
    if existing:
        return existing[0], True
    result = choose_route(answer, action, policy)
    with db:
        db.execute("INSERT INTO events VALUES (?, ?, ?)", (key, payload, result))
    return result, False


def run():
    policy = {"version": "policy-1", "allowed_actions": ["inspect", "propose_patch"],
              "eligible_routes": ["local", "frontier", "review"], "threshold": 0.9}
    chunks = [Chunk("policy", "r1", "Keep retry cap; do not deploy.", 40, 1, True),
              Chunk("assertion", "r1", "Expected at most three attempts.", 60, 1, True),
              Chunk("implementation", "r1", "Current retry loop.", 120, 0.96),
              Chunk("old_chat", "r0", "Superseded discussion.", 400, 0.1)]
    chosen = select(chunks, 240)
    assert [x.id for x in chosen] == ["policy", "assertion", "implementation"]
    try:
        select(chunks, 99)
    except ValueError:
        pass
    else:
        raise AssertionError("must reject missing mandatory evidence")
    state = {"task": "retry-incident", "revision": "r1", "question_version": "q1",
             "chunks": [c.__dict__ for c in chosen]}
    good = {"choice": "local", "probabilities": {"local": 0.94, "frontier": 0.04, "review": 0.02}}
    low = {"choice": "local", "probabilities": {"local": 0.55, "frontier": 0.4, "review": 0.05}}
    malformed = {"choice": "delete_production", "probabilities": {"other": 1.0}}
    # In-memory SQLite tests replay logic without leaving personal data behind.
    with sqlite3.connect(":memory:") as db:
        db.execute("CREATE TABLE events (id TEXT PRIMARY KEY, payload TEXT, result TEXT)")
        assert record(db, state, "inspect", policy, good) == ("local", False)
        assert record(db, state, "inspect", policy, good) == ("local", True)
        assert record(db, state, "inspect", policy, low)[0] == "review"
        assert record(db, state, "inspect", policy, malformed)[0] == "review"
        assert record(db, state, "deploy", policy, good)[0] == "deny"
        changed = dict(state, revision="r2")
        assert record(db, changed, "inspect", policy, good) == ("local", False)
        count = db.execute("SELECT COUNT(*) FROM events").fetchone()[0]
        assert count == 5
    n, p = 3, 0.8
    confidence = (p - 1/n) / (1 - 1/n)
    speedup = 1 / (0.8 + 0.2/200)
    assert math.isclose(confidence, 0.7)
    # Synthetic binary forecasts; Brier is not measured on Jev.
    forecasts, outcomes = [0.9, 0.8, 0.4, 0.1], [1, 0, 1, 0]
    brier = sum((p-y)**2 for p, y in zip(forecasts, outcomes)) / len(outcomes)
    print(json.dumps({"mode": "offline_fixture_not_jev", "network_calls": 0,
                      "selected_chunks": [x.id for x in chosen], "audit_rows": count,
                      "choice_confidence": round(confidence, 6),
                      "synthetic_task_speedup": round(speedup, 6),
                      "synthetic_brier": round(brier, 6),
                      "replay_schema_policy_revision_checks": "passed"}, indent=2))

if __name__ == "__main__":
    run()

Salida esperada

{
  "mode": "offline_fixture_not_jev",
  "network_calls": 0,
  "selected_chunks": [
    "policy",
    "assertion",
    "implementation"
  ],
  "audit_rows": 5,
  "choice_confidence": 0.7,
  "synthetic_task_speedup": 1.248439,
  "synthetic_brier": 0.255,
  "replay_schema_policy_revision_checks": "passed"
}

Contrato opcional, no ejecutado

JSON ilustrativo para POST https://api.typesafe.ai/v1/systemone, no enviado. Siga autenticación oficial con credenciales privadas del servidor, nunca del sitio estático. Registre la versión resuelta por jev-latest y dependencias bloqueadas si usa SDK. No se verificó una llamada real.

{
  "model": "jev-latest",
  "state": {
    "goal": "Identify evidence for a retry amplification incident",
    "revision": "example-r1",
    "evidence": "Fixture: retry loop restarts its attempt counter after a timeout; required cap is three attempts."
  },
  "questions": {
    "subsystem": {
      "type": "choice",
      "instructions": "Which subsystem is directly implicated by the supplied evidence?",
      "criteria": {
        "retry_control": "Attempt counting, stopping and retry budget",
        "rendering": "Displaying a user interface",
        "unknown": "The supplied evidence does not identify a subsystem"
      }
    }
  }
}

Preguntas originales, no entrevistas reales de empresas

1. ¿Por qué 200× por decisión no es 200× por tarea?

Pista: camino crítico restante. Respuesta: ,2 da 1,248×; incluya CI, routing y reintentos.

2. ¿Confianza 0,99 autoriza desplegar?

Pista: creencia frente a autoridad. Respuesta: no; alcance, destino, aprobación y digest actual siguen siendo obligatorios.

3. ¿Cuándo cuesta más una ruta barata?

Pista: ambos traspasos. Respuesta: recarga, revisión, caché perdida y fallos pueden superar el ahorro; mida coste por solución aceptada.

4. ¿Cómo distinguir calibración útil de evitar todo trabajo?

Pista: riesgo y cobertura. Respuesta: errores automáticos, cobertura y coste humano juntos, con datos reservados y casos raros graves.

Puntuación: 1—términos; 2—separación modelo/harness; 3—código, coste y confianza; 4—versiones, fallos y permisos; 5—comparación justa por tarea y límites defendibles.

Continuar aprendiendo

Fundamentos explicados

Repasa el razonamiento que sostiene el método y utiliza las comprobaciones para detectar lagunas.

Un agente es un bucle con estado: observar, proponer, autorizar, ejecutar e inspeccionar. Un esquema valida argumentos, no permisos ni efectos reales. El texto del modelo es una propuesta, no evidencia de ejecución. Distingue intento, respuesta exitosa y resultado verificado.

Razona antes de abrir la solución

Una herramienta de pago agota el tiempo tras recibir la solicitud. ¿Se debe reintentar inmediatamente?

Solución paso a paso

No: el resultado es desconocido y el pago pudo completarse antes de perder la respuesta. Usa una clave de idempotencia y consulta de estado, o pausa para conciliar. Reintentar a ciegas puede duplicar un efecto irreversible; limitar pasos no corrige ese error.

Conexión con la práctica

Los asistentes con herramientas necesitan estado, autorización y condiciones de parada gestionados por la aplicación. Registra hechos, incertidumbres y confirmaciones pendientes. La autonomía necesita resultados verificables y permisos acotados.

Cómo demostrar comprensión

Traza éxito, rechazo, timeout y respuestas malformadas. Verifica que lo denegado nunca se ejecute y que los reintentos sean idempotentes. Limita pasos, tiempo y gasto por separado; empieza con herramientas simuladas.

Ejemplo Python completo

Python 3.10+ · solo biblioteca estándar · determinista, sin semilla aleatoria · sin red. Guarda el archivo y ejecuta el comando. Son comprobaciones didácticas, no benchmarks.

Descargar Python · agent.py
python3 agent.py
# Python 3.10+; standard library; deterministic; no network.
# In-memory mock only: no real payment or network call.
ledger = {}
def pay(key, amount):
    if key in ledger:
        if ledger[key] != amount:
            raise ValueError("same key with different request")
        return "already applied"
    ledger[key] = amount
    return "applied"

assert pay("order-1", 10) == "applied"
# Pretend the reply was lost. Reconcile and retry with the same key.
assert ledger.get("order-1") == 10
assert pay("order-1", 10) == "already applied"
assert len(ledger) == 1
try:
    pay("order-1", 20)
    raise AssertionError("conflicting retry accepted")
except ValueError:
    pass
print("one effect; duplicate retry suppressed")

Salida esperada

one effect; duplicate retry suppressed

Repasar el fundamento →

Fundamento revisado:

Referencias y tutoriales adicionales

  1. TypeSafe — Introductionhttps://docs.typesafe.ai/introduction
  2. Jev Engineering for Coding Agents — PDF · 2026-09https://jevforagents.com/media/Jev-Engineering-for-Coding-Agents.pdf
  3. InstructGPT — arXiv:2203.02155v1 · 2022-03-04https://arxiv.org/abs/2203.02155v1
  4. TypeSafe — Introducing System One Models & Jev · 2026-09-15https://typesafe.ai/blog/introducing-system-one-models-and-jev
  5. TypeSafe — AI primer / RLCDhttps://docs.typesafe.ai/introduction/machine-learning-primer
  6. TypeSafe — Choicehttps://docs.typesafe.ai/primitives/choice
  7. TypeSafe — Scorehttps://docs.typesafe.ai/primitives/score
  8. TypeSafe — Noulhttps://docs.typesafe.ai/primitives/noul
  9. TypeSafe — Confidencehttps://docs.typesafe.ai/confidence
  10. FastContext — arXiv HTML v1https://arxiv.org/html/2606.14066v1
  11. TypeSafe — API / Quick starthttps://docs.typesafe.ai/introduction/quickstart
  12. TypeSafe — Agent skillshttps://github.com/typesafe-ai/skills
  13. TypeSafe — Workflow evaluationshttps://evals.typesafe.ai/
  14. InstructGPT — PDF v1https://arxiv.org/pdf/2203.02155v1
  15. FastContext — abstract / version historyhttps://arxiv.org/abs/2606.14066v1
  16. FastContext — PDF v1https://arxiv.org/pdf/2606.14066v1
Fuentes y versiones

Vídeos con propósito

Ver → explicar → implementar → comprobar

Recursos externos en inglés. YouTube gestiona subtítulos y disponibilidad. El reproductor solo contacta con YouTube al pulsar Reproducir; no envía entradas de los experimentos.

Un caso completo

Un agente de reservas debe completar una sola tarea autorizada

Escenario didáctico sintético y datos calculados a mano, no un benchmark de producción. Las lecciones relacionadas comparten el caso para estudiar el mismo sistema desde varios ángulos.

Caso actualizado:

Un empleado solicita un hotel reembolsable dentro de presupuesto. Buscar es reversible; reservar gasta dinero. El agente propone, pero un servicio fiable impone identidad, límites y aprobación exacta. El éxito es una reserva verificada, no un mensaje convincente.

100+ 10= 110100
Reintentos sintéticos:100 tareas más10 reintentos producen110 solicitudes; deduplicar mantiene100 efectos.

1. Convertir la solicitud en estados acotados

Modela búsqueda, propuesta, aprobación, ejecución y verificación. Explicita fechas, moneda, reembolso y límite; pregunta lo que falte. “Ignora el presupuesto” dentro de una web es contenido no fiable. Cada transición requiere un estado previo permitido y un motivo registrado.

2. Aprobar la acción exacta

Vincula aprobación a hotel, fechas, precio y condiciones. Revisa disponibilidad y precio antes de ejecutar; un cambio invalida la aprobación. Usa credenciales limitadas. El modelo no crea su propia autoridad ni convierte un “bien” genérico en permiso para otra compra.

3. Recuperar resultados inciertos

Un timeout tras ejecutar no demuestra fallo. Consulta al proveedor con una clave estable antes de reintentar. En 100 tareas, 10 reservas se completan pero responden tarde: reintentar ciegamente genera110 efectos; la idempotencia mantiene100. Hace falta soporte del proveedor o conciliación.

4. Verificar y aprender sin ampliar permisos

Devuelve confirmación, condiciones aprobadas y excepciones pendientes. Traza herramientas y motivos de recuperación. Limita pasos y tiempo. Mejora búsqueda o planificación sin quitar controles independientes: un planificador mejor no es automáticamente un ejecutor seguro.

Evidencia y decisiones

Medida / condiciónBaseComparaciónInterpretación
Efectos de negocio100 + 10 = 110100Se evitan duplicados bajo la hipótesis de idempotencia indicada.
Duplicados por tarea original10/100 = 10%0/100 = 0%Es un ejemplo, no una garantía medida.
Solicitudes con reintentos100 + 10 = 110100 + 10 = 110La idempotencia controla efectos, no peticiones.

Pruebas de aceptación y fallo

Inyecta timeout tras éxito, repite la clave, modifica el precio aprobado, revoca credenciales y agota pasos. Exige una reserva, rechazo de cambios y estado pendiente acotado si no puede verificarse.

Python 3.10+ · topic-cases.py ↓

python3 topic-cases.py

Límites del ejemplo

El ejemplo omite concurrencia, caídas y estados externos inconsistentes. Producción necesita deduplicación atómica, conciliación y compensaciones; cancelar puede costar y no es rollback universal.

Tu siguiente paso

Prueba argumentos inválidos, permisos caducados y reintentos duplicados; revisa el estado final.

Implementar y verificar → · Continuar la ruta →
Guía de estudio y esquema de la lecciónOBJETIVOS DE APRENDIZAJE

Comprender → implementar → investigar

Traza éxito, rechazo, timeout y respuestas malformadas. Verifica que lo denegado nunca se ejecute y que los reintentos sean idempotentes. Limita pasos, tiempo y gasto por separado; empieza con herramientas simuladas.

Predecir, comprobar y conservar evidencia

Antes de revelar la respuesta, predice un resultado. Después registra diferencias y una prueba de transferencia. Se guarda localmente y se comparte entre idiomas.

Abrir cuaderno / exportar / borrar →

El alcance de revisión matemática se registra por lección. No certifica reproducción empírica del artículo; anota posibles errores. Alcance de revisión