Undercurrent

A multi-agent AI system that detects cross-channel incidents in Slack, verifies them with external evidence, and delivers actionable alerts in real time.

Comment

Undercurrent

Inspiration

Engineering teams communicate across many Slack channels, but incidents rarely begin in just one place. A deployment issue may first appear in a backend channel, customer complaints may arrive in support, and payment failures may be discussed somewhere else. Individually, these messages seem unrelated, but together they reveal an emerging incident.

We built Undercurrent to solve this problem by acting as an organization's peripheral vision. Instead of waiting for someone to manually connect information across multiple teams, Undercurrent continuously detects, correlates, and verifies cross-channel signals in real time.

What it does

Undercurrent is a multi-agent AI system that continuously monitors Slack conversations across opted-in channels.

Instead of responding to individual messages like a chatbot, it analyzes events across the entire workspace to discover hidden relationships between conversations.

The system:

  • Monitors Slack messages in real time
  • Detects meaningful events using AI
  • Correlates signals across multiple channels
  • Generates cross-channel incident hypotheses
  • Verifies those hypotheses using external evidence
  • Presents verified incidents through a live dashboard

This enables teams to identify incidents before they become major outages.

How we built it

Undercurrent follows a modular five-agent architecture.

Observer Agent

  • Processes every Slack message
  • Generates embeddings
  • Classifies topics and signal strength

Planner Agent

  • Clusters related events
  • Detects cross-channel patterns
  • Creates incident hypotheses

Verification Agent

  • Uses Gemini and MCP tools
  • Validates hypotheses using monitoring, deployment, and ticketing data

Memory Agent

  • Stores historical organizational context
  • Supports future reasoning and calibration

Action Agent

  • Produces incident summaries
  • Publishes actionable insights

Technology Stack

  • Python
  • TypeScript
  • FastAPI
  • Slack Bolt
  • Socket Mode
  • Redis Pub/Sub
  • PostgreSQL
  • Google Gemini
  • Model Context Protocol (MCP)
  • Docker

Challenges we ran into

Building a true multi-agent system required coordinating several independent agents while keeping the pipeline reliable and observable.

Some challenges included:

  • Real-time communication between Slack, Redis, PostgreSQL, and the orchestrator
  • Designing structured agent communication through a shared blackboard instead of direct conversations
  • Handling malformed LLM outputs gracefully without stopping the pipeline
  • Building a responsive dashboard that updates continuously as new events arrive

Accomplishments that we're proud of

  • Built a complete end-to-end multi-agent architecture
  • Successfully correlated incidents across multiple Slack channels
  • Implemented real-time event visualization
  • Integrated AI reasoning with external verification
  • Designed a modular system that is easy to extend and debug

What we learned

This project demonstrated that specialized AI agents collaborating through structured state produce more transparent and maintainable systems than a single monolithic chatbot.

We also learned the importance of graceful error handling when working with LLM-generated outputs and real-time distributed systems.

What's next for Undercurrent

We plan to extend Undercurrent with:

  • Slack Marketplace deployment
  • GitHub, Jira, PagerDuty, Grafana and Datadog integrations
  • Organization-specific learning
  • Improved confidence calibration
  • Automatic incident channel creation
  • Historical incident analysis and recommendations

Built With

Share this project:

Updates