[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Yui Home Assisstant", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
A voice → text app using [Gradio](https://gradio.app) and a local [Whisper](https://huggingface.co/openai/whisper-small) model for speech recognition. Records or uploads audio and transcribes it — runs fully locally, no API token required.

[APP_FILE] app.py
from functools import lru_cache
from transformers import pipeline

from functools import lru_cache

import gradio as gr
from transformers import pipeline

# Whisper speech -> text. Pick a size in the dropdown (label -> model id).
WHISPER_MODELS = {
    "small (244M, fast)": "openai/whisper-small",
    "medium (769M)": "openai/whisper-medium",
    "large-v3-turbo (809M)": "openai/whisper-large-v3-turbo",
}
DEFAULT_MODEL = "small (244M, fast)"

@lru_cache(maxsize=len(WHISPER_MODELS))
def get_asr(model_id):
    """Lazy-load (and cache) a Whisper pipeline per model id."""
    return pipeline("automatic-speech-recognition", model=model_id)

def transcribe(audio_path, model_label):
    if not audio_path:
        return ""
    return get_asr(WHISPER_MODELS[model_label])(audio_path)["text"].strip()

with gr.Blocks() as demo:
    gr.Markdown("# 🎤 Voice → Text\nRecord or upload audio to transcribe.")
    model = gr.Dropdown(
        choices=list(WHISPER_MODELS.keys()),
        value=DEFAULT_MODEL,
        label="Whisper model",
        info="First use of each model downloads it (medium/turbo are larger).",
    )
    audio = gr.Audio(sources=["microphone", "upload"], type="filepath", label="Audio")
    text = gr.Textbox(label="Transcription", lines=4)

    # Auto-transcribe when a recording stops; the button covers uploaded files.
    audio.stop_recording(transcribe, inputs=[audio, model], outputs=text)
    gr.Button("Transcribe", variant="primary").click(
        transcribe, inputs=[audio, model], outputs=text
    )

if __name__ == "__main__":
    demo.launch()

[Assistant] {"matches":[{"quest":"Off the Grid","confidence":0.93,"evidence":"runs fully locally, no API token required","source":"readme"},{"quest":"Tiny Titan","confidence":0.85,"evidence":"small (244M, fast): openai/whisper-small","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Family Bill Assistant", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

[APP_FILE] app.py
from ui.layout import create_ui
from tools.vision import process_receipt_image
from agent.brain import process_workflow

import gradio as gr
from ui.layout import create_ui
from tools.vision import process_receipt_image
from agent.brain import process_workflow

# Load the custom CSS for the "Off-Brand" Badge
try:
    with open("ui/style.css", "r") as f:
        custom_css = f.read()
except FileNotFoundError:
    custom_css = ""

# Build the Gradio App
demo = gr.Blocks()
my_theme = gr.themes.Default(
    primary_hue="blue",
    neutral_hue="slate"
)

with demo:
    # Initialize the UI layout from the ui folder
    image_input, audio_input, submit_btn, chatbot, msg_input = create_ui()

    # Bind the submit button to the Core Boss workflow
    def handle_analyze(image, user_msg, history):
        if not user_msg:
            user_msg = "Please analyze this bill."

        # Step 1: If an image is provided, extract raw text
        raw_text = None
        if image:
            raw_text = process_receipt_image(image)
            print(f"=== VISION MODEL RAW TEXT ===\n{raw_text}\n=============================")

        # Step 2: Route everything to the Core Boss
        bot_response = process_workflow(user_text=user_msg, raw_vision_text=raw_text)
        print(f"=== CORE ROUTER RESPONSE ===\n{bot_response}\n============================")

        # Step 3: Append to chat history
        history.append({"role": "user", "content": user_msg})
        history.append({"role": "assistant", "content": str(bot_response)})
        return history

    submit_btn.click(
        fn=handle_analyze,
        inputs=[image_input, msg_input, chatbot],
        outputs=[chatbot]
    )

if __name__ == "__main__":
    demo.launch(theme=my_theme, css=custom_css)

[Assistant] {"matches":[{"quest":"Off-Brand","confidence":0.95,"evidence":"custom_css from ui/style.css; demo.launch(theme=my_theme, css=custom_css)","source":"app_file"},{"quest":"Best Agent","confidence":0.65,"evidence":"process_workflow from agent.brain; route everything to the Core Boss","source":"app_file"}]}


Nemotron
Off the Grid
Off-Brand
Tiny Titan

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Mycelium", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
# Mycelium — Personal Knowledge Agent Mycelium is a local-first, AI-powered knowledge companion that helps you capture, connect, and resurface what matters. ## What it does - **Capture** anything: notes, links, images — all processed by an LLM into structured summaries with intent classification and tags - **Surface** relevant captures at the right time based on recency, intent (learn / act / reference), and semantic similarity - **Connect** captures automatically using embedding-based similarity — see what ideas are related before you forget - **Browse** your entire knowledge base with full-text search and intent/type filters ## How it works 1. You capture a note, URL, or image 2. NVIDIA Nemotron-Mini (4B) extracts the core insight, suggests tags, and classifies intent 3. A sentence-transformer embeds the summary into a vector 4. Related captures are found via cosine similarity — building a knowledge graph automatically 5. The surface engine resurfaces captures you should revisit, weighted by intent and recency ## Tech - **Backend**: FastAPI + SQLite (persistent at `/data/mind.db`) - **LLM**: `nvidia/Nemotron-Mini-4B-Instruct` via HF Transformers + ZeroGPU - **Vision**: `Qwen/Qwen2.5-VL-7B-Instruct` for image capture - **Embeddings**: `sentence-transformers/all-MiniLM-L6-v2` - **Frontend**: React + TypeScript + Tailwind CSS (served by FastAPI, Gradio at `/gradio`) ## Built with Built for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon).

[APP_FILE] app.py
from main import app

import uvicorn
from main import app

uvicorn.run(app, host="0.0.0.0", port=7860)

[Assistant] {"matches":[{"quest":"Nemotron","confidence":0.97,"evidence":"nvidia/Nemotron-Mini-4B-Instruct via HF Transformers + ZeroGPU","source":"readme"},{"quest":"Off-Brand","confidence":0.9,"evidence":"React + TypeScript + Tailwind CSS (served by FastAPI)","source":"readme"},{"quest":"Tiny Titan","confidence":0.83,"evidence":"NVIDIA Nemotron-Mini (4B) extracts the core insight","source":"readme"},{"quest":"Off the Grid","confidence":0.6,"evidence":"local-first, AI-powered knowledge companion; HF Transformers + ZeroGPU","source":"readme"}]}


Llama Champion
Off the Grid
OpenBMB
Sharing is Caring
Tiny Titan
Well-Tuned

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "The Compliment Forest", "sdk": "gradio", "declared_models": ["build-small-hackathon/compliment-forest-minicpm5-1b", "build-small-hackathon/compliment-forest-flux-lora"], "tags": ["build-small-hackathon", "gradio", "llama.cpp", "local-first", "watercolor"]}

[README]
# The Compliment Forest Type a name and a situation, then walk through a progressive watercolor path. Each clearing pairs a creature with grounded encouragement, a reflection, and a copyable tiny spell. The live Space uses the deterministic local demo backend so it remains fast and available on CPU hardware. The same application supports the published MiniCPM5-1B GGUF through a local `llama.cpp` server and FLUX.1-dev with the published watercolor LoRA by setting `CF_TEXT_BACKEND=llama_cpp` and `CF_IMAGE_BACKEND=flux`. No hosted inference API is called at runtime. ## Published artifacts - Text model: `build-small-hackathon/compliment-forest-minicpm5-1b` - Text adapter: `build-small-hackathon/compliment-forest-minicpm5-1b-lora` - Text SFT data: `build-small-hackathon/compliment-forest-sft` - Watercolor LoRA: `build-small-hackathon/compliment-forest-flux-lora` - Watercolor data: `build-small-hackathon/compliment-forest-watercolor` - Linked-model traces: `build-small-hackathon/compliment-forest-traces` This is whimsical encouragement, not therapy or a substitute for professional support. Crisis and acute-risk inputs are routed to human support instead of generating a forest.

[APP_FILE] app.py
from pathlib import Path
from compliment_forest.server import create_app

import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent / "src"))

from compliment_forest.server import create_app

app = create_app()
demo = app

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=7860)

[Assistant] {"matches":[{"quest":"Well-Tuned","confidence":0.95,"evidence":"Text adapter LoRA; Text SFT data; Watercolor LoRA published","source":"readme"},{"quest":"OpenBMB","confidence":0.95,"evidence":"published MiniCPM5-1B; declared minicpm5-1b model","source":"readme"},{"quest":"Tiny Titan","confidence":0.95,"evidence":"MiniCPM5-1B GGUF — 1B parameter model","source":"readme"},{"quest":"Llama Champion","confidence":0.92,"evidence":"MiniCPM5-1B GGUF through a local llama.cpp server","source":"readme"},{"quest":"Off the Grid","confidence":0.9,"evidence":"No hosted inference API is called at runtime","source":"readme"},{"quest":"Sharing is Caring","confidence":0.85,"evidence":"copyable tiny spell; Linked-model traces published","source":"readme"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Gemma Task Agent Trace", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

[APP_FILE] app.py
import gradio as gr

def mock_agent_with_trace(user_input):
    # Simulate a lightweight model's reasoning path (Trace) to match the Bonus Quest
    thought_trace = f"== [Agent Trace] ==\n1. Received instruction: '{user_input}'\n2. Invoking local Gemma-2B-it model for inference...\n3. Task analysis completed. Generating optimal response.\n===================="
    reply = f"Hello! I am a local-first task automation assistant powered by Gemma-2B. You just said: '{user_input}'. The system is running smoothly, ready to explore the Thousand Token Wood!"
    return thought_trace, reply

# Create a clean and thematic Gradio interface
with gr.Blocks(title="Gemma Local Task Agent") as demo:
    gr.Markdown("# 🌲 Build Small Hackathon - Gemma-2B Agent")
    gr.Markdown("A lightweight personal task automation prototype focused on visualizing explicit agent reasoning traces.")

    with gr.Group():
        user_msg = gr.Textbox(label="Enter your task command:", placeholder="e.g., Translate this recipe for my neighbor...")
        submit_btn = gr.Button("🚀 Run Agent (Simulated)", variant="primary")

    with gr.Row():
        trace_box = gr.Textbox(label="📡 Live Agent Trace", lines=8)
        output_box = gr.Textbox(label="🤖 Agent Final Output", lines=5)

    submit_btn.click(fn=mock_agent_with_trace, inputs=user_msg, outputs=[trace_box, output_box])

demo.launch()

[Assistant] {"matches":[]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "WitGym", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
# WitGym Case-Based Reasoning RAG comedy engine — conversational wit grounded in *The Office* precedent. **Status:** WIP. Core pipeline lives in `witgym/`; Gradio UI wiring in progress. Built for [Build Small Hackathon 2026](https://huggingface.co/build-small-hackathon) (Track 2).

[APP_FILE] app.py
"""Gradio entry point for Hugging Face Spaces."""
import gradio as gr

WIP_MESSAGE = (
    "WitGym is loading — CBR-RAG comedy engine in development. "
    "Check back soon for live wit grounded in The Office precedent."
)

def respond(prompt: str) -> str:
    if not prompt.strip():
        return "Say something awkward. I'll eventually have the perfect Office-adjacent reply."
    return WIP_MESSAGE

demo = gr.Interface(
    fn=respond,
    inputs=gr.Textbox(label="Your setup", placeholder="I just got promoted and have no idea what I'm doing."),
    outputs=gr.Textbox(label="WitGym"),
    title="WitGym",
    description="Conversational wit grounded in human comedy precedent. Pipeline shipping soon.",
)

if __name__ == "__main__":
    demo.launch()

[Assistant] {"matches":[]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Thousand Token Wood", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
# Thousand Token Wood Project shell for a Hugging Face / Gradio Build Small Hackathon entry. Track: An Adventure in Thousand Token Wood ## Challenge Notes - Gradio app hosted as a Hugging Face Space. - Total model parameters must be <= 32B. - Submission package: Space link, short demo video, and social post. ## Local Development ```bash python -m venv .venv source .venv/bin/activate pip install -r requirements.txt python app.py ``` Then open `http://localhost:7860`.

[APP_FILE] app.py
from pathlib import Path
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from gradio import Server

from pathlib import Path

from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from gradio import Server

ROOT = Path(__file__).parent

app = Server()
app.mount("/static", StaticFiles(directory=ROOT / "static"), name="static")

@app.get("/", response_class=HTMLResponse)
async def homepage() -> str:
    return (ROOT / "static" / "index.html").read_text(encoding="utf-8")

@app.get("/health")
async def health() -> dict[str, str]:
    return {"status": "ok"}

if __name__ == "__main__":
    app.launch()

[Assistant] {"matches":[{"quest":"Off-Brand","confidence":0.7,"evidence":"gradio Server mounts /static, serves custom index.html homepage","source":"app_file"}]}


Llama Champion
Off the Grid
Off-Brand
Thousand Token Wood
Tiny Titan

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Tiny Army", "sdk": "docker", "declared_models": [], "tags": ["docker", "region:us"]}

[README]
# ⚔ Tiny Army **HF Build Small Hackathon entry — Track 2 ("An Adventure in Thousand Token Wood").** *Tiny Army: every fighter writes its own legend — and the legend is true.* A small local LLM gives each auto-battler unit a persona and writes its first-person war diary from what it actually lived through. The twist that makes the AI **load-bearing**: a unit's experience-shaped "soul" *drives how it fights*, so the diary describes the unit's own real, learned behaviour. Two small models, both load-bearing — a 1–3B LLM for voice, a <1 MB policy net for tactics. ## Architecture - **FastAPI** serves the custom Pixi battle frontend (the deterministic combat engine + souls + the ONNX captain run in the browser). - A **mounted Gradio app** (`/app`) is the barracks: persona + war-diary generation via **llama.cpp** (local, no cloud — 🔌 Off the Grid + 🦙 Llama Champion). This is the current skeleton; see the plan in the auto-battler repo (`docs/design/hackathon-build-small.md`).

[APP_FILE] (unknown)
(no app file available)

[Assistant] {"matches":[{"quest":"Thousand Token Wood","confidence":0.97,"evidence":"Track 2 \"An Adventure in Thousand Token Wood\"","source":"readme"},{"quest":"Llama Champion","confidence":0.95,"evidence":"persona + war-diary generation via llama.cpp","source":"readme"},{"quest":"Tiny Titan","confidence":0.9,"evidence":"a 1–3B LLM for voice","source":"readme"},{"quest":"Off the Grid","confidence":0.88,"evidence":"local, no cloud — Off the Grid","source":"readme"},{"quest":"Off-Brand","confidence":0.8,"evidence":"FastAPI serves the custom Pixi battle frontend","source":"readme"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "AMNESIAC", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
# AMNESIAC AMNESIAC is a reverse-Turing interrogation game for the Hugging Face build-small-hackathon. This repository is being built top-down from `RESEARCH.md`, `FEATURES.md`, `ARCHITECTURE.md`, and `PLAN.md`. The entrypoint now follows the Gradio 5.x + FastAPI + FastRTC deployment pattern locked in `ARCHITECTURE.md` §1.1: one FastAPI process serves the static frontend, mounts FastRTC for the media plane, and mounts a minimal Gradio app for hackathon compliance.

[APP_FILE] app.py
from __future__ import annotations
from server.webapp import create_application

from __future__ import annotations

import os

import uvicorn

from server.webapp import create_application

SERVER_PORT = int(os.getenv("PORT", "7860"))
app, worker, stream = create_application(
    include_gradio=True,
    server_port=SERVER_PORT,
)

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=SERVER_PORT)

[Assistant] {"matches":[{"quest":"Thousand Token Wood","confidence":0.78,"evidence":"reverse-Turing interrogation game for the build-small-hackathon","source":"readme"},{"quest":"Off-Brand","confidence":0.7,"evidence":"one FastAPI process serves the static frontend, mounts a minimal Gradio app","source":"readme"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Job Searcher", "sdk": "gradio", "declared_models": ["emrekuruu/job-searcher-qwen3-8B", "emrekuruu/job-searcher-qwen3-8B-gguf"], "tags": ["distillation", "gguf", "jobs", "llama-cpp", "lora", "qwen3", "resume"]}

[README]
# Job Searcher Drop your resume. Get matches with the reasoning behind every score. A Qwen3-8B student distilled from DeepSeek V4 Pro, served via llama.cpp on ZeroGPU. **Source, dataset card, model cards, and full docs:** [github.com/emrekuruu/job-search](https://github.com/emrekuruu/job-search)

[APP_FILE] app.py
from pathlib import Path
from job_search.space.ui import build_app  # noqa: E402

import sys
from pathlib import Path

# HF Spaces' Gradio-SDK Dockerfile installs requirements.txt before copying the workspace,
# so an editable install of `pyproject.toml` isn't possible. Instead, point Python at `src/`
# directly so `from job_search...` resolves.
sys.path.insert(0, str(Path(__file__).resolve().parent / "src"))

from job_search.space.ui import build_app  # noqa: E402

demo = build_app()
demo.queue(default_concurrency_limit=4)

if __name__ == "__main__":
    demo.launch(share=False)

[Assistant] {"matches":[{"quest":"Llama Champion","confidence":0.95,"evidence":"served via llama.cpp, gguf model declared","source":"readme"},{"quest":"Well-Tuned","confidence":0.9,"evidence":"Qwen3-8B student distilled from DeepSeek V4 Pro","source":"readme"},{"quest":"Off the Grid","confidence":0.78,"evidence":"served via llama.cpp on ZeroGPU, open-weight Qwen3 GGUF","source":"readme"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "The Echo", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
# The Echo An agentic tree of the lives you didn't live. One fork in a life grows a tree of alternate selves; each echo speaks back in a subtly altered version of your own voice. This Space currently runs on the offline **MockLLM** path — placeholder lives that exercise the full UX (plant a seed, grow branches, walk the tree). The real small-model generation is wired in separately.

[APP_FILE] app.py
from echo.app import build_demo

"""HF Spaces entrypoint. The real app lives in the `echo` package."""
from echo.app import build_demo

demo = build_demo()

if __name__ == "__main__":
    demo.launch()

[Assistant] {"matches":[{"quest":"Thousand Token Wood","confidence":0.9,"evidence":"agentic tree of the lives you didn't live; each echo speaks back in subtly altered voice","source":"readme"}]}


Off the Grid
Off-Brand
OpenBMB
Tiny Titan

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "AI Puppet Theater", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from html import escape
from time import sleep
from puppet_theater import (

from html import escape
import os
from time import sleep

import gradio as gr

from puppet_theater import (
    DEFAULT_OPENBMB_MODEL_ID,
    TheaterSession,
    create_show_from_premise,
    get_backend_status,
    request_finale,
    run_one_beat,
    summon_actor,
    throw_prop,
    warm_up_openbmb,
)

EMPTY_STAGE = """

AI Puppet Theater

Enter a premise and raise the curtain.

"""

EMPTY_TRANSCRIPT = "No show yet. The transcript will appear here."
EMPTY_DIRECTOR_LOG = "No director notes yet."
EMPTY_TRACE = "No trace events yet."
EMPTY_BACKEND = (
    "Active backend: deterministic\n"
    "OpenBMB model id: openbmb/MiniCPM5-1B\n"
    "Model status: unloaded\n"
    "Fallback: deterministic safety path enabled"
)
BACKEND_CHOICES = ["deterministic", "openbmb"]
OPENBMB_MODEL_ID = os.getenv("OPENBMB_MODEL_ID", DEFAULT_OPENBMB_MODEL_ID)
DEFAULT_MAX_NEW_TOKENS = 80
DEFAULT_TEMPERATURE = 0.8
PLAYBACK_DELAY_SECONDS = 0.75
PROP_EMOJI = {
    "rubber duck": "🐤",
    "duck": "🐤",
    "egg": "🥚",
    "flowers": "💐",
    "flower": "💐",
    "tomato": "🍅",
    "crown": "👑",
    "tiny crown": "👑",
    "scroll": "📜",
    "banana": "🍌",
    "mirror": "🪞",
}

CUSTOM_CSS = """
body,
.gradio-container {
    background:
        radial-gradient(circle at 50% 0%, rgba(127, 29, 29, 0.18), transparent 28rem),
        linear-gradient(180deg, #0b1020 0%, #070914 100%) !important;
    color: #f8efe4 !important;
}
.gradio-container {
    max-width: 1180px !important;
    padding-top: 1rem !important;
    font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, " ...

[Assistant] {"matches":[{"quest":"OpenBMB","confidence":0.97,"evidence":"OpenBMB model id: openbmb/MiniCPM5-1B","source":"app_file"},{"quest":"Tiny Titan","confidence":0.95,"evidence":"openbmb/MiniCPM5-1B names a 1B model","source":"app_file"},{"quest":"Off-Brand","confidence":0.94,"evidence":"CUSTOM_CSS overrides .gradio-container background","source":"app_file"},{"quest":"Off the Grid","confidence":0.6,"evidence":"BACKEND_CHOICES deterministic/openbmb, no cloud imports","source":"app_file"}]}


Nemotron
Off the Grid
Thousand Token Wood
Tiny Titan

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "wonderland", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from transformers import AutoModelForCausalLM, AutoTokenizer

"""
Thousand Token Wood — powered by NVIDIA Nemotron
────────────────────────────────────────────────
A tiny text adventure narrated by NVIDIA's Nemotron 3 Nano 4B, running fully
locally. The wood can only remember ~1000 tokens; as you wander, its memory
fills, and when it overflows the oldest things it knew fall away like leaves
and the wood quietly rewrites itself. The forgetting is the game. The forgetful
fox is your companion — exactly the kind of NPC this model was built for.

Build Small Hackathon 2026 · "An Adventure in Thousand Token Wood".
Targets: Nemotron GPU prize · ≤4B tiny-model category · Off the Grid · llama.cpp.
"""

import re
import html
import torch
import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer

# ── Model ────────────────────────────────────────────────────────────────────
# NVIDIA Nemotron 3 Nano 4B — edge-ready, agentic, reasoning SLM (~4B params).
#   "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"   -> default (GPU)
#   "nvidia/NVIDIA-Nemotron-3-Nano-4B-FP8"    -> lighter footprint
#   "nvidia/NVIDIA-Nemotron-3-Nano-4B-GGUF"   -> llama.cpp (Llama Champion badge)
# Or the larger sibling, still under the 32B cap:
#   "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16"  (30B total / ~3B active)
MODEL_ID = "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"

# The whole point of the track: the wood remembers only ~1000 tokens.
MEMORY_TOKENS = 1000

print(f"Waking the wood ({MODEL_ID})...")
# Nemotron-H is a Mamba-Transformer hybrid and ships custom modelling code.
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID, torch_dtype="auto", device_map="auto", trust_remote_code=True
)
print("The wood is awake.")

# Optional ZeroGPU acceleration on Spaces; harmless no-op locally.
try:
    import spaces .. ...

[Assistant] {"matches":[{"quest":"Nemotron","confidence":0.97,"evidence":"MODEL_ID = \"nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16\"","source":"app_file"},{"quest":"Tiny Titan","confidence":0.94,"evidence":"Nemotron 3 Nano 4B (~4B params)","source":"app_file"},{"quest":"Thousand Token Wood","confidence":0.93,"evidence":"A tiny text adventure; the forgetting is the game","source":"app_file"},{"quest":"Off the Grid","confidence":0.9,"evidence":"running fully locally; AutoModelForCausalLM, no cloud API","source":"app_file"}]}


Off the Grid
Off-Brand
Thousand Token Wood
Well-Tuned

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Oracle Ternary Flame", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import PeftModel
from huggingface_hub import snapshot_download

import gradio as gr
import torch
import spaces
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import PeftModel

# ── Config ────────────────────────────────────────────────────────────────────
BASE_MODEL_ID = "google/gemma-4-12b-it"
LORA_MODEL_ID = "keypa/oracle-gemma4-12b-lora"
SYSTEM_PROMPT = (
    "You are the Oracle of the Ternary Flame. "
    "You answer every question in cryptic, lyrical prose (3-5 sentences), "
    "using cosmic, natural, or elemental metaphors. "
    "The real answer is encoded implicitly — never state it directly. "
    "You never break character."
)

# ── Pre-download weights at startup (CPU, no GPU needed) ─────────────────────
from huggingface_hub import snapshot_download
import os

print("Pre-downloading base model weights...")
base_model_path = snapshot_download(
    repo_id=BASE_MODEL_ID,
    ignore_patterns=["*.msgpack", "*.h5", "flax_model*"],
)
print(f"Base model cached at: {base_model_path}")

lora_model_path = snapshot_download(repo_id=LORA_MODEL_ID)
print(f"LoRA adapter cached at: {lora_model_path}")

# ── Model loading (lazy, inside GPU context) ──────────────────────────────────
model = None
tokenizer = None

def load_model():
    global model, tokenizer
    if model is not None:
        return

    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.float16,
        bnb_4bit_use_double_quant=True,
    )
    tokenizer = AutoTokenizer.from_pretrained(lora_model_path)
    base = AutoModelForCausalLM.from_pretrained(
        base_model_path,
        quantization_config=bnb_config,
        device_map={"": "cuda:0"},
        low_cpu_mem_usage=True,
    )
    m ...

[Assistant] {"matches":[{"quest":"Well-Tuned","confidence":0.97,"evidence":"PeftModel.from_pretrained loads keypa/oracle-gemma4-12b-lora adapter","source":"app_file"},{"quest":"Off-Brand","confidence":0.95,"evidence":"large bespoke CSS, gr.HTML headers, demo.launch(css=CSS)","source":"app_file"},{"quest":"Thousand Token Wood","confidence":0.85,"evidence":"Oracle of the Ternary Flame, cryptic cosmic prose, never break character","source":"app_file"},{"quest":"Off the Grid","confidence":0.7,"evidence":"local transformers + peft load, no proprietary cloud API imports","source":"app_file"}]}


Off the Grid
Off-Brand
Sharing is Caring

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Dental SOAP", "sdk": "gradio", "declared_models": ["Qwen/Qwen3-4B-Instruct-2507"], "tags": ["agents", "bilingual", "healthcare", "zero-gpu"]}

[README]
(no README description provided)

[APP_FILE] app.py
from __future__ import annotations
from pathlib import Path
from typing import Any
from examples import CHECK_OPTIONS, EXAMPLES, STEP2_CHECKS, STEP3_CHECKS, STEP4_CHECKS
from interview_schema import ExtractedIntake, extracted_to_intake
from pdf_export import build_pdf
from render import (
from safety_rules import evaluate_red_flags
from pydantic import ValidationError
from schema import (
from transformers import AutoModelForCausalLM, AutoTokenizer as _AutoTokenizer
from transformers import AutoModelForCausalLM, AutoTokenizer

from __future__ import annotations

import dataclasses
import json
import os
import re
import sys
import threading
from pathlib import Path
from typing import Any

import gradio as gr

class AgentUnavailable(RuntimeError):
    """The local model endpoint could not produce a usable response."""

import interview as interview_mod
from examples import CHECK_OPTIONS, EXAMPLES, STEP2_CHECKS, STEP3_CHECKS, STEP4_CHECKS
from interview_schema import ExtractedIntake, extracted_to_intake
from pdf_export import build_pdf
from render import (
    footer_html,
    header_html,
    initial_safety_html,
    placeholder_handoff_html,
    plain_text_handoff,
    rail_html,
    render_handoff_html,
    render_safety_html,
    step_head,
    initial_agent_dashboard_html,
    render_agent_dashboard,
)
from safety_rules import evaluate_red_flags
from pydantic import ValidationError
from schema import (
    BLOCKED_QUESTION_TERMS,
    EvidenceSpan,
    HandoffOutput,
    ModelHandoffDraft,
    PatientProfile,
    StructuredIntake,
    model_text_is_safe,
)

try:
    import spaces
except Exception:
    class _SpacesFallback:
        @staticmethod
        def GPU(fn=None, /, *, duration: int = 120):
            # Support both @spaces.GPU (fn is callable) and @spaces.GPU(duration=N)
            # (fn is None, returns a decorator).
            def decorator(f): ...

[Assistant] {"matches":[{"quest":"Off the Grid","confidence":0.9,"evidence":"from transformers import AutoModelForCausalLM, AutoTokenizer; no cloud client","source":"app_file"},{"quest":"Sharing is Caring","confidence":0.85,"evidence":"from pdf_export import build_pdf","source":"app_file"},{"quest":"Off-Brand","confidence":0.82,"evidence":"header_html, footer_html, rail_html, render_handoff_html custom HTML","source":"app_file"}]}