anchor

Still switching between Slack and GitHub? Kinda mid. Anchor keeps everything in Slack—find work, track commitments, predict delays, and close the loop before things slip without leaving Slack.

Comment

Anchor

Anchor is the Slack-native accountability brain that keeps commitments from getting lost in the scroll. No more tab switching. No more “where did that promise go?” Just sharp, real-time action right where the team already works.

Inspiration

My sister works with Salesforce, and I noticed a very real problem: when teams work inside Slack but track tasks in GitHub, they keep bouncing between tabs just to find one issue one update, or one promise. That workflow feels messy, slow, and way too easy to lose context in.

So I built Anchor — a Slack-first agent that keeps commitments anchored right inside Slack itself. Once a commitment is made, Anchor captures it, tracks it, and helps close the loop without forcing the team to hop between Slack and GitHub.

The idea was simple: if the work starts in Slack, the follow-through should stay there too.

What it does

Anchor is your AI teammate for keeping work real, visible, and synced.

It starts with Reality Check, which acts like a commitment detector with a brain. When someone makes a promise or shares a plan, Anchor checks whether the timeline actually makes sense. It estimates whether the work is realistic, how much time it may take, and whether the deadline feels doable. You can stick to your own schedule, or let Anchor help you shape one that is more grounded and less “we’ll figure it out later.”

Then comes Context Snapshot, which turns messy Slack conversation into a clean GitHub issue. It captures the important stuff — who is assigned, what the task is, what the due date should be, and the technical context needed to keep the work moving. No drama, no lost thread, no half-remembered promise.

After that, Ask Anchor becomes the brain of the whole system. You can ask things like:

  • show open commitments
  • who is working on authentication
  • what is overdue
  • what is due this week
  • what is the status of this issue

Anchor searches its stored memory, GitHub metadata, and thread context to answer fast, directly in Slack.

Finally, Loop Closure keeps everything in sync. Anchor tracks progress, checks GitHub issue updates, and makes sure commitments do not just float around forever. When work is completed, it closes the loop and updates the team so everyone stays aligned.

Under the hood, Anchor is powered by:

  • Slack Bolt JS for the app logic and events
  • Gemini for reasoning and summarization
  • MCP for tool-style integration and extensibility
  • SQLite for commitment storage and history
  • GitHub integration for issue creation, tracking, and completion sync

The result is a Slack agent that feels less like a bot and more like a serious teammate.

How we built it

Anchor was built as a modular Slack agent using JavaScript and Bolt.

The app listens to Slack events, detects commitments, and routes them through a structured pipeline. Gemini helps interpret the intent and shape the response. GitHub handles issue creation and task tracking. SQLite stores commitment history, issue mappings, and sync state so Anchor can search and follow through later.

The architecture is intentionally clean and layered: At a high level:

  • Slack → User interaction layer
  • Anchor → Workflow orchestration engine
  • Gemini → AI reasoning & summarization
  • MCP → Tool integration layer
  • SQLite → Commitment memory & thread metadata
  • GitHub → Issue creation, tracking & synchronization
  • Background Sync → Loop closure & status updates

At a high level:

  • Slack is the surface where users interact
  • Anchor is the orchestration layer
  • Gemini handles reasoning and summarization
  • MCP connects Anchor to tools in a clean, extensible way
  • SQLite stores commitments and thread metadata
  • GitHub keeps tasks visible and actionable
  • the sync service keeps issue status aligned over time

The whole system is designed to feel native to Slack, while still acting like a real task-memory layer for the team.

Challenges we ran into

One of the toughest parts was making the integration flow actually feel smooth instead of stitched together.

MCP integration took real care because it needed to stay clean, extensible, and useful without making the system feel over-engineered. Building Ask Anchor and Reality Check also took a lot of iteration because the responses had to be accurate, useful, and fast without sounding generic or robotic.

Another challenge was managing the Slack-to-GitHub flow in a way that felt natural. A commitment should not just become an issue — it should stay connected to the original context, the thread, and the current status. That meant a lot of careful mapping between Slack messages, database records, and GitHub issues.

Getting the app to feel polished while keeping the logic reliable was probably the hardest part, but also the most rewarding.

Accomplishments that we're proud of

We built Anchor as a real Slack-native workflow companion using JavaScript, Bolt, Gemini, MCP, SQLite, and GitHub integration.

What makes me most proud is that Anchor does not just answer questions — it actually understands commitments, creates structure from conversation, and keeps the loop alive. That is not just a chatbot. That is a proper system for turning chat into accountability.

I am also proud of how much of the experience stays inside Slack. The whole point was to remove friction, and Anchor does exactly that.

What we learned

Before this challenge, I was new to Slack development and still getting comfortable with the platform. By the end of it, I was much more confident with Slack Bolt, event handling, interactive actions, background syncing, and MCP-style integration patterns.

I learned how to think in terms of workflows instead of just messages. I also learned how important it is to keep state clean, keep context visible, and keep the user experience simple enough that people actually use it.

Most importantly, I learned that building something useful inside Slack is not just about automation — it is about making the team feel faster, clearer, and more accountable without adding extra noise.

What's next for Anchor

The next step for Anchor is to bring in Ghost Weaver and make the product ready for Slack organizations at a deeper level.

The goal is to make Anchor even more powerful for teams by improving organizational workflow support, richer task intelligence, and more advanced commitment tracking. That means stronger visibility, smarter automation, and a more polished experience for real team use.

In short: keep Anchor inside Slack, keep the context sharp, and keep the loop closed.

Built With

Share this project:

Updates