Promise Rader

small prototype demo React web app plus a Node server/MCP layer that turns plain text (messages, notes, emails) into a short list of “invisible commitments / open loops” and a suggested next action.

Comment

Inspiration

Promise Radar is built on the observation that a lot of real work gets created as conversation signals, commitments, requests, intentions, and decisions before it ever turns into explicit tasks. The prototype’s goal is to extract that invisible backlog from ordinary text and turn it into a small, socially-aware next action.

What it does

  1. You paste or upload an everyday message/thread.
  2. The app extracts likely open loops (e.g., “I’ll send that Thursday”, “can you intro me next week”).
  3. For each signal, it shows: . category/tag (you promised / you intend / they asked / decision pending / reminder) . confidence . evidence phrases from the text . a small next move to close the loop
  4. You can run extraction in different modes: . fast logic (offline, explainable heuristics) . your AI key (BYOK via a user-provided chat-completions endpoint) . local AI (WebGPU WebLLM model in the browser, when supported)

How we built it

  1. Frontend (React + Vite): . src/App.jsx orchestrates the UX: text input, engine selection, and rendering results.
  2. Fast explainable extraction: . src/promiseEngine.js performs deterministic detection using: . sentence/clause splitting . regex “phrase families” for commitments/intent/requests/decisions/reminders . scoring signals like deadlines, hedging, and negation
  3. AI-backed extraction: . src/byokAI.js calls a compatible provider with a session-only API key and validates structured JSON. . src/localAI.js loads a Qwen2.5 model via @mlc-ai/web-llm (WebGPU) and enforces a JSON-only output contract.
  4. Backend tooling (server/MCP): . server/api.mjs exposes a lightweight analyze endpoint. . server/plan.mjs converts signals into an approval-required step list. . server/mcp.mjs registers MCP tools like analyze_text and plan_open_loops.

Challenges we ran into

  1. Implicit intent: people often imply commitments without explicit “I promise” wording, so detection needs careful context rules to avoid false positives.
  2. Structured AI outputs: BYOK/local AI modes must parse and validate JSON from models, and gracefully fall back when parsing fails.
  3. Explainability vs accuracy: the fast engine is transparent but less nuanced; AI modes are stronger but require strict output validation and privacy-aware integration.

Accomplishments that we're proud of

  1. A sort of working prototype loop: text → extracted signals → evidence → next-step plan.
  2. A deterministic baseline in src/promiseEngine.js that works instantly offline.

What we learned

  1. “Tasks” are often not the right unit open loops are.
  2. Users trust more when outputs include evidence and confidence, not just a generated list.

What's next for Promise Rader

  1. Improve detection precision/coverage in the fast engine
  2. Upgrade “save next step” into real workflow actions
  3. and overall working and actual project complement.

Built With

Share this project:

Updates