README.md

---
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. Arquitectura de tres piezas: base `Qwen/Qwen3-4B-Instruct-2507` **congelada e intacta** + un LoRA angosto + spores de conocimiento, 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 angosto** que lo especializa como cerebro de agente. La base queda **congelada**: la habilidad viene del LoRA y el **conocimiento** viene de los spores (sección siguiente) — no de re-entrenar el modelo entero. 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.

### 🧬 Spores de conocimiento (dataset companion)

El proyecto Daimon también publica **[daimon-spores](https://huggingface.co/datasets/lucas-mella/daimon-spores)**: un banco de 17 dominios
de herramientas (uv, docker, react, pytest…) como **KV-caches portables** — un manual
pasado UNA vez por el modelo, cuantizado int4+LZMA (~5.5×), que se antepone como
prefijo de cache para que el modelo "recuerde" el manual **sin gastar tokens de contexto**.
Medido con 3 brazos (base / RAG / spore): uv pasa de 8% → **96%** (supera al RAG).

⚠️ Importante: los spores NO se aplican sobre este adapter. Se atan a `Qwen/Qwen2.5-Coder-1.5B` (base, no Instruct) — otro modelo del mismo ecosistema; daimon-r sigue siendo el cerebro agéntico.
El dataset incluye un loader autocontenido y los benchmarks congelados para reproducir la tabla.

### 🎯 Benchmark de la tarea de Daimon (in-house, harness público)

Este benchmark lo construimos NOSOTROS (nuestro, harness abierto): mide la tarea
específica para la que existe este LoRA — elegir la acción JSON correcta como
agente de navegador/computadora/código de Daimon. Es held-out (vocabulario
disjunto del entrenamiento), determinístico y el harness es código abierto,
pero es nuestra propia cancha y corresponde decirlo.

<div align="center">
<img src="https://huggingface.co/lucas-mella/Daimon-R/resolve/main/daimon-r-benchmarks-light.png" width="640" alt="benchmark agente 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.*

### 💻 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 trabajo del LoRA — 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>&lt;tool_call&gt;</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.
Three-piece architecture — frozen `Qwen/Qwen3-4B-Instruct-2507` base + a narrow LoRA + knowledge spores — 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`)

### 🧬 Knowledge spores (companion dataset)

The Daimon project also ships **[daimon-spores](https://huggingface.co/datasets/lucas-mella/daimon-spores)**: 17 tool domains (uv, docker,
react, pytest…) as **portable KV-caches** — a manual run once through the model,
int4+LZMA quantized (~5.5×), prepended as a cache prefix so the model "remembers" the
manual **without spending context tokens**. 3-arm benched (base / RAG / spore):
uv goes 8% → **96%** (beats RAG).

⚠️ Note: spores do NOT apply on top of this adapter. They bind to `Qwen/Qwen2.5-Coder-1.5B` (base, not Instruct) — a different model in the same ecosystem; daimon-r remains the agentic brain.
The dataset bundles a self-contained loader and frozen benches to reproduce the table.

---

<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>