The more that models and agents read on your behalf, the more it matters what they're allowed to read, and whether you can move it. RSS looks dated next to an algorithmic feed. But an open, portable, permissioned feed layer is exactly the substrate an agent needs to act on your behalf without you losing control of what it sees. As LLMs slot themselves between you and information, owning that layer stops being nostalgia and starts being leverage.
That's the argument. The rest of this is the case for it, and an honest accounting of what it costs you.
The layer that's quietly becoming load-bearing
For most of its life, RSS has been a distribution format: a standard way for a publisher to say "here are my latest items," and for a reader to pull them into one place. That was useful and unglamorous. Closed apps out-competed it not on the format but on the experience — an algorithm that decides, ranks, and refills the feed so you never have to.
Then LLMs arrived and changed what sits between a person and their information. Increasingly it isn't a human scrolling a timeline; it's a model summarizing, filtering, and answering questions over a body of sources. When software reads for you, the format of the source starts to matter again — not for how it looks, but for whether a program can reliably parse it, move it, and be scoped to it.
RSS turns out to be well-suited to that job. An item is structured: a title, a link, a timestamp, a body, a source. A subscription list is portable: OPML is a plain file you can export from one reader and import into another. And the whole set is inspectable: you can see exactly which sources are in it, because you chose them. None of that is true of a closed algorithmic feed, where the ranking is opaque, the source set is unstated, and there is no file to take with you.
What an agent can actually do with a permissioned feed layer
The abstract case is easy to nod along to. The concrete case is where it earns its keep. Give an agent scoped access to a clean feed layer and a defined set of actions, and the work it can do is specific:
- Triage the queue. Read the day's unread items, flag the three worth your attention, and
downranka source that's been noisy for a week — the same canonical actions you'd take by hand, applied at machine speed. - Answer across sources. "What did my security feeds say about this CVE?" is a query an agent can run over the items you've actually subscribed to, not the open web, so the answer is grounded in sources you chose and trust.
- Watch and summarize. Keep a standing eye on a set of feeds and produce a digest, without you opening the app — because the items are structured, the summary can cite the specific entry it came from.
The connective tissue here is MCP — the Model Context Protocol — which gives an agent a defined interface to your feeds: a set of tools it can call, scoped to what you permit, using the same action vocabulary (save, dismiss, downrank, open, archive) as the app you use by hand. That last point matters. The agent isn't screen-scraping a UI or guessing at a private API; it's calling the same operations you call, with permission you grant, over data you can inspect. In tribb that layer is bring-your-own-key, and your reading isn't training data — the agent acts on your feeds, but your feeds don't quietly become someone's corpus.
Portability is the part you only value once you need it
Portability sounds like a checkbox until the day you want to leave. A closed feed keeps its value inside the app: the ranking, the follows, the history live on a server you don't control, and switching means starting over. An open feed layer keeps its value in a file. OPML — an outline of every source you follow — exports from one reader and imports into the next, and your subscriptions survive the move intact.
That matters more in an LLM world, not less. If you're going to hand an agent access to what you read, you want the thing it reads to be yours: exportable, forkable, not locked to one vendor's model or one company's roadmap. Portability is what keeps "your agent reads your feeds" from collapsing into "some platform's agent reads the feeds that platform lets you have." The file is the guarantee.
The tradeoffs, named plainly
An open feed layer asks more of you than a closed app does, and it would be dishonest to pretend otherwise.
You carry the curation. A closed algorithmic feed does the work of deciding what you see; that's the whole pitch, and for many people it's a good one. Owning your feed layer means you assemble it — you find sources, you add them, you downrank the noisy ones. There is no engagement algorithm quietly refilling the well. An agent can help triage what's already in the layer, but it can't want things on your behalf; the taste is yours to supply.
Adoption is patchy. RSS depends on publishers exposing a feed, and not all of them do. Some sites dropped their feeds; some expose one that's truncated to a summary; some never had one. A reader can work around this — full-text extraction, newsletter inboxes, botFetch for the awkward cases — but the underlying reality is that the open layer's coverage is only as complete as publishers make it, and that's uneven.
Structured beats slick, until it doesn't. RSS gives you clean, parseable items and no recommendation magic. That's the right trade when you want an agent to act on inspectable data. It's the wrong trade if what you actually wanted was to be handed a bottomless, effortless stream. Be honest with yourself about which one you're after.
None of these are fatal. They're the price of a feed layer you can inspect, move, and permission — and that price is worth naming up front, because a reader who's told the cost trusts the upside.
Where this leaves us
The instinct is to assume that as models get better at reading for us, the plumbing underneath matters less. It's the reverse. The more of your reading an agent mediates, the more it matters that the layer it reads is one you can see into, move, and scope. RSS, OPML, and MCP aren't a nostalgic throwback in the age of LLMs. They're the boring, durable substrate that keeps the agent working for you instead of the other way around — and that's worth carrying the curation for.