Upload folder using huggingface_hub

.gitattributes

@@ -33,6 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-examples/crochet.png filter=lfs diff=lfs merge=lfs -text
-examples/embroidery.jpeg filter=lfs diff=lfs merge=lfs -text
-examples/sew_keychain.jpeg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -14,10 +14,11 @@ import json
 import logging
 import os
 import tempfile
+import threading
 import time
 
 import gradio as gr
-from huggingface_hub import hf_hub_download
+from huggingface_hub import HfApi, hf_hub_download
 from PIL import Image
 
 from agents import cataloger, copywriter, pricer
@@ -28,11 +29,36 @@ from agents.pipeline import VISION_PROMPT
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Set HF token if available (for faster downloads)
+# HF token: env var > token.txt fallback
 hf_token = os.getenv("HF_TOKEN")
+if not hf_token:
+    _token_path = os.path.join(os.path.dirname(__file__), "token.txt")
+    if os.path.exists(_token_path):
+        hf_token = open(_token_path).read().strip()
 if hf_token:
     os.environ["HUGGING_FACE_HUB_TOKEN"] = hf_token
 
+TRACES_DATASET = "skamathramesh/craftpilot-traces"
+
+
+def _upload_trace_async(trace_json: str):
+    """Upload trace JSON to HF dataset in background thread."""
+    def _upload():
+        try:
+            api = HfApi(token=hf_token)
+            filename = f"trace_{int(time.time())}_{os.getpid()}.json"
+            api.upload_file(
+                path_or_fileobj=trace_json.encode(),
+                path_in_repo=f"traces/{filename}",
+                repo_id=TRACES_DATASET,
+                repo_type="dataset",
+            )
+            logger.info("Trace uploaded: %s", filename)
+        except Exception as e:
+            logger.warning("Trace upload failed (non-fatal): %s", e)
+    if hf_token:
+        threading.Thread(target=_upload, daemon=True).start()
+
 CRAFT_TYPES = [
     "Crochet",
     "Embroidery",
@@ -192,15 +218,116 @@ CUSTOM_CSS = """
     border-radius: 0 8px 8px 0;
 }
 
-/* Status indicator */
-#status-text {
+/* Pipeline progress stepper */
+.pipeline-status {
+    padding: 2.5rem 1.5rem;
     text-align: center;
-    padding: 0.75rem;
 }
 
-#status-text p {
-    color: var(--craft-amber) !important;
-    font-weight: 500 !important;
+.pipeline-status .status-label {
+    font-size: 1.15rem;
+    font-weight: 500;
+    color: var(--craft-amber);
+    margin-bottom: 1.5rem;
+    animation: pulse 1.8s ease-in-out infinite;
+}
+
+.pipeline-steps {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0;
+    margin: 0 auto;
+    max-width: 420px;
+}
+
+.pipeline-step {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    flex: 1;
+    position: relative;
+}
+
+.step-dot {
+    width: 28px;
+    height: 28px;
+    border-radius: 50%;
+    background: var(--craft-linen);
+    border: 2px solid #d5ccc3;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: #b0a89e;
+    transition: all 0.3s ease;
+    z-index: 1;
+}
+
+.step-dot.done {
+    background: var(--craft-amber);
+    border-color: var(--craft-amber);
+    color: white;
+}
+
+.step-dot.active {
+    background: white;
+    border-color: var(--craft-amber);
+    color: var(--craft-amber);
+    box-shadow: 0 0 0 4px rgba(212, 131, 10, 0.15);
+    animation: pulse-ring 1.8s ease-in-out infinite;
+}
+
+.step-label {
+    font-size: 0.7rem;
+    color: #b0a89e;
+    margin-top: 0.4rem;
+    font-weight: 500;
+    white-space: nowrap;
+}
+
+.step-label.done, .step-label.active {
+    color: var(--craft-warm-gray);
+}
+
+.step-connector {
+    height: 2px;
+    flex: 1;
+    background: #d5ccc3;
+    margin: 0 -2px;
+    margin-bottom: 1.2rem;
+}
+
+.step-connector.done {
+    background: var(--craft-amber);
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+@keyframes pulse-ring {
+    0%, 100% { box-shadow: 0 0 0 4px rgba(212, 131, 10, 0.15); }
+    50% { box-shadow: 0 0 0 6px rgba(212, 131, 10, 0.08); }
+}
+
+/* Auto-cycling wave animation for loading state */
+.pipeline-status.loading .step-dot {
+    background: white;
+    border-color: var(--craft-amber);
+    color: var(--craft-amber);
+    animation: dot-wave 2.4s ease-in-out infinite;
+}
+
+.pipeline-status.loading .step-connector {
+    background: linear-gradient(90deg, var(--craft-amber), #d5ccc3);
+}
+
+@keyframes dot-wave {
+    0%, 100% { transform: scale(1); opacity: 0.5; }
+    50% { transform: scale(1.2); opacity: 1; background: var(--craft-amber); color: white; }
 }
 
 /* Footer */
@@ -268,70 +395,6 @@ def get_client() -> LLMClient:
     return _llm_client
 
 
-def _format_summary(result: PipelineResult) -> str:
-    """Build a combined summary view of all pipeline results."""
-    parts = []
-
-    # Title & description
-    if result.copy_data:
-        c = result.copy_data
-        parts.append(f"## {c.title}\n")
-        parts.append(f"*{c.short_desc}*\n")
-
-    # Price highlight
-    if result.pricing:
-        p = result.pricing
-        parts.append(
-            f"### Suggested Price: ${p.suggested_price_min}"
-            f" \u2013 ${p.suggested_price_max}\n"
-        )
-
-    parts.append("---\n")
-
-    # Catalog snapshot
-    if result.catalog:
-        cat = result.catalog
-        tags = " ".join(f"`{t}`" for t in cat.tags[:6])
-        parts.append(
-            f"**Category:** {cat.category} / {cat.sub_category}  \n"
-            f"**Materials:** {', '.join(cat.materials)}  \n"
-            f"**Colors:** {', '.join(cat.colors)}  \n"
-            f"**Complexity:** {cat.complexity}\n\n"
-            f"{tags}\n"
-        )
-
-    parts.append("---\n")
-
-    # Full description
-    if result.copy_data:
-        parts.append(f"**Description**\n\n{result.copy_data.long_desc}\n")
-
-    parts.append("---\n")
-
-    # Instagram captions
-    if result.copy_data:
-        parts.append("**Instagram Captions**\n")
-        for i, cap in enumerate(result.copy_data.captions, 1):
-            parts.append(f"{i}. {cap}\n")
-
-    # Pricing reasoning
-    if result.pricing and result.pricing.reasoning:
-        parts.append(f"\n---\n\n**Pricing Rationale**\n\n{result.pricing.reasoning}\n")
-        if result.pricing.cost_breakdown:
-            parts.append(f"\n**Cost Breakdown:** {result.pricing.cost_breakdown}\n")
-
-    # Timing
-    if result.traces:
-        agent_times = " \u2192 ".join(
-            f"{t.agent_name} ({t.duration_ms}ms)" for t in result.traces
-        )
-        parts.append(
-            f"\n---\n\n<small>Pipeline: {agent_times} "
-            f"| Total: {result.total_duration_ms}ms</small>"
-        )
-
-    return "\n".join(parts)
-
 
 def _format_vision(result: PipelineResult) -> str:
     if not result.image_description:
@@ -463,20 +526,85 @@ def _build_export_text(result: PipelineResult) -> str:
     return "\n".join(lines)
 
 
-def _snapshot(result: PipelineResult, status: str):
-    """Yield a snapshot of all outputs from current pipeline state."""
-    summary = _format_summary(result) if result.image_description else ""
-    summary = f"**{status}**\n\n---\n\n{summary}" if summary else f"**{status}**"
-    return (
-        summary,
-        _format_vision(result),
-        _format_catalog(result),
-        _format_copy(result),
-        _format_pricing(result),
-        _format_traces(result),
-        gr.skip(),  # trace file — only on completion
-        gr.skip(),  # export file — only on completion
-    )
+def _status_html(active_step: int, label: str) -> str:
+    """Build an HTML progress stepper. active_step: 0-3 (or -1 for pre-pipeline)."""
+    steps = ["Vision", "Catalog", "Copy", "Pricing"]
+    parts = ['<div class="pipeline-status">']
+    parts.append(f'<div class="status-label">{label}</div>')
+    parts.append('<div class="pipeline-steps">')
+    for i, name in enumerate(steps):
+        if i > 0:
+            conn_cls = "step-connector done" if i <= active_step else "step-connector"
+            parts.append(f'<div class="{conn_cls}"></div>')
+        if i < active_step:
+            dot_cls, lbl_cls, icon = "step-dot done", "step-label done", "&#10003;"
+        elif i == active_step:
+            dot_cls, lbl_cls, icon = "step-dot active", "step-label active", str(i + 1)
+        else:
+            dot_cls, lbl_cls, icon = "step-dot", "step-label", str(i + 1)
+        parts.append(f'<div class="pipeline-step"><div class="{dot_cls}">{icon}</div>')
+        parts.append(f'<div class="{lbl_cls}">{name}</div></div>')
+    parts.append("</div></div>")
+    return "".join(parts)
+
+
+def _summary_html(result: PipelineResult) -> str:
+    """Build an HTML summary for gr.HTML output."""
+    parts = []
+
+    if result.copy_data:
+        c = result.copy_data
+        parts.append(f"<h2>{c.title}</h2>")
+        parts.append(f"<p><em>{c.short_desc}</em></p>")
+
+    if result.pricing:
+        p = result.pricing
+        parts.append(f"<h3>Suggested Price: ${p.suggested_price_min} \u2013 ${p.suggested_price_max}</h3>")
+
+    parts.append("<hr>")
+
+    if result.catalog:
+        cat = result.catalog
+        tags = " ".join(f"<code>{t}</code>" for t in cat.tags[:6])
+        parts.append(
+            f"<p><strong>Category:</strong> {cat.category} / {cat.sub_category}<br>"
+            f"<strong>Materials:</strong> {', '.join(cat.materials)}<br>"
+            f"<strong>Colors:</strong> {', '.join(cat.colors)}<br>"
+            f"<strong>Complexity:</strong> {cat.complexity}</p>"
+            f"<p>{tags}</p>"
+        )
+
+    parts.append("<hr>")
+
+    if result.copy_data:
+        parts.append(f"<p><strong>Description</strong></p><p>{result.copy_data.long_desc}</p>")
+        parts.append("<hr>")
+        parts.append("<p><strong>Instagram Captions</strong></p><ol>")
+        for cap in result.copy_data.captions:
+            parts.append(f"<li>{cap}</li>")
+        parts.append("</ol>")
+
+    if result.pricing and result.pricing.reasoning:
+        parts.append(f"<hr><p><strong>Pricing Rationale</strong></p><p>{result.pricing.reasoning}</p>")
+        if result.pricing.cost_breakdown:
+            parts.append(f"<p><strong>Cost Breakdown:</strong> {result.pricing.cost_breakdown}</p>")
+
+    if result.traces:
+        agent_times = " \u2192 ".join(
+            f"{t.agent_name} ({t.duration_ms}ms)" for t in result.traces
+        )
+        parts.append(
+            f"<hr><p><small>Pipeline: {agent_times} "
+            f"| Total: {result.total_duration_ms}ms</small></p>"
+        )
+
+    return f'<div class="prose">{"".join(parts)}</div>'
+
+
+# Stores the last pipeline result for tab-select handlers.
+_last_result: PipelineResult | None = None
+_last_trace_path: str | None = None
+_last_export_path: str | None = None
 
 
 def analyze_craft(
@@ -486,15 +614,22 @@ def analyze_craft(
     material_cost: str,
     time_hours: str,
 ):
-    """Streaming generator: yields results as each agent completes."""
-    empty = ("",) * 7 + (None, None)
+    """Streaming generator → gr.HTML (single output).
+
+    Uses gr.HTML to bypass Svelte 5 i18n bug that crashes gr.Markdown
+    during streaming. Tab content populated via tab-select handlers.
+    """
+    global _last_result, _last_trace_path, _last_export_path
+    _last_result = None
+    _last_trace_path = None
+    _last_export_path = None
 
     if image is None:
-        yield ("Upload an image to get started.",) + ("",) * 5 + (None, None)
+        yield "<p>Upload an image to get started.</p>"
         return
 
     if not craft_type:
-        yield ("Please select a craft type.",) + ("",) * 5 + (None, None)
+        yield "<p>Please select a craft type.</p>"
         return
 
     cost = float(material_cost) if material_cost else None
@@ -502,8 +637,7 @@ def analyze_craft(
     notes = user_notes.strip() or None
 
     try:
-        # Load model
-        yield ("**Loading model...**",) + ("",) * 5 + (None, None)
+        yield _status_html(-1, "Loading model...")
         llm = get_client()
 
         start = time.monotonic()
@@ -511,7 +645,7 @@ def analyze_craft(
         result = PipelineResult(image_description="")
 
         # Stage 1: Vision
-        yield _snapshot(result, "Analyzing image...")
+        yield _status_html(0, "Analyzing your craft...")
         description, vision_ms = llm.describe_image(image, VISION_PROMPT)
         traces.append(AgentTrace(
             agent_name="vision", input_text="[image]",
@@ -521,9 +655,12 @@ def analyze_craft(
         result.image_description = description
         result.traces = list(traces)
         result.total_duration_ms = int((time.monotonic() - start) * 1000)
-        yield _snapshot(result, "Vision complete. Cataloging item...")
 
         # Stage 2: Cataloger
+        yield (
+            _status_html(1, "Cataloging item...") +
+            f'<hr><p><strong>Vision</strong> ({vision_ms}ms)</p><p>{description}</p>'
+        )
         try:
             catalog_result, catalog_trace = asyncio.run(
                 cataloger.run(llm, description, craft_type.lower(), notes)
@@ -534,10 +671,10 @@ def analyze_craft(
             logger.warning("Cataloger failed: %s", e)
         result.traces = list(traces)
         result.total_duration_ms = int((time.monotonic() - start) * 1000)
-        yield _snapshot(result, "Catalog done. Writing copy...")
 
-        # Stage 3: Copywriter (needs catalog — skip if catalog failed)
+        # Stage 3: Copywriter
         if result.catalog:
+            yield _status_html(2, "Writing copy...") + '<hr>' + _summary_html(result)
             try:
                 copy_result, copy_trace = asyncio.run(
                     copywriter.run(llm, craft_type.lower(), result.catalog, notes)
@@ -548,10 +685,10 @@ def analyze_craft(
                 logger.warning("Copywriter failed: %s", e)
         result.traces = list(traces)
         result.total_duration_ms = int((time.monotonic() - start) * 1000)
-        yield _snapshot(result, "Copy done. Calculating pricing...")
 
-        # Stage 4: Pricer (needs catalog — skip if catalog failed)
+        # Stage 4: Pricer
         if result.catalog:
+            yield _status_html(3, "Calculating pricing...") + '<hr>' + _summary_html(result)
             try:
                 price_result, price_trace = asyncio.run(
                     pricer.run(llm, craft_type.lower(), result.catalog, cost, hours)
@@ -563,29 +700,65 @@ def analyze_craft(
         result.traces = list(traces)
         result.total_duration_ms = int((time.monotonic() - start) * 1000)
 
-        # Build export file
+        # Upload trace to HF dataset (background, non-blocking)
+        trace_json = json.dumps(
+            [t.model_dump() for t in result.traces], indent=2
+        )
+        _upload_trace_async(trace_json)
+
+        # Build download files for tab handlers
+        _last_trace_path = _make_trace_file(result)
         export_text = _build_export_text(result)
         export_file = tempfile.NamedTemporaryFile(
             mode="w", suffix=".txt", prefix="craftpilot-listing-", delete=False
         )
         export_file.write(export_text)
         export_file.close()
+        _last_export_path = export_file.name
+        _last_result = result
 
-        # Final yield with everything
-        yield (
-            _format_summary(result),
-            _format_vision(result),
-            _format_catalog(result),
-            _format_copy(result),
-            _format_pricing(result),
-            _format_traces(result),
-            _make_trace_file(result),
-            export_file.name,
-        )
+        # Final: render summary as HTML
+        yield _summary_html(result)
 
     except Exception as e:
         logger.exception("Pipeline failed")
-        yield (f"**Error:** {e}",) + ("",) * 5 + (None, None)
+        yield f"<p><strong>Error:</strong> {e}</p>"
+
+
+def _on_vision_tab():
+    if not _last_result:
+        return ""
+    return _format_vision(_last_result)
+
+
+def _on_catalog_tab():
+    if not _last_result:
+        return ""
+    return _format_catalog(_last_result)
+
+
+def _on_copy_tab():
+    if not _last_result:
+        return "", gr.DownloadButton(visible=False)
+    return (
+        _format_copy(_last_result),
+        gr.DownloadButton(value=_last_export_path, visible=True) if _last_export_path else gr.DownloadButton(visible=False),
+    )
+
+
+def _on_pricing_tab():
+    if not _last_result:
+        return ""
+    return _format_pricing(_last_result)
+
+
+def _on_traces_tab():
+    if not _last_result:
+        return "", gr.DownloadButton(visible=False)
+    return (
+        _format_traces(_last_result),
+        gr.DownloadButton(value=_last_trace_path, visible=True) if _last_trace_path else gr.DownloadButton(visible=False),
+    )
 
 
 def build_ui() -> gr.Blocks:
@@ -652,33 +825,33 @@ def build_ui() -> gr.Blocks:
             with gr.Column(scale=2, min_width=500, elem_id="output-panel"):
                 with gr.Tabs():
                     with gr.Tab("Summary"):
-                        summary_output = gr.Markdown(
-                            value="*Your results will appear here after analysis.*",
+                        # gr.HTML instead of gr.Markdown — experiment to
+                        # bypass Svelte 5 i18n crash during streaming
+                        summary_output = gr.HTML(
+                            value="<p><em>Your results will appear here after analysis.</em></p>",
                             elem_classes=["prose"],
                         )
-                    with gr.Tab("Vision"):
+                    with gr.Tab("Vision") as vision_tab:
                         vision_output = gr.Markdown(elem_classes=["prose"])
-                    with gr.Tab("Catalog"):
+                    with gr.Tab("Catalog") as catalog_tab:
                         catalog_output = gr.Markdown(elem_classes=["prose"])
-                    with gr.Tab("Copy"):
+                    with gr.Tab("Copy") as copy_tab:
                         copy_output = gr.Markdown(elem_classes=["prose"])
-                    with gr.Tab("Pricing"):
+                        export_download = gr.DownloadButton(
+                            label="Export Listing (Etsy / Instagram)",
+                            elem_id="export-btn",
+                            visible=False,
+                        )
+                    with gr.Tab("Pricing") as pricing_tab:
                         price_output = gr.Markdown(elem_classes=["prose"])
-                    with gr.Tab("Agent Traces"):
+                    with gr.Tab("Agent Traces") as traces_tab:
                         trace_output = gr.Markdown(elem_classes=["prose"])
-                        trace_download = gr.File(
-                            label="Download Trace JSON",
-                            file_count="single",
-                            interactive=False,
+                        trace_download = gr.DownloadButton(
+                            label="Download Agent Trace JSON",
+                            visible=False,
                         )
 
-                with gr.Row():
-                    export_download = gr.File(
-                        label="Download Listing (Etsy/Instagram ready)",
-                        file_count="single",
-                        interactive=False,
-                    )
-
+        # Streaming generator → single gr.HTML output (bypasses i18n crash?)
         analyze_btn.click(
             fn=analyze_craft,
             inputs=[
@@ -688,18 +861,17 @@ def build_ui() -> gr.Blocks:
                 material_cost,
                 time_hours,
             ],
-            outputs=[
-                summary_output,
-                vision_output,
-                catalog_output,
-                copy_output,
-                price_output,
-                trace_output,
-                trace_download,
-                export_download,
-            ],
+            outputs=[summary_output],
+            show_progress="minimal",
         )
 
+        # Tab-select handlers: populate content + downloads on demand
+        vision_tab.select(fn=_on_vision_tab, outputs=[vision_output])
+        catalog_tab.select(fn=_on_catalog_tab, outputs=[catalog_output])
+        copy_tab.select(fn=_on_copy_tab, outputs=[copy_output, export_download])
+        pricing_tab.select(fn=_on_pricing_tab, outputs=[price_output])
+        traces_tab.select(fn=_on_traces_tab, outputs=[trace_output, trace_download])
+
         # Footer
         gr.Markdown(
             "Built for the Build Small Hackathon 2026 \u00b7 Backyard AI track  \n"

blog-post.md

@@ -0,0 +1,90 @@
+# CraftPilot: Building a Multi-Agent Craft Business Assistant with a Single Small Model
+
+*How I built a tool for someone I know — a creative introvert who makes beautiful crafts but struggles to sell them.*
+
+## The Problem
+
+I know someone who crochets, embroiders, paints, and sews the most beautiful things. Friends and family constantly tell her: "You should sell these!" But she never does. Not because the work isn't good enough — it's because the *selling* part is overwhelming.
+
+Writing product descriptions? Agonizing. Picking a fair price? Impossible. Crafting Instagram captions? Exhausting for an introvert. So the crafts pile up, gifted away or tucked into drawers, while she moves on to the next project.
+
+I built CraftPilot to fix that.
+
+## The Solution
+
+**CraftPilot** is a photo-in, listing-out tool. Upload a photo of your handmade craft, and you get:
+
+- **Catalog metadata** — category, materials, colors, complexity, searchable tags
+- **Product copy** — a title, short description, full description, and 3 Instagram captions
+- **Fair pricing** — a price range based on material cost, labor time, and market rates
+- **Downloadable listing** — export everything as an Etsy/Instagram-ready text file
+- **Agent traces** — full transparency into what each AI agent did
+
+The key constraint: everything runs on a **single model** (MiniCPM-V 2.6, ~8B parameters) via llama.cpp. No cloud APIs. No subscriptions. No sending your craft photos to OpenAI.
+
+## How It Works: The Multi-Agent Pipeline
+
+CraftPilot uses a 4-agent pipeline, all powered by the same model:
+
+```
+Photo -> [Vision Agent] -> [Cataloger Agent] -> [Copywriter Agent]
+                                              -> [Pricer Agent]
+```
+
+1. **Vision Agent** — Takes the photo and produces a detailed text description of the craft item (materials, colors, techniques, style)
+2. **Cataloger Agent** — Reads the description and outputs structured metadata as JSON (category, materials, tags, complexity)
+3. **Copywriter Agent** — Takes the catalog data and writes warm, authentic product copy and Instagram captions
+4. **Pricer Agent** — Considers materials cost, labor hours, complexity, and market rates to suggest a fair price range
+
+Each agent has a specialized system prompt and outputs structured JSON via constrained generation. The pipeline streams results — you see the vision analysis appear first, then catalog data fills in, then copy and pricing.
+
+## The Technical Story
+
+### One Model, Four Agents
+
+MiniCPM-V 2.6 is a multimodal model from OpenBMB that handles both vision (image understanding) and text generation. Running it via llama.cpp means:
+
+- No GPU required (works on CPU)
+- No API costs
+- Full privacy — your photos never leave your machine
+
+### Why Not Just Use ChatGPT?
+
+Fair question. Here's the difference:
+
+- **No account or subscription needed** — privacy matters when selling your own work
+- **Structured, repeatable outputs** — same format every time, not a wall of text
+- **Purpose-built workflow** — pricing considers actual material costs and labor hours
+- **One-click export** — download a ready-to-paste listing for Etsy or Instagram
+
+### What I Learned About Small Models
+
+A small model is surprisingly capable when you give it:
+- Clear, focused system prompts (one job per agent)
+- Structured output constraints (JSON schema)
+- Pre-computed math (the model can't reliably add, so the pricing template does the arithmetic)
+
+Where it struggles: complex reasoning, nuanced pricing logic, and occasionally inconsistent JSON. Error recovery in the pipeline handles this gracefully — if one agent fails, you still get results from the others.
+
+## The Stack
+
+- **Model:** MiniCPM-V 2.6 (~8B) via llama-cpp-python
+- **UI:** Gradio 6.x with custom CSS
+- **Orchestration:** Python async pipeline with Pydantic models
+- **Hosting:** Hugging Face Spaces (CPU)
+
+## What's Next
+
+- Better pricing with real market data integration
+- Batch processing for multiple items at once
+- Support for more craft types and regional pricing
+
+## Try It
+
+CraftPilot is live on Hugging Face Spaces: [Try CraftPilot](https://huggingface.co/spaces/build-small-hackathon/craftpilot)
+
+Built for the Build Small Hackathon 2026 — Backyard AI track. Single model, no cloud APIs, full agent transparency.
+
+---
+
+*Built with love for someone who deserves to share her craft with the world.*