The Zero-Byte Story: Where a Chess Report Vanishes Between Board and Reader

Two seventeen in the morning. A table is open on the screen, and inside the table is a large empty space. At the top it says: domain — chess. Below that, one blank field after another: article title — N/A; source — N/A; one-sentence summary — N/A; information points — none; entities involved — none. And under those empty boxes, a line the system added by itself: “Ready for analysis.”

The chess was identified correctly. Everything else fell out along the way — the headline, the players, the event, the date, and the sentence the whole desk had been sitting there for.

In 2026 in Riyadh I filled forty pages on Viswanathan Anand’s endgames and learned there how to listen to the silence between moves. That night I understood there are two kinds of silence. One sits in the hall after a player’s clock stops, and it tells you something. The other sits in a server and calls itself preparation. The first is information. The second is just empty space.

In 2026 a chess story passes through four pairs of hands. The venue — players, arbiters, press officers, the federation release. The capture — result tables, live boards, crosstables, photographs of scoresheets. The deconstruction — title, information points, entity list, time-sensitivity. The publication. Between each pair of hands sits a number: an HTTP status, a response byte count, a token count, a publish timestamp. When a story goes missing, it goes missing between those numbers, and by the time anyone notices, the next deadline has already arrived.

Chess is unusually exposed here. The sport’s most reliable data lives in tables, not paragraphs — FIDE rating lists, tournament crosstables, live rating feeds. Pulling a story out of a table requires a pipeline that can read tables; a pipeline that only reads prose goes quiet in front of one. The second difficulty is the live board: most organisers embed it as a JavaScript widget, and a static fetch returns an empty container. The third is the outlet: a large media house keeps chess behind a paywall, and the fetcher retrieves the headline but not the body. The fourth is video. Chess coverage now lives largely on stream, where the content is audio, not text — and where the transcript has been dropped, there is nothing left to read.

This pattern — domain label populated, everything else blank — is not a coincidence. Every time I have seen this signature, the fault sat not in the domain classifier but in the content-fetch or parsing step immediately below it. The system recognised the subject; the body was never ingested.

The report lists six candidate causes, each with a verification step attached.

Paywall or login gate — medium plausibility. Title and lede arrive, the body is blocked, the extractor returns null. Check the raw HTTP response length and status code.

Image-only or video-embedded content — medium. The text extractor found no machine-readable paragraphs. Check whether an OCR or transcript fallback exists.

JavaScript-rendered page — medium to high, and the most consistently overlooked. Re-fetch with headless rendering.

A non-article input — a results index, a score table, a social post. There is no narrative structure to deconstruct, so the prompt returns exactly this null shape. Check the input MIME type and DOM root.

Upstream truncation — low to medium. The payload was cut between the two stages. Check the token-limit log.

And the last one: genuine operator error, an actually empty submission. Unlikely, not impossible.

Re-running the first stage without settling which of these six applies is wasted labour. The real decision is a single question: did the fetcher lose the story, or did the prompt? If the ingestion log shows a successful fetch with a substantive body, the fault is in deconstruction — fix the prompt or the model, leave the fetcher alone. If the fetch itself failed, re-running will reproduce this identical null output. This is the one triage question the whole exercise depends on.

An analysis built on zero input is not a crisis in itself, provided nobody passes it on. The crisis is that the document looks finished — eight sections, a dozen tables, thirteen glossary entries, a clean disclaimer at the bottom. The next stage down the line can reasonably read it as complete.

The report rates exactly this as the top risk: an analysis containing no facts reaching publication would damage not chess but the credibility of the newsroom that ran it. The second risk is the quiet propagation of the same empty payload. The third is pressure — someone asking the desk to “produce something anyway.” The report is firm: from an empty input there are exactly two acceptable outputs, a null report or a request for re-extraction. The third option, inventing a story from inference, is not an option at all.

The fix is in the same document and it is cheap. Put a schema check between the two stages: if the information-point array is empty and the title reads N/A, the payload does not move. That single condition likely closes this entire class of failure.

And build the test suite, two cases. A known-good chess article that must yield a minimum number of information points, and this empty payload, which must be rejected at the gate. This null payload is a free, real-world regression test, and no engineering team gets a better gift than that.

One further suggestion, past the report. Fix the minimum viable input before re-running: title and source name, publication date, three to five information points each carrying its own attribution, entities in three buckets — players, events, organisations — time control and format, every figure in the source preserved verbatim, an over-the-board or online tag on every result, and the time-sensitivity and source-quality fields actually filled. With those seven things, an eight-section analysis can stand on real ground.

The industry has settled on an easy opinion about this kind of failure — the model is weak, the prompt was wrong, AI cannot be trusted. That diagnosis is convenient, because it protects the part of the chain where the fault actually lives. In twenty years of watching newsrooms I have seen that intake is the least examined piece of the operation. Nobody asks what the fetch status code was. Nobody records that the title came back but the body was two hundred bytes long. The moment we separated data-writing from journalism and called it plumbing, the route by which stories disappear opened up. Brooklyn froze the final, but the notebook kept breathing — and that night too the work was done not by a script but by the man sitting in front of an empty screen.

The second point matters more for chess specifically. The centre of gravity of this sport’s coverage has shifted steadily towards formats a text pipeline cannot read — live boards, streams, reaction video, rating feeds. We moved the reader there and left the pipeline where it stood a decade ago. Coverage happening on video is invisible to a text system, and invisibility has been quietly mistaken for there being no news.

The third point is a habit of mine. I trust the pause more than the punch line. What the system did was also a pause — it identified chess, stopped, and declared itself ready. Treating empty space as readiness is the real error in this whole affair, and it is not an AI error. It is the human habit of reading any system’s output as an approval.

The notebook I opened after that night had no story in it. It had one question: if the next report comes back the same way — subject correct, everything else blank — will we recognise it? The most useful media metric of 2026 is not a rating. It is a byte count. The day we read fetch logs with the seriousness we give a scoresheet is the day fewer stories go missing.

At Chennai in 2026 Gukesh scored 9/11 on board one, and that week I took my eyes off the medal table to watch the parents standing in the concourse. Chennai gave me two bronzes and one unfinished sentence. This time the unfinished sentence belonged to a server — and finishing it is still the job of the person at the screen, not the system that declared itself ready.