TPTito Pinardo Gutiérrez
← Volver al rack
English
1U · HERMESqwen3:8b · 8 GB VRAM · 24 herramientas En producción

Posición 15 de 25 en el rack · En producción

Unidad 1U · Proyecto personal en producción

Hermes · asistente de IA local

117/120 en la batería, 23/23 en preguntas reales

Un asistente en el chat que conoce el estado de mis servidores, mi agenda y mi documentación. El modelo corre en una GPU de 8 GB de mi PC: nada sale de mi red. Como el modelo es pequeño, la precisión no se le pide al modelo: se construye alrededor de él.

La regla
Lo que se puede calcular, se calcula; al modelo solo se le pregunta lo que hace falta entender. Cada regla que se dejó en sus manos (fechas, días de la semana, sumas) acabó fallando, y dejó de fallar al pasarla a código.
Dónde corre
El bot, los conectores y los índices viven en un contenedor del servidor, encendidos siempre. El modelo de lenguaje, la voz y los embeddings, en la GPU de mi PC: si está apagado, las preguntas esperan en una cola.
Lo que no puede hacer
Por decisión mía, no enciende ni apaga servidores, no escribe notas, no envía correo y no ve documentos oficiales. Hay un caso de prueba que lo comprueba en cada medición.
  • 4,2×más rápido al dejar el modelo entero en la GPU
  • 17,5 → 73tokens por segundo, liberando VRAM del escritorio
  • 4,7 → 0,7 sal redactar sin razonamiento cuando ya hay datos
  • 24herramientas: estado, agenda, correo y memoria
  • 0,09 mslo que cuestan las guardias de salida
  • ~110pruebas sin modelo, más 48 casos × 3 semillas

Su código, en abierto Versión pública del repositorio: sin IPs ni secretos.

Un turno de chat por dentro

Cada pregunta pasa por varias fases antes de llegar a ti. Elige un recorrido para ver cuándo piensa el modelo, cuándo decide el código y qué se comprueba antes de enviar.

Recorridos Pulsa uno y sigue el paquete.

Fuera del servidor Contenedor del asistente · Proxmox bot, conectores, vigilantes e índices Mi PC · GPU de 8 GB Entrada y salida El turno, fase a fase Herramientas · lo hace el código Memoria · búsqueda por significado qwen3:8b Voz GPU 8 GB Mi móvil Correo Calendario Matrix Hermes Cola Formato 1 · Contexto 2 · Pistas 3 · think on/off 4 · Guardias 24 herramientas Estado en vivo 7 vigilantes Relevo Embeddings Qdrant Notas Conversaciones
Hermesde visita en la unidad

Pulsa una pieza o elige un recorrido. Si vienes de una habilidad, ya están encendidas las piezas donde la uso.

      Una pregunta, fase a fase
      1. Yo, desde Element — Pregunto desde el móvil: «¿Hay alguna alerta en el servidor?»
      2. Matrix (sala del asistente) — El mensaje llega a mi servidor de Matrix, en la sala del asistente.
      3. Hermes (el bot) — Hermes lo recoge. Lo primero no es llamar al modelo: es preparar lo que el modelo necesita saber.
      4. Fase 1 · Contexto que pone el código — Fase 1: el código pone la fecha de hoy, una tabla con los próximos 7 días y el historial resumido. Sin esto, el modelo cree que estamos en el año de su entrenamiento.
      5. Fase 2 · Pistas según la pregunta — Fase 2: la pregunta no encaja con ningún patrón especial, así que no se añade ninguna pista. Menos texto, mejor elige.
      6. Fase 3 · Razonar solo donde aporta — Fase 3: todavía no se ha ejecutado ninguna herramienta, así que el modelo PIENSA: tiene que elegir cuál y con qué argumentos.
      7. Modelo de lenguaje (Ollama) — El modelo, en la GPU de mi PC, decide llamar a la herramienta de salud del servidor.
      8. Herramientas — El código valida los argumentos contra el esquema y ejecuta la herramienta. El modelo nunca toca nada directamente.
      9. Estado del servidor — Llegan las alertas activas, con la antigüedad de cada dato pegada al resultado.
      10. Fase 3 · Razonar solo donde aporta — Fase 3 otra vez: el resultado trae datos y no hay avisos, así que ahora el modelo NO piensa. Solo tiene que redactar.
      11. Modelo de lenguaje (Ollama) — Redacta la respuesta en 0,7 s en vez de 4,7 s, con la misma calidad.
      12. Fase 4 · Guardias de salida — Fase 4: las guardias comparan la respuesta con las fuentes. Ninguna IP ni importe inventados: adelante.
      13. Maquetado — El Markdown se convierte en HTML para Element, con una copia en texto plano para la notificación.
      14. Matrix (sala del asistente) — Se envía a la sala y se indexa en la memoria de conversaciones.
      15. Yo, desde Element — Me llega la respuesta, con los datos y su antigüedad.
      Una búsqueda que vuelve vacía
      1. Hermes (el bot) — Pregunta de dos pasos: «¿Cuánto me costó la entrada de lo que tengo esta semana?»
      2. Fase 3 · Razonar solo donde aporta — Hay que elegir herramienta: el modelo piensa.
      3. Modelo de lenguaje (Ollama) — Elige buscar en las memorias el concepto «entrada».
      4. Herramientas — El código ejecuta la búsqueda.
      5. Qdrant (base vectorial) — Qdrant no encuentra nada útil con esas palabras.
      6. Fase 3 · Razonar solo donde aporta — Resultado vacío: el razonamiento se ENCIENDE otra vez. Sin esto, el modelo zanjaba con «no he encontrado nada» teniendo el dato a una llamada.
      7. Modelo de lenguaje (Ollama) — Aun pensando, con un modelo de 8B este caso fallaba 3 de cada 3 veces.
      8. Relevo del código — Así que el código toma el relevo: sabe que «lo que tengo esta semana» es un evento.
      9. Calendario — Consulta la agenda, filtrada con la propia pregunta, y saca el título exacto del evento.
      10. Correo (solo lectura) — Busca ese título en el correo y encuentra la confirmación con el importe.
      11. Modelo de lenguaje (Ollama) — El modelo recibe los datos ya reunidos y solo tiene que leerlos.
      12. Fase 4 · Guardias de salida — Las guardias comprueban que el importe de la respuesta aparece en el correo (o es una suma de importes que sí aparecen).
      13. Matrix (sala del asistente) — Respuesta correcta. Filtrar la agenda con la pregunta bajó el tiempo de 60-120 s a 31-41 s.
      El PC está apagado
      1. Yo, desde Element — Pregunto algo a las tres de la mañana.
      2. Matrix (sala del asistente) — Matrix lo recibe sin problema: el servidor está siempre encendido.
      3. Hermes (el bot) — Hermes comprueba si el modelo está disponible. No lo está: mi PC está apagado.
      4. Cola persistente — La pregunta se guarda en una cola persistente, en disco. No se pierde ni se contesta mal.
      5. La GPU de 8 GB — Por la mañana enciendo el PC y la GPU vuelve a estar disponible.
      6. Modelo de lenguaje (Ollama) — Hermes detecta que el modelo responde y vacía la cola por orden.
      7. Hermes (el bot) — Cada pregunta pasa por el turno completo, con la fecha de ahora, no la de cuando se preguntó.
      8. Matrix (sala del asistente) — La respuesta llega a la sala, marcada como respuesta en cola.
      9. Yo, desde Element — Me llega todo lo que pregunté durante la noche.
      Un audio
      1. Yo, desde Element — Le mando un audio desde el móvil.
      2. Matrix (sala del asistente) — Llega a Matrix como un fichero de audio.
      3. Hermes (el bot) — Hermes ve que es audio y lo manda a transcribir.
      4. Voz (Whisper + síntesis) — Whisper lo convierte en texto en la GPU del PC.
      5. Hermes (el bot) — Con el texto, el turno sigue como si lo hubiera escrito.
      6. Modelo de lenguaje (Ollama) — El modelo responde con sus fases de siempre.
      7. Hermes (el bot) — Hermes prepara la respuesta en texto.
      8. Voz (Whisper + síntesis) — El sintetizador de voz local la convierte en audio.
      9. Matrix (sala del asistente) — Se envía a la sala como mensaje de voz, con el texto al lado.
      10. Yo, desde Element — La escucho en el móvil. La transcripción también queda en la memoria de conversaciones.
      Buscar en las tres memorias
      1. Herramientas — Una herramienta de búsqueda recibe «¿qué pasó con el disco tras el corte de luz?».
      2. Embeddings — La pregunta se convierte en un vector.
      3. Qdrant (base vectorial) — Qdrant busca por significado, no por palabras exactas.
      4. Mi documentación — En la documentación aparece el postmortem del apagón.
      5. Memoria de conversaciones — En las conversaciones aparece cuando lo hablamos aquella noche.
      6. Qdrant (base vectorial) — El código junta los resultados de las tres memorias y etiqueta de dónde viene cada uno. Antes el modelo confundía las tres búsquedas y llegó a decir que no tenía base semántica.
      7. Modelo de lenguaje (Ollama) — El modelo recibe los fragmentos con su fuente y los resume.
      8. Maquetado — La respuesta sale con el enlace a la nota.
      Un correo con una reserva
      1. Correo (solo lectura) — Llega un correo de confirmación de una reserva.
      2. Embeddings — Se indexa al momento, con el texto del PDF adjunto.
      3. Qdrant (base vectorial) — Queda guardado en la base vectorial para siempre.
      4. Hermes (el bot) — El vigilante del correo lo pasa a Hermes sin que nadie pregunte.
      5. Modelo de lenguaje (Ollama) — El modelo responde a dos preguntas cerradas, sin herramientas: ¿es importante? ¿es una reserva con fecha y hora? Interpreta el texto, pero no decide nada.
      6. Relevo del código — El código decide: comprueba si se solapa con algo que ya existe. Esa comprobación evitó 4 duplicados reales.
      7. Calendario — No se solapa: se crea el evento con el lugar en su campo y la descripción ordenada. Una orden escrita dentro de un correo no puede crear ni borrar nada.
      8. Matrix (sala del asistente) — Aviso en la sala de eventos, con un 🗑️ para deshacerlo.
      9. Yo, desde Element — Me entero sin abrir el correo.
      Un vigilante encuentra algo
      1. Los siete vigilantes — Uno de los siete vigilantes revisa su tema; por ejemplo, los certificados.
      2. Estado del servidor — Consulta el estado real: fechas de caducidad de los certificados y de los dominios.
      3. Los siete vigilantes — Encuentra uno que caduca pronto. Las fechas las calcula el código: el modelo llegó a confundir un certificado con el registro de un dominio.
      4. Maquetado — Prepara un aviso con estructura: qué pasa, cuándo y qué hacer.
      5. Matrix (sala del asistente) — Lo publica en su propia sala. Si todo está bien, no dice nada.
      6. Yo, desde Element — Me llega solo cuando hay algo que mirar.

      1. Modelo de lenguaje (Ollama)

        Un modelo de 8.000 millones de parámetros cuantizado a 4 bits: unos 5 GB. Se carga solo cuando se le pregunta y se descarga a los 5 minutos, para dejar la GPU libre para el resto del PC.

        • LLM locales (Ollama, Qdrant, RAG)

      2. Voz (Whisper + síntesis)

        Whisper convierte los audios en texto y un sintetizador local responde con voz. También en la GPU del PC.

        • LLM locales (Ollama, Qdrant, RAG)

      3. La GPU de 8 GB

        El límite de todo el diseño. Si el modelo no cabe entero, una parte corre en la CPU y la velocidad cae de 73 a 17 tokens por segundo. El simulador de abajo lo enseña con las medidas reales.

      4. Yo, desde Element

        Pregunto por texto o por audio desde el chat, esté donde esté.

      5. Correo (solo lectura)

        Se indexa al instante en cuanto llega (IMAP IDLE), con el texto de los PDF adjuntos. Solo la bandeja principal: ni promociones ni redes sociales.

      6. Calendario

        Lo único donde Hermes escribe: crea eventos desde correos de reserva y deja un 🗑️ para deshacerlo con una reacción.

      7. Matrix (sala del asistente)

        Mi servidor de mensajería. Hermes tiene su propio usuario y verifica su dispositivo solo: nada de avisos de «fuente no verificada».

      8. Hermes (el bot)

        El programa en Python que orquesta el turno: recibe el mensaje, prepara el contexto, llama al modelo, ejecuta herramientas y revisa la respuesta antes de enviarla.

        • Python

      9. Cola persistente

        Si el PC con la GPU está apagado, la pregunta no se pierde: se guarda en disco y se responde sola en cuanto vuelve.

        • Python

      10. Maquetado

        Convierte el Markdown en HTML para Element y deja una versión en texto plano para las notificaciones. Todo lo que viene de fuera (asuntos, títulos) se escapa: es dato, no marcado.

        • Python

      11. Fase 1 · Contexto que pone el código

        Instrucciones, la fecha de hoy con una tabla de los próximos 7 días y el historial resumido a pregunta y respuesta. El modelo no sabe qué día es: si no se le dice, razona con la fecha de su entrenamiento.

        • Python

      12. Fase 2 · Pistas según la pregunta

        Si la pregunta encaja con un patrón («qué pasó con…», «por dónde se entra…»), se añade una frase solo a ese turno. Nunca al prompt global: cuanto más texto general, peor elige un modelo de 8B.

        • Python

      13. Fase 3 · Razonar solo donde aporta

        Pensar multiplica por seis el tiempo. Se enciende para elegir herramienta y calcular argumentos, y cuando un resultado viene vacío o con un aviso; se apaga para redactar con los datos delante.

        • LLM locales (Ollama, Qdrant, RAG)
        • Python

      14. Fase 4 · Guardias de salida

        Antes de enviar, el código compara la respuesta con las fuentes del turno: una IP o un importe que no aparece en ninguna se devuelve al modelo para corregir. Si insiste, se envía con un aviso.

        • Python

      15. Herramientas

        Estado del servidor, agenda, correo y tres memorias. El código valida los argumentos antes de ejecutar («7» pasa a 7) y, si el modelo nombra una herramienta sin llamarla, le pide una vez que la llame.

        • Python

      16. Estado del servidor

        Instantáneas de la monitorización y la seguridad, inventario de contenedores, ZFS y discos. Cada dato va con su antigüedad: si tiene más de 30 minutos, el modelo lo sabe.

        • Python

      17. Los siete vigilantes

        Copias, certificados, almacenamiento, actualizaciones, uso anómalo, accesos fallidos y red. Cada uno con nombre de la mitología griega y su propia sala: solo hablan cuando encuentran algo raro.

        • Python

      18. Relevo del código

        Cuando una pregunta en realidad son dos («¿cuánto costó la entrada de lo que tengo el jueves?»), el modelo fallaba 3 de 3. Ahora el código da el segundo paso: mira la agenda, coge el título y lo busca en el correo.

        • Python

      19. Embeddings

        Convierten cada texto en un vector de números para poder buscar por significado y no solo por palabras.

        • LLM locales (Ollama, Qdrant, RAG)

      20. Qdrant (base vectorial)

        Guarda los vectores de las notas, los correos, los documentos que le paso y las conversaciones. El código busca en las tres memorias a la vez para que el modelo no tenga que adivinar cuál.

        • LLM locales (Ollama, Qdrant, RAG)

      21. Mi documentación

        Procedimientos, incidentes y postmortems del homelab. Hermes los lee, pero nunca escribe en ellos.

      22. Memoria de conversaciones

        Cada conversación, también los audios transcritos, se indexa: «¿qué hice la semana pasada con…?» tiene respuesta.

        • LLM locales (Ollama, Qdrant, RAG)

      Lo que uso de mi árbol

      Pulsa una habilidad: se encienden en el mapa las piezas donde la uso y te cuento para qué.

      Python
      El bot entero: el bucle del turno, la validación de argumentos, las guardias, el relevo de las preguntas de dos pasos, los vigilantes y unas 110 pruebas sin modelo ni red.
      LLM locales (Ollama, Qdrant, RAG)
      Ollama con qwen3:8b para el chat, un modelo de embeddings para buscar por significado, Qdrant como base vectorial y Whisper para la voz. Todo local, ajustado para caber en 8 GB de VRAM.
      Linux (Debian, Alpine, Arch)
      Servicios systemd con permisos mínimos (rutas de solo lectura, sin privilegios), en un contenedor dedicado; la GPU en un PC con Linux.
      Ansible
      El rol que despliega el bot, sus servicios y su configuración; los secretos van cifrados con Ansible Vault.

      ¿Cabe el modelo en la GPU?

      Con 8 GB, cada megabyte cuenta: el escritorio, el navegador o Steam se quedan con memoria de la GPU, y lo que no cabe del modelo corre en la CPU, mucho más lenta. Cambia la configuración y mira qué pasa con las medidas reales.

      Caché KV (la memoria del contexto)
      Abierto en el PC
      Al redactar la respuesta
      Modelo en la GPU
      Velocidad
      Turno con una herramienta
      VRAM libre

      tiempo ≈ carga + (tokens al elegir + tokens al redactar) ÷ velocidad

      Medidas del 22-09-2026 con nvidia-smi y la API de Ollama. La velocidad se interpola entre los puntos medidos (71 %, 78 %, 84 % y 100 % del modelo en la GPU); los tokens de redactar sin pensar son una estimación.

      Bitácora de incidencias

      Averías reales. Lee el síntoma, elige la causa que creas y mira cómo se arregló.

      1. #1

        «El año 2026 es inconsistente»

        Septiembre de 2026 · agenda

        Al pedirle que creara un evento «el jueves que viene», Hermes respondió que la fecha no tenía sentido y que 2026 era «inconsistente». Otro día dijo «martes 28» cuando el 28 era lunes.

        ¿Qué crees que pasaba?

        Ver la solución
        Causa
        Un modelo de lenguaje no tiene reloj. Sin una fecha en el contexto, razona con la de sus datos de entrenamiento, y calcular el día de la semana tampoco se le da bien.
        Solución
        El código pone en cada turno la fecha y hora reales y una tabla con los próximos 7 días ya calculados. El día de la semana de cada evento también lo calcula el código.
        Lección
        Las fechas no se le piden al modelo: se le dan hechas.

      2. #2

        Después de una herramienta, ninguna más

        Septiembre de 2026 · conversación

        Tras una pregunta que usaba una herramienta, las preguntas siguientes de la misma conversación no usaban ninguna, ni pidiéndoselo por su nombre. Reforzar las instrucciones dio 0 de 4.

        ¿Qué crees que pasaba?

        Ver la solución
        Causa
        El historial guardaba los resultados intermedios de las herramientas, con JSON de muchos campos. Al modelo de 8B esos bloques le cambiaban el comportamiento en los turnos siguientes.
        Solución
        El historial de turnos pasados se resume a solo pregunta y respuesta final, sin los pasos intermedios. Verificado: 3 de 3 en la conversación real que había fallado.
        Lección
        Cuando más instrucciones no arreglan algo, la causa suele ser estructural: hay que cambiar lo que recibe el modelo, no lo que se le pide.

      3. #3

        141 segundos para una pregunta

        22-09-2026 · rendimiento

        Por la tarde una pregunta sencilla tardó 141 s y un caso de la batería que por la mañana pasaba 5 de 5 fallaba 8 de 8, con el mismo código.

        ¿Qué crees que pasaba?

        Ver la solución
        Causa
        Con un juego y el navegador abiertos, solo cabía en la GPU el 66 % del modelo; el resto corría en la CPU a 10 tokens por segundo. Además, al repartirse, los cálculos cambian un poco y los casos que están al límite se vuelcan.
        Solución
        Caché KV cuantizada a q8_0, flash attention, una sola petición y un solo modelo cargado a la vez. Con el navegador cerrado, el modelo entra al 100 %: de 17,5 a 73 tokens por segundo, y la batería subió de 106 a 114 de 120.
        Lección
        Antes de culpar al modelo, mira dónde corre. Ahora cada medición anota la versión de Ollama y qué porcentaje del modelo estaba en la GPU.

      4. #4

        Una IP pública inventada

        23-09-2026 · guardias

        Le pregunté por la IP pública de casa y respondió con una dirección con formato perfecto… que no era la mía. La correcta estaba en el resultado de la herramienta que acababa de usar.

        ¿Qué crees que pasaba?

        Ver la solución
        Causa
        Los modelos pequeños a veces completan con algo que «suena bien». Una IP con buen formato es justo eso: no hay manera de distinguirla a ojo.
        Solución
        Una guardia de salida busca cada IP y cada importe de la respuesta en las fuentes del turno. Si no aparece (o no es una suma de importes que sí aparecen), se pide corregir; si insiste, se envía con un aviso. Cuesta 0,09 ms.
        Lección
        Las guardias no deben saltar con datos buenos: un aviso que salta de más enseña a ignorarlo. Por eso las sumas legítimas se aceptan, sin límite de conceptos.

      5. #5

        Un día sin planes que no lo era

        25-09-2026 · resumen diario

        El resumen de la mañana dijo que no tenía nada en la agenda. Sí tenía cosas.

        ¿Qué crees que pasaba?

        Ver la solución
        Causa
        La autorización con el calendario se revocó por la noche. La consulta fallaba, y el resumen trataba el fallo como «no hay eventos».
        Solución
        Reautorizado, y ahora un fallo de una fuente se dice como fallo: «no he podido leer el calendario». Si el modelo redacta «no he encontrado nada» tras un error, el código añade el aviso.
        Lección
        «No hay nada» y «no he podido comprobarlo» no son lo mismo: el primero dice que el dato no existe y el segundo que el sistema está roto.

      Contado entero en un artículo:

      Cómo se construyó

      1. 22-09-2026

        Fase 0 · Medir mejor

        • Una línea de log por llamada al modelo: tokens de entrada y salida, tiempo de carga, velocidad y qué porcentaje del modelo estaba en la GPU.
        • Detector de «narración»: cuando el modelo dice «usa la herramienta X» en vez de llamarla.
        • La primera medida real destapó el problema: 141 s en una pregunta, 954 tokens de razonamiento solo para redactar.

      2. 22-09-2026

        Fase 1 · Que el modelo quepa en 8 GB

        • Flash attention y caché KV en q8_0: el contexto ocupa la mitad.
        • Una sola petición y un solo modelo cargado a la vez: cada petición paralela añade su propia caché.
        • Descubrir que el cuello no era el modelo sino el escritorio: el navegador se llevaba 805 MiB de VRAM.
        • Resultado: 4,2× más rápido y 8 fallos menos en la batería.

      3. 22-09-2026

        Fase 2 · Menos texto por turno (descartada)

        • Juntar herramientas para enviar menos texto: de 24 a 16.
        • El prompt bajó, pero la batería también: de 118 a 112 de 120.
        • Lección: para un modelo de 8B, el nombre de una herramienta pesa más que su descripción, y esconder capacidades detrás de un parámetro las hace invisibles.

      4. 22 y 23-09-2026

        Fase 3 · Robustez por código

        • Validación de argumentos contra el esquema y errores legibles que el modelo puede corregir.
        • Razonamiento adaptativo: pensar para elegir, no para redactar (de 4,7 a 0,7 s).
        • Guardias de salida para IPs e importes, relevo del código en preguntas de dos pasos y avisos cuando una fuente se cae.

      5. Pendiente

        Fase 4 y 5 · Modelo y dónde se procesa

        • Probar la misma familia con más bits (Q5_K_M) solo si cabe con el mismo contexto.
        • Mover el modelo al servidor cuando tenga una GPU propia: 1U de alto y 70 W por el slot. La candidata es una tarjeta pasiva de 16 GB.

      Decisiones (y por qué)

      • Dónde corre el modelo

        En local, en mi GPU

        Nada sale de mi red: el asistente lee mi correo y mi agenda. Probé un modelo de 14B y no cabía en 8 GB: el mismo fallo y de 4 a 8 veces más lento. La CPU del servidor no tiene AVX2: serían minutos por respuesta.

      • Cómo se consigue precisión con un modelo pequeño

        Mover reglas del prompt al código

        Añadir texto al prompt empeoró la batería (96 frente a 105 de 111) y los ejemplos hacían que imitara la forma de la frase, no su sentido. Lo que funcionó fue que el código calcule fechas, días, vencimientos, sumas y tipos, y que el modelo solo entienda y redacte.

      • Cómo se decide un cambio

        Medirlo con 3 semillas, caso por caso

        Cada cambio se mide por separado y solo se despliega si no hay regresiones. Además de la batería, hay pruebas contra producción y preguntas reales, porque la batería usa datos sintéticos y no ve una herramienta caída.

      • Qué puede tocar el modelo

        Leer casi todo, escribir casi nada

        El modelo interpreta y el código decide si se escribe algo. Por eso una orden escrita dentro de un correo no puede crear ni borrar nada, y los reintentos automáticos nunca se aplican a herramientas de escritura.

      Lo que aprendí

      • Con un modelo pequeño, la precisión no sale del modelo: sale de lo que el código hace a su alrededor.
      • Cuanto más texto general recibe un modelo de 8B, peor elige. Aislar una tarea la arregla.
      • La memoria de la GPU es parte del diseño: un navegador abierto cambiaba la velocidad por cuatro y el resultado de la batería.
      • Medir con varias semillas y con preguntas reales: la mitad de los fallos importantes no salían en la batería.

      Lo siguiente

      • Una GPU propia para el servidor, para que Hermes no dependa de que mi PC esté encendido.
      • Revisar los criterios de la batería: algunos casos medían la redacción y no el fondo.
      • Resolver las preguntas sobre incidentes pasados, que aún van a veces a las herramientas de estado actual.

      ¿Hablamos?

      Puedo contar cualquiera de estas decisiones en detalle en una entrevista.

      Descargar CV Contactar ← Volver al rack

      Reconstrucción a partir de mi documentación de Obsidian. Sin direcciones, nombres de máquinas ni datos personales: las respuestas de ejemplo son inventadas.