app model check

Dockerfile

@@ -16,8 +16,11 @@ WORKDIR /app
 COPY pyproject.toml uv.lock .python-version README.md models.yaml ./
 COPY apps/gradio-space/pyproject.toml apps/gradio-space/README.md apps/gradio-space/
 COPY libs/inference/pyproject.toml libs/inference/README.md libs/inference/
+COPY libs/agent/pyproject.toml libs/agent/README.md libs/agent/
 COPY apps/gradio-space/src apps/gradio-space/src
 COPY libs/inference/src libs/inference/src
+COPY libs/agent/src libs/agent/src
+COPY skills skills
 
 RUN useradd -m -u 1000 user && \
     uv sync --frozen --no-dev --package gradio-space && \
@@ -25,7 +28,11 @@ RUN useradd -m -u 1000 user && \
 
 USER user
 ENV HOME=/home/user \
-    PATH="/app/.venv/bin:$PATH"
+    PATH="/app/.venv/bin:$PATH" \
+    AGENT_OUTPUTS_DIR=/tmp/agent_outputs \
+    AGENT_TRACES_DIR=/tmp/agent_traces
+
+RUN mkdir -p /tmp/agent_outputs /tmp/agent_traces
 
 EXPOSE 7860
 

README.md

@@ -1,7 +1,7 @@
 ---
 
-## title: Small Model Hackathon
-emoji: 🦙
+## title: Lesson Agent
+emoji: 📚
 colorFrom: blue
 colorTo: green
 sdk: docker
@@ -9,11 +9,13 @@ app_port: 7860
 pinned: false
 license: apache-2.0
 
-# Small Model Hackathon
+# Lesson Agent
 
-Gradio chat Space for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon). Runs local inference with **llama.cpp** (GGUF) by default; optional **transformers** backend via env.
+**Backyard AI** Gradio Space for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon).
 
-See **[USAGE.md](USAGE.md)** for local run, Docker smoke test, and HF Space deployment steps.
+A local skill-based agent helps a teacher you know turn a **topic + grade level** into a downloadable **PowerPoint** — powered by a small transformers model (`MiniCPM5-1B` by default), no cloud LLM API.
+
+See **[USAGE.md](USAGE.md)** for local run, Docker smoke test, and HF Space deployment.
 
 ## Prerequisites
 
@@ -26,81 +28,75 @@ See **[USAGE.md](USAGE.md)** for local run, Docker smoke test, and HF Space depl
 uv sync --all-packages
 cp .env.example .env   # optional: edit model settings
 
-# Download GGUF for offline dev (optional)
-uv run python scripts/download_model.py
-
 # Run Gradio locally
 uv run --package gradio-space python -m gradio_space.app
 ```
 
-Open [http://localhost:7860](http://localhost:7860). The model downloads from Hugging Face Hub on the first chat message (or set `MODEL_PATH` to a local GGUF).
-
-## Environment variables
-
-
-| Variable            | Default                           | Description                                |
-| ------------------- | --------------------------------- | ------------------------------------------ |
-| `INFERENCE_BACKEND` | `llama_cpp`                       | `llama_cpp` or `transformers`              |
-| `MODEL_REPO`        | `Qwen/Qwen2.5-3B-Instruct-GGUF`   | Hub repo for GGUF                          |
-| `MODEL_FILE`        | `qwen2.5-3b-instruct-q4_k_m.gguf` | GGUF filename                              |
-| `MODEL_PATH`        | —                                 | Local GGUF path (skips Hub download)       |
-| `N_CTX`             | `4096`                            | Context window                             |
-| `N_GPU_LAYERS`      | `0`                               | GPU layers for llama.cpp (0 = CPU)         |
-| `MODEL_ID`          | `Qwen/Qwen2.5-3B-Instruct`        | Used when `INFERENCE_BACKEND=transformers` |
-
+Open [http://localhost:7860](http://localhost:7860). Use the **Lesson slides** tab: enter a topic, grade, and slide count. The model loads on first generate.
 
-See `[.env.example](.env.example)` for a full template.
+## How it works
 
-## Monorepo layout
+1. **Skill** — `skills/education-pptx/SKILL.md` (Hermes / agentskills.io format)
+2. **LLM** — local model drafts a JSON slide outline
+3. **Tool** — `create_pptx` builds the file with `python-pptx`
+4. **Trace** — JSON log saved under `outputs/traces/` for the Sharing is Caring badge
 
 ```text
-apps/gradio-space/   # Gradio UI (HF Space entrypoint)
-libs/inference/      # Swappable inference backends
-scripts/             # Dev utilities
+apps/gradio-space/   # Gradio tabs (Lesson slides + Chat debug)
+libs/agent/          # Skill agent runner, tools, trace recorder
+libs/inference/      # Transformers + llama.cpp backends
+skills/              # SKILL.md task definitions
 ```
 
-### Common commands
+## Environment variables
 
-```bash
-uv add --package gradio-space <package>
-uv add --package inference <package>
-uv run --package gradio-space python -m gradio_space.app
-uv run python -c "from inference.factory import get_backend"
-```
+| Variable | Default | Description |
+| -------- | ------- | ----------- |
+| `ACTIVE_MODEL` | `minicpm5-1b` | Preset key from `models.yaml` |
+| `AGENT_OUTPUTS_DIR` | `/tmp/agent_outputs` | Generated `.pptx` files |
+| `AGENT_TRACES_DIR` | `outputs/traces` | Agent trace JSON |
+| `SKILLS_DIR` | `./skills` | Skill definitions root |
+
+See [`.env.example`](.env.example) and [`models.yaml`](models.yaml) for model presets.
 
 ## Hugging Face Space deployment
 
 1. Create a Space under [build-small-hackathon](https://huggingface.co/build-small-hackathon) with **Docker** SDK.
 2. Link this repository (root `Dockerfile` + root `README.md` YAML above).
-3. Hardware: start with **CPU basic**; upgrade to GPU if you set `N_GPU_LAYERS > 0`.
-4. Add Space secrets: `MODEL_REPO`, `MODEL_FILE`, `N_CTX`, `N_GPU_LAYERS`.
+3. Hardware: **GPU basic** recommended for transformers (`minicpm5-1b`).
+4. Optional secrets: `ACTIVE_MODEL`, `N_GPU_LAYERS` (if using GGUF preset).
 
 ```bash
-# Optional local Docker smoke test
 docker build -t hackathon-space .
-docker run --rm -p 7860:7860 -e MODEL_REPO=Qwen/Qwen2.5-3B-Instruct-GGUF hackathon-space
+docker run --rm -p 7860:7860 -e ACTIVE_MODEL=minicpm5-1b hackathon-space
 ```
 
 ## Hackathon checklist
 
-- Choose a track (Backyard AI or Thousand Token Wood)
+- **Track:** Backyard AI — lesson slide builder for a teacher you know
 - Space live under build-small-hackathon
-- Demo video recorded
+- Demo video: real user enters topic → download `.pptx` → show agent trace
 - Social post published
-- Submission locked in by **June 15, 2026**
+- Submission by **June 15, 2026**
 
 ### Badge targets
 
-- **Off-the-Grid** — local llama.cpp inference (default setup)
-- **Llama Champion** — llama.cpp + GGUF model
-- **Off-Brand** — custom UI via `gr.Server` (Phase 2)
-- **Sharing is Caring** — agent traces dataset (Phase 2)
+- **Best Agent** — skill loop + `create_pptx` tool
+- **Tiny Titan** — MiniCPM5 1B (≤4B)
+- **OpenBMB** — `openbmb/MiniCPM5-1B`
+- **Sharing is Caring** — upload traces with `scripts/upload_trace.py`
+- **Off-the-Grid** — local inference only (no cloud LLM API)
+- **Well-Tuned** — optional fine-tuned preset in `models.yaml` (Phase 2)
 
-## Transformers backend (optional)
+## Agent trace upload
 
 ```bash
-uv sync --package inference --extra transformers
-INFERENCE_BACKEND=transformers MODEL_ID=Qwen/Qwen2.5-3B-Instruct \
-  uv run --package gradio-space python -m gradio_space.app
+uv run python scripts/upload_trace.py --repo-id YOUR_USER/build-small-agent-traces
 ```
 
+## Demo video script
+
+1. Introduce the teacher and the problem (building a 5-slide lesson takes 30+ minutes).
+2. Open **Lesson slides**, enter topic + grade, click **Generate**.
+3. Show outline preview and download the `.pptx`.
+4. Expand the agent trace JSON — local model, no cloud API.

apps/gradio-space/pyproject.toml

@@ -8,11 +8,13 @@ authors = [
 ]
 requires-python = ">=3.12"
 dependencies = [
+    "agent",
     "gradio>=5.0.0",
     "inference",
 ]
 
 [tool.uv.sources]
+agent = { workspace = true }
 inference = { workspace = true }
 
 [build-system]

apps/gradio-space/src/gradio_space/app.py

@@ -2,7 +2,6 @@ import os
 
 import gradio as gr
 
-from gradio_space.model_loading import warmup
 from gradio_space.tabs import build_chat_tab, build_education_pptx_tab
 from inference.config import get_app_config
 
@@ -38,8 +37,6 @@ Part of the [Build Small Hackathon](https://huggingface.co/build-small-hackathon
             with gr.Tab("Chat (debug)"):
                 build_chat_tab()
 
-        demo.load(lambda: warmup(_app_config.active_model))
-
     return demo
 
 

apps/gradio-space/src/gradio_space/model_loading.py

@@ -76,3 +76,26 @@ def warmup(model_key: str | None = None) -> str:
 def model_status(model_key: str) -> str:
     model = get_model_config(model_key)
     return f"**{model.label}**\n\n- Backend: `{model.backend}`\n- {warmup(model_key)}"
+
+
+def _history_to_messages(history: list) -> list[dict[str, str]]:
+    messages: list[dict[str, str]] = []
+    for item in history:
+        if isinstance(item, dict):
+            messages.append({"role": item["role"], "content": item["content"]})
+        else:
+            user_msg, assistant_msg = item
+            messages.append({"role": "user", "content": user_msg})
+            if assistant_msg:
+                messages.append({"role": "assistant", "content": assistant_msg})
+    return messages
+
+
+def chat(message: str, history: list, model_key: str) -> str:
+    load_error = ensure_model_loaded(model_key)
+    if load_error:
+        return load_error
+
+    messages = _history_to_messages(history)
+    messages.append({"role": "user", "content": message})
+    return get_backend(model_key).chat(messages)

apps/gradio-space/src/gradio_space/tabs/chat.py

@@ -1,37 +1,11 @@
 import gradio as gr
 
-from gradio_space.model_loading import (
-    chat as chat_fn,
-    ensure_model_loaded,
-    get_active_model_key,
-    model_status,
-    warmup,
-)
+from gradio_space.model_loading import chat, model_status, warmup
 from inference.config import get_app_config
 
 _app_config = get_app_config()
 
 
-def _history_to_messages(history: list) -> list[dict[str, str]]:
-    messages: list[dict[str, str]] = []
-    for item in history:
-        if isinstance(item, dict):
-            messages.append({"role": item["role"], "content": item["content"]})
-        else:
-            user_msg, assistant_msg = item
-            messages.append({"role": "user", "content": user_msg})
-            if assistant_msg:
-                messages.append({"role": "assistant", "content": assistant_msg})
-    return messages
-
-
-def chat(message: str, history: list, model_key: str) -> str:
-    load_error = ensure_model_loaded(model_key)
-    if load_error:
-        return load_error
-    return chat_fn(message, history, model_key)
-
-
 def build_chat_tab() -> None:
     gr.Markdown(
         """
@@ -41,7 +15,7 @@ Test the active local model with a simple chat interface.
 """
     )
 
-    model_key = get_active_model_key()
+    model_key = _app_config.active_model
 
     if _app_config.allow_model_switch and len(_app_config.models) > 1:
         model_dropdown = gr.Dropdown(
@@ -68,4 +42,3 @@ Test the active local model with a simple chat interface.
                 "Explain photosynthesis in one sentence.",
             ],
         )
-        gr.on(fn=lambda: warmup(model_key), outputs=status)

libs/agent/tests/test_runner.py

@@ -0,0 +1,23 @@
+from agent.models import SlideOutline, SlideSpec
+from agent.runner import AgentRunner
+from agent.tools.pptx import create_pptx
+
+
+def test_extract_json_from_fenced_block():
+    raw = '```json\n{"title": "T", "slides": [{"title": "S", "bullets": ["a"]}]}\n```'
+    data = AgentRunner._extract_json(raw)
+    assert data["title"] == "T"
+
+
+def test_create_pptx_writes_file(tmp_path, monkeypatch):
+    monkeypatch.setenv("AGENT_OUTPUTS_DIR", str(tmp_path))
+    outline = SlideOutline(
+        title="Photosynthesis",
+        slides=[
+            SlideSpec(title="What is it?", bullets=["Plants make food", "Uses sunlight"]),
+            SlideSpec(title="Why it matters", bullets=["Oxygen", "Food chain"]),
+        ],
+    )
+    path = create_pptx(outline, run_id="test")
+    assert path.exists()
+    assert path.suffix == ".pptx"

models.yaml

@@ -2,7 +2,7 @@
 # Select active preset with ACTIVE_MODEL; override any field via .env (see .env.example).
 
 defaults:
-  active_model: minicpm-v-4.6
+  active_model: minicpm5-1b
   # Dev: set ALLOW_MODEL_SWITCH=true in .env to expose a dropdown in Gradio.
   # Space: keep false so visitors use one pinned model.
   allow_model_switch: false

pyproject.toml

@@ -5,6 +5,7 @@ description = "Build Small Hackathon — Gradio Space with local llama.cpp infer
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "agent",
     "gradio-space",
     "inference",
 ]
@@ -22,5 +23,6 @@ members = [
 ]
 
 [tool.uv.sources]
+agent = { workspace = true }
 gradio-space = { workspace = true }
 inference = { workspace = true }

scripts/upload_trace.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Upload the latest agent trace JSON to a Hugging Face dataset repo."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+
+def _latest_trace(traces_dir: Path) -> Path:
+    files = sorted(traces_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+    if not files:
+        raise FileNotFoundError(f"No trace files in {traces_dir}")
+    return files[0]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Upload agent trace to HF dataset")
+    parser.add_argument(
+        "--traces-dir",
+        type=Path,
+        default=Path(os.environ.get("AGENT_TRACES_DIR", "outputs/traces")),
+    )
+    parser.add_argument(
+        "--repo-id",
+        required=True,
+        help="HF dataset repo, e.g. username/build-small-agent-traces",
+    )
+    parser.add_argument("--trace", type=Path, default=None, help="Specific trace file")
+    args = parser.parse_args()
+
+    trace_path = args.trace or _latest_trace(args.traces_dir)
+    data = json.loads(trace_path.read_text())
+
+    api = HfApi()
+    api.create_repo(args.repo_id, repo_type="dataset", exist_ok=True)
+    api.upload_file(
+        path_or_fileobj=trace_path.read_bytes(),
+        path_in_repo=f"traces/{trace_path.name}",
+        repo_id=args.repo_id,
+        repo_type="dataset",
+        commit_message=f"Add agent trace {trace_path.stem}",
+    )
+
+    print(f"Uploaded {trace_path} -> {args.repo_id}/traces/{trace_path.name}")
+    print(f"Skill: {data.get('skill')} | Model: {data.get('model')} | Run: {data.get('run_id')}")
+
+
+if __name__ == "__main__":
+    main()