Nexus Flow

Part of the Nexus network, Flow is an autonomous Slack agent that uses live RAG and MCP to eliminate engineering context-switching, answering technical questions and creating Jira tasks instantly.

Comment

Inspiration

Modern engineering teams spend an immense amount of time context-switching. Between reading Slack threads, updating Jira boards, and hunting down architecture decisions lost in old conversations, developer velocity drops drastically. We were inspired to build an autonomous agent that bridges the gap between conversational context and strict enterprise tooling, ensuring developers never have to leave Slack to get things done.

What it does

Nexus Flow is an autonomous engineering mastermind that lives inside your Slack workspace. It acts as part of the broader Nexus Agent Network.

  1. Contextual Intelligence (Slack RAG): When asked about technical decisions, it doesn't hallucinate. It dynamically reads the recent history of public channels (like #engineering) via the Slack Web API, fetching live context and injecting it into the LLM before answering.
  2. Action Execution: Using the Model Context Protocol (MCP), Nexus Flow can securely trigger enterprise backend tools directly from a Slack DM—such as parsing a conversation and instantly provisioning a high-priority Jira ticket for the engineering team.

How we built it

We built Nexus Flow using a 100% cloud-native, serverless architecture to ensure enterprise-grade scalability.

  • Slack Integration: We utilized the @slack/bolt framework running in Socket Mode to securely route Slack events without needing exposed ports.
  • The Brain: We integrated the Inception LLM (mercury-2) as the core reasoning engine. We gave Nexus Flow a custom persona prompt tailored specifically for software architecture, coding, and agile task management.
  • The Backend: We implemented the official Model Context Protocol (MCP) SDK on a Node.js server hosted on Railway. The MCP server exposes our custom enterprise tools to the Slack agent.
  • The Command Center: We built a real-time admin dashboard using Next.js hosted on Vercel. It uses Server-Sent Events (SSE) to monitor when the agent executes tools in real-time.

Challenges we ran into

Handling concurrent MCP client connections was a major hurdle. Initially, our MCP server crashed when multiple agents in our network attempted to connect to it simultaneously. We had to dive deep into the MCP SDK architecture to rewrite the server initialization, ensuring it spawns a dedicated, isolated server instance for every single Server-Sent Event (SSE) connection.

Accomplishments that we're proud of

We are incredibly proud of our Slack RAG (Retrieval-Augmented Generation) implementation. Instead of relying on dummy data, Nexus Flow actually parses the Slack Sandbox history dynamically. Watching the agent read an engineering channel and summarize a complex API architecture decision autonomously was a massive "wow" moment for us.

What we learned

We learned the incredible power of the Model Context Protocol. Standardizing the way LLMs interact with external enterprise tools drastically speeds up development. We also learned how to seamlessly bridge WebSocket-based streaming (Slack Socket Mode) with HTTP streaming (SSE) across different cloud providers (Railway and Vercel).

What's next for Nexus Flow

We plan to expand Nexus Flow's MCP toolkit to include direct GitHub repository access, allowing the agent to read PR diffs, trigger CI/CD pipelines, and deploy infrastructure straight from a Slack thread!

Built With

Share this project:

Updates