| ---
|
| license: apache-2.0
|
| base_model: Qwen/Qwen3-4B-Instruct-2507
|
| language:
|
| - es
|
| - en
|
| tags:
|
| - daimon
|
| - lora
|
| - tool-calling
|
| - agent
|
| - code
|
| - spanish
|
| library_name: gguf
|
| ---
|
|
|
| <div align="center">
|
| <img src="https://huggingface.co/lucas-mella/Daimon-R/resolve/main/daimon-R.png" width="220" alt="daimon r"/>
|
| </div>
|
|
|
| ---
|
|
|
| ## 🇪🇸 Español
|
|
|
| **daimon r** es el cerebro razonador (4B) de **Daimon**, un asistente personal local-first:
|
| corre en tu máquina, no en la nube. Fine-tune **LoRA** de `Qwen/Qwen3-4B-Instruct-2507` para el núcleo
|
| de Daimon: **acciones de agente (tool-calling JSON), código y conversación en español nativo**.
|
|
|
| **Qué es exactamente**: el modelo base `Qwen/Qwen3-4B-Instruct-2507` (GGUF cuantizado, intacto) + un
|
| **LoRA de ~66MB** que lo especializa como cerebro de agente. Es un modelo estándar:
|
| funciona con llama.cpp / LM Studio / cualquier stack GGUF, **sin necesidad del software
|
| de Daimon** — abajo está el contrato completo de prompts para usarlo standalone.
|
|
|
| ### 📊 Benchmark (medido, reproducible)
|
|
|
| <div align="center">
|
| <img src="https://huggingface.co/lucas-mella/Daimon-R/resolve/main/daimon-r-benchmarks-light.png" width="640" alt="benchmark daimon r vs base"/>
|
| </div>
|
|
|
| | Métrica (198 casos held-out) | Base Qwen3-4B-Instruct-2507 | **daimon r** | |
|
| |---|---|---|---|
|
| | JSON válido / valid JSON | 100.0% | **100.0%** | ➖ empata |
|
| | Acción correcta / correct action | 75.3% | **100.0%** | ✅ gana |
|
| | Acción + campos correctos / correct fields | 47.5% | **100.0%** | ✅ gana |
|
|
|
| *Benchmark objetivo y reproducible: 198 escenarios sintéticos held-out (vocabulario
|
| disjunto del entrenamiento, cero solapamiento textual), calificados determinísticamente —
|
| JSON parseable, acción esperada, campos correctos (`ref`/`path`/`command`/…). Sin juez LLM.
|
| Medido sobre estos GGUF exactos servidos con llama.cpp. Script:
|
| [`agent_actions_eval.py`](https://github.com/lucasmella-stack/daimon) — los JSONs de
|
| resultados se generan antes de cada publicación.*
|
|
|
| ### 🔍 Benchmarks de la comunidad (independientes de nuestro propio bench)
|
|
|
| Además del benchmark de agent-actions de arriba (que es nuestro propio esquema),
|
| corrimos Qwen3-4B-Instruct-2507 y este modelo contra benchmarks ESTÁNDAR de la comunidad,
|
| en las mismas condiciones exactas (misma cuantización GGUF, mismo serving,
|
| mismo harness) para que la comparación sea justa:
|
|
|
| | Benchmark | Base Qwen3-4B-Instruct-2507 | **Este modelo** | |
|
| |---|---|---|---|
|
| | HumanEval | 74.4% | **72.0%** | ❌ pierde |
|
| | MBPP | 82.5% | **75.8%** | ❌ pierde |
|
| | MMLU (subset) | 68.4% | **68.4%** | ➖ empata |
|
| | BFCL-lite (tool-calling estandar) | 76.0% | **77.0%** | ✅ gana |
|
|
|
| *HumanEval/MBPP: pass@1 con ejecución real de tests ocultos (no similitud de
|
| texto). MMLU: subset de 15 materias, precisión 0-shot. BFCL-lite: subset AST
|
| del Berkeley Function-Calling Leaderboard v3 (simple/multiple/parallel/
|
| parallel_multiple/irrelevance) — mide tool-calling en un esquema DISTINTO al
|
| nuestro.*
|
|
|
| **El trade-off, explícito**: este LoRA es un **especialista de agente**, no un
|
| fine-tune general-purpose. Los puntos que cede en código/conocimiento general
|
| son el costo deliberado de la ganancia enorme en su tarea núcleo (la tabla de
|
| arriba: de ~47% a ~100% en acciones correctas). Para programar "a mano" usá el
|
| modelo base; para operar como agente de Daimon, este. Si una dimensión pierde,
|
| se muestra perdiendo — preferimos que la card sea creíble a que sea linda.
|
|
|
| ### 🧠 Con qué se entrenó (por contribución)
|
|
|
| - **Acciones de agente (in-house, sintético)** — escenarios browser/computer/code con el
|
| esquema JSON exacto de producción de Daimon (`{"thought": …, "action": "click", "ref": …}`),
|
| generados por construcción (la respuesta correcta se conoce con certeza, sin teacher API).
|
| Es lo que mueve las tres métricas de arriba.
|
| - **Comportamiento e identidad Daimon (in-house)** — 231 seeds: persona en primera persona,
|
| honestidad ante lo que no sabe, registro rioplatense conciso, convención de canvas HTML.
|
| - El **código, el razonamiento y el multilingüe** vienen del modelo base (por eso el LoRA es
|
| chico y el nivel de código se mantiene intacto). Probamos también mezclas grandes con
|
| datasets públicos (xLAM, ToolACE, código, español nativo) y fine-tunes sobre el historial
|
| real de commits — **ninguna de esas variantes le ganó a esta en el gate, así que no se
|
| publicaron**. Solo publicamos lo que gana una comparación pre-registrada contra el base.
|
|
|
| ### 💻 Requisitos de hardware
|
|
|
| | Recurso | Requisito |
|
| |---|---|
|
| | Disco | ~2.6 GB (base GGUF + LoRA) |
|
| | RAM | 8 GB mínimo |
|
| | GPU / memoria unificada | ≥ 4 GB VRAM (ej. GTX 1650) o Apple Silicon ≥ 8 GB de memoria unificada |
|
|
|
| ### ✅ Probalo vos mismo (verificable)
|
|
|
| ```bash
|
| huggingface-cli download lucas-mella/Daimon-R --local-dir ./daimon
|
| llama-server -m ./daimon/Qwen3-4B-Instruct-2507-Q4_K_M.gguf --lora ./daimon/daimon-r-lora-f16.gguf -c 4096
|
| ```
|
|
|
| Después probá una acción de agente (el núcleo de lo que se entrenó — este es un caso
|
| real del set de evaluación, verificado contra estos pesos exactos antes de publicar):
|
|
|
| ```bash
|
| curl -s http://127.0.0.1:8080/v1/chat/completions -H "Content-Type: application/json" -d '{
|
| "temperature": 0,
|
| "messages": [
|
| {"role": "system", "content": "Sos el navegador autónomo de Daimon. En cada paso recibís el objetivo, la página actual (elementos interactivos con su ref + texto visible) y el historial. Respondé SOLO con un objeto JSON de esta forma:\n{\"thought\":\"...\",\"action\":\"navigate|click|fill|scroll|back|done\",\"ref\":<n>,\"text\":\"...\",\"url\":\"...\"}"},
|
| {"role": "user", "content": "Objetivo: poné 'gatos' en 'Email'\n\nURL: https://un-sitio-de-noticias.test/\nTítulo: Un Sitio De Noticias\nElementos:\n [0] input \"Nombre\"\n [1] input \"Email\"\nTexto:\nun sitio de noticias\n\nHistorial: (vacío)\n\nPróxima acción (JSON):"}
|
| ]
|
| }'
|
| ```
|
|
|
| Respuesta esperada (un único objeto JSON, sin prosa alrededor):
|
| `{"thought": "…", "action": "fill", "ref": 1, "text": "gatos"}`
|
|
|
| SHA-256 del LoRA publicado: `ee6ad40ac3e2c6019a4526b0f0ce6c423b16a32a875315b24008e6c789149f06`.
|
|
|
| ### 🔌 Cómo usarlo standalone (sin el software de Daimon)
|
|
|
| El modelo no depende de ninguna app: es un GGUF estándar servido con llama.cpp
|
| (o LM Studio, Ollama con adapter, etc.). Lo único que necesitás es hablarle con
|
| los **system prompts con los que fue entrenado**. Tiene 4 modos:
|
|
|
| <details>
|
| <summary><b>1. Agente de navegador</b> — devuelve UNA acción JSON por paso</summary>
|
|
|
| System prompt (exacto):
|
| ```text
|
| Sos el navegador autónomo de Daimon. En cada paso recibís el objetivo, la página actual (elementos interactivos con su ref + texto visible) y el historial. Respondé SOLO con un objeto JSON de esta forma:
|
| {"thought":"...","action":"navigate|click|fill|scroll|back|done","ref":<n>,"text":"...","url":"...","answer":"..."}
|
| - navigate requiere url. click/fill requieren ref (de la lista). fill además text.
|
| - Cuando cumpliste el objetivo: action='done' y poné el resultado en answer.
|
| - Un solo JSON, sin markdown ni texto extra.
|
| ```
|
| En el user message pasás: `Objetivo: ...`, la URL/título, la lista de elementos
|
| (`[0] input "Email"` …), el texto visible y el historial. Respuesta:
|
| `{"thought": "…", "action": "fill", "ref": 1, "text": "gatos"}`.
|
| </details>
|
|
|
| <details>
|
| <summary><b>2. Agente de computadora</b> — click/type/key/hotkey/scroll sobre una ventana</summary>
|
|
|
| System prompt (exacto):
|
| ```text
|
| Sos el control de computadora de Daimon. Cada paso recibís el objetivo, la ventana actual (elementos con su ref + nombre) y el historial. Respondé SOLO con un JSON:
|
| {"thought":"...","action":"click|type|key|hotkey|scroll|done","ref":<n>,"text":"...","key":"...","keys":["ctrl","c"],"dy":<n>,"answer":"..."}
|
| - click requiere ref (de la lista). type escribe text en el foco actual. key presiona una tecla; hotkey una combinación (keys). scroll usa dy (negativo = abajo).
|
| - Cuando cumpliste el objetivo: action='done' con answer.
|
| - Un solo JSON, sin markdown ni texto extra.
|
| ```
|
| </details>
|
|
|
| <details>
|
| <summary><b>3. Agente de código</b> — read_file/write_file/run/done sobre un workspace</summary>
|
|
|
| System prompt (exacto):
|
| ```text
|
| Sos el agente de código autónomo de Daimon. Trabajás sobre el repo real. En cada paso recibís la tarea, el árbol del workspace y el historial de acciones/observaciones. Respondé SOLO con un JSON:
|
| {"thought":"...","action":"read_file|write_file|run|done","path":"rel/ruta","content":"...","command":"...","answer":"..."}
|
| - read_file: leé antes de editar. write_file: contenido COMPLETO del archivo. run: comandos de verificación (tests/build) o shell. done: cuando terminaste, con answer.
|
| - Editá de a poco y verificá con tests/build. Un solo JSON, sin markdown.
|
| ```
|
| </details>
|
|
|
| <details>
|
| <summary><b>4. Tool-calling genérico</b> — formato estándar <code><tool_call></code> de Qwen</summary>
|
|
|
| Para function-calling clásico (tus propias tools con JSON schema), usá el
|
| formato nativo: listá las herramientas en el system prompt y pedí respuestas
|
| `<tool_call>\n{"name": ..., "arguments": {...}}\n</tool_call>`. Medido en
|
| BFCL-lite (tabla de abajo) — el fine-tune lo mantiene por encima del base.
|
| </details>
|
|
|
| El loop del agente (ejecutar la acción, observar, re-prompt con el historial)
|
| lo implementás vos — el modelo es el cerebro que decide la próxima acción.
|
|
|
| ---
|
|
|
| ## 🇬🇧 English
|
|
|
| **daimon r** is the 4B reasoning brain of **Daimon**, a local-first personal AI assistant.
|
| LoRA fine-tune of `Qwen/Qwen3-4B-Instruct-2507` for Daimon's core: **agent actions (JSON tool-calling),
|
| code, and native-Spanish conversation**. Benchmark table above — measured on these exact
|
| GGUFs, deterministic grading, no LLM judge; losing dimensions are shown losing.
|
|
|
| Hardware: ~2.6 GB disk, 8 GB+ RAM, GPU optional — see the Spanish
|
| table (unified-memory Apple Silicon works via llama.cpp Metal).
|
|
|
| ### Files
|
|
|
| - `Qwen3-4B-Instruct-2507-Q4_K_M.gguf` — base model (GGUF)
|
| - `daimon-r-lora-f16.gguf` — Daimon LoRA (apply with `--lora`)
|
|
|
| ---
|
|
|
| <sub>Base: Qwen/Qwen3-4B-Instruct-2507 (Apache-2.0). LoRA + data mix: Daimon project — coming soon.
|
| Watch <a href="https://huggingface.co/lucas-mella">@lucas-mella</a>.</sub>
|
| |
