“The AI reads a news article and summarises it.” That’s the mental model most operators arrive with — and it’s the one that turns into a lawsuit six months after go-live, because summarisation doesn’t create legal distance from the source and the model quietly hallucinates a number that nobody notices on screen.
The actual AI content pipeline is a 15-stage system. Seven stages use Claude Haiku; the other eight are deterministic algorithms. They are wired in that order on purpose: every AI output is checked by something that doesn’t hallucinate before it touches a public screen.
Why a pipeline and not a single prompt
A modern LLM is excellent at producing text that sounds right. That isn’t the same thing as text that is factually accurate, source-grounded, venue-appropriate, copyright-clean, and ready in fifteen languages.
A single LLM call can’t deliver this because:
- It has no independent quality gate
- It doesn’t know which content fits which venue
- It can hallucinate without flagging
- It doesn’t separate copyright-relevant material from public-domain
- It can produce 15 parallel languages, but not check itself on any of them
The 15-stage pipeline solves these one at a time, with the AI stages bounded by the deterministic ones.
The 15 stages
The numbering runs 0–13 then jumps to 15 — there is no stage 14. AI stages use Claude Haiku 3 (Haiku 4.5 for translation); the rest are SQL, n-gram analysis, TF-IDF, or rule-based.
Stage 0 — Ingestion (deterministic)
Connectors fetch from RSS/Atom feeds, REST JSON APIs, SDMX statistical endpoints, GeoJSON hazard feeds, and licensed sports/media providers. Round-robin scheduling, deduplication on (source_id, external_id), no AI yet. The raw item lands in PostgreSQL with its license type recorded.
Stage 1 — Fact extraction (Claude Haiku 3)
Each raw item is decomposed into discrete facts using a forced JSON schema: topic, actors, event, timeline, location, sector, context, significance, confidence. Outputs below confidence 0.1 are discarded; structured data items (financial time series, scoreboards) bypass this stage entirely.
Stage 2 — Topic clustering (Haiku 3)
Facts are pre-grouped by sector — that reduces the LLM’s search space — then the model clusters them into coherent topics. Returned fact IDs are validated against the batch; hallucinated IDs are rejected on the spot. Trivial groups (≤2 facts) skip the LLM and cluster automatically.
Stage 3 — Knowledge graph (Haiku 3)
Clusters are synthesised into Knowledge Objects with knowledge_type (trend / event / statistic / evergreen) and time_relevance (breaking / current / recent / evergreen). Both fields are validated against fixed enums. A 384-dimensional pgvector embedding is stored for later similarity work.
Stage 4 — Trend detection (deterministic SQL)
Each KO is scored on four weighted dimensions: source diversity (20%), geographic spread (25%), recency (30%), signage relevance (25%). Above the trend-strength threshold (default 0.3), a Trend record is created. No LLM, no hallucination surface.
Stage 5 — Geo-localisation (deterministic)
Keyword matching against a geography dictionary scores each KO for relevance to enabled channels. A Germany-specific channel scores 0.95 for German content, 0.5 for EU content. Below the 0.3 threshold, the KO is filtered out of that channel.
Stage 6 — Channel assignment (Haiku 3)
The LLM decides which channels a KO should run on, plus the framing angle for each (economic angle for a business channel, human-interest angle for lifestyle). Returned channel IDs are validated against enabled channels; invalid references are silently dropped.
Stage 7 — Content generation (Haiku 3)
The actual writing stage. Title ≤ 80 characters, body ≤ 300 characters for ticker / ≤ 500 for fullscreen. The system prompt is explicit: do not reference source articles, do not quote, do not reproduce source wording. The model writes from the extracted facts and the assigned angle, not from the source text.
Stage 8 — Legal distance check (deterministic n-gram)
The generated text is compared against the full source chain — content → KO → cluster → facts → raw item — using weighted n-gram overlap (3-grams 20%, 4-grams 30%, 5-grams 50%). Overlap ≥ 0.15 fails the check and the item is blocked from publication. This is a hard gate.
Stage 9 — Deduplication (deterministic TF-IDF)
Per channel, items are compared by cosine similarity over TF-IDF vectors. Anything above 0.85 is suppressed (lower-priority item drops out). No LLM — scikit-learn does the work.
Stage 10 — Quality scoring (Haiku 3, independent reviewer)
An AI stage that has never seen Stage 7’s output scores it on Clarity (25%), Readability (30%), Signage Score (30%), and Novelty (15%). Below 0.35, the item is suppressed. Scores are clamped to [0, 1]; unparseable values default to 0.5.
Stage 11 — Rate limiter (Venue Policies)
Deterministic SQL applies the venue’s content rules: hard-news cap, politics cap, minimum light-content percentage, topic cooldown, max topic repeats per hour. Priority boosts for light content (+0.10) and high-quality items (+0.10); penalty for over-represented sectors (-0.15).
Stage 12 — Formatter (rules)
Variant assignment by length: ticker (≤120 chars, 8s), card (≤300 chars, 12s), fullscreen (≤600 chars, 15s), or data_viz for structured data. Image matching runs a four-phase fallback: IDF-weighted tag matching, then category fallback, then channel default, then placeholder.
Stage 13 — Publisher (deterministic gate)
Five checks: title present, body present, legal_distance_pass = true, quality_score not null, variant assigned. Anything missing keeps the item in draft. On publish, dynamic TTL is set from time_relevance: 12 hours for breaking, 48 hours for current, 7 days for recent, 30 days for evergreen. A SourceTracking record locks in the full audit chain.
Stage 15 — Translation (Haiku 4.5, on demand)
Triggered when an API request arrives with ?lang=de (or any of the 15 supported languages: EN, DE, FR, ES, PT, IT, NL, PL, RU, ZH, JA, KO, AR, HI, TR). A subscription is created or reactivated; Stage 15 picks up queued items in batches of five. First batch can take up to 24 hours; after that, new published items translate immediately.
Where AI runs vs where it doesn’t
| Aspect | Single LLM prompt | 15-stage pipeline |
|---|---|---|
| Factual accuracy | Not guaranteed | Stage 1 confidence threshold; Stage 7 fact-bound prompt |
| Legal distance | Not enforced | Stage 8 n-gram check (hard gate at 0.15) |
| Venue relevance | Not enforced | Stages 5, 6, 11 |
| Multilingual | After-the-fact translation | Stage 15, on demand, Haiku 4.5 |
| Auditability | None | SourceTracking record at Stage 13 |
| Quality control | None | Stage 10 independent reviewer, suppress < 0.35 |
| Hallucination surface | Entire output | Bounded to 7 AI stages, all behind validation |
Seven AI stages, eight deterministic. The split is not academic — it’s why an n-gram check rather than another LLM enforces legal distance, and why deduplication is TF-IDF rather than embeddings only. Every place the AI could drift, something that can’t drift is watching.
Auditability isn’t a feature, it’s the spine
The SourceTracking record at Stage 13 links every published item to its source, raw item, fact IDs, cluster, and Knowledge Object. The chain reads in both directions: from a screen back to the original source, or from a source forward to every piece of content derived from it.
For operators in regulated industries — healthcare, finance, public infrastructure — that audit chain isn’t optional. It’s the answer to “where did this come from?” when somebody asks. For everyone else, it’s the answer to “why was this on the screen at 14:32?” when something on screen draws a complaint.
More on the legal frame: Legal distance and AI-generated content. On the failure modes when hallucination breaks through: When AI lies.
The scale this runs at
266 RSS sources. 20 channels in 5 layers (Global / Regional / National / Light / Venue). 15 languages on demand. ~11,600 published items in the corpus, ~1,371 extracted facts, 1,787 images on S3.
Per day, that means hundreds to thousands of new raw items pass through every stage, in parallel for every active venue profile, in every subscribed language. Without manual intervention.
For the system view: AI digital signage content generator.
Illustrative scenario: one feed item, 15 stages
How a regional news item becomes an independent 35-word hotel-screen text in five languages
Illustrative, not a customer reference.
Source: a regional feed reports the opening of a cultural centre in Bonn. The original article runs ~800 words with a programme-director quote and architect detail.
Stages 0–3 ingest, extract facts (location, date, programme highlights), and synthesise a Knowledge Object tagged event with time_relevance current. Stage 4 scores trend strength; Stage 5 routes it to German-language channels. Stage 6 assigns it to a Lifestyle channel for hotel venues with a “culture recommendation” angle.
Stage 7 generates a 35-word hotel-ready text from the facts — no source phrasing. Stage 8 confirms n-gram overlap is well below 0.15. Stages 9 and 10 confirm it isn’t a near-duplicate and scores 0.62 on quality. Stage 11 lets it through under the Hotel Lobby venue policy. Stages 12 and 13 set the card variant, attach an image via tag match, and publish with a 48-hour TTL.
Stage 15 fires when a screen in a multilingual hotel requests ?lang=fr — first request enrols French; within 24 hours the corpus is translated and from then on, new items hit the French feed within seconds.
End state: one 35-word hotel text in five languages, independently phrased, with a complete audit trail. Wall-clock time: minutes.
Screens that keep themselves fresh contboxx delivers licensed news and AI-generated content to your displays, fully formatted — multilingual, automatic, no editorial effort.
Frequently asked questions
Can I see which source was used for a specific displayed text?
Yes. The SourceTracking record links every published item to its source, raw item, extracted facts, cluster, and Knowledge Object, with timestamps at every stage and the score from every check. For follow-up questions — “where did this number come from?” — the audit log delivers the chain in seconds, not days of forensics.
How long does processing through all 15 stages take?
Seconds to a few minutes per item, depending on source length, target languages, and validation results. At scale, the pipeline runs thousands of items per hour without dropping per-item quality. Translation Stage 15 runs on demand: the first batch for a new language can take up to 24 hours, after that translations are effectively real-time.
What happens if a source goes offline?
The pipeline doesn’t depend on any single source. Ingestion is round-robin across 266 RSS feeds plus REST, SDMX, GeoJSON, sports, and media connectors. If one goes dark, cached published items continue to play under their TTL while other sources keep feeding the pipeline. In practice, a single source outage is invisible to the screen.
Can I add my own RSS sources?
Yes. Custom RSS feeds — industry publications, regional media, internal corporate feeds — are configured as additional sources and run through the same 15 stages. They get the same fact extraction, legal-distance check, quality gate, and SourceTracking record as the standard sources. Per-source license classification is preserved.
How is this different from summarisation?
A summary shortens an existing text. The copyright stays with the source author and there’s no legal distance from the original phrasing. The pipeline does something different: it extracts facts as a structured object, then writes an independent original text from those facts. That’s transformation, not summarisation — and the n-gram check at Stage 8 enforces it operationally, not just on paper.