LOOM — AI Decision Intelligence Platform

Built for ET AI Hackathon 2026 · PS-08: AI for Industrial Knowledge Intelligence

LOOM watches meetings, reads documents, remembers every decision, and proactively surfaces tradeoffs, risks, and research — like the most experienced engineer in every meeting.

This is a real, runnable full-stack application: a six-agent AI pipeline (orchestrated, not just prompted once), a knowledge graph that links every meeting/decision/risk/document together, semantic search, and — the flagship feature — a What-If Decision Engine that generates concrete cost/schedule/risk tradeoff scenarios for any decision and recommends one based on your stated priorities.

---

1. What's actually working here (read this first)

Everything described below runs end-to-end with zero external API calls and zero cost by default:

• Real NLP, not canned output. The 6 agents run a deterministic text-analysis engine (backend/src/agents/textEngine.ts) — sentence segmentation, speaker attribution, cue-phrase detection, and a small industrial ontology — against whatever transcript you give it. Paste a brand-new transcript through the "New Meeting" screen and the agents will genuinely extract decisions, risks, and action items from that text. This was verified directly: running the mock engine against the seed transcripts produces real, meeting-specific decisions/risks with no hand-authored matching output.
• The demo dataset is not faked. backend/src/seed/seed.ts creates 6 meeting transcripts and pushes them through the exact same processMeeting() pipeline that a live upload uses. The ~10 decisions / ~7 risks / ~13 action items you'll see were produced by the agents, not hard-coded to match.
• One-line upgrade to real Gemini. Every agent checks AI_MODE in one place (backend/src/lib/ai.ts). Set AI_MODE=live + GEMINI_API_KEY in backend/.env and every agent switches to real Gemini calls — no route or UI changes needed. If a live call fails for any reason, it falls back to the mock engine automatically so the demo never breaks.
• The What-If engine does real math. Given a decision's baseline cost/ schedule/risk numbers, it generates 4 scenarios (Conservative, Balanced, Cost-Optimized, Alternate-Vendor) with genuinely different cost/schedule/risk/ quality numbers, then scores each against your stated cost/schedule/risk preferences to pick a recommendation.
• Knowledge graph is queried, not decorative. Clicking a Decision or Meeting node in the graph navigates to that record. The Decision detail page pulls its actual graph neighbors (which meeting it came from, which risks it's linked to, which research it cites).

What's intentionally simplified for a 1-week MVP

• SQLite instead of Postgres. Zero-config, no server to install. The Prisma schema is written to be Postgres-compatible — swapping provider in prisma/schema.prisma and pointing DATABASE_URL at a real Postgres/pgvector cluster is all that's needed to go to production scale.
• Binary document parsing (PDF/PPTX/drawings) is stubbed. Uploading a .txt/ .md/.csv file is fully parsed and analyzed for real. Uploading a binary PDF/PPTX stores it and its metadata, and you can paste its text into the pastedText field to see full extraction run against real content — this mirrors exactly where OCR/document-intelligence would plug in for production (see backend/src/routes/upload.routes.ts).
• Research Agent uses a curated citation bank in mock mode, clearly labeled isDemoData: true in the UI. In live mode it's replaced by real Gemini grounding.
• Auth is simple JWT + workspace membership — enough for a real demo, not a full enterprise IAM system.

---

2. Quick start

Requires Node.js 18+.

Backend

cd backend
cp .env.example .env
npm install
npx prisma generate
npx prisma db push      # creates dev.db (SQLite) from the schema
npm run seed            # populates the demo dataset by running the real agent pipeline
npm run dev             # starts the API on http://localhost:4000

Frontend (in a second terminal)

cd frontend
npm install
npm run dev              # starts the app on http://localhost:5173

Open http://localhost:5173 — demo credentials are pre-filled on the login screen:

Email:    aditi.rao@bharathw.com
Password: loom-demo-2026

Note on this build environment: this project was assembled in a sandboxed container whose network policy blocks binaries.prisma.sh, so prisma generate / prisma db push could not be executed here to produce a live dev.db. Both the backend and frontend TypeScript were fully compiled (tsc --noEmit and a full vite build) with zero errors, and the agent logic itself was unit-tested directly against the seed transcripts (see section 5) to confirm it produces real, correct output. On any machine with normal internet access, the two commands above will work immediately — this is completely standard Prisma setup, not a workaround.

Switching to real Gemini (optional)

Edit backend/.env:

AI_MODE="live"
GEMINI_API_KEY="your-key-here"

Restart the backend. Every agent now calls Gemini 2.5 Flash directly, with automatic fallback to the mock engine if a call fails.

---

3. The demo flow

1. Log in → land on the workspace's project list.
2. Compressor Station Unit-4 Expansion → Mission Control dashboard: health score, recent meetings, open risks, pending actions, research updates.
3. Meetings → open "Foundation Design Review — Compressor Pad C-401" → see the full Meeting Agent summary, Decision/Risk/Action tabs, the 6-agent execution trace, and the raw transcript.
4. Click into a Decision → reasoning, alternatives considered, tradeoffs, evidence, assumptions — then open the What-If Simulator tab, adjust the cost/schedule/risk sliders, and run the simulation to see 4 scored scenarios.
5. Knowledge Graph → the force-directed graph of every meeting, decision, risk, and document, with click-through navigation.
6. Knowledge Search → try "foundation vibration" or "compressor bearing" — semantic search across the whole project.
7. New Meeting → paste your own transcript (or use the built-in sample) and watch the 6 agents actually analyze it live.

---

4. Architecture

┌─────────────────────────────────────────────────────────────────┐
│                        React Frontend (Vite)                     │
│  Dashboard · Meetings · Decisions · What-If · Knowledge Graph ·   │
│  Search · Documents — dark glass UI, Framer Motion, React Query   │
└───────────────────────────────┬───────────────────────────────────┘
                                 │ REST (JWT)
┌───────────────────────────────▼───────────────────────────────────┐
│                      Express API (TypeScript)                     │
│  auth · workspaces · projects · meetings · documents · decisions · │
│  knowledge · search · whatif · dashboard                          │
└───────────────────────────────┬───────────────────────────────────┘
                                 │
              ┌──────────────────▼──────────────────┐
              │            ORCHESTRATOR              │
              │   (src/agents/orchestrator.ts)        │
              └───┬───────┬───────┬───────┬───────┬───┘
                  │       │       │       │       │
             Meeting  Memory  Decision  Risk   Research
              Agent    Agent   Agent    Agent    Agent
                  │       │       │       │       │
                  └───────┴───┬───┴───────┴───────┘
                              │
                     Recommendation Agent
                              │
                  ┌───────────▼────────────┐
                  │  Knowledge Graph Builder │
                  │  (Nodes + Edges persisted)│
                  └───────────┬────────────┘
                              │
                    ┌─────────▼─────────┐
                    │  SQLite / Prisma   │
                    │  (Postgres-ready)  │
                    └────────────────────┘

           Separately: What-If Decision Engine
           (deterministic scenario generator + preference-weighted scorer)

Every agent lives in its own module under backend/src/agents/, is independently testable, and is called sequentially by the orchestrator — matching the brief's requirement that agents don't need to be autonomous, just coordinated.

---

5. Verifying the agents actually work

From backend/, after npm install:

npx tsx -e "
import { MEETINGS } from './src/seed/seedData';
import { runDecisionAgentMock } from './src/agents/decisionAgent';
import { runRiskAgentMock } from './src/agents/riskAgent';
for (const m of MEETINGS) {
  console.log(m.title, '->', runDecisionAgentMock(m.transcript, m.title).length, 'decisions,', runRiskAgentMock(m.transcript).length, 'risks');
}
"

This runs the exact same logic used in production against the seed transcripts with no database required — useful for judges who want to confirm the pipeline isn't hard-coded.

---

6. Project structure

loom/
├── backend/
│   ├── prisma/schema.prisma       # Data model (SQLite, Postgres-ready)
│   ├── src/
│   │   ├── agents/                # The 6 agents + orchestrator + What-If engine
│   │   ├── lib/                   # Prisma client, JWT, AI provider, embeddings
│   │   ├── middleware/            # Auth, error handling, audit logging
│   │   ├── routes/                # REST endpoints
│   │   ├── seed/                  # Demo dataset + seed script
│   │   └── index.ts               # Express entrypoint
│   └── .env.example
└── frontend/
    ├── src/
    │   ├── components/            # AgentTimeline, GraphView, WhatIfSimulator, ui/*
    │   ├── lib/                   # api client, auth context, utils
    │   └── pages/                 # Dashboard, Meetings, Decisions, WhatIf, ...
    └── index.html

---

7. Known limitations / next steps for production

• Swap SQLite → Postgres + pgvector for real vector search at scale (schema is already structured for this; only embed()/cosineSimilarity() in lib/embeddings.ts need to move server-side into pgvector).
• Wire real OCR / layout-aware PDF & PPTX extraction (Document AI, Textract, or a Gemini-vision pass) into upload.routes.ts in place of the pasted-text fallback.
• Add real Gemini grounding (Google Search retrieval) to the Research Agent, which already has a isLiveMode() branch ready for it.
• Role-based permissions are modeled (WorkspaceMember.role) but not yet enforced per-route — add middleware before production use.