SlackLens — Devpost Story

Inspiration

Every busy Slack workspace has the same problem: the decisions that matter are buried. A procurement team argues about below-tolerance approvals for three days, lands on an answer, and two weeks later nobody can find it. A new engineer joins and has to scroll a year of history to learn who owns what. A lead ships a release without realizing an earlier hotfix was a prerequisite.

The context already exists — it's just trapped in the scroll. We wanted one agent that reads a channel the way a thoughtful teammate would: it tells you what happened, answers questions with receipts, and helps you act — without ever leaking something you weren't allowed to see.

What it does

SlackLens is a single Slack workspace agent with eight focused capabilities, all running on live channel data:

• /recap — catch up on a channel: decisions, action items, blockers, and shared files as a clean structured card.
• /knowledge — ask a plain question and get an answer with the exact source messages cited, plus conflict detection when the channel contradicts itself.
• /mediapack — build an evidence brief from a channel's files, scoped to only the files you are allowed to open; anything you can't access is withheld and counted, never leaked.
• /onboarding — generate a new-joinee pack (overview, key decisions, links, glossary) as a Slack Canvas, plus a per-person canvas for each key teammate, dropped right into the channel.
• /pre-req-releases — before shipping a version, find what must land first, reference earlier releases, pull the owner's changelist, and summarize readiness.
• /threadpilot, /opsbrief, /notification — capture decisions from threads, generate operating briefs, and set personal alert rules.

Everything respects Slack permissions, and every answer points back to the messages behind it.

How we built it

• Slack Bolt for JavaScript + Socket Mode for the agent runtime, in an npm-workspaces monorepo (@slacklens/agent, @slacklens/mcp-server, @slacklens/shared).
• A real Model Context Protocol server with four tools — search_context, fetch_thread, detect_conflicts, and file_access_check. The agent connects as an MCP client; the file-access tool is what makes the permission-scoping real rather than cosmetic.
• Claude for reasoning, with a deterministic fallback. When a language model isn't available, every capability degrades to pure extract/parse/build logic, so the agent always responds — offline, in CI, or in a judge's sandbox.
• Slack Canvas API (canvases.create + canvases.access.set) for onboarding packs, shared to the channel so they open without an access request.
• Architecture pattern: capability functions are pure (extract → parse → build blocks) and separately testable; only a thin orchestration layer touches Slack. That's why we have 109 tests, all passing, all offline.

Challenges we ran into

• Canvas access. A bot-created canvas is private to the bot — users saw "request access." Fixed by calling canvases.access.set to share the canvas with the channel's members after creation.
• Permission scoping that actually holds. It's easy to list files; the hard part is proving you never surface one the caller can't see. We routed every file through the MCP file_access_check tool and withhold-and-count anything that fails.
• Recording a real demo without Accessibility permissions. macOS blocked keystroke automation into Slack, so we drove the desktop app with slack:// deep links instead and screenshotted real command output on live data.
• The demo video toolchain. Our ffmpeg build had no drawtext filter, so we pre-rendered lower-third titles as transparent PNGs and composited them with the core overlay filter. The macOS say voice sounded robotic, so we swapped in Piper — an offline neural TTS — for a natural voiceover that explains each screen instead of reading it.

Accomplishments that we're proud of

• A genuinely permission-aware agent — the safety story isn't a slide, it's enforced by an MCP tool and covered by tests.
• Eight capabilities behind one agent, sharing one context pipeline, instead of eight disconnected apps.
• Answers with citations — every knowledge result shows the messages it used, so you're never trusting a black box.
• 109 offline tests, so the whole thing is reproducible and reviewable without any API key.
• A 3-minute narrated demo built entirely from real Slack screenshots on live channel data.

What we learned

• In Slack, permissions are the product. A summary that leaks a restricted file is worse than no summary. Designing access-checking in from the start changed the architecture.
• Deterministic fallbacks make AI features demoable and trustworthy. Judges, CI, and offline runs all hit the same code path and get real output.
• Keeping capability logic pure (no Slack calls) made the difference between "we hope it works" and 109 tests that prove it does.
• Citations beat cleverness. Showing the source messages earned more trust in the demo than any single answer did.

What's next for SlackLens

• Promote /threadpilot, /opsbrief, and /notification from capability cards to full live analysis on the shared pipeline.
• Wire the Real-Time Search API for cross-workspace knowledge.
• Scheduled recaps and briefs (daily/weekly digests posted automatically).
• Richer onboarding: auto-generated glossary from linked docs, and "who to ask about X" routing.
• Marketplace submission for the Organizations track.

Built With

• anthropic
• block-kit
• claude
• esm
• faker
• ffmpeg
• javascript
• mcp
• model-context-protocol
• node-test
• node.js
• npm-workspaces
• piper-tts
• rest-api
• resvg
• slack
• slack-api
• slack-bolt
• slack-canvas
• socket-mode
• svg
• websocket