Hearth — Shared Operations Brain

Hearth turns messy household and workplace messages into clear, evidence-backed action plans extracting people, tasks, dates, purchases and conflicts before anything changes.

Comment

Hearth: Turn scattered messages into shared action

Inspiration

I was brainstorming ideas for this hackathon, but none of my first ideas felt like something people would actually use.

Then my mom told me to go outside and buy some groceries. A little later, she told my sister to take out the trash. Both were normal things, but they were communicated separately and could easily be forgotten.

That gave me the idea for Hearth: what if you could paste one messy household message and automatically turn it into groceries, chores, appointments and bills?

While building it, I realized the same exact problem exists at work. Teams constantly send messy updates containing tasks, meetings, purchase requests, deadlines and invoices. So Hearth expanded from a household organizer into a shared operations brain for both homes and workplaces.

The basic idea stayed the same:

Paste the messy message. Review the plan. Approve what should actually happen.

What it does

Hearth takes an unstructured message and separates it into useful actions.

For a household, it can find:

  • Groceries
  • Chores and who should do them
  • Appointments and events
  • Bills and due dates
  • Scheduling conflicts

For a workplace, it can find:

  • Purchase requests
  • Tasks and owners
  • Meetings and deadlines
  • Expenses and invoices
  • Conflicts across the team calendar

Hearth does not immediately save whatever the AI produces.

Instead, it opens a review screen where every proposed change includes the original source phrase and an AI confidence score. The user can edit incorrect information, remove unnecessary proposals and review any conflicts or missing details.

Nothing is added to the shared workspace until the user approves it.

How I built it

I built Hearth with Next.js, React and TypeScript.

Prisma and SQLite handle the workspace data, including members, tasks, events, purchases, expenses and the activity history. Zod validates the AI response before it can be shown or committed.

The extraction flow uses GPT-5.6 through the OpenAI API. It receives the original message, today’s date, the workspace type and the current workspace members. It returns a structured proposal instead of directly editing the database.

The flow is:

  1. Paste an unstructured message
  2. Let GPT-5.6 identify the actions
  3. Validate the complete response
  4. Show conflicts, assumptions and missing information
  5. Let the user edit or remove proposals
  6. Commit all approved changes together
  7. Update the shared workspace

I used Codex throughout the project. It helped me inspect the codebase, create the API routes, extend the database, debug problems and test the interface in the browser.

A large part of the process was not just asking AI to generate something. It was looking at the result, deciding what felt wrong and repeatedly improving it.

Challenges

One of the biggest challenges was avoiding the classic “vibecoded website” look.

AI-generated sites often use the same gradients, floating cards, oversized rounded corners and generic dashboard layouts. I wanted Hearth to feel like an actual designed product, so I spent a lot of time improving the typography, spacing, colors, information hierarchy and the differences between household and workplace mode.

There were also many small features that were easy for AI to miss at first.

For example:

  • Items needed proper edit controls
  • Purchase requests needed prices
  • Completed tasks needed a fulfilled section
  • Members needed to be manageable
  • Workplace mode could not still show groceries and family language
  • The enterprise schedule needed to look like a real calendar
  • The AI review originally appeared too far down the page, making it seem like nothing happened

Each individual issue was small, but together they made the difference between a generated prototype and something that felt coherent.

Another challenge was AI reliability. Relative dates such as “Tuesday” or “tomorrow” can be ambiguous, and the model must not invent owners, locations or prices.

That is why Hearth shows source evidence, confidence, assumptions and unresolved questions instead of pretending every extraction is automatically correct.

Accomplishments I’m proud of

I am especially proud that Hearth became more than a text-to-task demo.

It now includes:

  • Household and workplace workspaces
  • Different interfaces and terminology for each workspace type
  • AI extraction with source evidence
  • Conflict and uncertainty detection
  • Human review before saving
  • Editable proposed changes
  • Atomic database commits
  • Member creation, editing and removal
  • Groceries and workplace purchasing
  • Chores and a workplace Workboard
  • Household and enterprise calendars
  • Bills, expenses and invoices
  • Fulfilled-task sections
  • Responsive mobile and desktop layouts
  • A reviewable activity history

What I learned

The biggest thing I learned was how powerful AI has become.

The barrier between having an idea and building a working version of it is much lower than it used to be. Someone who is willing to experiment, learn and keep improving the result can now build things that would previously have required a much larger team.

At the same time, I learned that AI does not automatically make the right product decisions.

It can create a button or a database route, but it does not always notice that an interface feels generic, that an important edit feature is missing or that a result appears outside the visible screen.

You still need judgment, taste and a clear idea of what the product should feel like.

AI made Hearth possible for me to build, but the hardest part was deciding what should be built and continuing until the result felt right.

What’s next

The next step would be letting Hearth receive messages from the places people already communicate, such as Slack, email or group messaging platforms.

I would also like to add:

  • Secure accounts and invitations
  • Live collaboration
  • Workspace permissions
  • Calendar integrations
  • Recurring workflows
  • Notifications after approved changes
  • Better organization-specific memory

The goal is not to replace communication. It is to stop useful actions from disappearing inside it.

Built With

Share this project:

Updates