Hatch

• 

  Hatch Reactive

• 

  Plan Catalogue

Inspiration

We have a group chat that's been active for four years. Last winter, somebody sent: "we should do something for new year's." Eight enthusiastic responses. Zero plans. By the time we picked something, NYE was three days away and half the group had already committed to other things.

This is a universal story. Plans don't die because people don't want to hang out, they die because nobody wants to do the research, calendars never line up, and nobody wants to be the one who makes the first concrete proposal. The thread goes quiet, and the moment is gone.

Everyone's building AI for one person. Almost nobody's building it for groups. Group coordination is still broken. We wanted to build the friend who always has an idea and actually follows through.

What it does

Hatch is an ambient multi-agent system that lives inside a friend group's chat. It knows everyone's calendars, it knows the group's interests, and it proactively turns dying threads into real, booked plans.

It runs in two modes:

• Reactive. When somebody floats a concrete idea ("anyone down for the Lakers next week?"), Hatch quietly threads a folded reply under the message, three real ticket options, ranked against the group's interests, with everyone's calendar overlap pre-checked. No takeover or noise. One tap to propose to the group.
• Proactive. When the chat goes silent and the nest starts cooling, Hatch fires on its own. It asks the calendar agent for the shared free window, ranks events for that window, and pins a proposal at the top of the chat: "You're all free Sat 2–6pm. Free gallery opening, Arts District 3pm. Want me to set it up?"

One tap on Book it and Hatch writes the event to all Google Calendars, RSVPs, and posts a confirmation in the chat. The nest animates from cooling to glowing, the group's reward for actually following through.

Chats never expire, only warmth does. You see your group's health at a glance, and you actually want to keep it warm.

How we built it

Four agents, one orchestrator, no glue code:

1. Calendar agent runs Google Calendar freebusy.query across all authenticated accounts and surfaces overlap windows.
2. Event agent queries a curated corpus of ~50 hand-picked LA events and ranks them against each group's interest profile.
3. Proposer agent composes the in-chat message in friend-voice using ASI:One.
4. Booking agent executes Google Calendar writes across all accounts and restores the nest to full warmth.

A single Hatch orchestrator uAgent is registered on Fetch.ai's Agentverse, speaks the Chat Protocol, and is discoverable via ASI:One under keywords like group scheduling, hangout planner, and LA plans. Behind that public endpoint, a LangGraph workflow runs the four-stage pipeline — Calendar → Event → Proposer → (user tap) → Booking — inside our local FastAPI backend, where it can hold the live Google OAuth tokens that write to each user's calendar. One front door, multi-agent coordination behind it.

The frontend is a phone-frame React + Vite + Tailwind app — designed to feel like a real messaging app, not a dashboard. Framer Motion powers the nest animation. FastAPI bridges the agents to the UI. The nest itself is a small control loop — warmth decays as time-since-last-message grows, restores on a successful booking — small in code, but the mechanic that ties the whole product's emotional arc together.

Challenges we ran into

Google Calendar OAuth across accounts was a challenge External consent screen, Testing mode, teammates added as test users, refresh tokens, conflicting timezones, write-back failures that don't surface until you check the calendar tab. We burned a meaningful chunk of our first day on it.

Coordinating four agents is a UX problem, not just a routing one. Chat Protocol gives you the wires. Deciding who speaks first, who can interrupt, and what the user sees mid-pipeline is the actual product surface. Our first version surfaced every event match. The system felt like a noisy intern. Cutting to one pinned proposal and accepting a beat of silence between agent steps was the key.

Accomplishments that we're proud of

• Live, end-to-end booking. Tap one button, watch the Google Calendars update in real time. No mocks.
• The nest a small mechanic that tied an entire product's emotional arc together. -Hatch's orchestrator agent registered on Agentverse and discoverable via ASI:One message it in plain English ("hatch a plan", "book it") and watch the group chat update live, because the agent and the web UI share the same backend state.
• A demo path that didn't need cuts. We locked scope on day one and didn't chase any flaky features in the final six hours.

What we learned

• Choose what not to build. We deliberately didn't scrape Eventbrite, didn't build voice ingestion, didn't infer interests from messages, didn't build a profile system. Every cut made the demo sharper.
• A product's restraint is its personality. Agents that talk less, win. The reason no one would let an AI into their group chat is because every previous attempt was loud. Hatch's defining trait is silence.
• Friction into function. Group coordination is the kind of friction nobody complains about because they assume it's just life. The biggest unlock was naming it as a real, solvable problem.

What's next for Hatch

• Voice-message ingestion ElevenLabs integration. The agent reads the room when nobody's typing.
• Real event corpus replace the curated 50 with a live, refreshing index from Eventbrite, DICE, and city event APIs.
• Real ticket checkout via Fetch.ai's Payment Protocol split-pay the moment all four say "I'm in."
• Ship beyond the phone frame. The chat surface is a thin client. iMessage, WhatsApp, Discord, anywhere groups already live.

Built With

• agentverse
• asi:one
• chat-protocol
• fastapi
• fetch.ai-uagents
• framer-motion
• google-calendar-api
• httpx
• langgraph
• pydantic
• python
• react
• tailwind-css
• typescript
• vite