CloseLoop AI

Meetings shouldn't end with forgotten action items. They should end with execution.

CloseLoop AI is an MCP-powered autonomous meeting execution platform that transforms meeting conversations into real work.

Most meeting assistants stop at notes. CloseLoop AI continues after the meeting: it detects decisions, finds the owner, creates the task, sets a deadline, monitors progress, follows up automatically, escalates overdue work, and generates a weekly report — with zero manual handoff between "we decided X" and "it's tracked, assigned, and chased."

Meeting → Transcript → Decision Extraction → Owner Detection → Jira Ticket
        → Calendar Deadline → GitHub PR Tracking → Follow-up → Escalation
        → Weekly Report → Executive Dashboard

Built on NitroStack. Every integration below hits a real external API when credentials are configured — nothing fabricates a fake ticket ID, message timestamp, or event link.

❌ The Problem

Every organization spends hundreds of hours in meetings.

Yet after every meeting, someone still has to:

• remember action items
• create Jira tickets
• assign owners
• schedule deadlines
• send Slack follow-ups
• update project boards
• prepare weekly reports

These repetitive tasks are manual, error-prone, and often forgotten.

Meeting assistants today summarize conversations.

But summaries don't execute work.

✅ Our Solution

CloseLoop AI closes the gap between decision and execution.

Instead of generating another meeting summary, it transforms conversations into live project management workflows.

The platform automatically:

• detects decisions
• identifies task owners
• extracts deadlines
• prioritizes work
• creates Jira issues
• schedules Calendar events
• notifies teams in Slack
• tracks GitHub progress
• escalates overdue work
• generates executive reports

Everything happens through MCP tools, allowing any compatible AI client to orchestrate the workflow.

Architecture — MCP servers (modules)

Module	Primitives	What it does
meeting-ingest	Tool: import_meeting. Resources: meeting_transcript, meeting_metadata, participant_roster	Ingests a meeting (Zoom/Teams/Meet/Slack Huddles/MP4)
decision-extraction	Tool: extract_decisions. Resources: decision_log, extracted_actions. Prompts: extract_decisions_v1, owner_detection_v1, deadline_extraction_v1	Gemini-based structured extraction of decisions/owners/deadlines/confidence, with a heuristic fallback if no API key is set
jira-server	Tools: create_jira_ticket, update_jira_ticket, fetch_jira_status, close_jira_ticket. Resource: jira_task_board	Real Jira Cloud REST v3. Enforces the confidence gate (< 80% blocks ticket creation)
calendar-server	Tools: create_calendar_event, create_deadline_event, create_reminder. Resource: upcoming_deadlines	Real Google Calendar invites via a service account
slack-server	Tools: send_followup, send_manager_escalation, send_approval_request. Resource: notification_history	Real Slack messages (chat.postMessage)
github-server	Tools: create_github_issue, fetch_pull_requests, fetch_commits, link_pr_to_decision. Resource: github_activity_board	Real GitHub REST API — tracks Decision → Issue/PR → Merge
notion-server	Tools: publish_report, create_project_page, update_project_status. Resource: published_reports	Real Notion pages for weekly reports
analytics-server	Tool: get_dashboard (widget). Resources: executive_dashboard, analytics_metrics	Live-aggregated Control Tower metrics, no separate pipeline
escalation-scanner	Background service (no MCP surface)	Hourly timer that auto-escalates overdue tasks to Slack, independent of any AI tool call

Human-in-the-loop confidence gate: any decision extracted with confidence < 80% is not turned into a ticket automatically. create_jira_ticket returns requiresApproval: true instead, and the orchestrating AI is expected to call send_approval_request and wait.

Widgets (NitroChat rich widgets, not plain text): decision-card (on extract_decisions), task-card (on create_jira_ticket), executive-dashboard (on get_dashboard).

Connet to CloseLoop

{
  "mcpServers": {
    "closeloop-ai": {
      "url": "https://meeting2mission-1-one-piece-amrita-university-amritapuri-campus.app.nitrocloud.ai/"
    }
  }
}

Setup

npm install
cp .env.example .env   # fill in the values below
npm run build
npm start

Required for the demo to run at all

• MONGODB_URI — a MongoDB Atlas connection string.

Required for real (non-fallback) behavior — see .env.example for exact steps

• GEMINI_API_KEY — real decision extraction (aistudio.google.com/apikey). Without it, extract_decisions uses a much weaker regex heuristic and logs a warning.
• JIRA_BASE_URL / JIRA_EMAIL / JIRA_API_TOKEN / JIRA_PROJECT_KEY — real Jira tickets. Without it, tasks are recorded locally with a LOCAL-... id and real: false.
• SLACK_BOT_TOKEN / SLACK_DEFAULT_CHANNEL / SLACK_ESCALATION_CHANNEL — real Slack messages. Without it, Slack tools throw (they never fabricate a message id).
• GOOGLE_SERVICE_ACCOUNT_JSON / GOOGLE_CALENDAR_ID — real Calendar invites. Without it, events are recorded locally only.
• GITHUB_TOKEN / GITHUB_OWNER / GITHUB_REPO — real issue/PR tracking.
• NOTION_API_KEY / NOTION_PARENT_PAGE_ID — real published reports.

Every tool tells you in its response (real: true/false + a message) whether it hit the live API or fell back locally, so a judge's run is never silently fake.

Multi-tenant accounts (web/)

CloseLoop stays a single MCP server (not a host) even with real user accounts — a host is the thing that orchestrates calls to MCP servers (NitroStudio/ChatGPT/Claude do that job). Adding login just makes this server multi-tenant: each tool call resolves whose credentials to use.

• .env credentials above are the single-tenant fallback — used whenever no authenticated user (or no user with that integration connected) is making the call. This is what the hackathon judge's NitroStudio session uses, since it never sends a login token.
• web/ is a separate, standalone signup/login + "connect your accounts" app (Express, its own package.json, runs on its own port). It shares the same MongoDB and the same JWT_SECRET/CREDENTIAL_ENCRYPTION_KEY as the MCP server (see web/.env.example).
• A signed-up user connects GitHub/Jira/Slack/Google Calendar/Notion via real OAuth (each provider needs its own OAuth app registered on that platform's console — web/lib/oauth-providers.js documents exactly where). Tokens are encrypted (AES-256-GCM, reversible — never hashed, since hashed tokens can't be replayed to call the provider's API later) and stored per-user in the credentials collection.
• The user's dashboard (web/public/dashboard.html) shows a personal JWT to paste into their MCP client as Authorization: Bearer <token>. When a tool call arrives with that header, OptionalJWTGuard (never blocks — just tries to identify the caller) populates ctx.auth.subject, and credential-resolver.ts uses that user's connected account instead of .env.

Run it locally:

cd web
npm install
cp .env.example .env   # MONGODB_URI/JWT_SECRET/CREDENTIAL_ENCRYPTION_KEY must match the root .env
npm run dev             # http://localhost:3010

Why MCP?

Instead of building a standalone application, CloseLoop exposes every capability through the Model Context Protocol.

This allows any compatible AI client—including NitroStudio, Claude Desktop, Cursor, and ChatGPT—to invoke the same tools. CloseLoop becomes infrastructure rather than another application.

Supported Platforms

✅ Zoom ✅ Microsoft Teams ✅ Google Meet ✅ Slack ✅ Jira Cloud ✅ GitHub ✅ Google Calendar ✅ Notion ✅ MongoDB ✅ Gemini ✅ NitroStack MCP

Impact

CloseLoop reduces the manual work that happens after every meeting.

Instead of spending 15–30 minutes creating tickets, assigning owners, sending reminders, and updating project boards, teams can move directly from discussion to execution.

The platform improves:

• accountability
• execution speed
• project visibility
• deadline adherence
• management reporting

Demo script (for judges)

A single conversational chain through NitroStudio (or any MCP client) exercises the whole CORE loop:

1. Import a meeting: "Import a meeting titled 'Sprint Planning', platform zoom, participants ['Alex Rivera', 'Sam Okafor'], startTime/endTime today, transcript: '...Alex Rivera will own the payments retry logic and have it done by next Friday. Sam Okafor is investigating the checkout latency spike, high priority...'" → import_meeting runs, returns a meetingId.
2. Extract decisions: "Extract the decisions from that meeting." → extract_decisions runs, the decision-card widget renders with confidence scores per decision.
3. Create the ticket: "Create a Jira ticket for the payments retry decision." → If confidence ≥ 80%, create_jira_ticket runs and the task-card widget renders with a real Jira link. If confidence < 80%, the agent is told to call send_approval_request instead — demonstrate this path with a deliberately vague transcript.
4. Schedule the deadline: "Create a calendar deadline event for that task." → create_calendar_event sends a real Google Calendar invite.
5. Follow up: "Send a Slack follow-up for that meeting to #engineering." → send_followup posts a real Slack message.
6. Show the dashboard: "Show me the dashboard." → get_dashboard runs, the executive-dashboard widget renders live counts.
7. (Escalation, if time allows): manually backdate a task's deadline in Mongo, wait for the hourly scanner or call send_manager_escalation directly — a real escalation appears in the Slack escalation channel.
8. (Stretch): link_pr_to_decision against a real PR number in your configured repo, and publish_report to generate a real Notion weekly report.

Domain justification (Open Innovation track)

We target enterprise engineering & operations governance — the decision-to-execution gap that costs every org meeting-hours of lost accountability. The demo scenario is a sprint planning / engineering standup because it shows a full, independently verifiable loop: decision → Jira ticket → GitHub PR link → escalation → report.

---

Original NitroStack template docs: docs.nitrostack.ai · Studio: nitrostack.ai/studio