Loop- The merry Go Round

Loop pogo
Loop handles you dependecies and work priorities
Homepage
System arcitecture
proof based loop detect and clearance
Auto meeting handler , detects meetings in chat and send confirmation in thread
Auto heal at its best

Inspiration

Every day, thousands of dependencies are created inside team conversations. Someone asks a question. Someone promises a code review. Someone proposes a meeting. And not a single one of them is tracked. They sink under a flood of new messages, and the cost is always the same: confusion, dropped handoffs, and missed deadlines.

Task managers don't fix this, because nobody files a ticket for "I'll get back to you by Thursday." The promise lives only in the conversation — so that's where the agent has to live too. We built Loop around one idea: your team doesn't have a communication problem, it has an open-loop problem.

What it does

Loop is a Slack AI agent that maintains a live obligation graph: every open loop where someone is blocked on you, or you are waiting on someone, auto-detected from plain conversation with no forms, no commands, and no manual marking.

Detects commitments in real time. "Can you review my PR?" / "I'll send it by Friday" / "Can we meet tomorrow at 4?" each become a tracked obligation with parties, a summary, and a deadline.
Verifies against reality before acting. PR-review loops are grounded in actual GitHub state via the GitHub MCP server. Loop never nudges anyone about work that's already merged — it checks first.
Heals loops autonomously. When the PR merges, Loop closes the loop itself and files it in the Auto-Healed feed. Nobody clicked anything.
Understands meetings. Proposed times are extracted in the author's own timezone and turned into scheduled obligations with a one-click prefilled calendar event — no OAuth required.
Acts as you, with consent. Loop drafts polite nudges in your voice and sends them as you — but only ever after a one-tap confirmation. Snooze, delegate, and a daily digest round out the actions.
Talks back. Ask the Assistant pane "what am I waiting on?" and an LLM planner composes a plan over Loop's real tools, executes it, and shows you the full tool-use trace.
Learns. Every Confirm or Dismiss tunes a surfacing threshold, so Loop gets sharper every day about what your team actually cares about. Dismissed loops never resurface.

The signature reveal on the dashboard: "N people are blocked on you right now and you don't know it."

Loop App Home — the live obligation dashboard: who's blocked on you, who you're waiting on, and what auto-healed

Feature spotlight — Meetings, both sides of the loop

Sender side — the ask. One plain sentence in chat ("can we meet tomorrow at 4 PM?") is all it takes: Loop extracts the proposed time on the author's own clock and the meeting appears on the dashboard with a Schedule It action.

Sender side — a plain "can we meet tomorrow at 4 PM?" becomes a meeting obligation with a proposed time and Schedule It action

Receiver side — one tap to lock it in. Loop proposes the meeting right in the thread where it was suggested: Confirm meeting heals the loop; Add to Google Calendar creates the prefilled event — no OAuth, no timezone math, no back and forth.

Receiver side — Loop proposes the meeting in-thread with one-tap Confirm and Add to Google Calendar

Feature spotlight — Auto-heal, end to end

The ask becomes a grounded loop. A review request with a PR link is detected, adjudicated, and stamped with the real GitHub artifact — the dashboard now shows exactly who is waiting on whom.

A PR review ask becomes a tracked loop, grounded to the real GitHub PR

The PR merges — and Loop closes the loop itself. The Verifier reads the real merge state through the GitHub MCP server and heals the loop autonomously: "Closed by Loop — PR merged." Nobody clicked anything in Slack.

Auto-heal in action — the PR merges on GitHub and Loop closes the loop itself: "Closed by Loop — PR merged"

How we built it

Loop architecture — Perceive, Reason, Verify, Act, Learn around one obligation graph

Loop is five cooperating agents around one SQLite obligation graph:

Watcher (Perceive) — a fast-tier LLM classifier sweeps live message events plus Slack's Real-Time Search (assistant.search.context) for high-recall open-loop candidates.
Adjudicator (Reason) — a smart-tier model decides who owes what to whom and by when, extracts meeting times anchored to the author's Slack timezone, and stamps GitHub artifact references parsed from free text.
Verifier (Verify) — grounds PR-referencing loops in real GitHub state through the GitHub MCP server, returning RESOLVED / UNRESOLVED / UNVERIFIED before any nudge or auto-close is allowed to fire.
Action Agent (Act) — renders the App Home command center in Block Kit, drafts and sends nudges as the user behind a confirmation gate, auto-closes verified-merged loops, and delivers the daily digest.
Learn Engine (Learn) — records Confirm/Dismiss feedback and tunes the surfacing threshold in bounded, clamped steps.

A sixth surface, the Conversational Agent, fronts everything in the Slack Assistant pane with a ReAct-style planner that composes the other agents as tools at runtime — and degrades gracefully to a deterministic parser if planning fails, so a bad plan never blocks the user.

The stack: Python, Slack Bolt over Socket Mode (no public endpoint needed), SQLite for the graph, a two-tier LLM setup on Groq (an 8B model for cheap high-recall filtering, a 120B model for precise adjudication), APScheduler for sweeps and digests, and the GitHub MCP server for proof-of-work verification. A single pure is_surfaced predicate is the one source of truth for "is this shown?" across every surface, and the core invariants are enforced by property-based tests (Hypothesis, 100+ examples per property).

Challenges we ran into

Announcements are not obligations. Early prompts happily turned "we will have a meeting at 4pm" into a loop. Teaching the Adjudicator the difference between an announcement and a proposal that awaits confirmation — and requiring two distinct parties, with an explicit self-loop guard — was prompt-engineering trench warfare.
Timezones. "Tomorrow at 4 PM" means nothing in UTC. We anchor spoken times to the author's Slack tz_offset at adjudication time, then convert to UTC for storage.
The feedback loop feeding itself. Loop's own posts were being detected as new open loops. The Watcher now drops bot-authored candidates before they ever reach the Adjudicator.
Trusting an agent to act. Auto-close only fires on verified GitHub state; transport failures return UNVERIFIED and safely block action. Anything sent as the user sits behind an explicit confirmation. Autonomy is earned per-action, not assumed.
Slack rate limits. Real-Time Search throttles aggressively, so live event-driven detection carries the experience while sweeps retry politely in the background.

What we learned

The hard part of an autonomous agent is not intelligence — it's restraint. Loop's most important lines of code are the discard guards, the verification gate, and the confirmation tap: every path where the agent chooses not to act. Grounding LLM judgments in external proof (real GitHub state) turned out to be the difference between a demo and something you'd actually let post as you.

What's next for Loop

The obligation graph is deliberately general: a meeting is just an obligation of kind meeting, and a code review is an obligation with a GitHub artifact. Every new vertical is just a new obligation kind on the same engine — same Watcher, same Adjudicator, same Verifier, same Learn loop. That makes the roadmap wide:

New verticals on the same engine

Docs and approvals — "can you review the design doc?" becomes a loop verified against Google Docs / Notion comment state, healing itself when the review lands.
Tasks and tickets — promises like "I'll pick that up" sync into Jira or Linear, and the loop closes when the ticket does.
HR and IT requests — leave approvals, access requests, onboarding checklists: loops between an employee and a system of record.
Finance — invoice sign-offs and budget approvals with deadlines that never silently pass.
CRM follow-ups — "I'll send the proposal by Friday" becomes a loop tied to a Salesforce or HubSpot deal, so no customer promise is ever dropped.
DevOps and incidents — post-incident action items from the retro thread, verified against PagerDuty and GitHub until every follow-up actually ships.

Deeper connections

MCP as a universal proof-of-work layer. The Verifier already speaks MCP; every new MCP server (Jira, Google Drive, Salesforce, calendar) is a new source of ground truth Loop can verify against — no bespoke integrations, just plug in another system of record.
Meeting transcripts. Commitments made out loud in Zoom or Meet calls flow into the same graph via transcript ingestion — the promise made in a meeting finally has the same accountability as one typed in Slack.
Email bridging. Half of a team's obligations cross the Slack boundary into Gmail or Outlook; Loop can track the loop across both.
Full calendar OAuth — one-click scheduling that creates the real event and auto-confirms the meeting loop end to end.

Intelligence on top of the graph

Team reliability analytics — the obligation graph is a dataset no other tool has: where loops pile up, which handoffs break, average time-to-close by team. A dashboard of organizational follow-through.
Deadline risk prediction — with enough closed loops, Loop can flag "this promise will probably slip" before it does.
Cross-workspace federation — obligations that span companies (agency and client, vendor and buyer) tracked on both sides.

One engine, every vertical — the Loop roadmap