How it actually works.

The news has a structural problem: every outlet’s incentives point away from informing you. Most readers feel the result — everything seems louder, angrier, more partisan, more repetitive — without seeing the mechanism. The mechanism is a stack of biases that compound when news is funded by attention.

Each of these is a rational response to the wrong incentive. Outlets that don’t optimize for attention lose to ones that do. Algorithms that don’t feed you content you already agree with lose to ones that do. The news you read is shaped by the structural pressures on the people making it, not by anyone’s editorial intentions.

Nova’s response is structural, not editorial. We don’t hire a different kind of journalist. We built a system whose objective function is verifiable information density — getting you informed and back to your life as efficiently as possible, and not a second more. The architecture changes what we’re rewarded for producing.

The rest of this page is the how. Pipeline, sources, claim extraction, verification, gates, what ships to your feed, where we still get it wrong.

The pipeline’s objective is to produce stories whose every factual claim is supported by independent evidence. If a story can’t clear that bar, it is discarded. Most ingested content does not survive — either because it duplicates something we already have, fails verification, or fails the editorial-significance gate. What you see is what made it through.

Each stage has independent quality gates. An article can be killed at any point—most are. The vast majority of raw ingested content is either duplicate, low-information, or fails verification. What survives is what you see.

Deduplication runs at three independent layers, because the same news event can echo across the system in three different shapes. (1) At ingest, near-identical articles from the same temporal window collapse into a single record — the wire-service echo effect where dozens of outlets republish the same AP or Reuters rewrite. (2) At synthesis, events with overlapping actors, matching event_keywords, and embedding similarity collapse into a single EventNarrative, so “Apple announces earnings” and “Tim Cook reports Q3 numbers” resolve to one story. (3) Canonical entities are clustered at cosine ≥ 0.88, so “Apple,” “Apple Inc.,” and “Apple Inc” resolve to a single record across the graph.

A staged-replay harness re-runs the extraction pipeline at progressively larger scales (250 → 500 → 1,000 articles) and gates the next stage on the previous stage’s quality metrics. If a stage fails its gate — bad event-merge rate, bad entity-resolution rate, drop in claim quality — the harness halts before scaling further and writes an alert artifact. The live pipeline keeps running so users aren’t blacked out; operators are notified within hours of the offending change. We do not auto-roll-back production. A human looks at the alert and decides.

We ingest from over 100 news outlets spanning the full political and editorial spectrum—wire services, legacy print, broadcast, digital-native, international, and partisan media from both sides—plus direct feeds from primary source APIs: SEC filings, Congressional records, FDA approvals, WHO outbreak reports, court opinions, central bank statements, arXiv, and bioRxiv.

This is deliberate. You cannot detect bias if you only read one side. You cannot verify facts if you only have secondary reporting. The system needs the full picture to do its job.

Every source domain is scored automatically using an ensemble of five signals. No human editors assign ratings—the credibility score is derived entirely from observable, auditable data. TLD quality, HTTPS presence, subdomain depth, and suspicious URL patterns are penalized at the infrastructure layer.

Sources are classified into nine categories: wire service, legacy broadcast, legacy print, digital native, partisan media, opinion outlet, international, local, and aggregator. Each category carries a different baseline credibility range, which is then adjusted by the domain-specific ensemble score.

News articles are unstructured text mixed with opinion, framing, speculation, and background. To verify facts, we first have to extract them. The system breaks every article into atomic, individually verifiable claims—each tagged with a calibrated confidence score.

Confidence scores are not raw LLM outputs. Every extracted claim runs through a four-axis quality scorer:

The four axes combine into a composite score from 0.0 to 1.0. Borderline claims (composite between 0.3 and 0.7) escalate to a dedicated LLM judge that returns a three-way verdict: good_claim, weak_claim, or not_a_claim. Each verdict is stored with reasoning. Over time those labels become a corpus for recalibrating the scorer — a closed measurement loop, not a one-shot guess.

A core invariant for entities: confidence only increases, never decreases. When an entity appears in a later extraction with higher confidence, the score upgrades via max(existing, new); a weak observation never overwrites a strong one. This is what protects established facts — a person’s employer, a company’s stock ticker — from being silently degraded by a transient ambiguous mention.

We do not trust any single source. A claim is only promoted to “verified” status when it meets specific thresholds across independent ownership groups. The minimum confidence for a verified claim is 0.85. Below 0.60, a claim is considered ungrounded and filtered from the UI entirely.

Verification follows a four-tier hierarchy, from highest to lowest authority. The system attempts each tier in order and stops at the first successful verification:

At the extraction layer, every claim is also verified against its original article text. The grounding verifier checks whether supporting text exists, whether quoted statements are actually present, and whether numeric values match. Claims scoring below a grounding threshold of 0.6 are flagged as potential hallucinations; below 0.3, they are discarded.

Most news products try to hide bias. We treat it as structured data. Every source in our system carries a political lean classification on a seven-point scale. Every claim tracks which perspectives reported it. This is not editorial judgment—it is a data model.

Contradiction detection works via semantic similarity combined with sentiment analysis. When two claims have high semantic overlap but opposite sentiment polarity, they are flagged as a ContradictionPair and surfaced in the feed with both positions attributed.

Every synthesized story is decomposed into an EventNarrative structure: confirmed facts (all perspectives agree), disputed claims (left vs. right with source attribution), coverage unique to one side of the spectrum, and a spectrum coverage map showing which parts of the political landscape have reported on the event. You see this directly in the feed. We don’t pick a winner. We show you the data.

LLMs want to please the user. Left unchecked, they smooth over uncertainty, add plausible-sounding filler, and produce confident text about things they don’t actually know. To prevent that, every story passes through two evaluation layers: one at the claim level (does this single fact hold up?) and one at the article level (does this whole story belong here?). A draft can be killed at either layer.

Claim-level evaluation

Each extracted claim is scored on the four axes shown in Section 04 — specificity, attribution, falsifiability, newsworthiness — producing a composite quality score. The display thresholds are: below 0.6 the claim is hidden from your feed, between 0.6–0.7 a low-confidence indicator is shown, between 0.7–0.85 it is marked as inferred, and at 0.85 or above it is presented as verified.

Claims that land in the borderline band (0.3–0.7) escalate to a dedicated LLM judge that returns a three-way verdict: good_claim, weak_claim, or not_a_claim. Each verdict is stored with reasoning, building a labeled corpus that’s used to recalibrate the rule-based scorer over time.

A separate grounding check runs alongside the quality scorer. The grounding verifier compares each claim against its source article text, looking for unmatched quotes, unmatched named entities, and unmatched numeric values. Claims that fail to ground are flagged or discarded depending on how badly they miss. This is the “the LLM made it up” check, and it runs on every claim, every time.

Article-level gates

Saga drift. When a new article is being attached to an ongoing saga (an active war, a multi-year trial, a regulatory investigation), a separate, stronger reasoning model compares its framing against the saga’s established trajectory. If the new article introduces a contradiction without a corrective signal — reframing “indictment” as “exoneration” without citing new evidence, say — it is rejected from the saga. Roughly one in five candidate articles is rejected here.

Editorial tier. Every synthesized article is classified Tier 1 (essential, major news everyone should know) through Tier 5 (noise — historical rehash, opinion, blog posts, listicles, press releases). Tiers 4 and 5 are filtered from the main feed. The tier and a one-sentence reasoning are stored on the article, so every editorial decision is auditable.

The feed you read is the output of all of this. Every story includes:

• •Source count and confidence—how many independent outlets confirm this, and how confident the system is
• •Contradictions—when sources disagree, you see both positions with full attribution
• •Primary sources—direct links to official documents, filings, transcripts, and studies
• •Political perspectives—what different parts of the spectrum are reporting, decomposed via the EventNarrative structure
• •Story continuity—ongoing stories are linked into multi-event sagas with chronological timelines

We show our work. If you want to know why the system believes something, the evidence chain is there.

We want you to trust this tool, which means we need to tell you exactly when you shouldn’t.