Sift

Stop cross-referencing. Start deciding. Sift ingests your fragmented sources, flags where they disagree, and drafts the fix — but never sends anything without your sign-off.

Comment

Inspiration

We picked our track by looking at YC's Summer 2026 "Company Brain" RFS — systems that turn fragmented internal knowledge into something agents can actually use. Rather than guess at the pain point, we spent $3.50 running 12 AI-moderated synthetic interviews (via Cookiy) before writing a line of code. The finding that shaped everything: the expensive moment isn't searching for information, it's reconciling contradictions between sources — and people explicitly rejected any tool that acted autonomously without a human approving first. That became the whole design: catch disagreements, cite everything, never auto-send.

We landed on insurance claims specifically because it's a real YC RFS category ("AI-Native Service Companies"), and because the stakes of acting on a wrong fact (a denied claim, a bad payout) make the "catch the contradiction before you act" story concrete instead of abstract.

What it does

Sift ingests a claim's fragmented sources — the policy document, the claim form, call and inspection notes — into a graph. A walker traverses that graph, cross-references facts on the same topic across sources, and if two sources disagree (e.g. the customer says a pipe burst suddenly, the inspector's own notes suggest gradual seepage instead), it flags the conflict with citations rather than silently picking a side. It drafts a follow-up question to resolve the ambiguity, but nothing is ever sent without a human clicking Approve — that requirement came directly from the research, not from us assuming it.

How we built it

Entirely in Jac, Jaseci Labs' AI-native language — backend and frontend both, using Jac's full-stack cl {} pathway (a cl block compiles to a real React bundle; everything else compiles to Python; a client component calling a backend walker is a real compiler-generated RPC, not a hand-written fetch call).

  • Graph + walkers: Source/Fact/Claim nodes; a ClaimReview walker traverses from a claim to its facts and the global policy facts, runs a holistic by llm() conflict analysis, then a second by llm() call decides an action (answer / flag_conflict / escalate).
  • Citation integrity: extraction is constrained to copy vestic (non-LLM) substring check rejects anything that isn't anexact quote — so a citation can never be a hallucination. - Sensitive-content handling: facts marked internal-only aime and withheld from every citation, answer, and draft —tracked and shown ("N sensitive facts withheld"), never silently dropped. - Real routing: /, /dashboard, /review/:id via Jac'sal URLs, browser back/forward, deep-linking.
  • Copilot: a text-chat panel that answers questions grounded in the same facts, and can trigger navigation or the Approve action via natural language — it only classifies intent; the client calls the exact same he's one action pathway, not a second one bolted on.
  • Real tests: an 11-test Playwright suite driving actual Chromium against the running app, no mocks, committed to the repo.

Challenges we ran into

  • Neither of us had written a line of Jac before today — we scraped the real docs (via Firecrawl) into local reference files so we weren't guessing asyntax mid-build.
  • Windows doesn't yet have Jac's native single-binary installer, so we had to fall back to the pip-installable jaclang package in an isolated venv.- Jac's experimental native-compilation path hit an llvmliteot-reload flaky on both backend and frontend changes — welearned to do a clean restart after structural edits rather than trust HMR, which also surfaced a real bug: hot-reloading a node class definition bretype-filtered graph queries against already-persisted data.
  • Our first conflict-detection prompt over-triggered, flagging ordinary claim identifiers as "sensitive" (which literally broke the demo — the draft addressed the customer as "Dear Policyholder" instead of theirfication prompt fixed it.
  • A subtle CSS gotcha: a transform on any ancestor (even a completed translateY(0) from a finished animation) turns that ancestor into a containing block for position: fixed children — which quietly broke oursitioning after we added page-transition animations.

What we learned

Jac's object-spatial model (computation moves through a graph,d into a fixed place) is a genuinely different way to thinkabout "RAG" — once the walker's traversal is the comparison logic, conflict detection stops being a prompt-engineering trick and becomes a real graph algorithm. And spending under $5 on real research before codinverage half hour of the whole build — it's the reason the apphas actual constraints (citations, human approval) instead of guessed ones.

Built With

Share this project:

Updates

Submission history