Watch a topic for new work and summarize what turns up

Somebody keeping up with a field wants the same thing every Monday: what came out last week that they have not already seen, and enough about each item to decide whether to open it. That is two job shapes joined, and the join is what this page is about. The first half is keeping an eye on sources and saying what changed: a fixed schedule, a fixed list of sources, and code working out which records are new. The second half is turning one piece of text into another: one call per new item, reading a title and an abstract and writing three sentences about it. This was the first page here to work two shapes at once, and it is the simplest of them: the two halves run in series, and the first decides how much of the job the second is asked to do. The weekly status report joins the same two shapes head on instead, and the tracker it sits beside joins a different pair. Here the job is two, and the two settle at different levels.

One rule holds the join together, and it is the reason the halves can meet at all: the citation is written by code, from the source record, and never by the model. The schema the model answers in has no field for a link, an author or a year, so there is nowhere for it to put one, and the line under each title in the digest is built from the record the summary was made from. A digest whose citations came out of a model is a digest nobody can trust at a glance, which defeats the point of having one.

Not in scope: choosing what to watch, following a reference to the next paper, or deciding when enough has been read. Nothing here reads a full text either; it reads what the source listed. And nothing here is a substitute for opening the work: the digest tells a person which two items are worth an hour, and they spend the hour.

Example run

A weekly schedule, fixed when the watch was set up.
The sources and the topic were chosen by a person, once,
and nothing in this run changes either

Walkthrough

The watch half is one function, and no model is anywhere near it:

def _select_new(
    sources: dict[str, tuple[Record, ...]], since: str, seen: set[str]
) -> tuple[list[Record], list[SourceReport], list[str]]:
    """The watch half, whole. No model, no judgment: a date comparison and a set difference.

    Returns the records to summarize, one report per source, and the titles that were dropped
    because a previous run already reported them.
    """
    new: list[Record] = []
    reports: list[SourceReport] = []
    repeats: list[str] = []
    for name in sorted(sources):
        records = sources[name]
        fresh = [r for r in records if r.date >= since]
        picked: list[Record] = []
        for record in fresh:
            key = title_key(record.title)
            if key in seen:
                repeats.append(record.title)
                continue
            seen.add(key)
            picked.append(record)
        new.extend(picked)
        reports.append(SourceReport(source=name, returned=len(records), fresh=len(fresh), new=len(picked)))
    return new, reports, repeats

Against the sample week, with the watch having last run on 09/15/2026, three sources list five records between them. Two are dated before the last run and are dropped. One is the peer-reviewed version of a preprint last week’s digest already carried: a different id, a different date and a different capitalization, the same work, and comparing normalized titles is what catches it. One source returns nothing at all, which the report keeps separate from returning nothing new, because a broken feed and a quiet week look identical in a digest that only lists items. Two records come out the other side.

This is the seam. _select_new decided which records exist as far as the rest of the run is concerned, and the read half never sees the other three. Everything downstream is a loop over that list: one call each, validated against the schema, one retry if the reply does not parse, and a record whose reply never validates is named in the digest rather than dropped from it.

The other side of the seam is the citation, which is the one thing the model is structurally unable to write:

def _cite(record: Record) -> str:
    """The citation line, built from the record. The model never writes one and has no field to
    write it in; this is the only function on this path that produces one."""
    return f"{record.authors} ({record.date[:4]}). {record.title}. {record.venue}. {record.url}"

run calls that for every item it keeps, with the record the summary was made from. A model that writes a link into its prose anyway is flagged by name in the digest rather than published quietly, because a link inside a digest entry reads as a citation and the citation here is _cite’s alone. A model that writes a plausible wrong author and year into a sentence is not caught by anything, and the line under the title is still the record’s; that limit is in the failure modes below.

The run ends with a digest holding two items, each with three sentences and a citation, one already-reported item named, one silent source named, and a history of three titles for next week’s run to compare against.

What it costs

Illustrative, not measured: no result file exists for this technique yet, so every number below is a worked example. See docs/EVALS.md for how a real run is recorded and scored.

The unit is per week, and the number to watch is not the token count. It is how many of the records the sources listed actually reached a model: two of five here, and at a real source list it is a much smaller fraction. That ratio is set entirely by the half that calls no model.

How it fails

What to measure

Score the two halves separately, because they fail separately and a single number over the digest hides which one moved. For the watch half, take a week a person has already gone through by hand and compare: every item the person found that the watch missed, and every item the watch reported that the person had already seen. Those are different mistakes with different costs. A missed item is the expensive one, because nothing later in the pipeline can recover it; a duplicate costs a reader three seconds.

For the read half, the labeled set is the reader’s own judgment after opening the full text: for each item, would a person who read it write the same three sentences. Ten to fifteen items is enough to see the common failure, which is usually a condition dropped rather than a fact invented. Score that against the summary, not against the abstract: an abstract the model copied faithfully can still be a bad description of the work, and the digest’s job is to be a good one.

No result file exists for this recipe, so it claims no score. What is above is the method for building one, and the split is the part worth keeping.

Variations

• Replace the fixture records with whatever a real source returns. The watch half is the only part that changes, and the seam is the reason: everything downstream takes a record, not a feed.
• Compare on a stable identifier instead of a normalized title wherever the sources publish one, and keep the title comparison as a second pass for the sources that do not.
• Send the digest to several people with different topics by running the same code once per topic with its own source list and its own history. Nothing in either half is shared between runs except the code.
• Add a checking pass at level 3 only once real weeks show summaries a reader disagrees with often enough to be worth a second call. A check over three sentences written from an abstract can only catch what the abstract also says, so it is a smaller gain here than on a page that writes from a full document.
• The same watch half, over a different mechanism, is the nightly monitor: that one diffs a page against last night’s copy, this one takes the difference between two result sets. Same shape, same level, different arithmetic.

Design choices