Upload README.md with huggingface_hub

README.md

@@ -26,6 +26,11 @@ library_name: gguf
 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">
@@ -56,17 +61,21 @@ mismo harness) para que la comparación sea justa:
 |---|---|---|---|
 | HumanEval | 74.4% | **72.0%** | ❌ pierde |
 | MBPP | 82.5% | **75.8%** | ❌ pierde |
-| MMLU (subset) | 68.4% | **67.2%** | ❌ 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. Si el fine-tune pierde en alguna dimensión, se muestra perdiendo:
-el LoRA se entrenó para el núcleo de Daimon (agent-actions), no es un
-fine-tune general-purpose, y ese trade-off queda documentado acá en vez de
-escondido.
+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)
 
@@ -115,6 +124,65 @@ Respuesta esperada (un único objeto JSON, sin prosa alrededor):
 
 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