Memora: a Slack agent for teams that forget

Memora started with a problem I kept running into. I've been President of AusLeap since March 2025 and an Associate at TechSoc UTS, and both clubs hand over to a new committee every year. The reasons behind last year's decisions leave with the people who made them. Why a venue was picked, why the budget was capped where it was: the answer is in a Slack thread or a Google Doc somewhere, and the new committee works it all out again from scratch. Clubs are the extreme case, but every team that loses a person does the same.

Two teammates and I built Memora for the Slack Agent Builder Challenge (4,426 participants). It lives in Slack, keeps a record of what the team decided, and answers questions about it later with a source and a confidence level.

What it does

Almost everything runs through a handful of slash commands:

• /decide records a decision. The text is split into sentence-aware chunks, embedded and stored so it can be found later.
• /ask answers a question from the team's memory: recorded decisions plus any connected Google Docs and Sheets.
• /connect-folder links a Google Drive folder. Its Docs and Sheets are ingested and kept in sync. /disconnect-folder takes it away again.
• /register links your Slack account to a Google account, and /unregister removes the link.
• /reconcile-run starts a reconciliation run and posts what it finds to a review channel.

The part I built

We split the work by area. Mine was the Google Drive side and the approval half of reconciliation. I wrote the Google Docs ingestion pipeline, the connected-folder sync behind /connect-folder and /disconnect-folder, the worker that polls Drive for changes, and /register and /unregister. For reconciliation I built the proposal model: how a proposal is stored, which states it can move between, the 72 hour expiry, and the checkmark reaction that approves it. Near the end I also reviewed the pull requests that made Memora installable across multiple workspaces.

My teammates built /decide and the embeddings behind it, /ask with its confidence levels and answer writing, Sheets ingestion, Slack message ingestion, and the reconciliation run that finds the mismatches in the first place.

Answers that admit when they don't know

The thing we cared about most was /ask not making things up. It embeds the question, searches decisions and documents together, and throws away anything below a similarity threshold. Claude then writes the answer from whatever evidence is left and cites where it came from.

Every answer is tagged High, Medium or Low, with a one-line reason such as "Supported by a formal /decide statement." If nothing relevant gets past the threshold, Memora says Low and tells you it found nothing, rather than guessing. For a handover tool that matters more than anything else. A Low answer tells the next person to go and ask someone, which is exactly what they should do.

A person signs off on every change

Reconciliation is where Memora looks across the team's records for things that no longer line up, like a budget in one sheet that doesn't match the handover doc. It's only useful if it can eventually act on what it finds, but an agent quietly rewriting a budget is the fastest way to lose a team's trust. So it doesn't fix anything by itself. Each finding is saved as a proposal with its source evidence and a suggested action, then posted to the review channel.

An approver confirms a proposal by reacting to it with a checkmark. Anything nobody acts on expires after 72 hours, and a newer run can replace an older one. Nothing gets written back until someone has said yes, and every step is kept in an audit trail. It adds a step, but it's the step that makes the rest believable.

What we found hard

Building it was the easy part to describe. Here's what actually slowed us down, and what we did about it.

Three countries, two clocks

One teammate was in Vancouver, one was on the US West Coast, and I was in Sydney. Vancouver and the West Coast share a timezone, so the two of them could work together in real time. I was 17 to 19 hours ahead, depending on daylight saving. That left a window of two to four hours where all three of us were awake and working.

We stopped fighting the gap and started using it:

• One short call in the overlap. We saved the shared window for talking things through together and kept everything else async.
• Written updates in Slack. Before logging off, each of us posted what got done, what was blocked and what was next, so whoever woke up could pick it straight up.
• One area each. Each of us owned a separate part of the system, so most days nobody was stuck waiting on someone who was asleep.
• Reviews overnight. Open a pull request before bed and wake up to a review. The code kept moving while each of us slept.

It was a little on the nose. We were building a tool for teams that lose context, and what held our own team together was writing things down.

Keeping Google Drive in sync

A connected folder changes all the time. Re-reading everything on every change is slow and wasteful, but missing a change means /ask answers from a stale document. The worker now polls Drive's Changes API every five minutes by default. A change points to the connected folders it affects, those get rescanned, and only files whose modifiedTime actually moved are ingested again.

Removal needed the same care. When a team disconnects a folder, Memora purges the documents that no other connected folder still references, so the memory doesn't hang on to things the team took away. On the Slack side, the daily walk catches any edits and deletions the bot missed in real time.

Making three services feel like one

Splitting the work by area solved the timezone problem and created a new one. Memora runs as three services (the Slack bot, an ingestion API and a Drive sync worker), and their parts were written separately by people who were rarely online at the same time. The seams were where things broke. What helped was keeping the contract between them small. Everything ends up as document rows in Supabase, tagged with where it came from (a decision from /decide is stored with the source slack_decide), so each service only had to agree on that one shape.

What I'd take from it

The biggest lesson matched the product. Context disappears unless someone deliberately writes it down, whether that's a club handing over to next year's committee or three people passing work across seventeen hours of time difference. Memora makes that the default for teams. Working across three countries made it the default for us.