Skip to content

Interpretación del rendimiento: cómo se midieron los 7.073 segundos ​

En la lección anterior viste con tus propios ojos cómo el agent buscó vuelos en 7 segundos. En esta lección desarmamos el cronómetro: los 7.073 segundos no son un eslogan publicitario, sino una grabación real con límites de medición completos: el equipo oficial no solo publicó el informe, sino que también incluyó el JSON de mediciones crudas en el repositorio, con el hash del código fuente y hasta la versión del navegador. Si lees bien los datos de rendimiento de Jev Ultrafast, no solo podrás reproducirlos, sino que también podrás copiar este método para medir tu propio agent.

Las cifras de esta lección provienen principalmente de tres archivos del repositorio jev-ultrafast que clonaste: docs/performance.md (cuerpo del informe), docs/flights-measurement.json (datos de la grabación) y docs/full-speed-measurement.json (datos del experimento comparativo).

Qué podrás hacer al terminar ​

  • Explicar el criterio de cronometraje de los 7.073 segundos: arranca con la primera predicción y se detiene al aceptar DONE; cuáles son los cinco elementos dentro del cronómetro y los tres fuera
  • Desglosar la factura de la grabación: 17 solicitudes de decisión (mediana 178 ms, total 3,720 ms), 2 generaciones de texto, 11 acciones, y en qué segundo se ejecuta cada acción
  • Entender el diseño del experimento comparativo de 9.450 → 7.092 segundos y explicar por qué el propio equipo oficial dice que «3 pares son demasiado pocos, no es un benchmark general»
  • Explicar con claridad qué recortó la optimización: llamadas de protocolo del navegador 1,092 → 101, de las cuales las 828 llamadas a DOM.resolveNode se redujeron directamente a cero
  • Usar el trace de examples/flights.py para alinear el mismo criterio y medir tus propios segundos

Tu dilema actual ​

  • «El equipo oficial dice 7 segundos, a mí me salen 12 segundos: ¿no habrán escogido la mejor corrida?». Sin conocer el criterio, comparar no sirve de nada
  • Quieres citar estas cifras de velocidad de ultrafast en un informe, pero te acobardas en cuanto te preguntan «¿cómo se midió?»
  • Quieres hacer una comparación de rendimiento para tu propio browser agent, pero no sabes qué variables controlar: ¿el modelo? ¿la red? ¿el navegador? Quieres copiar un ejemplo y ni siquiera encuentras el paradigma

Cuándo usar esta técnica ​

Cuando necesites:

  • Transmitir o citar las cifras de rendimiento de Jev Ultrafast y resistir la pregunta de «¿cómo se midió?»
  • Hacer tu propia comparación de rendimiento para un browser agent y necesitar un paradigma de medición listo para copiar (criterio de cronometraje, verificación independiente, declaración de tamaño de muestra)
  • Decidir si estas cifras encajan en tu escenario: es de tarea única, red en vivo y muestra pequeña

Y no quieras:

  • Tomar los segundos de una sola ejecución como un indicador estable y citarlos por todas partes
  • Comparar cifras con criterios distintos (inspector con capturas vs. script sin capturas; jev-1.13 vs. jev-1.14)

🎒 Preparativos antes de empezar ​

  • Completaste Ejecutar Google Flights: ejecutaste examples/flights.py al menos una vez y viste el JSON de verificación de "passed": true y artifacts/flights/latest/
  • Recuerdas el «una ida y vuelta, dos decisiones» de Jev Ultrafast: principios: cada una de las 17 solicitudes de esta lección sigue esa estructura
  • (Opcional) Ten abierto el repositorio jev-ultrafast y lee junto con docs/performance.md y los dos JSON de medición; cada cifra de esta lección se puede encontrar ahí
  • Un vaso de agua: esta lección es principalmente de lectura, la parte práctica está en «Técnicas avanzadas»

Idea central ​

La actitud del equipo oficial ante las cifras de rendimiento se puede resumir en tres frases:

  1. Cada cifra viene con su criterio: desde qué milisegundo arranca el cronómetro de los 7.073 segundos, en cuál se detiene, qué cuenta dentro y qué fuera, todo está escrito con toda claridad en la documentación
  2. Las comparaciones deben controlar variables: las versiones nueva y vieja corren alternadas 3 veces cada una, con la misma tarea, el mismo modelo, el mismo presupuesto y la misma verificación independiente
  3. Declarar las limitaciones por iniciativa propia: tamaño de muestra, red en vivo, tarea única; el propio equipo oficial lo dice primero, sin esperar a que se lo señalen

Los cuatro grupos de cifras oficiales que esta lección va a desglosar:

CifraCriterio oficialFuente
7.073 sprimera predicción → aceptación de DONE; incluye llamadas al modelo, generación de texto, operaciones del navegador, decisiones stale, cargadocs/performance.md, flights-measurement.json
9.450 → 7.092 s6 ejecuciones alternas, mediana tomada, ambos lados 3/3 verificados de forma independientedocs/full-speed-measurement.json
1,092 → 101mediana de llamadas al protocolo del navegador del mismo experimento comparativodocs/full-speed-measurement.json
$0.00006272facturación de OpenRouter solo de los dos helpers de texto, sin incluir TypeSafedocs/performance.md

Una cosa más que conviene recordar de antemano: todas las cifras de este conjunto provienen de la misma combinación: modelo de decisión jev-1.13.0 + modelo de texto inception/mercury-2.5 (vía OpenRouter, con razonamiento desactivado). En el JSON de medición, TYPESAFE_MODEL es null, es decir, se usó el valor predeterminado del código jev-latest (jev_ultrafast/model.py, línea 108), que en ese entonces se resolvía a 1.13.0; hoy jev-latest ya apunta a jev-1.14.0. Si lo reproduces hoy, el modelo será distinto y, naturalmente, los segundos diferirán.

💡 Por qué esta lección merece una lectura detenida

Más útil que memorizar la cifra 7.073 es el paradigma de «criterio de medición + factura + declaración del tamaño de muestra». Puedes copiarlo tal cual al medir el rendimiento de cualquier agent, ya sea Ultrafast u otro.

Hazlo conmigo ​

Paso 1: alinear el criterio de cronometraje: desde qué milisegundo arranca el cronómetro oficial ​

Por qué: antes de comparar dos cifras en segundos hay que alinear el criterio; de lo contrario, todas las comparaciones son inválidas. Ya sea que tú mismo obtengas 9 segundos o 12 segundos, el primer paso es entender cómo corre el cronómetro oficial.

El criterio oficial, explicado en una sola tabla:

ÍtemContenido
Arranque del cronómetrola primera predicción tras la observación inicial de la página de inicio
Parada del cronómetroel momento en que se acepta DONE
Dentro del cronómetrollamadas al modelo, generación de texto, operaciones del navegador, decisiones stale (predicciones descartadas y rehechas), esperas de carga
Fuera del cronómetroinicio del navegador, navegación inicial, verificación verify() independiente ejecutada al terminar

Este criterio se corresponde en el código (jev_ultrafast/agent.py):

  • started_at solo se establece en la primera predict; por eso la observación inicial de la página queda fuera del cronómetro
  • DONE se actualiza cuando se acepta en act dentro de elapsed_ms; ese es el punto de parada del cronómetro
  • Una predicción caducada (StalePage) descarta la decisión, vuelve a observar y a predecir; el tiempo descartado queda dentro del cronómetro

El video usa el mismo criterio: 1× velocidad original, sin pausa inicial, solo 0.5 segundos de pausa al final; 186 fotogramas de grabación continua de pantalla más 1 captura inicial (en el JSON, source_frames: 187); solo se recortó la barra de cuenta/navegación superior de 64 px; no hay ningún montaje que recorte el inicio o el final.

Deberías ver: el pasaje de cronometraje de docs/performance.md se corresponde punto por punto con la tabla anterior: "begins at the first prediction after initial homepage observation and ends at the accepted DONE choice", sin discrepancia de una sola palabra entre lo que está dentro y fuera del cronómetro.

  • Poder enumerar los cinco ítems dentro del cronómetro y los tres fuera

Paso 2: desglosar la factura de los 7.073 segundos: en qué se gastaron las 17 solicitudes ​

Por qué: la documentación oficial registró cada cifra de esta grabación real en docs/flights-measurement.json, así que la factura se puede copiar directamente. Resumen:

MétricaValor
Tiempo total7,073 ms
Solicitudes de decisión17 veces
Latencia de decisiónmediana 178 ms, total 3,720 ms
Acciones ejecutadas11 (10 interacciones + 1 WAIT explícito)
Generación de texto2 veces (Zurich 581 ms, London 346 ms)
token90,558 de entrada + 6,325 de salida
Modelo de decisiónjev-1.13.0

Destino del tiempo (las dos primeras filas son campos originales del JSON oficial, la tercera es un cálculo de esta página: 7073 − 3720 − 927):

DestinoTiempoProporción
17 solicitudes de decisión3,720 ms≈ 53%
2 generaciones de texto927 ms≈ 13%
Ejecución del navegador, observación, carga de páginas≈ 2,426 ms≈ 34%

17 solicitudes no equivalen a 17 acciones: 11 acciones más 1 DONE aceptado suman 12 predicciones «bien aprovechadas»; las otras 5 fueron interceptadas por la verificación de frescura antes de ejecutarse: la huella de la página cambió, la decisión basada en la instantánea antigua se descartó y se rehízo; estas son las stale decisions del criterio, y su tiempo también cuenta dentro del total de segundos. (5 = 17 − 11 − 1, calculado en esta página según la lógica de bucle de agent.py de «cada predicción se consume exactamente una vez y, si se descarta, se vuelve a medir»; el número de stale no fue publicado por separado por la documentación oficial.)

Posición de las 11 acciones en la línea de tiempo (executed_ms, tomado del array actions del JSON de la grabación):

MomentoAcción
0.336 sCLICK Cambiar tipo de billete. Ida y vuelta
0.640 sCLICK Solo ida
1.595 sTYPE_TEXT ¿Desde dónde? → Zúrich (generación de texto 581 ms)
1.930 sCLICK Zúrich, Suiza (se selecciona la sugerencia de autocompletado)
2.748 sTYPE_TEXT ¿Hacia dónde? → Londres (generación de texto 346 ms)
3.053 sCLICK Londres, Reino Unido
3.452 sCLICK Abrir salida
3.769 sCLICK Domingo, 20 de septiembre de 2026
4.097 sCLICK Listo. Buscar vuelos de solo ida…
5.217 sCLICK Buscar (texto oficial: la búsqueda se ejecuta en el segundo 5.217)
5.587 sWAIT esperar la actualización de la página
7.073 sDONE aceptado, se detiene el cronómetro

Los primeros 5.2 segundos se dedican a rellenar el formulario y enviarlo; los últimos 1.9 segundos, a esperar el resultado y confirmar la finalización. El WAIT se ejecuta en el segundo 5.587 y el DONE se acepta en el segundo 7.073: esos últimos unos 1.49 segundos, según la explicación oficial, corresponden a la carga de la página de resultados, los cambios de estado y la decisión de finalización. Las dos generaciones de texto provocaron cada una una «pausa de escritura» de unos 0.3–0.6 segundos, y esa es la razón por la que en el vídeo el campo de entrada «piensa un momento antes de mostrar el texto».

Deberías ver: en flights-measurement.json los cuatro campos de nivel superior elapsed_ms, decision_requests, decision_median_ms, decision_total_ms, y el executed_ms de los 11 elementos del array actions: la línea de tiempo de arriba se copió precisamente de ese array.

  • Poder decir cuántas de las 17 peticiones se convirtieron en acciones, cuántas fueron stale y cuántas fueron DONE

Paso 3: entender el experimento comparativo de rendimiento de Jev Ultrafast: 9.450 → 7.092 s ​

Por qué: los 7.073 s de una sola ejecución son solo la grabación; la conclusión de «25% más rápido» proviene de otro grupo de experimentos de control. Su diseño determina hasta dónde puede llegar la conclusión.

Diseño del experimento (sección «Matched runtime comparison» de performance.md):

  • 6 ejecuciones, alternadas: una de la línea base y otra de la versión optimizada, en total 3 pares; la misma tarea, el mismo perfil de Chrome ya existente
  • Los dos brazos usan exactamente lo mismo: objetivo en lenguaje natural, verificador de resultados independiente, viewport de 1120×780, jev-1.13.0, mercury-2.5 (sin razonamiento), presupuesto de acciones y peticiones
  • La navegación inicial no se cronometra en ninguno de los dos lados; cada ejecución abre y cierra su propia pestaña; las 6 ejecuciones se cuentan todas, sin descartar ninguna, sin fallos de proveedor ni de verificación
  • El brazo de la línea base está congelado en el commit 68c077bf…; ambos lados usan Mercury, para evitar que las dos variables «cambiar el modelo de texto» y «modificar el código» se mezclen

Resultados:

ParLínea baseVersión optimizadaVerificación
111.214 s6.964 sambos superan
28.984 s7.913 sambos superan
39.450 s7.092 sambos superan
mediana9.450 s7.092 scada uno 3/3

Tres cambios en las medianas: tiempo de tarea −25.0%, peticiones TypeSafe 22 → 17, llamadas al protocolo del navegador 1,092 → 101. La versión optimizada fue más rápida en los tres pares.

Pero justo después, la propia parte oficial da tres advertencias:

  1. Demasiados pocos pares (3), prueba de signos bilateral p = 0.25, insuficiente para sostener una conclusión estadística fuerte
  2. Esto es una comparación controlada de muestra pequeña, no un benchmark amplio de agentes
  3. Google, las respuestas de la red, el enrutamiento y la caché del navegador son elementos vivos, sin controlar

⚠️ La forma correcta de citar estas cifras

«En 3 pares de ejecuciones alternadas con la misma tarea, el mismo modelo y el mismo navegador, la versión optimizada fue más rápida cada vez, con una mediana un 25% más rápida»: esto es una afirmación con fundamento. «Jev Ultrafast es un 25% más rápido que tal agente»: no tiene fundamento, la parte oficial nunca hizo una comparación entre agentes.

Deberías ver: la tabla comparativa de performance.md es la tabla de 3 números de arriba con una fila adicional de mediana en negrita; "p = 0.25" y "not a broad agent benchmark" están en el texto original.

  • Poder explicar qué variables controló el experimento y cuáles no

Paso 4: averiguar a dónde se fue el tiempo — 1,092 → 101 llamadas de protocolo, qué se eliminó ​

Por qué: la razón del "25% más rápido" está toda en las llamadas al protocolo del navegador. La fuente oficial guardó en el JSON de medición el detalle completo de las llamadas CDP (Chrome DevTools Protocol) de cada ejecución; es el conjunto de evidencia más sólido de todo el curso.

Las tres cargas del bucle antiguo (performance.md, "Where the time went"):

  1. Cada cambio del DOM——incluidas las animaciones——invalidaba las decisiones y obligaba a re-predecir una y otra vez
  2. Lecturas repetidas de todo el árbol de accesibilidad (Accessibility.getFullAXTree)
  3. Análisis de cientos de nodos del DOM (DOM.resolveNode)

Lo que hace el bucle nuevo (performance.md, "Where the time went" + README):

  • Una sola llamada al navegador lee de una vez los controles HTML/ARIA comunes——ya no se lee el árbol repetidamente ni se analiza nodo por nodo
  • El guardián de clics solo compara el objetivo, el contexto cercano y el estado del documento/formulario; la geometría y las pruebas de acierto se siguen haciendo antes de la entrada
  • La espera de eventos del combobox: las sugerencias de autocompletado llegan primero (README: límite de 200 ms; otras interacciones a lo sumo dos fotogramas de animación o 50 ms) antes de preguntar a Jev
  • El reemplazo de texto nativo emite explícitamente el comando select-all del navegador

Detalle de las llamadas CDP (listadas una a una en las tres ejecuciones, tomado del objeto cdp de cada run en full-speed-measurement.json):

Método de protocoloLínea base (3 veces)Versión optimizada (3 veces)
DOM.resolveNode828 / 828 / 8280 (la clave ya no aparece)
Accessibility.getFullAXTree30 / 30 / 300
Runtime.callFunctionOn40 / 40 / 400
DOM.getBoxModel + DOM.getNodeForLocation10 + 10 / 10 + 10 / 10 + 100
Runtime.evaluate158 / 146 / 14875 / 77 / 71
Input.dispatchMouseEvent / KeyEvent / insertText20 / 4 / 2 (idéntico cada vez)20 / 4 / 2 (sin cambios)
Total1102 / 1090 / 1092 (mediana 1,092)101 / 103 / 97 (mediana 101)

Dos ideas clave al leer la tabla:

  • Cambia la forma de "mirar la página", pero no la de "hacer clic en la página"——las llamadas de entrada de los tres tipos (ratón, teclado, inserción de texto) son idénticas en ambos lados; todo lo eliminado son llamadas de observación
  • También hay menos solicitudes (mediana 22 → 17): las decisiones ya no se invalidan constantemente por las animaciones, así que naturalmente hay menos re-predicciones

💡 Esta es la evidencia cuantitativa de "una instantánea, una llamada al navegador"

La lección de principios explicó el principio de diseño del README "One browser call per snapshot". En números: Runtime.evaluate baja de unas 150 veces a unas 75 veces, y DOM.resolveNode pasa de 828 veces a cero. La afirmación arquitectónica y los datos medidos coinciden.

Deberías ver: en el detalle cdp de las tres ejecuciones de la línea base en full-speed-measurement.json, DOM.resolveNode aparece 828 veces en todas; en el detalle cdp de las tres ejecuciones de la versión optimizada, ese método no aparece en absoluto.

  • Poder decir cuáles son los tres tipos de llamadas de observación eliminadas y por qué las llamadas de entrada no cambian

Paso 5: calcular el costo——tokens, helpers de texto y el precio que la fuente oficial no reportó ​

Por qué: la interpretación del rendimiento no puede mirar solo los segundos; también hay que ver cuánto costó esta pasada. La fuente oficial reportó la mitad; la otra mitad se puede deducir por uno mismo.

Lo que reportó la fuente oficial:

  • Todas las solicitudes de la sesión grabada suman 90,558 tokens de entrada + 6,325 tokens de salida
  • OpenRouter factura las dos llamadas de texto $0.00006272 (Zurich $0.0000293 + London $0.0000334)
  • La fuente oficial declara explícitamente: esto es solo el costo del helper de texto, no el costo total de la tarea——en la respuesta de TypeSafe solo hay números de tokens, sin factura en dólares, y el costo del navegador tampoco está incluido

Lo que la fuente oficial no reportó y se puede deducir por uno mismo (estimación de esta página, no son cifras oficiales):

Según la tarifa oficial de TypeSafe ($42 por cada mil millones (B) de tokens de entrada, salida gratis), 90,558 tokens de entrada ≈ $0.0038. Cálculo: 90558 × 42 ÷ 10⁹ ≈ 0.0038 dólares. Sumando los $0.00006272 del helper de texto, esta tarea de 7 segundos tuvo un coste total del modelo de aproximadamente 0.4 centavos de dólar.

Un ejemplo de fluctuación (todo está en full-speed-measurement.json): igualmente generando London, la grabación real tardó 346 ms con 94 tokens de completion ($0.0000334); en cambio, la versión optimizada del par 2 del experimento comparativo tardó 1,137 ms con 511 tokens ($0.0000961) — la latencia de una sola llamada de texto puede variar en más de 3 veces, y todas estas fluctuaciones entran en el total de segundos.

Deberías ver: en performance.md, el pasaje "$0.00006272" dice «text-helper charge, not total task cost»; el precio unitario de las dos llamadas está en text_calls de flights-measurement.json (2.93e-05 + 3.342e-05).

  • Poder explicar qué incluye $0.00006272 y qué no

Punto de control ✅ ​

  • Poder describir completa la metodología de cronometraje: punto de inicio, punto de parada, los cinco ítems dentro del reloj y los tres fuera
  • Poder citar los cuatro números clave de la factura de la grabación real: 17 peticiones, mediana de 178 ms, 11 acciones, búsqueda ejecutada en el segundo 5.217
  • Poder explicar el diseño experimental de 9.450 → 7.092 segundos y citar las tres advertencias del propio oficial
  • Poder indicar los tres tipos de llamadas que se ponen a cero en las llamadas de protocolo 1,092 → 101
  • Poder aclarar que $0.00006272 es solo el coste del helper de texto y que la factura de TypeSafe debe calcularse aparte según la tarifa

Advertencias sobre errores comunes ​

❌ Cuestionar directamente los números oficiales con tus propios segundos ​

Fenómeno: obtienes 9 segundos, 12 segundos, y crees que los 7.073 segundos tienen truco.

Causa: al menos cuatro diferencias de metodología — ① modelo distinto: la medición usó jev-1.13.0, mientras que hoy jev-latest ya apunta a jev-1.14.0; ② la red es cambiante: la propia versión optimizada oficial se repartió en tres ejecuciones entre 6.964–7.913 segundos; ③ el inspector abierto con capturas de pantalla nunca fue un modo de cronometraje (se explicó en la lección anterior); ④ tu ejecución pudo toparse con más decisiones stale.

Manera correcta: ejecuta con examples/flights.py (sin capturas) y lee el elapsed_ms del nivel superior de artifacts/flights/latest/state.json — ese es el número con la misma metodología que el oficial; antes de comparar, alinea modelo, URL y objetivo.

❌ Presentar el «25 % más rápido» como conclusión entre agents ​

Fenómeno: «Jev Ultrafast es un 25 % más rápido que tal agent de navegador.»

Causa: lo que el oficial comparó fueron sus propias dos versiones, nueva y vieja — la línea base es la implementación antigua congelada en el commit 68c077bf…, no ningún otro agent; además, con 3 muestras p = 0.25, el propio oficial lo llama una muestra pequeña controlada.

Manera correcta: al citar, incluye los matices: «en 3 pares de ejecuciones alternadas con la misma tarea y el mismo modelo, la versión nueva fue una mediana de un 25 % más rápida que la vieja».

❌ Creer que el oficial llegó a los 7 segundos de una sola vez ​

Fenómeno: al ver los 7.073 segundos, se asume que el rendimiento salió de forma natural.

Causa: performance.md conserva el registro completo de desarrollo: la versión antigua pasó una vez por 9.302 s; dos propuestas de árbol de accesibilidad con 9.395 s y 10.157 s; la primera propuesta de DOM directo 8.697 s, perofalló la verificación independiente (extracción de nombres/valores incompleta); tras la reparación, 8.051, 8.631, 8.395, 8.385, 7.741 s en ascenso continuo, y el diagnóstico de Mercury 7.559 s. Aún antes hubo una grabación de 11.387 s y una regresión de estrategia de 12.898 s.

Manera correcta: toma «8.697 s pero verify fallido» como recordatorio — por bonitos que sean los segundos, si no pasa la verificación independiente, no cuenta como superado. Que el oficial se atreva a escribir todos los intentos fallidos en la documentación muestra precisamente que la reproducibilidad importa más que la apariencia.

❌ Aplicar los 7 segundos a todos los sitios web ​

Fenómeno: «Flights en 7 segundos, entonces mi panel de administración complejo también debería tardar 7 segundos.»

Causa: el oficial solo publicó los segundos de tres tareas: Flights 7.073 s, abrir el teorema de incompletitud de Gödel en Wikipedia 2.798 s, tarea de hotel local 1.896 s — el oficial aclara que los dos últimos son «pruebas de humo, no comparaciones equivalentes». El DOM reader solo admite controles habituales de HTML/ARIA; shadow DOM, canvas, subidas de archivos, etc. no están admitidos.

Manera correcta: mide con tu propio sitio y tus propios objetivos; primero contrasta con la lista de no admitidos de Ultrafast troubleshooting y descarta las páginas no aplicables.

Técnicas avanzadas (opcional) ​

Mide tu propia metodología. Cuando termine de ejecutarse el uv run --env-file .env python examples/flights.py --keep-open de la lección anterior, abre artifacts/flights/latest/state.json: el elapsed_ms del nivel superior son los segundos con la metodología oficial de esta ronda; en history cada acción lleva executed_ms, latency_ms, text_latency_ms, donde decisions es cada predicción y text_calls es el helper de texto. El JSON de medición oficial es justamente un informe elaborado a partir de estos campos. Ejecuta tres rondas y toma la mediana: convence más que una sola ejecución.

Verifica campo por campo los números de esta lección. docs/flights-measurement.json (grabación real) y docs/full-speed-measurement.json (experimento comparativo) traen todos los datos brutos: hash del código fuente, número de tokens, coste de cada llamada de texto; las 6 ejecuciones del experimento comparativo incluyen además cada una la versión del navegador (Chrome/152.0.7977.83) y el detalle completo de CDP. Para contrastar cualquier número de este texto, acude a estos dos archivos.

Ten en cuenta los cambios de código posteriores a la medición. performance.md registra: después de completar el cronometraje y la grabación, se endureció el manejo de interrupciones del SELECT nativo (detenerse cuando el resultado es incierto, en vez de tratarlo como una lectura stale reintentable); Flights no dispara SELECT nativo, por lo que los hashes del cronometraje y de la grabación se mantienen sin cambios. Que el código que clonas sea un poco más nuevo que en la medición es normal.

Al elegir un helper de texto, mira cómo lo hace el equipo oficial. El equipo oficial usó como sondas campos de dos vuelos reales y probó Gemini 2.5 Flash Lite, Gemini 3.1 Flash Lite y Mercury 2.5; todos devolvieron valores correctos; una sonda anterior descartó un modelo que invertía origen/destino, y también descartó un modelo que no generaba JSON válido y producía comentarios. Lección: al cambiar TEXT_MODEL no te fijes solo en la latencia; haz una sonda de corrección con campos reales antes de pasarte.

Resumen de esta lección ​

✅ Las cifras de rendimiento de Jev Ultrafast se dividen en tres grupos: grabación real 7.073 s (criterio: primera predicción → DONE aceptado), experimento comparativo 9.450 → 7.092 s (6 rondas alternadas, mediana, ambos con 3/3), llamadas de protocolo 1,092 → 101 (mismo experimento).

✅ Factura de la grabación real: 17 solicitudes de decisión (mediana 178 ms, total 3,720 ms, alrededor del 53% del tiempo total), 2 generaciones de texto (927 ms), 11 acciones, 90,558 + 6,325 token; la búsqueda se ejecutó en el segundo 5.217.

✅ 17 solicitudes = 11 acciones + 1 DONE aceptado + 5 stale (predicción anulada por un cambio de página antes de ejecutarse, el tiempo se cuenta igual).

✅ La razón de la aceleración es que cambió la forma de «mirar la página»: DOM.resolveNode 828 → 0, árbol de accesibilidad completo 30 → 0, Runtime.evaluate aprox. 150 → aprox. 75; las llamadas de entrada no cambian en ninguno de los dos.

✅ Cita siempre con las salvedades: tarea única, 3 pares alternados, red en vivo, p = 0.25: el equipo oficial escribió las limitaciones junto a las cifras, y tú debes transmitirlas así.

Repaso de las cifras clave:

MétricaCifra oficialCriterio
Tiempo de la grabación real7.073 sPrimera predicción → DONE aceptado
Solicitudes de decisión / latencia mediana17 veces / 178 msGrabación real
Momento de ejecución de la búsqueda5.217 sGrabación real, una de las 11 acciones
Mediana de tiempo comparativa9.450 → 7.092 s (−25.0%)3 rondas alternadas
Mediana de llamadas de protocolo1,092 → 101Mismo experimento comparativo
Costo del helper de texto$0.00006272Solo 2 llamadas de texto (OpenRouter)
token TypeSafe90,558 entrada / 6,325 salidaTodas las solicitudes de la grabación real

Avance de la próxima lección ​

Ya vimos las cifras; en la próxima lección escribe tus propias tareas de navegador: Agent en la práctica convertirás Ultrafast en tu propia herramienta. Aprenderás:

  • El uso completo de Agent(url, goals): goals puede ser una cadena o una lista, run() obtiene el state paso a paso
  • Cómo usar cada campo de state: history, decisions, text_calls, status, elapsed_ms — justamente la fuente de los datos de la factura de esta lección
  • Cambiar una URL y una frase de objetivo ya es una tarea nueva, y cuándo conviene configurar tu propia verificación independiente
  • Cómo cambiar el modelo de texto: método de configuración para DeepSeek, GLM y otros endpoints compatibles con OpenAI

Apéndice: referencia del código fuente ​

Haz clic para expandir y ver la ubicación en el código fuente

Última actualización: 2026-11-04 (repositorio github.com/browser-use/jev-ultrafast, fuente local de información sources/jev/repo-ultrafast/)

FunciónRuta del archivoUbicación clave
Texto principal del informe de rendimientodocs/performance.mdCriterio de cronometraje (Timing begins…); factura de la grabación real (17 solicitudes / 178 ms / 5.217 s / 7.073 s / 90,558+6,325 token / $0.00006272); tabla del experimento comparativo y p=0.25; Where the time went; Other checks (2.798 s / 1.896 s); Development attempts; Limits
Datos medidos de la grabación realdocs/flights-measurement.jsonelapsed_ms 7073; decision_requests 17; decision_median_ms 178; decision_total_ms 3720; actions el array 11 con la línea temporal executed_ms de cada entrada; text_calls (581/346 ms y $2.93e-05/$3.342e-05); tokens 90558/6325; video (187 fotogramas / 1× / 0 pausa inicial / 500 ms de pausa final / recorte de 64 px); el campo timing es el texto original del criterio
Datos del experimento comparativodocs/full-speed-measurement.jsonsummary (9450/7092, 1092/101); runs 6 entradas (elapsed_ms, decision_requests, detalle cdp, hash del código fuente, tokens, text_calls de cada par); scope (3 pares, 1120×780, red en vivo sin controlar); baseline_commit 68c077bf…
Resumen del READMEREADME.md«Evidence and limits»: 7,073 ms de métrica, 3/3 aprobados, 25 %, llamadas de protocolo 1,092 → 101, 2.798 s / 1.896 s, DONE requiere verificación independiente
Inicio del cronómetro y manejo de stalejev_ultrafast/agent.pyL68–69 started_at se establece en el primer predict; L93–99 se actualiza al aceptar DONE elapsed_ms; L55–64 StalePage → descartar la decisión y volver a observar; L75–76 presupuesto de llamadas al modelo MAX_STEPS×2; L102–104 presupuesto de acciones
Modelo por defectojev_ultrafast/model.pyL108 os.environ.get("TYPESAFE_MODEL", "jev-latest")
Campos guardados en el traceexamples/flights.pyL50–52 imprime elapsed_ms/status; L54–56 state.json = agent.snapshot() + verification (incluye elapsed_ms, history, decisions, text_calls)
Texto original de los principios de diseñoREADME.mdL98 «One browser call per snapshot»; L100 para combobox se sugiere un límite de espera de 200 ms, y para otras interacciones dos fotogramas de animación o 50 ms
Lista de precios de Jev (base del cálculo de costos)Documentación oficial de TypeSafe docs/models.md (local sources/jev/docs/models.md)$42 por B (mil millones) de tokens de entrada, salida gratuita; el alias jev-latest apunta actualmente a jev-1.14.0
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.