📐 Blueprint — the continuous cloud PM for Slack

A Slack Agent template built with Workflow DevKit's DurableAgent, AI SDK tools, Bolt for JavaScript (TypeScript), and the Nitro server framework.

Inspiration

Every engineering team quietly leaks context. A decision gets made in a thread on Tuesday and forgotten by Friday. A PM drops a feature request with no owner, no scope, and no acceptance criteria. Someone in London is blocked overnight because the one person who understands the auth service is asleep in San Francisco. And two weeks later somebody reopens a debate the team already settled — because nobody remembered they'd settled it.

We didn't want another dashboard that people have to remember to update. We wanted a teammate that just remembers — one that lives where the work already happens (Slack), listens to the conversation, and steps in exactly when context is about to be lost. That teammate is Blueprint: a continuous cloud PM.

What it does

Blueprint turns everyday Slack conversation into a living knowledge graph, then acts on it. On top of that memory it runs four autonomous agents plus a live dashboard:

• 🧠 Team memory — classifies every channel message into a Neo4j graph of decisions, blockers, questions, topics, and who-knows-what. Ask @Blueprint what did we decide about auth? and it answers with sources.
• ⚠️ Decision Drift Detector — when someone proposes something that contradicts a past decision, Blueprint flags it in-thread with the original decision and buttons to record a new direction or keep the old one.
• 📝 Context Gap Detector — spots feature requests missing an owner, scope, acceptance criteria, or dependencies and asks for the gaps before engineering starts.
• 🗂️ Plan → Execute → Verify agent — @Blueprint break down <feature> produces a graph-grounded plan (phases + owners drawn from the expertise graph + constraints from past decisions), waits for human approval, then autonomously follows up on progress.
• 🌙 Timezone Handoff + Async Relay — hands off open work at the end of someone's local day, and if a question sits unanswered it either answers from memory or DMs the right expert at the start of their workday.
• 📐 Interactive App Home dashboard — recent decisions, active blockers, plan progress, and trending topics — where you can resolve a blocker or check off a plan phase with one click.

How we built it

• Slack — built on the Vercel Slack Agent template (Bolt + Nitro), using Slack's Assistant (AI) API for streamed replies and typing status, Block Kit for the interactive dashboard and cards, and the Real-Time Search API for recall across the workspace.
• Durable agents — Workflow DevKit makes the long-running, multi-step features (planning, the 25-minute relay, end-of-day handoff) suspendable and reliable on serverless, with human-in-the-loop approval hooks.
• Multi-model AI — an AI SDK + Vercel AI Gateway rotation across Mistral, Groq, Gemini, and Cerebras, so the agent stays fast and within free-tier limits by switching models at runtime.
• Knowledge graph — Neo4j AuraDB stores the team's memory as a graph (Person, Topic, Decision, Question, Plan, Feature), which is what makes cross-feature reasoning ("this touches auth — you chose OAuth2") possible.

See the Architecture diagram below for how it all fits together.

Challenges we ran into

• CommonJS in an ESM workflow runtime — the Neo4j driver's internal require("os") crashed inside Workflow DevKit's ESM workflow bundle (ReferenceError: require is not defined). We fixed it by keeping all database access inside "use step" functions with dynamic imports, so the driver only ever loads in the Node step runtime.
• Durable hook collisions — plan approval hooks were keyed to the Slack thread, so re-running a plan in the same thread threw "hook token already in use." We re-keyed hooks to a unique per-run plan id.
• Timezone caching that never ran — timezone lookups were buried inside a workflow that sleeps until 5:30pm, so profiles were never populated. We moved caching to each user's first message.
• Cost and latency at message volume — classifying, drift-checking, and detecting gaps on every message risked rate limits, so we added cheap regex pre-filters and in-process caches, and gave features a priority order so they don't all fire on the same message.
• Serverless + external state — a Neo4j restart left the deployment with stale credentials, and durable workflows kept running old code after edits — both good reminders that serverless state lives outside the function.

Accomplishments that we're proud of

• Four genuinely autonomous features — Blueprint initiates, waits, and follows up on its own, rather than only responding when spoken to.
• A knowledge graph that populates itself from natural conversation — no forms, no manual logging.
• Durable, suspendable workflows (a 48-hour verify window, a 25-minute relay) that survive serverless cold starts.
• A polished, interactive Home dashboard where blockers and plan phases are actionable in one click.
• Multi-model resilience — the agent keeps working even as individual model providers hit limits.

What we learned

• Durable workflows are powerful but have real constraints — determinism on replay and careful bundling of native dependencies.
• Slack delivers a single @mention as two events (app_mention and message), so agents need a clear priority order to avoid double-responding.
• Modeling team knowledge as a graph unlocks reasoning that a flat log can't — "who knows this," "what contradicts this," "what informed this."
• Gating model calls behind cheap heuristics is the difference between a demo and something you can run on a busy workspace.

What's next for Blueprint

• A real MCP server exposing Blueprint's tools (query decisions, who-knows, search history, design) so other agents and IDEs can tap the team's memory — currently an extension point, not yet enabled.
• Semantic topic matching (embeddings) so drift detection and recall aren't limited to exact topic labels.
• Proactive staleness detection — surface plans and blockers that have gone quiet, not just track them.
• Deeper integrations — link decisions and plans to GitHub PRs/issues and calendars.
• Production hardening — restore real-world timers (5:30pm handoffs, 25-minute relay, 48-hour verify) and the daily handoff schedule.

Built With

• bolt
• cerebras
• durableagent
• gemini
• github
• javascript
• mistral
• neo4j
• nitro
• rts-api
• slack
• typescript
• vercel