Trace

Trace turns scattered team conversations into evidence-backed decision memory—showing what was tried, why it changed, who owns it, and what to do next.

Comment

Inspiration

Important team decisions are rarely lost because nobody wrote anything down. They are lost because the context is scattered across Slack, tickets, pull requests, documents, and incident reports.

We wanted to solve the moment every new project owner faces: “Have we tried this before—and why did the team choose this path?” Trace preserves the reasoning, evidence, ownership, and outcomes behind decisions so teams do not repeat work or lose critical knowledge during handoffs.

What it does

Trace is an organizational-memory search workspace.

A user can ask a question such as, “Why did we postpone enterprise SSO?” Trace then:

  • breaks the question into concepts, intent, owners, and requested information;
  • retrieves relevant project evidence;
  • extracts structured decisions, including context, alternatives, owner, date, outcome, and confidence;
  • produces evidence-backed claims with source citations;
  • flags contradictions between earlier commitments and later decisions;
  • generates a project handoff brief; and
  • runs a “before you build” preflight check to warn when a proposed change could bypass a previous decision.

The demo uses a realistic enterprise SSO workspace containing records from Slack, Notion, GitHub, Linear, and incident reviews.

How we built it

We built Trace with Next.js, React, TypeScript, Tailwind CSS, Zod, and Node.js.

The application uses a transparent, deterministic reasoning pipeline for the hackathon demo: question planning, evidence ranking, decision extraction, contradiction detection, handoff compilation, and preflight checks. This makes each result inspectable instead of presenting an opaque answer.

We used Codex and GPT-5.6 throughout development to shape the architecture, accelerate implementation, refine the UI/UX, troubleshoot the local setup, and verify the application.

Challenges we ran into

The main challenge was building something that feels intelligent without making unsupported claims.

A generic AI summary can sound convincing even when it misses important context. We addressed that by designing Trace around evidence first:

  • each important claim is linked to source records;
  • confidence reflects evidence coverage and source diversity;
  • contradictions are surfaced rather than hidden;
  • extracted decisions can be reviewed by humans; and
  • connector and permission states are clearly labelled as demo snapshots until live integrations are connected.

We also encountered a corrupted local dependency cache during setup, which required rebuilding dependencies before we could complete production-build and lint verification.

Accomplishments that we're proud of

We are proud that Trace is more than a search interface. It turns fragmented project history into a usable decision trail.

In particular, we are proud of:

  • the evidence-backed answer flow;
  • structured decision extraction rather than plain summarization;
  • contradiction detection between commercial commitments and technical/security decisions;
  • a handoff brief that turns history into actionable next steps;
  • the preflight workflow, which helps prevent teams from repeating past mistakes; and
  • an interface designed to make trust visible through citations, confidence, and source context.

What we learned

We learned that organizational memory is not just a retrieval problem. The valuable information is often the reasoning behind a decision, the alternatives rejected, and whether the outcome changed later.

We also learned that trust needs to be designed into the product. Showing sources, uncertainty, conflicts, and review states is more useful than presenting a single confident answer.

What's next for Trace

Next, we plan to add live, permission-aware integrations for Slack, Notion, GitHub, Linear, and other enterprise tools.

We also want to add:

  • OAuth-based source connections and inherited access controls;
  • semantic retrieval with embeddings and reranking;
  • human approval and correction workflows for extracted decisions;
  • decision lifecycle tracking, including superseded and revisited decisions;
  • proactive alerts when a new ticket, PR, or message conflicts with an existing decision; and
  • team analytics that reveal repeated debates, unresolved risks, and knowledge gaps.

Our long-term goal is simple: before a team repeats a discussion or rebuilds a feature, Trace should show what they already tried, why, and what happened.

Built With

Share this project:

Updates