DecisionIQ - AI Decision Capture for Slack

Auto-detects decisions in Slack conversations, saves them with full context, and proactively recalls them when related topics arise - so your team never re-decides the same thing.

Comment

Inspiration

Every distributed team knows the pain: someone asks "wait, what did we decide about the database?" and nobody remembers. The decision was made three weeks ago in a Slack thread, buried under 200 messages, and the people who made it have moved on to other projects.

We've lived this. Decisions get made constantly in Slack — in channels, in threads, in DMs — but they're never captured. New team members spend 2–4 weeks just figuring out what's already been decided. Teams re-litigate the same questions over and over. Institutional knowledge evaporates the moment someone goes on leave or leaves the company.

Studies estimate this costs the average knowledge worker 5+ hours per week — a $47B/year productivity drain globally. Yet no tool automatically captures the decisions that happen naturally in Slack conversations. Meeting note tools (Otter, Fireflies) only catch meetings. Knowledge bases (Notion, Confluence) require manual documentation that nobody actually does. Slack search is keyword-only with no decision intelligence.

So we built DecisionIQ — a proactive intelligence layer that captures decisions as they happen and resurfaces them before your team re-decides the same thing.

What it does

DecisionIQ is an organizational memory agent for Slack. It does five things:

🤖 1. Auto-Detects Decisions

Every message in a channel is analyzed by Claude AI in real time. When decision language is detected — "we'll go with PostgreSQL", "let's go with the API approach", "agreed, shipping Friday" — DecisionIQ posts a subtle confirmation card with the detected decision, category, and confidence score, plus [Log Decision], [Edit], and [Not a Decision] buttons. This human-in-the-loop step eliminates false positives.

✅ 2. Confirms & Tags

The team confirms the decision (or edits the summary/category via a modal). Only confirmed decisions are stored — keeping the decision log clean and trustworthy. Decisions are auto-categorized into Architecture, Product, Process, People, Budget, or General.

💾 3. Indexes with Full Context

Each decision is stored in PostgreSQL with: summary, full message context, who decided, channel, thread timestamp, category, and timestamp. Every logged decision also auto-syncs to a Notion database so there's a permanent, searchable record outside Slack.

💡 4. Proactively Recalls

When someone starts discussing a topic that has prior decisions, DecisionIQ proactively surfaces the related past decision in-thread — before the team re-hashes it. A 30-minute per-channel cooldown prevents spam. This is the "organizational memory" moment: the agent comes to you, not the other way around.

🔌 5. Exposes an MCP Server

DecisionIQ runs a Model Context Protocol (MCP) server (JSON-RPC 2.0 over Streamable HTTP) exposing four tools — search_decisions, get_recent_decisions, get_decision_stats, log_decision — so any AI tool (Claude Desktop, Cursor, other agents) can query your team's decision history programmatically. This turns your Slack decisions into a queryable knowledge layer for the broader AI ecosystem.

💬 Slash Commands

  • /decide recall <topic> — search past decisions by topic
  • /decide log — manually log a decision via modal
  • /decide digest — this week's decisions at a glance
  • /decide export — export all decisions to Notion, CSV, or Markdown
  • /decide help — command reference

🏠 App Home Dashboard

A decision dashboard showing total decisions, decisions this week, top category, recent decisions timeline, and a search modal — plus an onboarding flow for first-time users.

How we built it

Architecture:

Slack Workspace → Bolt.js (Socket Mode) → Claude AI (Detection)
                                              ↓
                        PostgreSQL (Neon) ← store + Notion (sync)
                                              ↓
                                   MCP Server (JSON-RPC 2.0)
                                              ↓
                              External AI tools (Claude, Cursor)

Tech stack:

  • Runtime: Node.js 20+
  • Slack SDK: Bolt.js with Socket Mode (no public URL needed)
  • AI: Anthropic Claude (claude-sonnet-4-6) — single LLM call per message returns is_decision, confidence, summary, category, and topics together (efficient — one call powers both detection and proactive topic matching)
  • Database: PostgreSQL on Neon, with decisions and decision_links tables, scoped per workspace_id for multi-workspace isolation
  • MCP: @modelcontextprotocol/sdk — a real MCP server with Streamable HTTP transport and Bearer token authentication
  • Integrations: Notion (auto-sync + bulk export) via the official SDK
  • Deployment: Docker + Railway, runs 24/7

Decision detection prompt: We engineered a Claude prompt that recognizes explicit ("we decided"), implicit ("let's go with"), and consensus ("everyone agreed") decision patterns, returns a confidence score (0.0–1.0), and only triggers the confirmation card above a 0.75 threshold.

MCP server: Built per the MCP spec — JSON-RPC 2.0 over Streamable HTTP, with per-request server instances and optional Bearer token auth via MCP_SERVER_SECRET. Tools are registered with Zod-validated schemas so any MCP-compatible client can discover and call them.

Challenges we ran into

  • LLM false positives: Early on, Claude flagged questions and discussions as decisions. We solved this with a confidence threshold (0.75) plus the human confirmation step, so the model never silently logs anything.
  • Proactive spam: Surfacing related decisions on every message would be annoying. We added a 30-minute per-channel cooldown so each channel gets at most one proactive recall per half hour.
  • Single-call efficiency: Running two LLM calls per message (one to detect, one to extract topics) was slow and costly. We combined both into a single prompt that returns detection + topics in one JSON response.
  • MCP authentication: Exposing decision data over MCP required securing the endpoint. We added optional Bearer token middleware so teams can lock down the server in production.
  • Multi-workspace data isolation: Decisions from one workspace must never leak to another. Every query is scoped by workspace_id from the Slack team context.
  • Keeping the agent unobtrusive: The hardest UX challenge: being helpful without being noisy. The confirmation card, cooldown, and opt-in commands all serve this goal.

Accomplishments that we're proud of

  • ✅ A real, working MCP server: Not a stub. JSON-RPC 2.0, Streamable HTTP, 4 tools, Zod-validated schemas, Bearer auth. Any MCP client can query your team's decisions today.
  • ✅ Human-in-the-loop detection: Keeps the decision log trustworthy — no silent AI logging.
  • ✅ Single LLM call: Powering both detection and topic extraction — cost-efficient and fast.
  • ✅ Three export formats: Notion, CSV, and Markdown out of the box.
  • ✅ End-to-end flow working in production: Hosted on Railway — detect → confirm → store → sync to Notion → recall → export → query via MCP.
  • ✅ Polished Block Kit UX: Confirmation cards, edit modals, App Home dashboard with analytics, onboarding for new users.

What we learned

  • The MCP protocol: JSON-RPC 2.0, Streamable HTTP transport, tool registration with schemas. It's a clean standard that makes AI tools interoperable.
  • Slack Bolt.js Socket Mode: Perfect for agents that don't need a public endpoint; instant event delivery without ngrok.
  • Prompt engineering for structured output: Getting Claude to reliably return strict JSON with confidence scores took iteration.
  • Block Kit UX patterns: actions blocks for confirm/edit/dismiss, context blocks for metadata, modals for editing. Compact, mobile-friendly cards matter.
  • The "proactive vs. noisy" balance: The single most important design lesson. An agent that speaks too often gets muted; one that speaks rarely but relevantly earns trust.

What's next for DecisionIQ

  • 🔍 Real-Time Search (RTS) API integration: Replace keyword matching with Slack's semantic search (assistant.search.context) for far more accurate proactive recall and /decide recall results.
  • 🤖 Agent surface with streaming: Add the Slack Agent Builder split-view surface, suggested prompts, and streaming responses for conversational decision queries.
  • 🔗 More integrations: Linear, Jira, and GitHub via MCP, with real decision-to-ticket linking using the decision_links table.
  • 🧠 Semantic search with pgvector: Store decision embeddings for vector similarity matching as a complement to RTS.
  • 📬 Scheduled Smart Digests: Automated weekly DM digests highlighting decisions posted outside a user's timezone.
  • 📊 Deeper analytics: Decision velocity, reversal rate, and top decision-makers in the App Home dashboard.
  • 🧪 Test suite: Vitest unit/integration/e2e coverage for the detection engine, MCP server, and full lifecycle.

Built With

Share this project:

Updates