The fact I never entered
Last Tuesday my system knew I'd been to the gym. I never told it that. I didn't tick a box, log a workout, or open a fitness app. All it had was a raw signal it already collected anyway: my phone's location history said I was within a hundred metres of one spot for about an hour and ten minutes.
From that — and one rule I'd written once — it concluded: personal training session. It even knew to be careful, because the gym is right next to the train station, so "I was near here" isn't enough on its own; the duration is what separates "trained" from "waited for a delayed train." An hour-plus means training. Ten minutes means transit.
That inferred fact — "trained on Tuesday" — is worth more than almost anything I type by hand, precisely because I didn't type it. It cost me nothing to produce and it's now queryable forever. Multiply that by every kind of thing a life emits, and you have the real payoff of a structured second brain: the data you never typed.
Reasoning, without the vocabulary that scares people
If you've read the enterprise version of this story, you've met the intimidating ladder: raw data → schema → metadata → ontology → RDF → knowledge graph → reasoning. It's a good ladder, and every rung is real. But for a person trying to make their own life legible, most of it is machinery you can admire and then walk past.
Here's the honest shortcut. The last rung — reasoning, deriving new facts from existing ones — is the one that actually pays. And you can reach it without formally standing up the middle ones. You do not need a triple-store, an OWL ontology, or RDF serialisation to infer "that was a holiday." You need two humble things you probably already have: data with a consistent shape, and a rule that reads it.
The enterprise stack writes the rule as a formal axiom over a graph. I write it as a line in a config file that my daily-note enrichment reads. Same move — if these conditions hold, assert this new fact — different weight class. The reasoning isn't in the RDF. It never was. The reasoning is in the rule, and the rule only works because the data underneath it was structured enough to be read. Structure plus a rule is a reasoning engine. The rest is tooling you add only when you outgrow the simple version.
What a rule actually looks like
None of my rules are clever. They're just written down, which is the whole trick. A few real ones:
- Location + duration → activity. If I'm at the gym's coordinates for more than an hour, that block was training. (The duration guard is the ontology's "constraint," doing real work: it stops the train-station false positive.)
- Date inside a range → context. If an event falls between these two dates, it happened on holiday in Sicily — so every photo, expense and note in that window inherits "trip: Sicily" without me tagging a single one.
- Physical location → client. If I'm at this address on a weekday, I'm working for that project, and the hours can be attributed to that customer.
Each of these takes a raw, meaningless signal — a coordinate, a timestamp, a date — and derives a fact with meaning: trained, on holiday, billable to Acme. That's the entire content of "reasoning." It is the same enrichment machinery, pointed at inference instead of validation: instead of checking whether a value is allowed, it creates a value that was implied.
The one guardrail that keeps it honest
There's a caveat, and it's the important one, because an inference is a guess with structure — and a guess can be wrong. The location rule assumes I actually trained, not that I met a friend in the café next door for seventy minutes. The holiday rule assumes I didn't duck home for a day in the middle.
So the rule that derives is always paired with a rule that checks. The system flags the inference rather than trusting it blind: "looks like training — confirm?" On anything load-bearing, a derived fact is a proposal, not a verdict, until it's either plausible on its face or I've waved it through. Derive, then verify — the same double loop that keeps a production data platform honest, shrunk to fit a life. Reasoning that can't be wrong isn't reasoning; it's just a lookup wearing a cape. The value is in the inference and the humility about it.
Why this is the shape of the systems that will matter
Here's the part I think is bigger than a personal trick. For a long time, the way to make a system more valuable was to put more in — more fields, more forms, more manual tagging. That era is ending. The systems that actually add value now are the ones that put less in and derive more: they take the signals you already emit and reason over them to produce knowledge nobody entered.
That's the real move behind the current wave of "AI-powered" everything worth paying for. Not a chatbot bolted onto a database — a reasoning layer over structured context that surfaces the fact you'd never have typed: the customer who's quietly about to churn, the deadline three linked tasks imply, the pattern across a year of days you couldn't hold in your head. The moat isn't the model, which everyone rents. It isn't even the data, which everyone hoards. It's the structure plus the rules that let a model reason over that data and hand you back something new. Derived insight is the product.
Which lands, as ever, on the same sentence. The magic looks like the AI "just knowing" you went to the gym. The structure is a coordinate, a duration, and one rule you wrote once. Reasoning is what structure does after you stop feeding it and start asking it. Give your life a shape it can read, add a few honest rules — and it will start handing you the data you never typed.