Sourced

1What Sourced is (and is not)

Every feed, every aggregator, every “is this real?” moment re-solves the same problem badly or not at all: a thousand items, each equally loud, with no signal for which ones the world actually agrees happened. The missing layer is the oldest heuristic in journalism — get a second source — computed continuously over a live stream. Sourced ships that layer as one small, dependency-free function.

The framing is load-bearing: Sourced never claims a thing is true. Truth is not a property you can compute from headlines — corroboration is. “Six independent outlets report this, first seen 17:04” is a checkable fact about the world’s reporting, not a verdict handed down. This distinction is the difference between a trust layer that earns credibility and one that inflates it until it pops.

Deliberately not

• Not a fact-checker — it counts sources; it does not adjudicate claims.
• Not a truth oracle — the output vocabulary contains no “true” (guarantee G2).
• Not sentiment or bias analysis — an orthogonal concern, left to others.
• Not a recommender or ranker — it annotates; it never reorders for engagement.
• Not ML-bound — event grouping is pluggable (LLM, regex, embeddings, upstream editor); the counting and the guarantees are independent of it.

The surface stays this small on purpose. A building block does one thing well enough that a hundred products can lean on it — the narrower the surface, the wider the reach.

2Quick start

import { assess, createMemoryStore } from "@sourcedhq/core";

const store = createMemoryStore(); // or your KV / SQLite / file — anything with load()/save()

const verdicts = await assess(
  [
    { id: "a", title: "Central bank raises rates", origin: "reuters", publishedAt: "2026-01-01T12:00:00Z" },
    { id: "b", title: "Central bank raises rates", origin: "bbc",     publishedAt: "2026-01-01T12:04:00Z" },
    { id: "c", title: "Celebrity opens restaurant",  origin: "gossip",  publishedAt: "2026-01-01T12:05:00Z" },
  ],
  { store },
);

// verdicts[1] — the BBC claim:
// {
//   corroboration: 2,                  // distinct independent origins reporting this event
//   corroboratingSources: ["reuters"], // the receipts: who else (never the claim's own origin)
//   firstSeenAt: "2026-01-01T12:…",    // when THIS system first saw the event (persists across runs)
//   signal: "breaking"                 // "confirmed" | "breaking" | "developing" | null
// }
//
// verdicts[2] — the single-origin claim:
// { corroboration: 1, corroboratingSources: [], firstSeenAt: "…", signal: null }   // bare, by design (G5)

One call. Verdicts come back in input order, null for claims that cannot be assessed (e.g. a title with no meaning-bearing tokens) — those simply pass through unlabeled. assess never throws into the stream it annotates (G7).

Prefer to try it without installing anything? The hosted playground and API live at sourced.run.

3Data model

Claim — what you put in

Verdict — what you get back

Injected collaborators

4The algorithm

Sourced maintains a persistent event store and folds each batch of claims into it. Five steps, all deterministic given the same inputs and clock:

4.1 · Identity

A title is reduced to meaning-bearing tokens: lowercased, punctuation stripped, stopwords removed (EN + DE built in, injectable), tokens shorter than 3 characters dropped. The deterministic event key is the sorted set of the top 8 tokens. Same key → same event, no similarity math needed.

4.2 · Matching (the dual gate)

If the key doesn’t match an existing event, a similarity fallback runs — but merging requires both gates to hold:

• Jaccard similarity of token sets ≥ 0.60, and
• at least 3 shared meaning-bearing tokens.

Why both: short headlines can reach high Jaccard from two words shared by chance ("Tesla recall" vs "Tesla recall expands" scores 0.67 on two tokens). The token floor blocks that; the similarity floor blocks keyword-stuffed titles that share 3 tokens buried in noise. This is guarantee G1 in mechanical form: when in doubt, do not merge — a missed corroboration costs little, a false “confirmed” costs the only thing that matters.

4.3 · Counting

A matched claim joins its event: the event’s origin set becomes the union of every distinct origin ever seen for it (this batch ∪ history), and the freshest title wording is retained. corroboration = |distinct origins|. The receipts are the other origins, capped for display. Articles are never counted — origins are (G3).

4.4 · Signal

The age test uses the claim’s published timestamp — a reliable upstream value — never Sourced’s own firstSeenAt guess. Consequence: an identity mistake can shift a count, but it can never invent urgency (G6).

4.5 · Decay, bound, archive

The working set stays bounded so matching stays sharp: events unseen for 36 h retire, and the store caps at the 400 most-recently-seen events. Retiring events are handed to your archive sink rather than deleted — corroboration reflects a living window, while the full history (every event, every first-seen timestamp) accumulates forever in your archive. That history is the part of a Sourced deployment nobody can copy out of a feed later.

5Configuration

6Honesty guarantees G1–G7

Invariants, not preferences — each one is enforced by adversarial cases in the conformance suite, which you can run live right now.

7Adversarial analysis

How would someone game a corroboration count — and why Sourced resists:

Astroturf many outlets

Inflating a count requires genuinely distinct origins, not many articles — G3 collapses syndication and copies to one. The cost of faking corroboration is the cost of standing up many independent sources, which is the real-world cost of the thing being true enough to report.

Keyword-stuff a headline to hijack an event

Sharing 3 tokens with a real event is easy; passing Jaccard ≥ 0.60 at the same time requires the titles to genuinely be about the same thing. The stuffed title fails gate 1 and stays what it is: a single-origin claim with no signal. (This exact attack is a live test case — watch it fail.)

Rush a “breaking” label

The urgency clock is the upstream publish time (G6). A planted first-sighting changes nothing; an old story newly corroborated reads “developing”, never “breaking”.

8Beyond news

The unit Sourced operates on is (claim, origin, timestamp) plus a pluggable way to group claims into events — not “a news article.” Any domain with independent reports of discrete events fits: swap the clustering and the storage, keep the counting and the guarantees untouched.

The outage row isn’t hypothetical — it ships as a runnable example in the repository, tuned with confirmedAt: 3 and a 10-minute breaking window, using the identical engine.

9Hosted API

A public, stateless instance of the engine runs at sourced.run — paste claims in the playground or POST /api/assess directly. Full request/response reference, limits, and examples in curl, JavaScript and Python live there.

curl -s https://sourced.run/api/assess \
  -H "content-type: application/json" \
  -d '{"claims":[{"id":"a","title":"…","origin":"reuters","publishedAt":"2026-07-10T21:00:00Z"}]}'

10Conformance

The guarantees ship as an executable, adversarial test suite — @sourcedhq/conformance. It targets the function shape, not this implementation: point it at any engine that claims to count sources and it reports, case by case, whether that engine is Sourced-honest or just counting volume.

import { runConformance } from "@sourcedhq/conformance";

const report = await runConformance(myAssessImplementation);
// { passed: 14, failed: 0, results: [{ id, guarantee, pass, detail }, …] }

The reference engine runs the suite on every commit in CI, and you can run it against the live deployment in your browser at sourced.network — it executes fresh every time, no cached results.

11Transparency log

@sourcedhq/log chains verdict batches into a tamper-evident hash chain: each record commits to the previous record’s hash (Certificate-Transparency style, SHA-256 over canonicalized JSON). Publish the chain head anywhere public — a git commit, OpenTimestamps — and the entire history up to that point becomes verifiable: rewriting any past verdict breaks every hash after it.

This turns “we have issued honest verdicts since day one” from a marketing line into a checkable claim. Record format, verification semantics and a hosted verifier live at sourced.network.

12Error FAQ & Troubleshooting

Reference for common HTTP status codes, API response errors, and troubleshooting steps across the Sourced network and API endpoints:

13Packages, status, license

Agent-readable summaries: /llms.txt on every Sourced domain.

Install

# the engine
npm install @sourcedhq/core

# give it to your AI agent (Claude Code)
claude mcp add sourced -- npx -y @sourcedhq/mcp

Status: v1.0.0, published on npm — the stability promise is in force: the guarantees, the verdict shape and the hosted /api/v1/* paths do not break. No install needed to evaluate: the hosted API at sourced.run runs the same engine.

License: MIT for all code — use it, embed it, fork it. The Sourced name and mark are reserved: forks ship under their own name, and “Sourced-conformant” is a claim you earn by passing the conformance suite (see TRADEMARK-POLICY in the repository). Source: github.com/Ryan-hasi/sourced.

Built on Sourced

Contact: hello@tickwire.news