Klear

Klear turns a team's messy chat into one shared state every human and every AI copilot reads the same way — then keeps it live as work hands back.

Comment

Inspiration

In a hackathon, the work drifts faster than the chat. A team makes a call on a late-night voice chat — "we pivoted to face masks," "the budget's $500" — and half of it never gets written down. So one teammate keeps building the old thing, and each person's AI copilot (Claude, Cursor, ChatGPT) has a slightly different picture of the plan. Everyone is technically on the same team and actually building slightly different projects. We call it context drift — and in a few-day sprint, it's the silent killer.

What it does

Klear is the clarity layer for your team and its AI. Paste your team's messy chat, notes, or a meeting transcript, and Klear returns one shared project state every human teammate and every AI copilot reads the same way — then keeps it alive as work comes back.

Klear — the living loop: Intake → Process → Store → Dispatch

  • Find the shared state — an I→P→S→D engine reads the raw conversation, hunts the decided-but-never-written gap, flags verbal-only decisions as risk, and maps each person's next action + where their work rejoins.
  • Split into companions — the state splits into one portable companion.md per teammate, each ending in a Pack Back block.
  • Merge back — paste a returned handoff and the state bumps v1 → v2, closes loops, re-points next actions, and logs what changed — until the folder is reconciled.

Every merged handoff updates the shared state, so the folder is always current — anyone, human or AI, can jump in at any point and pick up exactly where the team stands, no catch-up reading required.

It speaks your team's language: paste in any language, and the state, companions, and handoffs all come back in it.

How we built it

React + Vite single-page app, no backend. The engine is a set of system prompts calling Anthropic claude-sonnet-4-6 directly from the browser, returning fixed JSON schemas validated client-side. The whole thing is self-contained — the API key stays in the browser, nothing is stored or proxied. The engine does what rules can't: it reads intent from messy language, detects decisions that were only said out loud, flags how confident it is, and maps who's blocked by whom — judgment calls, not pattern matching.

Challenges we ran into

Separating real signal from tangent in a messy multi-person transcript, keeping the "living loop" (split → pack back → merge → converge) simple enough to grasp in seconds, and resisting scope creep — we cut audio capture and real-time sync to ship one sharp engine instead of three half-built features.

Accomplishments that we're proud of

We tested Klear on a real, messy multi-person work meeting — full of tangents and crosstalk — and it correctly isolated the one decision living only in someone's head, flagged it as the root-cause gap, and gave each person a clean next action. The engine holds its discipline: it never invents structure that wasn't in the conversation, and it tells you when it's only as confident as the input allows.

What we learned

The hardest part wasn't the UI — it was the engine's discipline. Early versions invented structure that wasn't in the conversation, which makes the output look clean but useless. We locked hard guardrails: never invent, never generic, show inference (mark it and ask), and a front-door isolation-confidence check — so the state is only ever as reliable as the paste.

What's next for Klear

Live capture (voice/transcript ingest), Git/Slack sync, and a team dashboard. And because Klear is a self-contained browser app with no backend, it's ready to deploy as-is — zero setup, works today. If it wins, we'd love to put it live for builders during the week.

Built With

Share this project:

Updates