Hearth

Hearth is an always-on AI teammate — remembering what matters, coordinating work, and surfacing what's falling through the cracks.

Comment

Inspiration Most AI systems answer questions. Hearth is designed to remember an organization. Small teams lose context constantly — not because people don't care, but because no single person can see everything at once. Conversations happen across platforms. Tasks get discussed but never marked complete. Important signals disappear the moment the conversation that raised them ends. We didn't want to build a chatbot that starts over every time someone talks to it. When the conversation ends, Hearth doesn't forget — it updates the organization's memory instead. We wanted a system that actually accumulates understanding, the way a real, attentive teammate would. What it does Hearth's memory is organized as a city, not a database. Every creator, coach, and manager in the organization has a Building in Hearth's memory, with rooms for: Identity — who they are Furniture — durable facts learned about them over time, each one tied to the exact evidence it came from State — what's currently true right now Roads — their relationships to other people in the organization Episodes — specific things that happened, worth remembering Reflection — Hearth's own evolving understanding of them Nothing is treated as true just because a model said it confidently. Every fact stored in Furniture is grounded in a verbatim quote from a real source — a check-in answer, a training comment, a support message. Above the level of individual Buildings, Hearth maintains a Worldview: accumulated organizational beliefs, built carefully over time, never asserted without evidence. This isn't a prototype. Hearth already runs in daily production for Pathway, a real creator management agency. It continuously watches real organizational activity — onboarding, check-ins, training engagement, support requests, community participation — and every morning, it tells managers and coaches specific, concrete things that need their attention: a creator who's been waiting weeks for a Discord invite, a check-in that's gone unanswered, a concern pattern worth a second look. Real people act on it every day. What makes Hearth different from most AI systems is that it knows the difference between what it knows, what it believes, and what it's genuinely uncertain about — and it treats that difference as important. Instead of guessing and sounding confident either way, Hearth surfaces its uncertainty directly to a manager, asks a real question grounded in what it actually observed, and only learns from the answer once that answer has been validated against real evidence. Most AI systems hide uncertainty behind confident-sounding language. Hearth exposes it on purpose. How we built it Hearth itself is model-agnostic. Its memory architecture, evidence model, and organizational reasoning stay the same regardless of which language model is plugged into it. Today it uses Google's Gemini for high-level reasoning and a local Ollama instance (running Llama 3.1:8B) for routine classification tasks, keeping day-to-day operation cost-effective and privacy-conscious, and falling back to Gemini only for genuine ambiguity. The newest capability — and the one we're proudest of — is a general-purpose learning engine. Rather than hand-teaching Hearth what every possible manager answer might mean for every possible question, we built an interpreter that reasons from the actual question and answer text itself, extracts specific structured claims (never more than three per answer, each one backed by an exact quote), and validates each claim through two independent passes before anything is safely retained. We proved this generalizes — not just to the question types we designed it for, but to a completely invented question type it had never seen before, which it handled correctly on the first real attempt. Challenges we ran into Getting Hearth to genuinely generalize — rather than just supporting a longer fixed list of question types — was the hardest architectural problem. Our first version only understood one kind of question. We rebuilt the interpretation engine so it reasons from the actual question and context, then proved it wasn't secretly hardcoded by testing it live against a question type invented purely to check we weren't cheating. We also hit real trust problems in production. One watcher was matching stale, archived records instead of live ones, quietly generating false alerts. A piece of logic removed during an earlier refactor left one episode permanently stuck open for over a month, silently inflating its "days waiting" count in every daily brief until we traced it back to a specific commit. Both taught us the same lesson: a system that reasons about organizational data has to be provably grounded in what's actually true right now, not what used to be true — and that takes real, deliberate verification, not just trusting that the code runs without errors. Most recently, we discovered our local-model inference only ran on a developer machine, not in the actual production environment — a real infrastructure gap between "works when I test it" and "works when it's deployed," which we're still working through. Accomplishments that we're proud of Hearth distinguishes between organizational knowledge it can ground in real evidence and general knowledge it can answer conversationally — without ever pretending one is the other. Every fact it surfaces is tied to a verbatim quote from a real source. We're especially proud that Hearth's learning capability generalizes to question types it was never specifically taught — proven live, not just in a unit test, against an entirely fictional scenario. It correctly extracted accurate, evidence-backed conclusions on the first attempt. Most of all, we're proud that this isn't theoretical. Hearth runs today, in production, and real managers act on what it tells them every morning. What we learned The biggest lesson: an AI system that manages organizational memory has to be conservative by design, not by accident. Every safeguard we built — requiring exact evidence quotes, never letting model confidence override validation, keeping human review in the loop before anything becomes a permanent belief — exists because we deliberately chose to make "Hearth may fail to learn something" an acceptable outcome, while "Hearth confidently learns the wrong thing" never is. Ultimately, we learned that organizational AI isn't just about generating good answers. It's about becoming a trustworthy long-term teammate that grows alongside the people it supports, remembers what matters, and knows the difference between observation, belief, and uncertainty.

Built With

Share this project:

Updates