← sagar hugar

Lore

The reasoning layer for remote product teams, a system of record for why decisions get made, that watches for when that reasoning quietly breaks.

Founder, designed and built soloIn development

the call I made

decision

Build the system of record for product reasoning

assumption: the belief that made me confident

As AI fragments decision-making into private agent chats, the reasoning behind decisions becomes the most valuable thing a team can own, and nobody is capturing it.

confidence at the time
70% · high

what it looks like

9
signal types detected
3
product surfaces
4
pipeline stages
Lore's Decisions surface: each decision card shows the assumption beneath it, its confidence label, stated risks, dissent, constraints and success criteria
  1. 1The confidence label is extracted, not typed. A hypothesis and a fact get treated differently, and teams routinely forget which one they were working from.
  2. 2"None detected" is shown, never hidden. A consequential call made with nobody dissenting is a fact worth knowing six months later.
  3. 3Same fields, different confidence. This decision came out of an actual bake-off, so it is labelled fact and data-backed.
the Decisions surface, running on demo data
Lore's Signals surface: warnings grouped by type, each quoting the evidence that triggered it
  1. 1Nine signal types, not one generic alert. Contradictions, stale dependencies and unaddressed risks fail in different ways and deserve different triggers.
  2. 2Every warning says why it fired. An alert you cannot audit is an alert a team learns to ignore.
  3. 3The evidence is the team's own words, quoted from the transcript. Lore never paraphrases the claim it is challenging.
the warning surface, filtered by signal type
Lore's reasoning graph: sources at the top, statements and findings in the middle, decisions at the bottom, with edges marked supports, contradicts or invalidates
  1. 1Sources are first-class. Every claim traces back to where it came from, including who said it.
  2. 2Red means contradicts. A later finding invalidated the reasoning under this decision, and nobody had to spot it by hand.
  3. 3The decision is still marked provisional and now sits under a contradiction. That gap is the whole reason Lore exists.
sources → statements → decisions, with contradictions drawn as edges
Lore's four-stage pipeline: capture, extract, store, triggers, feeding three surfaces: Decisions, Signals, Reasoning Graph
capture → extract → store → triggers, feeding the three surfaces

what I did

Every company has a record of what it decided: docs, tickets, Slack, code. No company has a record of why: the assumption underneath the decision, how sure anyone really was, what risks were named, who disagreed, and what it would take to prove it wrong.

Teams don't forget what they decided. They forget why. And they keep building on assumptions that quietly stopped being true.

Why now

This was always a problem; AI is making it acute. Everyone on a team now ideates with their own agent: the PM prompts one model, the engineer another. Everyone moves faster, but the reasoning behind every decision happens inside dozens of private AI conversations no one else can see. We're shipping faster and understanding each other less. Remote teams feel it worst: there's no hallway, no overheard debate, no whiteboard nobody erased.

What it does

Feed Lore the raw exhaust of how a team thinks (today: meeting transcripts) and it does three things. It captures the reasoning, not just the decision: for every decision, an LLM extracts the assumption beneath it, the confidence level (fact / belief / hypothesis / speculation), the risks named, the constraints, who dissented, what success would look like, and who wasn't in the room. It watches for when the reasoning breaks: nine trigger types, from direct contradictions to "you said you'd know in three weeks whether this worked; it's been three weeks." And it shows the lineage: a reasoning graph mapping sources → assumptions → decisions, with contradictions drawn as edges.

Every signal stores the exact sentence that fired it. An AI that flags a contradiction has to show its work.

The design decision I'd defend hardest

"None detected" is shown, never hidden. If a decision was made with no stated risks and no success criteria, Lore says so explicitly, because a consequential call made with no risks named and no way to measure it is exactly the kind of decision a leader should worry about. The absence is itself a signal.

Where it goes

The endgame is an Agent API: agents log their reasoning to Lore before they act, and query it so they stop re-litigating settled questions. As orgs shift toward one human orchestrating many agents, reasoning gets lost orders of magnitude faster, because agents reason inside context windows that are wiped after every task. The only way a human stays in control of a hundred agents is governance by exception, and that requires exactly this layer.

what happened

Not yet evaluated. This one is still open.

▸ the full record: evidence, alternatives, risks, what I traded away
context: the problem I was solving

As a product manager at a remote startup, I watched cross functional teams and AI ship faster than ever, leaving fragmented context that needed grounding.

evidence: what informed it
  • FoundersRepeatedly asking for clarity on product decisions.
  • EngineersNot knowing why something was built.
  • DesignersNot having context of a particular product decision.
  • Product ManagersLacking context behind key product decisions.
signals: what I concluded from it
  • Providing clarity on what is being built, why it is being built, current blockers, and the downstream impact of decisions keeps everyone aligned and working from the same context.
risks I named
  • The category doesn't exist yet, so this may simply be too early
  • Capture friction could kill adoption before the reasoning graph compounds into a moat
constraints
  • Nights-and-weekends build, solo, cost constraints
how I'd know it worked

A team outside my own uses it weekly and queries past decisions instead of re-litigating them.

what I knowingly traded away

  • Three separate surfaces (Decisions / Signals / Graph) instead of one feed: the first version crammed everything together and the decisions got buried under the warnings
  • Transcript paste-in before integrations: capture friction now, but it proved the extraction quality before investing in Slack and meeting bots
  • SQLite over a hosted database: the reasoning graph must survive and compound; one file with in-place schema migration beats infrastructure I'd have to babysit

built with: Python · FastAPI · SQLite · LLM extraction (provider-swappable) · Embedding-based contradiction detection