This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Yard Sloth is a local-first garden assistant for people who want a cared-for yard without becoming a part-time horticulture researcher.

You enter the name of plants in your yard (in the future, you will take one yard walk on your phone—snap photos), tag locations like "front bed, left of steps"—and confirm the plant list. From there, three cooperating agents:

1. Plant census — turns the name of a plant (in the future, turns photos + live web excerpts) into candidate plants with confidence scores (you stay in the loop before anything is saved).
2. Care calendar — spreads prune, feed, and protect tasks across the season and exports an .ics you can drop into any calendar app.
3. Frost watch — pulls tonight’s forecast and raises a banner when tender plants are at risk, with a checklist instead of panic-googling at 9 PM.

The sloth branding is intentional: the app is built for slow, steady laziness. You do the one walk; open models and agent workflows do the recurring mental load. You can use it every day to keep your yard in check. Urgent tasks are marked with an urgent icon, so you can see what you really need to do today.

Demo

Local demo: clone the repo, run python3 server/main.py and npm run dev, open http://localhost:3000. You will need Ollama running with the models configured in settings.

Video demo: https://youtu.be/AV80gnBCeYw

Code

├── agents/             # CrewAI Agent & MCP Tooling Subsystem
│   ├── agent/         # Census, Calendar, and Frost watch agents
│   ├── assets/        # Agent personas, prompt templates & roles
│   ├── mcp/           # MCP tools (live web browsing for weather, frost, care rules)
│   ├── memory/        # Ephemeral in-memory session state (zero disk storage)
│   ├── main.py        # CrewAI pipeline coordinator
│   └── README.md      # Agents architecture documentation
│
├── server/             # 100% Pure Python HTTP Backend
│   ├── api/           # REST endpoint handlers (routes.py)
│   ├── server/        # Multithreaded HTTP server engine & network config
│   ├── main.py        # Python server entry point (python3 server/main.py)
│   └── README.md

Public repo: github.com/myluco/YardSloth

All substantive work for this submission landed October 21–22, 2026 (initialize → LangGraph judge pipeline → task list polish), inside the Week 3 entry window.

How I Built It

Yard Sloth is open-source AI at the core, not a thin wrapper around a single chat API.

Default Ollama stack (each role can be overridden):

• Gemma (gemma4:31b-cloud) — primary gather / care-profile draft
• Qwen2.5 14B — second gather (different model family, same excerpts)
• Llama 3.1 8B — judge merges the two JSON drafts

Plant-care refresh is deliberately three Ollama calls: research_a and research_b in parallel, then judge. Terminal tracing ([YardSloth LLM]) makes it obvious when the sloth is thinking vs. when Python is enforcing dates.

Model explains, code decides: frost thresholds (36° / 32° / 28° F), old-wood vs. new-wood prune windows, and calendar spacing are deterministic Python—not LLM guesses. That’s how you get trustable alerts without babysitting the model.

Why Does Open Innovation Matter?

Closed garden apps want your photos, your address, and a subscription. Yard Sloth flips that:

• Open-weight models via Ollama — you can run offline-capable stacks, swap Gemma for Qwen, or point at a local runner without re-architecting the app.
• Open agent patterns — LangGraph’s gather/judge graph is inspectable; you see two drafts and a merge, not one black-box completion.
• No mandatory cloud brain — session state stays in memory on your machine; the sensitive part is “what’s in my yard,” not a vendor’s training set.
• MCP instead of frozen JSON — care guidance is fetched from live sources when needed, so you’re not locked to a vendor’s stale plant database.

A closed API could summarize a blog post about hydrangeas. It couldn’t give me reproducible frost math, calendar exports I own, and two-model disagreement resolved by a judge—unless I paid forever and sent my yard data upstream. Open stacks made the lazy path local.

My Agent Session

This session is related to publishing the project to dev

agents/llm/graphs/dual_judge_graph.py

LangGraph StateGraph: DualJudgeState with parallel _gather_a/_gather_b (chat_completion to model_a/model_b), warnings on single-gather failure, judge node merges candidates into final_text + judge_rationale.

The Lazy Payoff

Before Yard Sloth, my “system” was: random Notes app bullets, one panicked frost search per cold snap, and pruning guilt.

Now:

• One yard walk seeds the season (≈15 minutes once).
• Confirm screen is the only mandatory human gate for plant identity.
• Calendar spreads chores so I’m not cramming dormant pruning into a single overwhelmed Saturday.
• Tonight tells me if I need buckets and blankets before I’m in pajamas.

Conservative estimate: 2–3 hours/month of tab-hopping and calendar thrashing replaced by a Sunday glance and an occasional frost checklist. The sloth wins by doing less, more reliably.

Prize Categories

I'm entering:

• Best Use of Gemma — primary gather model (gemma4:31b-cloud via Ollama) drafts structured plant-care JSON from web excerpts before the judge step.

I'm not claiming categories for tools I didn't integrate (MongoDB Atlas, Render, Sentry tracing, etc.).

Built for Hacktoberfest 2026 — Slow and Steady. Questions welcome in the comments.