Vouch

Inspiration

Every team we've been on has the same graveyard: a Notion doc that was accurate for about two weeks after it was written. The real decisions — "we're dropping support for X", "auth service owns rate limiting now" — happen in Slack threads at 11pm, get a few 👍 reactions, and never make it back to the doc. Six months later someone onboards, reads the doc, and builds the wrong thing.

We didn't want another "AI summarizes your Slack" tool. Summaries are cheap and nobody trusts them. What's missing is the human vouching step: someone with context saying "yes, this is real, write it down." So we built Vouch around that.

What it does

Vouch is a Slack agent that:

1. Listens across your workspace (it auto-joins public channels) and detects when a thread contains an actual decision, not just chatter.
2. Drafts a resolution note — what was decided, by whom, and which doc section it affects.
3. Nudges a human via DM with the draft and interactive buttons. Nothing gets written until someone vouches for it.
4. Writes it back to the right Notion section with provenance: who decided, who vouched, and a link back to the original thread. Receipts, not vibes.

There's also a /vouch command for manual syncs, and a Notion webhook receiver so if someone edits the doc directly, Vouch's picture of it stays current.

How we built it

Node/TypeScript, deliberately boring — a single flat package, no monorepo ceremony.

• Slack layer: channel listener, DM nudges with interactive actions, slash command.
• Store: an MCP server exposing bindings, sections, threads, and provenance as tools. Making the store an MCP server meant the detection logic and any future agent can talk to it the same way.
• Detection + drafting: an LLM via Ollama Cloud's OpenAI-compatible endpoint decides "is this a decision?" and drafts the resolution note.
• Notion: workspace-wide import that generates stable, idempotent section IDs (re-imports don't duplicate), a --dry-run flag so you can preview before touching anything, and a signature-verified webhook for live sync.
• Real-Time Search for enrichment and a dedupe backstop, so the same decision surfacing in two threads doesn't produce two nudges.

We enforced a strict build order: nothing touched live Slack or Notion until decision detection passed against offline fixtures.

Challenges we ran into

• Decision detection is genuinely hard. "Let's go with Postgres" is a decision; "let's go with Postgres?" is not; "fine, Postgres, whatever" usually is. We spent more time on the eval fixtures than on the prompt itself, and testing offline first saved us from spamming a real workspace while iterating.
• Per-channel bindings didn't survive contact with reality. Our first design required manually binding each channel to a doc. Nobody would ever configure that. We ripped it out mid-hackathon and rebuilt around workspace-global mode: auto-join everything, import everything, route by content.
• Idempotency everywhere. Slack retries deliveries, Notion webhooks fire more than you'd expect, and demos get re-run constantly. Stable section IDs and dedupe checks turned out to be load-bearing, not nice-to-have.
• Demoability. "Wait for your team to make a decision" is a terrible demo. We built a one-command reset that wipes the DB, replays a scripted Slack build-up fixture, and resets Notion — so the whole flow runs cleanly every time.

Accomplishments that we're proud of

• The full loop works end to end: a Slack thread turns into a vouched, provenance-stamped Notion update with zero manual copy-paste.
• We rebuilt the core routing model mid-hackathon — from per-channel bindings to workspace-global — and shipped it, because the first design was something nobody would actually configure.
• The one-command demo. Reset DB, replay a scripted conversation, reset Notion, start the app. It runs clean every single time, and it doubles as our integration test.
• Nothing writes without a human. It would've been easier to let the AI write directly, and the product would've been worse. Holding that line is the whole point.

What we learned

• The trust problem in AI-writes-your-docs tools isn't a model problem, it's a workflow problem. Adding one human checkpoint changes the product from "AI guesses" to "team memory with receipts."
• Provenance is the feature. The link back to the thread is what makes people actually believe the doc.
• Design your demo path as early as your happy path. The replay fixture ended up doubling as our integration test.

What's next for Vouch

• Smarter routing. Right now we match decisions to doc sections by content; we want confidence scores and a "not sure — pick a section" fallback in the nudge itself.
• Beyond Notion. The store is already behind an MCP server, so Confluence, Google Docs, or a plain markdown repo are adapters away.
• Decision expiry. Decisions rot too. Nudge the original voucher after N months: "still true?"
• Private channels and DMs, opt-in. Some of the most important decisions happen there — but that needs careful consent design, not just a scope bump.
• A decision log view. Once every decision has provenance, you get a searchable timeline of why the system is the way it is — for free.

Built With

• mcp
• node.js
• notion
• notion-api
• ollama
• openai
• slack
• slack-api
• sqlite
• typescript
• webhook
• websockets
• zod