Every time we classify an article, we start from nothing. We have the title, the first couple thousand characters of body, and the live category list from the target site. We do not have the categorizations of prior articles. We do not know what the author’s previous pieces were tagged as. We do not know which category has been overused this month, or which one the editors have been quietly steering away from.
This was not an oversight. It is the shape we wanted.
What stateless classification looks like
The job is small. An article comes in as a parsed document: title, excerpt, body. The category list comes in as a JSON array fetched from the live API. We score the article against each category, return the best match with a confidence number, and exit. The next time we run, we have no record of what we just decided.
A more “intelligent” system would remember. It would notice that we have been picking one category too often and rebalance. It would see that an article cites the same author as last week’s piece and lean toward continuity. It would learn the editor’s preferences and adjust over time.
We considered all of that. We chose not to do it.
The reasons it stays this way
Auditability is the first reason, and the most important one. Every classification we make is a function of the article and the current category list. Nothing else. If someone asks why a piece landed in Devotional and not Doctrinal, the answer is sitting in two places: the article itself and the category descriptions at the time. Both can be inspected, and the decision can be replayed. There is no learned bias, no quiet drift, no “well, the model has seen a lot of articles since then.” The reasoning is local.
Once you let memory in, that audit story falls apart. A classification can no longer be explained from inputs alone. You have to reconstruct the state of whatever store the classifier was reading from at the moment of decision, and you have to trust that store to have been correct. For a content site that runs for years, that store will accumulate errors, and the errors will compound silently.
The second reason is fairness across articles. Without memory, a guest contributor’s piece is judged the same way as the editor’s. A long-running series gets the same treatment as a one-off. No article borrows credibility from its neighbors, and no article inherits its neighbors’ miscategorizations. We have seen what happens in systems that quietly weight things by author or by source: the popular content gets more accurate routing, and the marginal content gets worse routing. We did not want that here.
The third reason is taxonomy honesty. If our classifier kept memory, it could paper over a bad taxonomy by using historical decisions to fake consistency. A category that has become incoherent over time would still get fed articles, because past decisions would suggest it had a clear identity. Without memory, an incoherent category produces low-confidence results immediately, and the editorial team finds out. The classifier becomes a kind of taxonomy stress test.
What we give up
Some of this is real loss.
We cannot honor a series. If an editor publishes part one of a four-part walkthrough and tags it Practical, parts two through four arrive at the classifier with no awareness of that decision. We pick a category from scratch each time, and sometimes we pick differently. The series ends up split across two categories on the live site. A reader following the thread has to click around to find the next piece.
We cannot detect editorial drift. If the site has been running heavy on commentary articles for six weeks and the editors would like to redirect, the classifier is no help. It cannot rebalance, because it does not know which categories have been getting attention. That kind of judgment lives entirely with the human editors, and we have learned not to pretend otherwise.
We cannot notice when a category should be retired. A category that hasn’t been used in nine months is a useful signal, but only if you have nine months of memory. Our system sees the category list fresh every run, treats every option as live, and has no opinion about which ones have gone cold. The retirement decision lives elsewhere.
These costs are real, and we have not solved them inside the classifier. They get handled by other parts of the system, or by people. That feels right to us. The classifier should be small and predictable. The judgments that depend on history should sit in places that are explicitly stateful, where the history is visible and editable.
The pattern this fits
We have ended up with a soft rule across the pipeline: stateless tools at the edges, stateful judgment in the center. The agents that touch a single article do one thing each, with no memory between articles. Coordinators and editorial reviews have access to history when they need it. The boundary between “needs to remember” and “should not remember” is drawn deliberately, and it is drawn at the place where a single decision becomes part of a longer story.
A classifier is a single decision. A taxonomy is a longer story. We try not to mix them up.
When we look at a year of categorizations now, the decisions are individually defensible and collectively imperfect. Some series got split. Some categories accumulated articles that did not quite fit. The fixes happened where they should have, in the taxonomy and in the editorial workflow, not in the classifier. The classifier kept its small, predictable job, and the larger system absorbed the rest.
That tradeoff has held up. The temptation to make the classifier smarter shows up every few months, usually after a frustrating misclassification. Every time, we trace the frustration back to a taxonomy problem, not a memory problem. The classifier was telling us the truth. We just did not want to hear it.