RoomRead

Inspiration

In nine days I went to five events: three hackathons, a voice-AI meetup and a chess night. A week later, I could barely remember who I'd met, and I'd forgotten half the things I promised people. Then a consultant I met here said something that stuck with me: he ignores LinkedIn invites from people he can't place, but a message that says "we met yesterday, we talked about X" always gets a yes.

So the problem isn't meeting people. It's remembering them, keeping your word, and knowing when there's a real reason to reach out.

What it does

Room Read is a personal brain that remembers everyone you meet, why they matter to your goals, and what you promised them. It forgets everyone else. There is no chat box. It acts on triggers.

Debrief in 20 seconds. After a conversation, tap Speak and talk. An agent matches the person against the event's guest list (287 people tonight), saves what you discussed, and sets a timer for every promise you actually made. If a name is ambiguous ("Aditya" matches three guests), the agent pauses and asks which one you meant.
A sandboxed scout checks the web. A second agent looks up the person's public LinkedIn through Bright Data. Everything it finds is labeled with its source and retrieval time.
It notices when something changes. Every week it compares hundreds of new internship postings against everyone you've met, and stays quiet unless there's a real reason to reach out. Tonight it found one out of 750: a company posted a software role, and a CTO I interviewed with in April, who told me to keep in touch, used to work there. It knew he's a former employee, so it drafted a request for advice instead of a referral. It also marked the connection honestly: "from my notes; not confirmed by public profile."
It picks who to meet before you walk in. From the guest list, it suggests who can help you, who you can help, and who's building similar things, using only what each person published.
A map with provenance. Every line says what it means and how you know it: heard it yourself, from your notes, or from the web.
It forgets on purpose. The guest list is temporary memory. At midnight, Cognee forgets everyone you didn't meet and consolidates the people you did. "Forget" on any person deletes them completely. Drafts are never sent.

How we built it

Strands Agents runs three agents: a debrief agent, a scout and a warm-path finder. The exact rules (name matching, promise timers, memory writes) are tools, and the model decides when to use them. We used Strands interrupts for "which Aditya?", hooks for guardrails and a live audit log, MCP tools, and typed structured output.
Bright Data's MCP server runs inside a Docker Sandbox. Strands connects to it over stdio through sbx exec -i. The sandbox has a deny-all network policy that allows only api.brightdata.com, and it has no access to the brain. A hook rewrites every Bright Data result before any model reads it: free-text fields like "about" and posts are dropped, and injection-looking lines are stripped.
Cognee runs locally (LadybugDB, LanceDB, SQLite) with three datasets: me (goals, offers, stories), a temporary room for tonight, and permanent people. Meeting someone promotes them from the room to people, midnight runs forget on the room and then improve, and per-person forget deletes by exact data id.
The rest: a FastAPI backend with a SQLite ledger for things that must be exact (due dates, statuses), gpt-4o-transcribe for the mic (prompted with tonight's names so they're spelled right), and a phone-first web UI with a vis-network relationship map.

Challenges we ran into

Testing on real people tonight found bugs that a demo script never would have:

The agent invented a promise from its own follow-up draft. Timers now come only from commitments you actually stated, and drafts can't make new ones.
A first-name-only search matched the wrong person, because the scout accepted "the only result." Lookups now need a full name plus context, or they're skipped in code.
Background memory writes failed silently, because Strands runs plain tools on worker threads with no event loop. They're now handed to the server loop thread-safely.
"Forget" deleted nothing, because remember() didn't return per-item hashes. We now record the exact Cognee data ids each write creates.
The right posting was invisible because of a fixed snapshot baseline. We switched to a rolling seven-day window.
Smaller ones: "Cisco" matched "San Francisco." Blank .env lines made Cognee switch to S3 mode. And after-tool hooks run in reverse order, so the audit log saw raw text before the sanitizer did.

What we learned

Memory without provenance isn't trustworthy. Every fact needs a source and a date.
A good agent knows when to stop and ask.
Forgetting is a feature. The guest list is useful for one night, then it should disappear.
Deterministic rules work best as tools, with the model deciding when to call them.