Quorum

The Slack agent that represents you in the decisions that happen while you're asleep.

Comment

Inspiration

On global teams, decisions happen where the daylight is. By the time a teammate in Manila, Nairobi, or São Paulo logs on, the thread has moved on and the decision is already made. Researchers call this the timezone tax. A peer-reviewed study of 12,038 employees ("Working Around the Clock," Organization Science, 2024) found that 43% of real-time workplace communication happens while at least one person involved is outside their working hours.

Every "solution" we found online was culture advice: document more, default to async. No tool actually defends your voice while you sleep. Slack AI can tell you what you missed, but by then it's history. We wanted an agent that works one step earlier, while the decision is still forming.

So we built Quorum: an agent that represents you in the decisions that happen while you're asleep.

What it does

Quorum makes one promise: being offline should never mean being unheard. It keeps that promise with four connected features.

1. The inclusion check. Add Quorum to a channel with /quorum on. It quietly watches threads. When a conversation starts converging on a decision while someone it affects is offline, it posts a gentle flag right in the thread:

Quorum inclusion check. This thread looks like it's converging on a decision: cutting the onboarding checklist. Priya Sharma is affected, and it's 02:14 for them (Manila time), offline right now. [Capture async input] [Proceed anyway]

It's a question, never a block. The team can always proceed. But now they proceed knowingly.

2. The daybreak brief. When you come back online, you don't scroll 400 messages. You ask Quorum one question: "what moved while I was offline?" It streams back a brief that separates what was decided, what's still forming, and what's just discussion. Every item comes with a permalink receipt back to the exact thread.

3. One-tap voice-back and loop-closer. Every forming item in your brief has an Add my input button. Pick a stance, add a note, and Quorum posts it into the original thread as your async voice. Then it nudges the decision-maker to look again before the decision locks: "an affected teammate weighed in, does it change the call?" In our demo, it does. The feature gets trimmed instead of cut. The decision doesn't just get fairer. It gets better.

4. The equity receipt. Type /quorum report and Quorum shows the pattern no one could see before: "13 of 15 decisions in this channel formed while an affected teammate was offline (87%). Most affected: Priya Sharma." Quorum logs every detected decision, even when nobody was offline, so the number is honest. The invisible timezone tax becomes a metric a team can act on.

There's also an App Home dashboard with live counters (channels watched, decisions detected so far), a one-tap Watch a channel button, and the authorize link for briefs. Full opt-in control: /quorum on, off, and status.

A few details worth knowing. Both flag buttons act and leave a record: Capture async input routes the thread into the absent person's brief, and Proceed anyway notes who chose to proceed while the offline teammate still sees the outcome in their next brief. Either way, the choice to include or exclude someone is now visible. The brief triggers on natural language ("catch me up", "what happened overnight"), not one magic phrase. And beyond the scripted flows, Quorum is a full conversational agent: DM it anything, ask whether a decision locked, or have it draft a constructive reply in your voice. It keeps conversation memory across thread turns and puts feedback buttons on its answers.

How we built it

All three challenge technologies, each doing a job only it can do.

  • Real-Time Search API powers the daybreak brief. Here's the part we're proudest of: RTS with a bot token needs an action_token minted from a live user event, so a background scan of everyone's messages is architecturally impossible. We built the brief to run on each user's own OAuth user token instead. That means privacy by construction: Quorum can only search what you can already see, it acts only when you ask, and it stores none of your message content.
  • Slack AI capabilities power decision detection and the brief itself. Channel events are buffered per thread, a fast Claude model classifies whether a decision is forming, who it affects, and whether they're offline (timezones come from Slack profiles). A stronger Claude model then writes the brief, streamed token by token into Slack's assistant pane with live status ("Scanning your offline window…").
  • Slack MCP server gives the agent its hands: the tools it calls to read threads and post your async voice back into the original conversation.

Under the hood: Bolt for Python + the Claude Agent SDK (fully async), SQLite persistence for watched channels, flags, and the decision log, all over Socket Mode. Deployed in Docker on AWS EC2, running 24/7 with auto-restart, verified live with the laptop off.

Engineering quality (the parts you can't see in a 3-minute video)

Detection that knows when to stay quiet. A false flag erodes trust faster than a missed one, so the classifier is biased hard toward silence: strict bar (explicit convergence with visible agreement, confidence 0.7 or higher), red-teamed against sarcasm, hypotheticals, decision-shaped questions, and prompt injection hidden in message text. It stayed quiet on all of them. Detection is debounced and de-duplicated: a rolling 30-message buffer per thread, a 20-second cooldown between classifier calls, and one flag per thread, ever. Two Claude models are matched to their jobs: a fast one for high-frequency classification, a stronger one for writing the brief.

Fairness details most tools would miss. Presence is deliberately ignored: Quorum uses working hours, not the green dot, because someone glancing at their phone at 2am is not "in the room." Active thread participants are never counted absent. Every detected decision is logged, even when nobody was offline, so the equity report has a true denominator. Voice-back input is always labeled as added via Quorum; nothing pretends to be organic. And the nudge goes to one person, the thread's proposer, never the whole channel.

Retrieval engineering in the brief. Hybrid search probes (semantic questions plus keyword queries), de-duplicated and filtered to the user's offline window. When Real-Time Search returns a hit with empty content, Quorum re-fetches the real thread text, again on the user's own token, so the synthesis never works blind. The agent's own posts are filtered out so it never reports on itself. And if nothing relevant moved, the brief honestly says so instead of padding.

Built to keep running. 31 passing tests covering the classifier contract, offline-hours logic, equity math, buffer behavior, and every Block Kit view. Graceful degradation everywhere: unparseable model output becomes a safe "no flag," a streaming failure falls back to a plain post, and an unauthorized brief request gets a friendly one-click authorize message instead of an error. Three written ADRs document the real trade-offs: why RTS runs on the user's token, why decision detection uses the Events API plus an LLM instead of polling, and why we chose a persistent VM over serverless (Socket Mode plus stateful thread buffers make Lambda the wrong shape). Architecture is documented twice: a Mermaid diagram in the README and a full end-to-end HTML architecture page.

Challenges we ran into

  • The action_token wall. Our first design was an overnight cron scan using bot-token RTS. Dead end: that token only exists inside live user events. The redesign (user token, on-request retrieval) cost us a day and became the best decision in the project. It made Quorum provably private instead of just promising to be.
  • Teaching an LLM to shut up. Decision detection is easy to over-trigger. Threads full of "should we…?" aren't decisions. We rewrote the classifier contract around a strict bar (explicit convergence plus a named owner acting on a deadline) and validated it adversarially.
  • Keeping demo state honest. Socket Mode means exactly one live instance may own the event stream. We learned this the hard way when a local hot-reloader silently competed with the cloud instance.

Accomplishments that we're proud of

  • A genuinely new category of agent: not an assistant that serves the people present, but one that represents the person who's absent. We haven't found this anywhere else.
  • All three hackathon technologies are load-bearing. Remove any one and a pillar collapses.
  • Privacy as an architectural property, not a policy promise.
  • The same code, unchanged, protects a product engineer's feature and a field coordinator's clinic schedule, including care for 30 prenatal patients in our seeded nonprofit storyline.
  • Deployed, always on, and tested end to end before the deadline.

What we learned

  • Constraints are design partners. Slack's strictest API rule (the action token) pushed us into the most trustworthy architecture we could have chosen.
  • For agents that interrupt humans, restraint is the product. Most of our engineering went into deciding when Quorum stays silent.
  • An agent for good doesn't need a new UI. The most inclusive surface is the thread the team is already in.

What's next for Quorum

  • Team equity dashboards: /quorum report across channels and quarters, so orgs can track whether inclusion is improving.
  • Personal working-hours profiles that go beyond timezones: caregiving hours, focus blocks, accessibility preferences.
  • Slack Marketplace listing: the agent is already architected for multi-workspace OAuth.
  • Deeper voice-back: letting Quorum draft your input from your past positions, so one tap becomes zero.

How to test it

Sandbox: https://quorum-hackathon.enterprise.slack.com

Access: member invitations have been sent to [email protected] and [email protected] (valid through the judging period). Testing steps are also pinned in #general.

The 2-minute path (everything is pre-seeded and visible):

  1. Open #proj-onboarding: the team proposes cutting the checklist Priya Sharma owns while she is offline in Manila (02:14 local). Quorum's inclusion check names who is affected, with Capture async input and Proceed anyway buttons. Her async input and the proposer's reply show the loop closing.
  2. Open #ops-clinics: a nonprofit HQ moves a mobile health clinic while field coordinator Amara Otieno is offline in Nairobi. Her one-tap input about 30 booked prenatal follow-ups reverses the reroute.
  3. In either channel, type /quorum report for the equity receipt.

Live interaction (the agent runs 24/7 on AWS EC2):

  1. Click Quorum under Apps. From a DM, ask "what moved while I was offline?" for the streamed daybreak brief. It searches on the requesting user's own authorization, so it can only see what that user can already see.
  2. On a forming item, click Add my input: your stance and note land in the original thread, and Quorum nudges the decision-maker before it locks.
  3. /quorum on watches a channel, /quorum status checks, /quorum off stops.

Built With

  • anthropic
  • aws-ec2
  • bolt
  • claude
  • claude-agent-sdk
  • docker
  • mcp
  • pytest
  • python
  • real-time-search-api
  • slack
  • slack-ai
  • slack-block-kit
  • socket-mode
  • sqlite
Share this project:

Updates

Submission history