Lattice

Inspiration

Slack is home to promising conversations of ideas, bugs and overall developer thoughts. However, channels get filled with noise, valuable context gets buried, and we’re stuck copy-pasting into Jira or a PR. As interns, we kept hitting this wall and losing time on repetitive glue work. That frustration inspired Lattice: a way to turn Slack into the front door for developer workflows using MCP. Whether it be tickets, bugs, issues, and even PRs, Lattice wants to turn the noisy chats in Slack into action!

What it does

Lattice is a Slack-based interface to an MCP architecture. When someone mentions the bot in a channel, it pulls in the surrounding context and lets an LLM decide which tool to call. That might mean spinning up a Jira ticket with the right summary and description, or creating a GitHub PR with a branch, title, and body. Instead of bouncing between tools, you can stay in Slack and let Lattice turn conversations into concrete actions.

How we built it

We built Lattice as a Slack bot integrated with Socket Mode (via Bolt) and ngrok. When triggered in a Slack thread, it uses a Cohere LLM together with an MCP orchestrator to parse and tokenize the conversation. The parsed request is then sent through Martian's Deimos Router, which applies routing rules and chained tasks to balance cost and quality of the LLM response. From there, Lattice connects to the Jira API to automatically create tickets, and to the GitHub API to draft pull requests, all while keeping Slack as the central interface.

Challenges we ran into

In our MCP project, we faced challenges with understanding and implementing a new protocol, dealing with unexpected errors and debugging complexity, managing integration between multiple components (Slack, the LLM, and the MCP server), and handling differences between environments and setups. We also struggled with parsing messy Slack conversations into clear inputs, aligning on design decisions as a team, and managing time effectively while learning new tools on the fly.

Accomplishments that we're proud of

One of the things we’re most proud of was getting Deimos Router working. None of us had used it before, but we dug into the docs, climbed the learning curve, and built an integration that went from simple examples to a complex, real use case. We’re also proud that this was our first time working with the Cohere API and building Slack bots. It was an ambitious combination, but we pushed through the challenges and are proud of what we accomplished.

What we learned

We learned how powerful MCP’s architecture is for making tools modular and reusable, and how important it is to design clear schemas so an LLM can reliably call them. We also picked up practical lessons about Slack’s event system, Socket Mode, and handling context from threads. Most of all, we learned how to quickly pick up unfamiliar tech, break it down, and apply it to a real project under tight time pressure.

What's next for Lattice

Next, we want to improve how Lattice identifies which files should change in a PR, so the generated code is more precise and useful. We also plan to expand beyond Jira and GitHub by adding more MCP servers for tools like Notion and other services. This will let Lattice support a wider range of developer workflows and make Slack an even stronger entry point for getting real work done.