Skip to content

Toma de decisiones del Agent: elegir habilidades y convertir a llamadas a funciones ​

💡 Resumen en una frase: usa Jev para gestionar la toma de decisiones del Agent — un Choice clasifica 194 habilidades, dos compuertas deciden si hablar o no, y las solicitudes en lenguaje natural se convierten en llamadas a funciones tipadas con parámetros siempre válidos.

Qué habilidad debe cargar el agent, qué función debe llamar: si le tiras ese tipo de preguntas a un LLM, obtienes un texto que hay que volver a analizar; si se lo das a Jev, obtienes una respuesta tipada + probabilidades, y el poder de decisión queda en tu código.

Los oficiales desglosaron esta receta de decisiones del Agent con Jev en dos cookbooks: Skill suggestion filtra habilidades para un agent con 194 habilidades montadas, y Function calling convierte solicitudes de transacción en lenguaje natural en llamadas a funciones tipadas normales. Ambos comparten la misma filosofía: Jev hace los juicios, el código toma las decisiones.

text
Solicitud del usuario en este turno
        │
        ▼  Solicitud TypeSafe 1 (ranking + compuertas, el mismo state evaluado en paralelo)
┌──────────────────────────────────────────────┐
│ Un Choice: ¿cuál de 194 habilidades elegir?               │
│   → las probabilities son el ranking, el código toma los tres primeros        │
│ Tres Noul: ¿hay que actuar? (tres formas distintas de preguntar)          │
│ Un Noul: ¿se mencionó una herramienta / plantilla / método concreto?   │
└──────────────────────────────────────────────┘
        │
        ▼  Código: ¿gate ≥ 0.30 o named ≥ 0.50?
   No ──┤── Sugerir no cargar nada (y enviar una frase de «no hay habilidades relevantes»)
        │ Sí
        ▼  Solicitud TypeSafe 2 (solo mira los tres primeros, con descripción completa + inicio de SKILL.md)
┌──────────────────────────────────────────────┐
│ Un Choice: ¿cuál de los tres es realmente?               │
│ Tres Noul: ¿esta habilidad realmente hace esto? (cada uno responde por su cuenta) │
└──────────────────────────────────────────────┘
        │
        ▼  Código: ¿el mejor fits ≥ 0.30?
   No ──┤── Sugerir no cargar nada
        │ Sí
        ▼
El bloque <skill_relevance> se añade después del roster → el agent conserva su propio juicio

¿Por qué poner otro juicio delante del juicio del agent? Los oficiales van directo al grano: un agent con un catálogo grande de habilidades elige casi sin información — el catálogo llega como índice, una habilidad por línea, con descripciones truncadas para no desplazar la conversación; truncadas a 60 caracteres, la habilidad de Office para editar .pptx y la habilidad financiera para crear decks se leen ambas como «herramienta de PowerPoint». En turnos donde no existe ninguna habilidad adecuada, puede igualmente cargar una a la fuerza, porque una lista de nombres por sí sola invita a adivinar.

Esta lección dura unos 20 minutos. Todos los números de pruebas de la página provienen de datos grabados de los cookbooks oficiales: la sugerencia de habilidades usa jev-1.14.0 (agent bajo prueba claude-haiku-4-5-20251001, renderizado 2026-10-30), la llamada a funciones usa jev-1.12; los archivos de grabación se publican con el repositorio oficial, se pueden reproducir y verificar sin ninguna key.

Qué podrás hacer al terminar ​

  • Añadir a un agent con habilidades un filtro de «qué habilidad cargar»: dos solicitudes (primero un Choice clasifica 194 habilidades, luego revisa los tres primeros); en pruebas oficiales, carga errónea 15.7% → 7.9%, carga inútil 14.0% → 5.2%
  • Escribir suggest(): devuelve como máximo un nombre de habilidad, se envuelve con suggestion_block() en un bloque <skill_relevance> que se añade al system prompt — el agent conserva el índice completo y su propio juicio, la sugerencia solo dice «mira primero cuál»
  • Convertir solicitudes en lenguaje natural en llamadas a funciones tipadas: closed_sets lee las firmas de las funciones, Literal → Choice, list[Literal[...]] → un Noul por miembro, bool → Noul, 54 preguntas en una sola solicitud; lo que entra a la función siempre son valores válidos según la firma
  • Entender dos usos de la confianza: el confidence de una llamada a funciones = el juicio con menos certeza de toda la llamada (un parámetro erróneo arruina todo); al elegir habilidades, si solo importa «elegir el mejor», basta tomar la opción de mayor probabilidad, sin necesidad de poner umbrales de confidence por todas partes

Por qué usar Jev y no dejar que el agent elija solo? ​

CapacidadEl LLM elige solo del índice / genera JSONJev Decisión estructurada
¿Distingue entre «la que crea decks» y «la que modifica decks»?❌ Descripciones del índice truncadas a 60 caracteres, ambas habilidades .pptx se leen como herramientas de PowerPoint; en pruebas oficiales, 15.7% de cargas erróneas✅ La solicitud de revisión lleva descripción completa + los primeros 700 caracteres de SKILL.md; las solicitudes de deck pasan de pptx-author a microsoft-office
¿Se atreve a callar cuando no hay habilidad adecuada?❌ Una lista de nombres invita a adivinar; en pruebas oficiales, 14.0% de cargas a la fuerza✅ Cuatro Noul guardan la puerta; si en la revisión nadie califica, se sugiere «no cargar nada» (5.2%)
¿Son válidos los parámetros de la función?❌ El LLM genera JSON y luego se analiza; los valores de los campos pueden inventarse y el código de análisis crece sin parar✅ Los parámetros de conjuntos cerrados se mapean a Choice / Noul; palabras oficiales: lo que entra a la función siempre son valores que la función acepta
Cuánta certeza se necesita para ejecutar❌ La confianza que un LLM reporta de sí mismo es texto, y hay que analizarla una vez más✅ Entrenamiento de calibración RLCD (lo marcado con 0.2 ocurre en aproximadamente el 20% de las carreras largas), confidence = el juicio más débil, y si está por debajo del umbral se pasa a confirmación
Cambiar la política de decisión❌ Cambiar el prompt y reejecutar todo; a la hora de revisar, no hay forma de buscar✅ Dos umbrales + la redacción de las preguntas centralizados en constantes de código; la recomendación oficial es ponerlos en un solo archivo para facilitar la revisión humana

Tu dilema actual ​

  • «El agent tiene 194 habilidades montadas, y cada descripción del índice solo tiene 60 caracteres—le pides que modifique un deck existente y carga la habilidad de crear un deck nuevo; en turnos donde no hay ninguna habilidad adecuada, igual carga una a la fuerza»
  • «Las llamadas a funciones dependen de que el LLM genere JSON y luego se analice; los valores de los parámetros a veces se inventan, los nombres de los campos no coinciden, y el código de análisis se vuelve cada vez más grueso»
  • «Quieres que el modelo mismo decida “qué hacer después”, la respuesta es un fragmento de texto, y los umbrales, reintentos y respaldos están todos dispersos en el prompt; a la hora de revisar, no hay forma de buscar»

Cuándo usar esta técnica ​

Cuando necesitas:

  • que el catálogo de habilidades / herramientas del agent sea tan grande que las descripciones se truncan, y las cargas erróneas e inútiles empiecen a comerse la fiabilidad
  • convertir las solicitudes en lenguaje natural del usuario en llamadas a funciones tipadas existentes, con parámetros que provienen de una lista fija
  • que el umbral de «debería hacerlo o no» esté claramente en el código, para cambiar la política sin reescribir el prompt

Y no quieres:

  • meter el catálogo completo en el system prompt—palabra oficial: eso degrada la selección de habilidades y provoca context rot en el resto de la conversación
  • pagar cada turno una llamada completa de generación LLM como árbitro
  • analizar el JSON que escupe el LLM

🎒 Preparativos antes de empezar ​

  • Haber completado Choice, pregunta de selección: saber qué son el map de opciones criteria y probabilities—la primera solicitud de esta página es precisamente un Choice de 194 opciones (límite 255)
  • Haber completado Preguntas paralelas y fan-out especulativo: saber que «el código debe tener la respuesta anterior para poder construir la siguiente solicitud» es lo que cuenta como dependencia real—las dos solicitudes de esta página son precisamente uno de los tres casos oficiales de solicitudes verdaderamente dependientes
  • Haber corrido con éxitoInstalación y primera solicitud: .venv contiene typesafe-sdk, y TYPESAFE_API_KEY está en las variables de entorno
  • (Opcional, reproducción sin ninguna key) Descargar los datos oficiales: del repositorio typesafe-public-examples, en el directorio cookbooks/skill_suggestion los archivos hermes_roster.json, requests.json, json_cache.json, y en el directorio cookbooks/function_calling los archivos trader.py, dispatch.py, spec.json, json_cache.json—corre tal cual el código oficial, sin necesitar ni una key
  • Solo necesitas ANTHROPIC_API_KEY si quieres correr la prueba real completa de sugerencia de habilidades (paso 4): el agent bajo prueba es un modelo de Anthropic; si solo haces los pasos 2 y 3 de suggest(), con TYPESAFE_API_KEY basta
  • Saber de dónde salen los números de esta página: la grabación de sugerencia de habilidades usó jev-1.14.0 (renderizado 2026-10-30), la grabación de llamadas a funciones usó jev-1.12; si corres en vivo ahora usarás jev-latest (actualmente apunta a jev-1.14.0), y las probabilidades tendrán diferencias—ajusta los umbrales contra la versión que fijes

Hazlo conmigo ​

Paso 1: conocer el catálogo de habilidades y la línea base del agent desnudo (el modo de fallo del índice de 60 caracteres) ​

Por qué: primero el equipo oficial pone sobre la mesa el modo de fallo de «el agent elige solo»: las 194 habilidades de Hermes entran al system prompt en forma de índice, una habilidad por línea, con descripciones truncadas a 60 caracteres.

Primero trae los datos de los dos cookbooks al directorio de trabajo (las dependencias se instalan en dos líneas: las líneas pip oficiales de ambos originalmente no incluían typesafe-sdk, aquí se añade):

bash
mkdir agent-decisions && cd agent-decisions
base=https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks
curl -sLO $base/skill_suggestion/hermes_roster.json
curl -sLO $base/skill_suggestion/requests.json
curl -sLO $base/skill_suggestion/json_cache.json
curl -sLO $base/function_calling/trader.py
curl -sLO $base/function_calling/dispatch.py
curl -sLO $base/function_calling/spec.json
curl -sLO $base/function_calling/json_cache.json
pip install typesafe-sdk anthropic matplotlib ipython polars numpy 'cooksafe>=0.2.0,<0.3.0'

hermes_roster.json son las 194 habilidades de NousResearch/hermes-agent en un commit fijado: cada registro tiene name, category, la descripción truncada tal como aparece en el índice, la descripción completa, y el inicio del SKILL.md. Cárgalo y mira la salida de estadísticas oficial (extracto de la sección del paso 1 oficial):

python
import json
from collections import defaultdict
from pathlib import Path

ROSTER = json.loads(Path("hermes_roster.json").read_text(encoding="utf-8"))
BY_NAME = {skill["name"]: skill for skill in ROSTER}

def render_index() -> str:
    """The body of <available_skills>: skills grouped by category, both sorted by name."""
    by_category = defaultdict(list)
    for skill in ROSTER:
        by_category[skill["category"]].append(skill)
    lines = []
    for category in sorted(by_category):
        skills = sorted(by_category[category], key=lambda s: s["name"])
        if len(skills) == 1:  # a one-skill category is a single top-level row
            lines.append(f"  - {skills[0]['name']}: {skills[0]['description']}")
            continue
        lines.append(f"  {category}:")
        lines.extend(f"    - {skill['name']}: {skill['description']}" for skill in skills)
    return "\n".join(lines)

widths = [len(skill["description"]) for skill in ROSTER]
print(f"{len(ROSTER)} skills in {len({s['category'] for s in ROSTER})} categories")
print(f"index description: {sum(widths) / len(widths):.0f} characters on average, "
      f"{max(widths)} at most")

Deberías ver (publicación oficial):

text
194 skills in 32 categories
index description: 55 characters on average, 60 at most

requests.json son 452 solicitudes de un solo turno: 280 están cubiertas exactamente por una habilidad (145 habilidades distintas), 172 no las cubre ninguna habilidad. Las solicitudes cubiertas fueron escritas por Claude Sonnet 5 a partir del SKILL.md de cada habilidad; las 172 no cubiertas están todas escritas para «castigar las adivinanzas»—84 solicitudes cotidianas, 42 preguntas técnicas sin habilidad que las atienda (explain what a monad is), 46 que piden algo que no está en el catálogo (post this to Mastodon cuando el catálogo solo cubre X).

Línea base del agent desnudo (las 452 solicitudes corridas una por una, el modelo bajo prueba fijado a claude-haiku-4-5-20251001):

text
wrong loads    15.7%   (280 covered requests)
needless loads 14.0%   (172 uncovered requests)

of 26 wrong first picks, 11 came from the right skill's own category

Ambas métricas son tasas de error, cuanto más bajas mejor: wrong load es, en las solicitudes cubiertas, que la primera llamada a skill_view no sea a la habilidad que cubre (también cuenta no cargar nada); needless load es, en las solicitudes no cubiertas, haber llamado a skill_view. De los 26 errores de carga, 11 caen en la propia categoría de la habilidad correcta—el agent mira más o menos en el lugar correcto; lo difícil es separar varias que se parecen entre sí.

💡 Así se ve «preguntar en la capa equivocada»

El SKILL.md oficial de Agent Skill lo dice sin rodeos: preguntas que hacen que Jev decida directamente («¿debería escalarse este ticket?», «¿qué debería hacer el agent ahora?») suelen indicar que la pregunta se hizo en la capa equivocada—descompón la decisión en los juicios de los que depende, y escribe la decisión misma en el código, visible y comprobable. La filosofía completa está en Desarrollar en conjunto con Claude Code; esta página la sigue de principio a fin: Jev ordena y filtra, el código retiene los umbrales y la decisión de «decirlo o no».

  • Puedo explicar qué mide cada una de las dos tasas de error de la línea base, y qué significa que de los 26 errores de carga, 11 provengan de la propia categoría de la habilidad correcta

Paso 2: la primera solicitud—un Choice que ordena 194 habilidades, y cuatro Noul de porteros ​

Por qué: el ranking y el juicio de «este turno, ¿hace falta una habilidad?» comparten el mismo state, así que el equipo oficial los mete en una sola solicitud—las probabilities del Choice son el ranking, y los cuatro Noul se encargan de la compuerta.

Un Choice con 194 opciones cabe de sobra (límite 255); el equipo oficial además dejó dicho: si creciera varias veces más, se ordenaría por bloques y se reordenaría a los ganadores de cada bloque. El criteria de las opciones usa la misma descripción del índice que ve el propio agent (el mismo texto); el instructions original de la pregunta es el siguiente:

python
CHOICE_INSTRUCTIONS = (
    "Which of these skills, if any, is the right one to load to help with the "
    "user's latest request?"
)

La compuerta son cuatro Noul: tres preguntan desde ángulos distintos «este turno, ¿hay que actuar?», más uno que pregunta «¿se nombró un método concreto?»—un turno necesita una habilidad por solo dos razones: o hay que actuar sobre los archivos / cuentas / dispositivos del usuario, o se nombró un método que una habilidad posee (plantilla de meme, prompt de Suno).

python
GATE_QUESTIONS = {
    "acts_on_user_system": (
        "Is the assistant being asked to act on the user's files, accounts, devices, "
        "or online services, rather than only to explain or advise?"
    ),
    "would_follow_documented_procedure": (
        "Would a careful expert answering this consult a specific documented procedure "
        "or set of commands, rather than answering from general understanding?"
    ),
    "prose_suffices": (
        "Could a knowledgeable generalist fully satisfy this request in prose, with "
        "no tools, no documentation, and no access to the user's files or accounts?"
    ),
}
INVERTED = {"prose_suffices"}  # a yes here points away from needing a skill
NAMED_QUESTION = (
    "Does the request ask for a specific named tool, format, template, or method to be "
    "used, rather than for general help?"
)

GATE_THRESHOLD = 0.30   # mean of the three action nouls; at or above it, a skill is wanted
NAMED_THRESHOLD = 0.50   # the "names a method" noul; at or above it, a skill is wanted too

def build_state(request: str) -> dict:
    return {"request": request, "recent_context": ""}

@json_cache
def rank_wide(request: str) -> dict:
    """Request 1: rank all 194 skills, and score the request for whether a skill applies."""
    questions = {
        "which": Choice(
            instructions=CHOICE_INSTRUCTIONS,
            criteria={skill["name"]: skill["description"] for skill in ROSTER},
        )
    }
    for key, text in GATE_QUESTIONS.items():
        questions[f"gate::{key}"] = Noul(instructions=text)
    questions["named"] = Noul(instructions=NAMED_QUESTION)
    response = client.system_one(
        state=build_state(request), questions=questions, model=TYPESAFE_MODEL
    )
    ranked = sorted(
        response.answers["which"].probabilities.items(), key=lambda kv: -kv[1]
    )
    values = {
        key.removeprefix("gate::"): answer.noul
        for key, answer in response.answers.items()
        if key.startswith("gate::")
    }
    oriented = [(1.0 - v) if k in INVERTED else v for k, v in values.items()]
    return {
        "ranked": ranked[:12],
        "gate": sum(oriented) / len(oriented),
        "named": response.answers["named"].noul,
    }

def needs_skill(wide: dict) -> bool:
    """Either reason is enough: an action is wanted, or a named method is asked for."""
    return wide["gate"] >= GATE_THRESHOLD or wide["named"] >= NAMED_THRESHOLD

Hay tres puntos de diseño que conviene vigilar:

  • Las preguntas de acción preguntan «¿hay que actuar?», no «¿de qué tema se trata?». Las preguntas por tema no separan explain what a monad is de las solicitudes que sí necesitan habilidad—ambas son software.
  • prose_suffices es una pregunta inversa: que responda yes indica precisamente que no se necesita ninguna habilidad, así que se toma 1.0 - v antes de entrar en el promedio.
  • named no entra en el promedio y abre su propia puerta. Palabra oficial: las respuestas de las tres preguntas de acción la dejarían fuera por votación (outvote); en los turnos donde se menciona un método por nombre pero no se actúa (hacer un meme), solo ella puede rescatarlo.

needs_skill son las dos entradas de la tabla de verdad: media de la compuerta de acción ≥ 0.30 o mención por nombre ≥ 0.50; solo si alguna supera la línea se continúa; si ambas son bajas se recomienda no cargar nada.

Ejecutamos las cuatro solicitudes DEMO oficiales (la salida son los valores publicados oficialmente):

text
"Can you save this recipe as a new note in my 'Recipes' folder in Notes.app so "
  action 0.83, names a method 0.88 -> suggest   (0.14s)
    0.990  apple-notes                           Manage Apple Notes via memo CLI: create, search, edit.
    0.010  computer-use                          Drive the desktop background-first; escalate on signal.
    0.000  apple-reminders                       Apple Reminders via remindctl: add, list, complete.

"I've got a client pitch deck as a .pptx template - I need to duplicate slide 4"
  action 0.73, names a method 0.64 -> suggest   (0.25s)
    0.730  pptx-author                           Build PowerPoint decks headless with python-pptx.
    0.270  microsoft-office                      Create, read, and edit Word, PowerPoint, and Excel files.
    0.000  apple-notes                           Manage Apple Notes via memo CLI: create, search, edit.

"Post this announcement to my Mastodon account."
  action 0.86, names a method 0.61 -> suggest   (0.1s)
    0.280  xurl                                  X/Twitter via xurl CLI: raw post search, posting, DM, media.
    0.240  social-media-content-calendar         Plan multi-platform social campaigns: briefs to posting.
    0.190  computer-use                          Drive the desktop background-first; escalate on signal.

"Can you make me a Gru's Plan meme about a developer's plan to refactor the cod"
  action 0.12, names a method 0.87 -> suggest   (0.12s)
    1.000  meme-generation                       Create meme PNGs from templates with Pillow text overlay.
    0.000  apple-notes                           Manage Apple Notes via memo CLI: create, search, edit.
    0.000  apple-reminders                       Apple Reminders via remindctl: add, list, complete.

Cada una de las cuatro ilustra algo: la solicitud de Notes no tiene ambigüedad, el primero de la lista es el correcto; en la solicitud de deck, dos habilidades de .pptx van adelante, pero con la descripción de 60 caracteres, la de crear decks pptx-author aparece primero — para una solicitud que pide modificar un deck existente, esto es justo la señal de un error; en la solicitud de Mastodon la compuerta de acción 0.86 la deja pasar igualmente (publicar es una acción), pero la primera de la lista, xurl, es una habilidad para publicar en X — el ranking no puede rescatar algo que no está en el catálogo; en la solicitud de meme la compuerta de acción 0.12 es muy baja, todo depende de que named 0.87 abra la puerta, y la primera de la lista es precisamente la habilidad de memes.

💡 Este es el valor único de Jev

El ranking (una pregunta Choice) y la compuerta (cuatro preguntas Noul) se evalúan en paralelo y de forma independiente sobre el mismo state dentro de la misma solicitud — añadir preguntas casi no aumenta el tiempo de respuesta, solo cuesta los tokens de unas pocas preguntas más. En la grabación oficial, la primera solicitud tardó 0.1–0.25 segundos. Frente a «poner un juez LLM en cada turno»: eso exige pagar una llamada de generación completa para el ranking y otra para el control, además de analizar el texto que escupe el juez. El mecanismo de varias preguntas en una sola solicitud se describe en preguntas en paralelo y fan-out especulativo.

💡 Atención con contenido en chino

La nota oficial: el inglés es el idioma principal de entrenamiento de Jev; otros idiomas, incluido el chino, funcionan pero con menor precisión. Para las preguntas de arriba se recomienda conservar el texto original en inglés (la redacción oficial fue validada empíricamente); para hacer sugerencias de habilidades con solicitudes en chino, primero ejecuta un lote con tus propios datos y fija los umbrales observando las distribuciones de probabilidad.

Deberías ver: las compuertas / rankings de las cuatro DEMO coinciden con la tabla anterior (idénticos bit a bit en la reproducción en caché; en ejecución live las probabilidades variarán, la tendencia se rige por la versión que hayas fijado).

Paso 3: segunda solicitud — revisión de los tres primeros, permitiendo que todos queden descartados ​

Por qué: este es uno de los tres casos oficiales de «verdaderas segundas solicitudes»: el código debe obtener el ranking de la primera para poder construir las opciones de la segunda — cada uno de los tres primeros lleva su descripción completa y el inicio del SKILL.md.

El principio de preguntas en paralelo es «si se puede preguntar junto, se pregunta junto»; ¿por qué aquí precisamente se envía una segunda solicitud? Porque las opciones de la segunda dependen de la respuesta de la primera: cada candidato debe llevar description_full y los primeros 700 caracteres de body (el archivo roster guarda 1600 caracteres por entrada), y esos textos largos solo pueden ensamblarse en los criteria una vez que se sabe quiénes son los tres primeros. La documentación oficial de primitives menciona este cookbook como una verdadera segunda solicitud: una solicitud para clasificar todas las habilidades, y luego tomar el texto completo de los tres primeros y juzgar de nuevo con mejor evidencia.

python
SHORTLIST = 3       # candidates carried from the first request into the second
EXCERPT_CHARS = 700  # SKILL.md characters each candidate brings; the roster file stores 1600
FITS_THRESHOLD = 0.30  # a shortlist whose best "does this fit" noul is under this is dropped

RERANK_INSTRUCTIONS = (
    "Exactly one of these skills is the right one to load for the user's latest "
    "request. Which one? Read what each actually does, not just its name."
)

def rerank_questions(names, excerpt):
    questions = {
        "which": Choice(
            instructions=RERANK_INSTRUCTIONS,
            criteria={
                name: f"{BY_NAME[name]['description_full']} — {BY_NAME[name]['body'][:excerpt]}"
                for name in names
            },
        )
    }
    for name in names:
        questions[f"fits::{name}"] = Noul(
            instructions=(
                f"Does the skill '{name}' do the specific thing the user's request asks "
                f"for? It is described as: {BY_NAME[name]['description_full']}"
            )
        )
    return questions

@json_cache
def rerank(request, names, excerpt):
    """Request 2: the same Choice over a shortlist, plus one absolute noul per candidate."""
    response = client.system_one(
        state=build_state(request),
        questions=rerank_questions(names, excerpt),
        model=TYPESAFE_MODEL,
    )
    return {
        "winner": response.answers["which"].choice,
        "fits": {
            key.removeprefix("fits::"): answer.noul
            for key, answer in response.answers.items()
            if key.startswith("fits::")
        },
    }

fits Las tres preguntas Noul responden cada una por su cuenta y pueden salir todas bajas — ellas y which deciden cosas distintas: which determina «cuál de los tres», fits determina «si decir algo o no». Recorriendo las cuatro DEMO de principio a fin (valores publicados oficialmente):

text
"Can you save this recipe as a new note in my 'Recipes' folder in Notes.app so "
  was apple-notes -> apple-notes   (0.11s)
    fits 0.81  apple-notes
    fits 0.50  computer-use
    fits 0.02  apple-reminders

"I've got a client pitch deck as a .pptx template - I need to duplicate slide 4"
  was pptx-author -> microsoft-office   (0.11s)
    fits 0.77  pptx-author
    fits 0.76  microsoft-office
    fits 0.01  apple-notes

"Post this announcement to my Mastodon account."
  was xurl -> nothing fits   (0.07s)
    fits 0.10  xurl
    fits 0.27  social-media-content-calendar
    fits 0.28  computer-use

"Can you make me a Gru's Plan meme about a developer's plan to refactor the cod"
  was meme-generation -> meme-generation   (0.16s)
    fits 0.84  meme-generation
    fits 0.03  apple-notes
    fits 0.01  apple-reminders

.pptx La escena estelar se da en la segunda solicitud: al separar las dos habilidades, cada una con su texto completo, la solicitud de deck pasa de pptx-author a microsoft-office, que edita archivos existentes. Nótese que sus dos fits no son bajos (0.77 / 0.76 — ambos pueden hacer algo con el deck), pero esta pregunta no decide «cuál»; el vuelco lo logra la Choice.

La solicitud de Mastodon se detiene en la segunda: de las tres habilidades aproximadas, ninguna hace realmente esto, la mejor fits 0.28 queda por debajo de 0.30, y todo el grupo se descarta — esta solicitud pasó la compuerta en ambas rondas y aun así al final se recomienda no cargar nada; ese es el significado de «permitir que todos queden descartados».

Reunir las dos solicitudes y los dos umbrales en una sola función — toda la receta es solo esto:

python
def suggest(request: str) -> tuple[str, ...]:
    """At most one skill name for a request, or () for "nothing here applies"."""
    wide = rank_wide(request)
    if not needs_skill(wide):
        return ()
    shortlist = tuple(name for name, _ in wide["ranked"][:SHORTLIST])
    result = rerank(request, shortlist, EXCERPT_CHARS)
    if max(result["fits"].values()) < FITS_THRESHOLD:
        return ()
    return (result["winner"],)

def suggestion_block(names: tuple[str, ...]) -> str:
    """What gets appended after the roster, in the suggestion."""
    body = (
        f"Relevant to the current request: {', '.join(names)}. Ignore this if it does not "
        "fit what the user actually asked for."
        if names
        else "No skill in the roster appears relevant to this request."
    )
    return f"\n\n<skill_relevance>\n{body}\n</skill_relevance>"

print(suggestion_block(suggest(DEMO[1])))
print(suggestion_block(suggest(DEMO[2])))

Deberías ver:

text
<skill_relevance>
Relevant to the current request: microsoft-office. Ignore this if it does not fit what the user actually asked for.
</skill_relevance>

<skill_relevance>
No skill in the roster appears relevant to this request.
</skill_relevance>

El nombre del ganador solo entra en una línea del system prompt. El agente conserva el índice completo y su propio criterio; esa línea solo le dice «qué mirar primero». Ambos detalles de redacción salieron de pruebas empíricas (palabra oficial):

  • La sugerencia dice «puede ignorarse»: si se hace la sugerencia más coercitiva, la tasa de obediencia a sugerencias erróneas también sube — y una sugerencia equivocada es peor que ninguna.
  • Sin sugerencia también se envía una frase «no hay habilidades relevantes»: si no se envía nada, la instrucción del propio roster de «mejor cargar de más» se queda sin rival.

Fíjate además en la posición: el bloque de sugerencia se añade después del roster y no dentro de él — el texto del roster se mantiene idéntico turno a turno para que el prefix caching pueda aprovecharlo.

  • Puedo explicar qué hace cada una de las dos solicitudes y por qué deben enviarse dos veces (las opciones de la segunda las determina la respuesta de la primera)
  • La solicitud de Mastodon pasó la compuerta dos veces y al final se recomienda no cargar nada — puedo señalar qué pregunta la detuvo

Paso 4: rendición de cuentas — medición de tres brazos con 452 solicitudes ​

Por qué: la parte oficial ejecutó cada una de las 452 solicitudes tres veces; los tres brazos difieren en una sola cosa: qué más se metió en el system prompt además del roster.

qué se metió en el system prompt
agent alone (línea base)nada
agent with a suggestionsuggest() el bloque de sugerencia devuelto
agent given the answerel nombre de la habilidad correcta, o «nothing applies» si no hay habilidad de cobertura

El tercer brazo es el suelo: ningún sistema real conoce de antemano las habilidades de cobertura, así que traza el límite inferior para los dos primeros — ningún método de selección, por bueno que sea, puede superarlo.

text
run         wrong loads  needless loads
baseline          15.7%           14.0%
TypeSafe           7.9%            5.2%
oracle             3.2%            4.1%

baseline -> TypeSafe:  2.0x fewer wrong loads, 2.7x fewer needless ones

Resumen oficial: las cargas erróneas se reducen a menos de la mitad (15.7% → 7.9%), cerrando más de la mitad de la brecha entre «adivinar desde un índice truncado» y «recibir la respuesta directamente»; las cargas inútiles se reducen casi dos tercios (14.0% → 5.2%), cerrando casi por completo su parte de la brecha.

El costo también queda sobre la mesa: de 280 solicitudes de cobertura, la sugerencia arregló 29 y estropeó 7. En algunas solicitudes el agente ya estaba en lo correcto por sí mismo y una sugerencia errónea pero segura lo desvió — oficialmente, este es el costo de poner una sugerencia antes del turno.

Deberías ver: la tabla de tasas de error de tres filas y dos columnas coincide con lo anterior (idéntica bit a bit en la reproducción en caché; en ejecución live se rige por la versión que hayas fijado).

  • Puedo explicar en qué difiere cada uno de los tres brazos y por qué el oracle es el suelo y no un concursante
  • Sé que el 7.9% no es gratis: 29 arreglados, 7 estropeados, por eso la redacción de la sugerencia lleva «puede ignorarse»

Paso 5: pasar a llamadas de función — closed_sets lee las firmas, 54 preguntas en una sola solicitud ​

Por qué: segunda aplicación de la misma filosofía: las funciones no cambian ni una línea, se añade un spec — una pregunta por cada parámetro, una línea de descripción por cada opción, un párrafo de descripción por cada función, más una pregunta para elegir la función.

La metáfora oficial es directa: pides «un latte grande de avena con hielo sin azúcar» y el barista no anota tus palabras exactas, sino que marca cuatro opciones en el vaso. Este cookbook hace lo mismo con una API de trading — entra una frase, salen el nombre de la función y los valores de los parámetros, cada uno con su nivel de confianza:

text
"plot rolling correlation between nvda and spy for the past month"
    rolling_correlation(symbol='NVDA', benchmark='SPY', window='1mo')   confidence 0.91

"compare nvda amd and msft over the past three months"
    compare_returns(symbols=['NVDA', 'AMD', 'MSFT'], window='3mo')      confidence 0.94

"show me apple daily with volume"
    plot_price(symbol='AAPL', resolution='1d', include_volume=True)     confidence 0.75

"what tickers do you have"
    list_symbols()                                                     confidence 1.00

trader.py son diez funciones corrientes. Los parámetros cuyos valores provienen de listas fijas ya llevan Literal en su anotación de tipo — closed_sets lee las firmas y divide los parámetros rellenables en tres formas:

python
def plot_price(
    symbol: Literal["SPY", "NVDA", "AMD", "AAPL", "MSFT", "TSLA"],
    style: Literal["line", "candles"] = "line",
    resolution: Literal["1m", "5m", "15m", "1h", "1d"] = "15m",
    window: Literal["1d", "1w", "1mo", "3mo"] = "1w",
    include_volume: bool = False,
    moving_average: Literal["9", "20", "50"] | None = None,
    log_scale: bool = False,
): ...
formaanotación de tipoen qué pregunta se convierte
choiceLiteral[...]una pregunta Choice, cuyas opciones son los valores legales
setlist[Literal[...]]una Noul por cada miembro (el {} se reemplaza por el nombre del miembro)
flagbooluna Noul, ≥ 0.5 significa activado

Los demás tipos —texto libre, números, fechas— no generan preguntas, y el valor por defecto de la función se respeta: el tercer parámetro limit: int = 3 de top_movers nunca genera preguntas y siempre conserva el valor por defecto 3.

El spec admite spec.json, que en una frase aclara «qué quiere decir el usuario al decir esto» — Literal solo ofrece las dos cadenas "1mo" y "3mo", y no puede decir que «this quarter» se refiere a la segunda. La documentación oficial añade una frase: el spec permite que el LLM lo escriba por ti a partir de la firma. Las preguntas de rol de los dos parámetros homólogos de rolling_correlation merecen leerse palabra por palabra:

json
"symbol": {
  "question": "Which stock is the user asking about - the one being measured, named first?",
  "options": { "SPY": "SPY, the S&P 500 index ETF, the market as a whole", "…": "…" }
},
"benchmark": {
  "question": "Which stock is it being compared against - the second one named, the yardstick?",
  "stated": "Does the user name a second symbol to compare against?",
  "options": { "SPY": "SPY, the S&P 500 index ETF, the market as a whole", "…": "…" }
}

symbol y benchmark extraen del mismo grupo de seis opciones y, gracias a las preguntas de rol, cada uno ocupa su lugar — «el que se mide, el nombrado primero» frente a «el segundo nombrado, la vara de medir». Las claves de las opciones son las cadenas que recibe la función, lo que elimina la capa de mapeo.

stated hace que un parámetro sea opcional: es una segunda pregunta de sí/no que pregunta «¿se mencionó este parámetro en el comando?». Si no se mencionó (por debajo de 0.5), todo el parámetro queda vacío y entra en vigor el valor por defecto de la propia función.

Dispatcher construye todas las preguntas de una vez a partir del spec. Después cada comando es una sola solicitud: la selección de función y todos los parámetros de las diez funciones viajan juntos, y el código solo lee las respuestas de la función elegida — todas las preguntas se formulan antes de saber «qué función se eligió»; es la forma extrema del fan-out especulativo:

python
assistant = Dispatcher(SPEC, TOOLS, client)   # SPEC 来自 spec.json,TOOLS 来自 trader.py
print(f"{len(assistant.questions)} questions per command, among them:")
for qid in ("__tool__", "plot_price.style", "plot_price.style?", "compare_returns.symbols.NVDA"):
    question = assistant.questions[qid]
    print(f"  {qid:<30}{question['type']:<8}{str(question['instructions'])[:64]}")

Deberías ver (publicación oficial):

text
54 questions per command, among them:
  __tool__                      choice  What is the user asking the trading assistant to do?
  plot_price.style              choice  Does the user want a plain line or candles?
  plot_price.style?             noul    Does the user say how the chart should be drawn, such as a line,
  compare_returns.symbols.NVDA  noul    Does the user want NVDA in the comparison?

Las diez funciones suman 28 parámetros rellenables; con la selección de función y las preguntas de cada stated, cada comando responde 54 preguntas en una sola solicitud. Las preguntas expresan «la idea», no «las palabras que el usuario podría decir»: lo que se empareja es el significado — is amd tracking nvidia lately acierta con rolling_correlation, aunque las palabras tracking y lately no aparecen para nada en spec.json.

Ejecuta los 14 comandos oficiales (la salida son los valores publicados oficialmente):

text
  "show nvda 1h"
      plot_price(symbol='NVDA', resolution='1h')                        confidence 0.78   tool 1.00
  "plot rolling correlation between nvda and spy for the past month"
      rolling_correlation(symbol='NVDA', benchmark='SPY', window='1mo') confidence 0.91   tool 1.00
  "when during the day does nvda trade the most"
      intraday_pattern(symbol='NVDA')                                   confidence 0.53   tool 1.00
  "what moved today"
      top_movers(window='1d', direction='gainers')                      confidence 0.90   tool 0.90
  "what tickers do you have"
      list_symbols()                                                    confidence 1.00   tool 1.00
  "how did the market do this week"
      market_summary(window='1w')                                       confidence 0.96   tool 0.99
  "candles for tesla with a 20 period moving average"
      plot_price(symbol='TSLA', style='candles', moving_average='20')   confidence 0.69   tool 0.97
  "compare nvda amd and msft over the past three months"
      compare_returns(symbols=['NVDA', 'AMD', 'MSFT'], window='3mo')   confidence 0.94   tool 1.00
  "how volatile is tsla"
      volatility(symbol='TSLA')                                         confidence 0.96   tool 1.00
  "biggest losers today"
      top_movers(window='1d', direction='losers')                       confidence 0.98   tool 0.98
  "worst drawdown for nvda this quarter, and chart it please"
      drawdown(symbol='NVDA', window='3mo', plot=True)                  confidence 0.84   tool 0.84
  "spy stats for the last month"
      summary_stats(symbol='SPY', window='1mo')                         confidence 0.88   tool 0.88
  "show me apple daily with volume"
      plot_price(symbol='AAPL', resolution='1d', include_volume=True)   confidence 0.75   tool 0.85
  "is amd tracking nvidia lately"
      rolling_correlation(symbol='AMD', benchmark='NVDA')               confidence 0.82   tool 0.82

Los dos comandos largos son los que mejor muestran el valor: rolling correlation rellena cuatro parámetros en una frase, con symbol y benchmark cada uno en su lugar; el comando compare mete tres tickers en el conjunto y deja a otros tres fuera.

  • Puedo explicar en qué pregunta se convierte cada una de las tres formas de conjunto cerrado, y por qué limit: int no aparece entre las 54 preguntas
  • Sé por qué las claves de las opciones del spec usan directamente las cadenas que recibe la función

Paso 6: leer confidence — el juicio más débil determina la certeza de toda la llamada ​

Por qué: el confidence de una llamada a función reporta el juicio con menor certeza de toda la llamada, no el producto de todos los juicios — un solo parámetro erróneo basta para arruinar el resultado.

Palabras textuales de la documentación: el producto responde a otra pregunta («¿es correcta cada parte?») y además baja cuantos más parámetros haya, sin importar qué juicio esté realmente en duda. min te deja ver el punto débil directamente. Conciliación parámetro por parámetro para is amd tracking nvidia lately (valores publicados oficialmente):

text
"is amd tracking nvidia lately"  ->  rolling_correlation(symbol='AMD', benchmark='NVDA')   confidence 0.82
  symbol      'AMD'                     p 0.87   AMD 0.87  NVDA 0.13  AAPL 0.00
  benchmark   'NVDA'                    p 0.78   NVDA 0.92  AMD 0.08  AAPL 0.00
  window      omitted, default stands   p 0.96
  resolution  omitted, default stands   p 0.99
  weakest argument: benchmark

window y resolution se omiten ambos — lately no dice ni cuánto mirar atrás ni qué barra, así que rolling_correlation corre con sus propios valores por defecto: un mes, velas horarias. Esa es la utilidad de stated: sin él, el Choice se vería obligado a especificar una ventana, y lo haría con total confianza.

El confidence de 0.82 viene del benchmark más débil (p 0.78). Ejecutar o no, confirmar o no con el usuario un «¿te parece bien comparar con NVDA?»: esta información es directamente utilizable — el umbral se define en tu código.

Por último, conecta los dos escenarios con el mismo principio. En la mitad de elegir habilidades, las preguntas frecuentes oficiales del Agent Skill dicen justo lo contrario: si solo te importa «elegir la mejor», basta con tomar la opción de mayor probabilidad, sin poner umbrales de confidence por todas partes; si necesitas algoritmos estadísticos, usa probabilities. Las dos solicitudes con filtro controlan el «decir o no decir» — ese es un umbral puesto sobre la propia probabilidad de Noul, que de todos modos no tiene un confidence separado.

Deberías ver: el desglose por parámetros coincide con la tabla anterior; la línea weakest argument: benchmark señala el parámetro más dudoso de toda la llamada.

  • Puedo explicar por qué confidence toma el min y no el producto, y de dónde salen los valores por defecto cuando stated se omite

📋 Prompt mágico ​

El «Prompt» de esta página es una plantilla de preguntas y código de decisión para la API — cópiala, sustituye los marcadores 【】 (los que llevan ? son opcionales) y ya funciona.

📝 Grupo de preguntas de ranking de habilidades (una Choice + cuatro Noul) ​

Efecto esperado: descomponer «qué habilidad cargar» en dos grupos de juicios, ranking + compuertas, y obtener todas las respuestas en una sola solicitud.

python
QUESTIONS = {
    "which": Choice(
        instructions="【这些技能里哪个适合用户的这一轮请求?】",
        criteria={【技能名】: 【一行索引描述】},  # 194 个也放得下,上限 255
    ),
    "gate::acts": Noul(
        instructions="【用户是要对文件 / 账户 / 设备 / 线上服务动手,还是只要解释或建议?】",
    ),
    "gate::procedure": Noul(
        instructions="【认真回答这个问题的专家要不要查一份具体流程或命令集?】",
    ),
    "gate::prose": Noul(
        instructions="【一个什么都接触不到的通才,纯靠文字能把这请求答满意吗?】",  # 反向题:yes = 不需要技能
    ),
    "named": Noul(
        instructions="【请求点名了具体工具、格式、模板或方法吗?】",
    ),
}
# 必填项:state = {"request": 【用户这轮的原话】, "recent_context": 【近期对话,可为空串】}
# 选填项:闸门题按你的领域改问法,但保持「问动作,不问主题」?
# 输出规范:probabilities 降序取前三;gate = 三道动作题的均值(prose 取 1-p 再平均);named 单独读
# 约束条件:
# ✅ 问「要不要动手」,别问「主题是什么」——主题题分不开 explain what a monad is
# ✅ 官方英文原文经过了 452 请求实测,中文化前先用自己的数据验证
# ❌ 不要问「该不该建议技能」——那是代码的活,改政策不该改问题

✅ Decisión sugerida con dos umbrales (cierre con tabla de verdad) ​

Efecto esperado: los dos grupos de probabilidades se convierten en «como mucho un nombre de habilidad», y toda la política queda en constantes visibles.

python
GATE_THRESHOLD = 【0.30】   # 三道动作 Noul 的均值,官方给这套请求挑的起点
NAMED_THRESHOLD = 【0.50】  # 「点名了方法」单独开门,不进平均
FITS_THRESHOLD  = 【0.30】  # 复查里最好的 fits 低于它就整组放弃
SHORTLIST = 【3】            # 第一道带进第二道的候选数

def suggest(request):
    wide = rank_wide(request)
    if not (wide["gate"] >= GATE_THRESHOLD or wide["named"] >= NAMED_THRESHOLD):
        return ()                        # 两个理由都不成立:什么都不建议
    shortlist = top(wide["ranked"], SHORTLIST)
    result = rerank(request, shortlist)  # 第二道:选项 = 前三的全文,真二请求
    if max(result["fits"].values()) < FITS_THRESHOLD:
        return ()                        # 允许全员落选
    return (result["winner"],)
# 必填项:三个阈值——官方说明它们是起点,不是默认值
# 选填项:建议块措辞保留「可以忽略」,并给「没有建议」也发一句话?
# 输出规范:至多一个技能名,或 ();包进 <skill_relevance> 块加在 roster 之后
# 约束条件:
# ✅ 建议块加在 roster 之后,别改 roster 文本——prefix caching 靠它逐回合一致
# ✅ 阈值、问题措辞集中在一个文件里,方便人审(官方 Agent Skill 的建议)
# ❌ 不要把建议写死成命令——自信的错误建议比没有更糟(实测弄坏 7 个本来对的)

🔧 Plantilla de spec para llamadas a funciones (una entrada por función) ​

Efecto esperado: cada parámetro de conjunto cerrado de la firma recibe su pregunta de «preguntar la idea», y los valores que entran en la función son siempre legales.

json
{
  "question": "【用户想让这个助手做什么?(挑函数的那道题)】",
  "functions": {
    "【函数名】": {
      "description": "【用户想要这个函数做什么,一段话】",
      "arguments": {
        "【参数名】": {
          "question": "【这个参数用户要什么——按想法问,不按参数名问】",
          "stated": "【用户说没说这个参数?】",
          "options": {
            "【合法值,即 Literal 成员】": "【这个值是什么意思,一行】"
          }
        }
      }
    }
  }
}
# 必填项:每个 Literal 参数一条;list[Literal] 的 question 里放 {} 占位(每成员一道 Noul)
# 选填项:可选参数配 stated;bool 参数不需要 options(一道 Noul ≥ 0.5 为开)?
# 输出规范:Dispatcher 一次建 54 道问题(本页示例规模),每条命令一次请求
# 约束条件:
# ✅ 选项键 = 函数收的字符串,省掉映射层
# ✅ spec 可以让 LLM 从签名帮你写(官方原话),写完人审一遍
# ❌ 不要拿参数名当问题("Which resolution?")——没给命令任何可匹配的东西

Punto de control ✅ ​

  • Puedo explicar qué hace cada una de las dos solicitudes: la primera, una Choice que ordena 194 habilidades + cuatro Noul de compuerta; la segunda solo mira las tres primeras, con descripciones completas para revisión, y permite que nadie resulte elegido
  • Sé por qué hay que enviar la segunda solicitud: las opciones de la segunda (el texto completo de las tres primeras) solo pueden construirse cuando llega el ranking de la primera — uno de los tres casos oficiales de verdadera doble solicitud
  • Puedo recitar la prueba real de tres brazos: cargas erróneas 15.7% → 7.9% (más que la mitad de recorte), cargas inútiles 14.0% → 5.2% (casi dos tercios); suelo oracle 3.2% / 4.1%
  • Puedo nombrar las tres formas de conjunto cerrado en llamadas a funciones: Literal → Choice, list[Literal[...]] → una Noul por miembro, bool → Noul; números y texto libre no generan preguntas y conservan los valores por defecto
  • Sé que confidence en llamadas a funciones toma el juicio más débil (min) y no el producto, y también que al elegir habilidades, si solo se «elige la mejor», no hace falta poner umbrales por todas partes

Advertencias de errores comunes ​

❌ Pedir a Jev que responda directamente «qué debe hacer el agent a continuación» ​

Texto literal de SKILL.md: este tipo de pregunta suele indicar que se está preguntando en la capa equivocada. La postura correcta es descomponer la decisión en los juicios de los que depende — ranking, compuerta de acción, compuerta de mención, fits — entregar los juicios a Jev, y escribir la decisión (dos umbrales + tabla de verdad) en el código, visible y comprobable. Las dos solicitudes y las cuatro constantes de esta página son la demostración completa.

❌ Poner umbrales de confidence por todas partes ​

La lista de preguntas frecuentes del Agent Skill oficial incluye justo esto: si solo te importa «elegir la mejor», basta con tomar la opción de mayor probabilidad. Si necesitas algoritmos estadísticos, usa probabilities. Las compuertas de esta página usan la propia probabilidad de Noul (Noul no tiene un confidence separado); el confidence del lado de las llamadas a funciones sí se usa como «grado de certeza», y solo toma el juicio más débil.

❌ Usar una pregunta temática como compuerta ​

«¿Esto está relacionado con software?» no separa explain what a monad is de una petición de software que necesita una habilidad — ambas son software. La pregunta de acción pregunta «hay que tocar o no los archivos, la cuenta, el dispositivo o los servicios en línea del usuario», y eso sí separa. En la pregunta inversa (prose_suffices) recuerda tomar 1-p antes de entrar en el promedio.

❌ Usar el nombre del parámetro como pregunta ​

"Which resolution?" recibe crítica nominal de la documentación oficial: no le da al comando nada con qué emparejar. Pregunta la idea: "How far back is the user asking about - today, the past week, the past month, or the past three months?" — así this quarter caerá en 3mo y lately dejará honestamente todo vacío.

Técnicas avanzadas (opcional) ​

🔧 Apunta a tu propio directorio de habilidades. Texto oficial: basta con sustituir hermes_roster.json — cada pregunta de arriba solo lee los cuatro campos name, description, description_full, body, y en suggest() no hay nada más específico de Hermes.

📚 ¿Qué pasa con un catálogo más grande? El mensaje oficial: a esta escala, una sola Choice es más que suficiente; si crece varias veces más, se hace ranking por bloques y los ganadores de cada bloque se reordenan como en el paso 3. El cookbook de Rerank (búsqueda y coincidencia) usa el mismo enfoque de dos pasos de «primero una lista corta, luego repuntuación», cambiando la primera pasada barata por BM25.

⏳ Reproducción de todos los números sin key. Las llamadas de ambos cookbooks quedan grabadas en sus respectivos json_cache.json, con clave basada en la entrada; la reproducción no envía ni una sola petición; borra el archivo de caché y todo va en vivo. La grabación de la publicación de la sugerencia de habilidades usa jev-1.14.0 + claude-haiku-4-5-20251001 (render 2026-10-30), y la de llamadas a funciones usa jev-1.12.

🚀 Deja que un coding agent escriba esto por ti. Instala la TypeSafe Agent Skill y entrégale esta página para que lo haga siguiéndola:

bash
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

La recomendación oficial es concentrar las preguntas y las constantes de umbral en un solo archivo para facilitar la revisión humana: los GATE_THRESHOLD / NAMED_THRESHOLD / FITS_THRESHOLD de esta página y las cuatro preguntas de compuerta son justo lo que debería ir en ese único archivo. Véase Desarrollar en conjunto con Claude Code.

Resumen de la lección ​

✅ Sugerencia de la skill = dos peticiones + dos umbrales: la primera pasa usa una sola Choice para clasificar las 194 skills y cuatro Noul de guardia (tres preguntas de acción preguntan «¿hace falta actuar?» y una pregunta «¿se le nombró?»); la segunda solo mira las tres primeras, cada una con descripción completa + los primeros 700 caracteres del SKILL.md; si fits es todo bajo, se descarta el grupo entero. El resultado es como máximo un nombre de skill, y el bloque <skill_relevance> se añade después del roster.

✅ Beneficios y costes medidos: carga errónea 15.7% → 7.9%, carga inútil 14.0% → 5.2%; el suelo oracle 3.2% / 4.1% muestra que, por bueno que sea, no supera a «dar la respuesta directamente». De 280 peticiones cubiertas, la sugerencia arregló 29 y estropeó 7: que el texto de la sugerencia diga «puede ignorarse» no es cortesía.

✅ Llamada a funciones = una spec + una petición: closed_sets lee las firmas y clasifica los parámetros de conjunto cerrado en tres formas: choice / set / flag; las 54 preguntas se hacen todas en una sola petición, y el código solo lee las respuestas de las funciones elegidas. Lo que entra en la función siempre son valores legales de Literal; números y texto libre no se preguntan y se conserva el valor por defecto.

✅ confidence toma el más débil: la certeza de toda la llamada la determina el juicio con menos confianza (min, no el producto); stated hace que los parámetros no mencionados se omitan por completo y apliquen sus valores por defecto; weakest() indica qué parámetro conviene poner en duda.

Repaso de los campos de configuración clave:

CampoValor de esta páginaDescripción
SHORTLIST3Número de candidatos que la primera pasada lleva a la segunda
EXCERPT_CHARS700Caracteres iniciales del SKILL.md que acompañan a cada candidato (el archivo roster guarda 1600 por entrada)
GATE_THRESHOLD0.30Si la media de las tres Noul de acción supera la línea, se considera «hace falta una skill»
NAMED_THRESHOLD0.50«Se nombró el método» abre su propia compuerta por separado, sin entrar en la media
FITS_THRESHOLD0.30Si en la revisión los mejores fits quedan por debajo, se descarta el grupo entero
MEMBER / STATED0.5Umbral para que un miembro entre en el set / para que un parámetro opcional se considere rellenado
TYPESAFE_MODELjev-1.14.0 (skill) / jev-1.12 (llamada a funciones)Versión de grabación oficial; en vivo, bloquea tu propio ID de versión
AGENT_MODELclaude-haiku-4-5-20251001Agente bajo prueba; comentario oficial: fijarlo garantiza puntuaciones estables

Tutoriales relacionados:

Avance de la próxima lección ​

El harness de esta lección decide «qué herramienta llamar, qué skill elegir»; la próxima lección añade memoria al harness: Sistema de memoria básico: deja que Jev decida qué recordar.

Aprenderás:

  • Tras la llamada, una Noul de compuerta juzga «¿esta petición enuncia un hecho del cliente que valga la pena recordar?»; solo se guarda si P ≥ 0.5
  • La memoria se guarda en un diccionario Python normal y se fusiona en el state antes de la llamada: ask_with_memory() y ask() tienen los mismos parámetros y el mismo valor de retorno; cambiar a una no exige modificar el resto del código
  • Medición oficial: el enrutamiento de tickets posteriores pasa de 3/6 a 6/6, con solo una petición más por llamada
  • El concepto de harness según la definición oficial: código alrededor del modelo que le da capacidades extra (tool calls, ejecución en bucle): el Dispatcher de esta página es justamente el tipo que añade tool calls al modelo
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.