Drift

Inspiration

Every engineering team has a runbook that is quietly wrong. Ours said "Apollo uses MongoDB" weeks after the team had moved it to PostgreSQL. Nobody lied; reality moved and the document didn't.

What bothered us is that the new generation of tools makes this worse, not better. Enterprise search finds the stale page instantly and ranks it highly. AI assistants read it and repeat it with total confidence. Agent memory only changes its mind when someone explicitly corrects it. Every Company Brain we looked at was good at storing and finding knowledge, but none of them ever asked: is this still true?

So we built Drift, a Company Brain that notices when it is wrong.

What it does

Drift turns docs, decision records (ADRs) and chat into facts that know where they came from and when they were true. Then, instead of waiting to be corrected, it keeps checking those facts against the live systems that run the company, using TriggerWare.

When something changes in the real world, Drift:

Updates memory without erasing history. The old fact is closed off, not deleted.
Flags every document that still repeats the old fact as stale.
Traces what depends on the change through the service dependency graph.
Alerts the owner, with the decision record and approver that explain why.

Every line of an answer is labelled with how Drift knows it: Verified (checked live), Stale (a doc still says something false), Decision, History, or Inferred (a best guess, never presented as fact). Ask a plain AI search bot the same question over the same documents and it confidently says "MongoDB".

How we built it

Facts with time. Each claim is a triple with a validity interval and an authority level:

$$c = (s,\ p,\ o,\ [t_{from},\ t_{to}),\ a)$$

Here a is the authority level: 1 is the live system of record, 2 an ADR, 3 a doc and 4 chat. A fact is current at time t when:

$$t_{from} \le t < t_{to}$$

So "what did we believe on Feb 10?" is just a query, and nothing is ever overwritten.

An authority rule for contradictions. For single-valued predicates like uses or owned_by, when a new claim c′ contradicts a current claim c, a lower authority number means a stronger source:

If the new claim comes from a stronger source, it supersedes the old one:

$$a(c') < a(c) \Rightarrow \text{supersede } c$$

If it comes from a weaker source and the old claim comes from the live system, it is stale on arrival:

$$a(c') > a(c) \ \text{and}\ a(c) = 1 \Rightarrow \text{stale on arrival}$$

Otherwise, Drift opens a conflict for a human to resolve.

A Slack message can never silently overwrite the system of record, and a new runbook that contradicts the live catalog is flagged the moment it is ingested.

TriggerWare as the engine. Every fact Drift can check becomes a TriggerWare trigger: a scheduled SQL query against the live system, for example

SELECT datastore FROM service_catalog WHERE org = 'acme' AND service = 'apollo'

TriggerWare pushes back only the delta (− MongoDB, + PostgreSQL), and that single row change sets off the whole reaction. Drift never scrapes or diffs anything itself. It also re-runs a fact's query in the middle of answering a question, so "Verified" means verified just now.

Blast radius. A recursive SQL query over the dependency edges, limited to depth 2, finds what's affected: Payments depends on Apollo and Checkout depends on Payments, so all of them get flagged.

Stack. FastAPI and SQLite on the backend, with server-sent events for live updates. The frontend is Next.js 16 with React 19, Tailwind and React Flow for the knowledge graph. Extraction is rule-based by default, with an optional LLM, and has a filter that drops small talk, secrets and unverified guesses. It runs with zero API keys.

Challenges we ran into

A logout bug that only appeared under load. Users were randomly kicked out with a 401. Our auth check ran in FastAPI's threadpool while sharing one SQLite connection with the event loop. Making it async fixed it, and 30 concurrent requests then all returned 200.
Extraction is harder than it looks. A chat-speaker regex stripped ADR-007: off a document title, so the decision lost its name. We also learned that "Decision: migrate to PostgreSQL" must not create a fact that Apollo uses PostgreSQL; only the system of record can say that.
Questions that never name the subject. "Why did we move off MongoDB?" mentions a datastore, not a service. Drift now resolves the datastore back to the services that used it.
No Docker, no TriggerWare server. We couldn't run the sponsor starter or a live TriggerWare instance, so we wrote an adapter for the real TriggerWare SDK plus a local engine with the same interface (create a trigger, watch it, get deltas pushed) to build and test the whole loop end to end.
Demo-day surprises. Another project's Docker container grabbed port 8000 and localhost started pointing at it, which made the app look broken. Pointing the web app at 127.0.0.1 fixed it.

Accomplishments that we're proud of

The full loop works end to end. Change one value in the live catalog and, within seconds, Drift updates memory, flags the stale runbook, finds three affected services and alerts the owner, all without anyone touching a document.
Answers you can audit. Every line says how Drift knows it, down to the source document and the approver of the decision.
History is never lost. The graph has a time slider that shows what the company believed at any point in time.
Measured, not just demoed. On our synthetic company:

Metric	Result
Questions answered correctly	12 / 12 (plain search baseline: 2 / 12)
Live changes detected	9 / 9, with 0 false alerts
Change to alert	about 2 ms on the local engine
Durable-fact filter	precision 1.00, recall 1.00
Tenant isolation	another org's data returns 404

We wrote the questions ourselves, so we treat these as a sanity check, not a benchmark.

What we learned

Push beats pull for truth. Re-reading every source on a timer doesn't scale. Subscribing to changes does, and it makes "how fresh is this fact?" a question you can actually answer.
Time is a first-class field. Once facts have validity intervals, history, auditing and "what did we believe then?" come almost for free.
Provenance is the product. People don't just want an answer; they want to know whether to trust it. Labelling every line was the most persuasive part of the demo.

What's next for Drift

Connect to a real TriggerWare server and real sources such as GitHub, Jira and cloud configuration.
Integrate into the sponsor app starter.
Let owners fix a stale doc right from the alert, closing the loop from "this is wrong" to "this is fixed".