TheadPilot

Inspiration

Modern engineering teams do not suffer from a lack of communication—they suffer from too much of it. Important decisions, blockers, ownership changes, and cross-team dependencies are often buried inside hundreds of Slack messages spread across multiple channels. Team leads then spend hours reading conversations, manually compiling updates, and chasing people for context.

We built ThreadPilot to transform that communication overload into structured, actionable intelligence. Our goal was not to create another chatbot that users must constantly interact with, but an autonomous coordination agent that quietly observes team conversations, identifies what matters, and delivers the right information to the right people.

What it does

ThreadPilot is an AI-powered Slack intelligence system that automatically converts daily team conversations into structured, personalized digests.

It:

Collects new messages from multiple Slack channels.
Summarizes each team’s progress and overall tone.
Extracts blockers, decisions, action items, owners, deadlines, and severity.
Detects dependencies between teams, such as one team waiting for another team’s specifications or approval.
Publishes an organization-wide digest to a shared Slack channel.
Sends detailed breakdowns to individual team channels.
Delivers concise executive summaries directly to leadership.
Remembers unresolved blockers and previous decisions across digest runs.
Learns from Slack emoji reactions to improve future summaries.
Ranks information differently for leads, individual contributors, project managers, and executives.

Instead of asking every employee to read every channel, ThreadPilot gives each person a focused view of the information that is most relevant to their role.

How we built it

We designed ThreadPilot as a modular, serverless multi-agent pipeline.

The process begins with a MessageAggregator, which uses the Slack API to retrieve new messages from configured team channels. It filters and enriches the conversations before sending them to specialized AI agents powered by Amazon Bedrock and Amazon Nova Micro.

The TeamAnalyzerAgent processes each team’s messages and returns structured JSON containing the team summary, blockers, decisions, action items, ownership details, deadlines, severity, and communication tone.

A second agent, the DependencyLinker, analyzes information across all teams to uncover relationships that might not be obvious inside a single channel. For example, it can identify that the electrical team is blocked because it is waiting for dimensions from the mechanical team.

The resulting information is passed to a digest formatter that generates structured Slack Block Kit messages. A distributor then publishes the organization-wide digest, team-specific summaries, and personalized leadership DMs.

The production pipeline runs inside AWS Lambda and can be invoked automatically every day through Amazon EventBridge or manually through a Lambda Function URL. Amazon DynamoDB stores run state, long-term blocker and decision memory, and personalization signals. Amazon S3 stores timestamped digest outputs for auditing, while AWS Secrets Manager securely stores Slack credentials.

We also created an end-to-end demonstration flow that generates realistic engineering conversations, posts them into Slack, retrieves them again, runs the complete AI analysis pipeline, and publishes the final digest. The entire infrastructure is defined using AWS SAM and CloudFormation so that it can be deployed reproducibly.

Challenges we ran into

One of our biggest challenges was turning informal Slack conversations into dependable structured data. Real messages are incomplete, conversational, and often spread across multiple replies. A blocker may be implied rather than explicitly stated, while ownership or deadlines may appear several messages later.

We addressed this through carefully constrained prompts and schema-based JSON outputs. We separated team-level analysis from cross-team dependency detection instead of asking one model call to solve every problem at once.

Another challenge was identifying dependencies across channels. A team may report normal progress in its own channel while another team is waiting for its output. Building a dedicated dependency-linking stage allowed ThreadPilot to reason across team boundaries rather than treating every channel as an isolated conversation.

Maintaining context across multiple runs was also difficult. Without persistent memory, the system could repeatedly report the same blocker without understanding whether it was new, recurring, or resolved. We introduced DynamoDB-backed state and memory to preserve previous blockers, decisions, and processing timestamps.

We also had to design Slack messages that were detailed enough to be useful but compact enough to avoid creating more noise. This led us to build role-based ranking, separate channel and DM outputs, and structured Slack Block Kit layouts.

Finally, deploying AI workloads inside a serverless environment required careful handling of execution time, dependencies, credentials, retries, and observability. We created separate Lambda entry points, IAM-scoped permissions, secure secret retrieval, audit logging, and infrastructure-as-code deployment to make the system reliable and reproducible.

Accomplishments that we’re proud of

We are proud that ThreadPilot is more than a summarization demo—it is a complete, deployable coordination system.

We successfully built:

A working multi-agent pipeline for team analysis and dependency detection.
Real Slack ingestion and Slack Block Kit output.
Organization-wide, team-specific, and leadership-focused digests.
Persistent memory for blockers, decisions, and previous runs.
Reaction-based feedback and prompt personalization.
Persona-aware ranking for leads, individual contributors, project managers, and executives.
A fully serverless AWS architecture.
Secure credential management through AWS Secrets Manager.
Timestamped S3 audit logs with lifecycle management.
Scheduled and on-demand digest generation.
A zero-dependency public demo trigger.
Infrastructure-as-code using AWS SAM and CloudFormation.
Mock and preview modes for safe local testing.
An end-to-end demonstration that generates conversations, posts them to Slack, analyzes them, and publishes a digest automatically.

Most importantly, ThreadPilot demonstrates how generative AI can move beyond passive question answering and become an active coordination layer for real teams.

What we learned

We learned that summarization alone is not enough to improve team coordination. A useful workplace agent must understand structure: what happened, why it matters, who owns the next step, what is blocked, and which other teams are affected.

We also learned that smaller, specialized AI stages can be more reliable than a single large prompt. Separating message aggregation, team analysis, dependency linking, formatting, distribution, memory, and personalization made the system easier to test and improve.

Persistent context proved essential. A valuable team assistant needs to understand changes over time—not merely summarize the latest batch of messages. Remembering unresolved blockers and previous decisions allows ThreadPilot to distinguish new information from repeated updates.

User feedback also needs to be lightweight. Instead of introducing a separate feedback form, we used familiar Slack reactions as direct learning signals. This makes it possible for users to mark an item as accurate, incorrect, incomplete, or irrelevant without interrupting their workflow.

Finally, we learned that production readiness is as important as model quality. Security, auditability, observability, deployment automation, error handling, and cost-efficient infrastructure are necessary for an AI prototype to become a system that teams can trust.

What’s next for ThreadPilot

Our next step is to evolve ThreadPilot from a daily digest generator into a real-time organizational intelligence layer.

We plan to add:

Near-real-time alerts for critical blockers and emerging dependencies.
Interactive Slack commands for querying decisions, owners, and project history.
Thread-aware and file-aware analysis for richer context.
Integrations with Jira, GitHub, Linear, Notion, and Google Calendar.
Automatic linking between Slack discussions, pull requests, tickets, and project documents.
A visual dependency graph showing how teams, tasks, and blockers are connected.
Trend analysis for recurring blockers and delivery risks.
Automated follow-ups when action items approach their deadlines.
Configurable retention, redaction, and data-governance controls.
Multilingual analysis for globally distributed teams.
Human approval workflows for high-impact alerts.
More granular personalization based on projects, responsibilities, and individual preferences.
Evaluation dashboards for measuring extraction accuracy and user trust.
Support for Microsoft Teams and other workplace communication platforms.

Our long-term vision is for ThreadPilot to become a proactive organizational copilot that understands how work moves across a company, surfaces risks before they become delays, and keeps teams aligned without adding more meetings or communication overhead.