Why a
graph?
Fair question. "Knowledge graph" is exactly the kind of phrase people throw around to sound sophisticated. So here's the honest version — what it actually is, and why every piece of it exists to keep a promise to you, not to sound clever.
An article is a
dead end.
When a newspaper publishes a story, it writes a document and ships it. The document is the thing. If a fact in it changes tomorrow, they write a new document. The old one sits there, quietly wrong, forever. Nothing in the system knows that the two articles are about the same event, that they share a fact, that one corrects the other, or that you read the first one.
That's not a small limitation. It's the reason news can't tell you what's new (it doesn't model what you knew), can't tell you it was wrong (it doesn't model what changed), and re-explains the world every single time (it doesn't model the world at all — only individual tellings of it).
Circa got halfway here. It broke the article into atoms — but the connections between them lived in editors' heads and a Trello board. The graph was designed, and never got the runway to be built.
Maintain the world.
Don't publish documents.
Here's the whole move. Instead of storing articles, Edition stores a structured, living model of what is known — and treats every article, email, and briefing as a temporary rendering compiled from it on demand. The graph is the source of truth. Everything a person reads is compiled from the graph, the way a program is compiled from source code.
reporting · filings · transcripts · wires
↓ extraction + reconciliation
the knowledge graph — canonical, structured, revisable
↓ compile for one reader, one moment
a story · a delta · an explainer · an audio brief · silence
Once you make that move, a lot of impossible things become easy. But only if the graph is built from the right ingredients.
Six parts.
Each keeps a promise.
The whole model is: entities + events + claims + relationships + time + evidence. Not architecture for its own sake — every one exists because a specific promise to you is impossible without it.
People, places, things — as first-class objects
"Follow the person, not just the story."
A person, a company, a bill, a court, a conflict — each is a real node with its own identity, its aliases, and its own page. So you can follow a senator or a piece of legislation and get every development that touches it, wherever it surfaces. A name buried in prose is just ink; an entity is something the system can actually watch.
The thing that happened — separate from the telling of it
"Show me the timeline, and how we got here."
An event is an occurrence in time, distinct from any report about it. This sounds pedantic until you notice: five outlets reporting one event, two sources contradicting each other about it, a correction three days later — all point at the same event. Separate the occurrence from the tellings, and timelines, "what changed," and compare-the-coverage all fall out naturally. (Also: the software release is an event; the software itself is a thing. Keeping them separate is how lineage works.)
What a source asserts — before we decide if it's true
"Know the difference between reported and confirmed."
This is the one that matters most. A fact doesn't enter the graph as "the suspect acted alone." It enters as "police said the suspect acted alone" — an attributed claim, status unverified. Only corroboration, primary evidence, and absence of contradiction let it climb to established. The payoff: a system that knows why it believes what it believes — not a database of things the internet said.
Typed, directional links that know why they link
"Hop from the 50-state tracker to my state's story."
Person leads organization. Bill passed chamber. This atom summarizes that story; this story continues a decade-old one. An edge isn't a dumb hyperlink — it carries meaning and direction. Which means when one node changes, the system can trace every place that points at it and reconsider them. The old Circa "bridges," finally computable.
Two clocks on every fact
"What did we know, and when did we know it?"
Every fact carries two timestamps: when it happened, and when we learned it. That's called bitemporality, and it's the difference between a database and a memory. With two clocks, the same storyline can render as "the current state" or "how it unfolded" from identical data — and a retired fact isn't deleted, it's time-scoped. It's why the news can finally be longform over time without drowning you in the moment.
The receipt under every sentence
"Tap anything. See why we believe it."
Every claim links to its sources — the roll-call vote, the filing, the transcript, the wire — each tagged primary or secondary, each snapshotted at the moment we cited it. You never have to look. The whole point is earning enough trust that you don't. But when something feels off, the floorboards lift and the machinery is right there.
Everything is
a node.
Under the hood it's less exotic than it sounds. There's no table of "articles" and a table of "people" and a table of "events." There's one idea — a node — and everything is one: atoms, entities, narratives, even the tag definitions and the rulebook entries. What a node is comes from composable tags it wears (#person, #event, #author), and each tag brings its own fields.
And nothing is ever overwritten. Every fact is an assertion — a small, append-only record that says: this node, this field, this value, learned at this time, from this evidence, at this level of certainty. Change your mind, and you don't erase the old assertion; you supersede it. The history is the point.
node: senate-bill-218
field: status = "passed, 53–47"
event_time: 2:13 PM · asserted: 3:41 PM
provenance: authored · evidence: roll-call #218
supersedes: "vote scheduled for Thursday"
That's the honest core of it. Boring, even. But boring-and-consistent is exactly what lets everything above it be extraordinary — and what lets it run on nothing more exotic than well-organized tables.
One graph.
Seven faces.
Here's the test that proves it wasn't jargon. Take a real, messy storyline — say, the months of Ebola coverage. Build the graph once, chronologically. Then, without changing a single canonical fact, ask it to produce:
| Ask | What comes out of the same graph |
|---|---|
| the story | the historical, Circa-style narrative |
| the delta | just what's new, for someone current through yesterday |
| the explainer | a from-scratch catch-up for a newcomer |
| the briefing | a five-minute audio script for the commute |
| the timeline | an entity dossier, ordered by event time |
| the correction | after injecting a bad fact — who read it, what changed |
| the machine answer | structured, receipted data for another AI to consume |
If all seven fall out of one substrate with zero re-authoring, you haven't proven "an agent can write news." You've proven the architecture. That's the actual first experiment — and the recovered Circa corpus, eleven thousand real stories, is the freakishly good apparatus to run it on.
What it buys,
what it costs.
This isn't free. Storing every fact as an append-only assertion is more work than a column in a table. Maintaining a live graph is harder than publishing documents — genuinely, the hard part. And there are real open questions we haven't settled: exactly where a shared fact "lives" when many stories use it; whether claims eventually need to be their own first-class layer; how the risk math tunes in practice.
But the trade is deliberate. The expensive thing — a continuously maintained, provenance-aware, temporally-correct model of what's known — is precisely the thing that can't be faked by pointing a language model at a feed. The interface is cheap. Trustworthy state is the asset. The graph is where that asset lives.
If you take one thing from this page: the graph isn't there because graphs are cool. It's there because "show me only what's new," "tell me when you were wrong," and "explain it at my level, in my language, on my device" are all impossible without modeling the world and the reader as structured, living state. Everything else — the calm, the receipts, the silence — is downstream of that one decision. Next: how it's built →