Capture runs through a phone shortcut, so a thought can be recorded from the lock screen without opening anything. It accepts typed text or a voice recording, transcribes the audio, and posts it to a single endpoint. A first pass classifies what kind of thing was said; a second extracts the fields for that kind.

Relative dates are resolved at the moment of capture and stored as absolute dates. This is the difference between a system that works and one that quietly lies to you: store the phrase instead, and something reading it back four days later has no idea when it was written and will repeat the word “tomorrow” about a deadline that has already passed.

A deduplication pass sits in front of the write, so saying the same thing twice in a week produces one record plus a note that it has now been said twice, which is itself worth knowing.

Edges live in a single table keyed on(from_type, from_id, to_type, to_id, relation) and written with an upsert, so extraction can be re-run over the same text as often as you like without multiplying the graph.

Extraction matches text against records that already exist, on whole-word boundaries, and never on a model's impression that two things feel related. Names under three characters are ignored outright, because the false-positive rate on those swamps anything they find. A wrong edge is worse than a missing one, since everything downstream treats edges as fact.

Lookups return both directions and preserve which is which. “This note mentions a contact” and “this contact is mentioned by a note” are the same edge but not the same sentence, and a briefing that confuses them reads as nonsense.

Each detector is an ordinary function over the graph rather than a prompt. It either matches a shape or it does not, so any finding can be traced back to the exact records that produced it, and the same input always produces the same output.

A model is involved only at the final step, to phrase a finding that has already been established as true. Findings are then deduplicated against what has recently been delivered and passed through the same interruption budget as everything else. A pattern being interesting does not exempt it from being an interruption.

Calendar, tasks, contacts, projects, open intentions, mail and cross-domain signals are gathered in parallel. Each source settles independently, so one slow upstream call degrades a single line rather than blanking the whole briefing.

Event kinds are classified in code as well. A meeting with other people, an appointment, an hour set aside for yourself and a bare reminder are not the same thing and must not be described as if they were. Overlaps are detected before the prompt is built, so the model states a collision as fact rather than trying to spot one.

The instruction is explicit: do no arithmetic. A model that does its own arithmetic will occasionally be wrong and will always sound certain, and a briefing you have to double-check is worth less than no briefing at all.

Hard limits rather than heuristics: at most two messages per run, and never two about the same intention inside three days. Candidates are batched and deduplicated before anything is sent, which is what prevents the obvious failure mode of three notifications about one deadline arriving before breakfast.

Every kind of message declares a minimum urgency tier, and those tiers are matched against your notification setting through a shared table rather than compared as free-form strings. Two vocabularies drifting apart is exactly how a system ends up silently delivering nothing while reporting that it is set to deliver everything.

Delivery windows are set per kind. A check-in about a person goes out in the morning; a reminder about an evening block goes out in the late afternoon. Nothing is queued overnight, because a notification read at seven in the morning in a stack of six is a notification you dismiss.

Classification is rule-first and model-second. A merchant is matched against an ordered rule list, and only an unrecognised one is escalated to a model, whose answer is then cached so the same merchant is never paid for twice. Rule order carries real meaning: fuel has to be tested before groceries, or a supermarket-branded petrol station gets filed as food.

Repeating charges are found structurally, by looking for the same merchant at roughly the same amount more than once, rather than by matching against a list of known subscription names. A list only ever finds the services someone thought to add to it.

Account data is pulled on a fixed schedule, cached, and then sliced locally for whatever window the page asks for. Every figure on the page is computed server-side, and no model produced any number on it.