The Engine is the reusable platform underneath every app. One clean, deduplicated stream of genuinely new content, from any source. Point it at a live source like Bluesky, a feed-based RSS or JSON feed, or a feed-less HTML page we diff, and it auto-detects the format and normalizes the rest. There is no curated source list, just an engine built to handle whatever you point it at. Here is what runs under the hood.
We speak the open web's real protocols natively: ATProto and Jetstream, RSS, Atom and JSON feeds, WebSocket streams, SSE endpoints. Those carry every kind of source, whether it's an always-on push source, a feed we poll, or a feed-less HTML page we diff. Each source has a purpose-built connector that normalizes into one shared event shape.
We speak ATProto natively. Bluesky's Jetstream is the primary source: no DAG-CBOR, no CAR decoding, no ceremony. Any app built on the AT Protocol flows through the same connector.
Universal parsing across RSS 2.0, Atom 1.0, and JSON Feed, polled on a polite adaptive schedule. Hot feeds get checked often; quiet ones back off. You never see the same item twice.
Plenty of the web's most valuable pages have no feed and no API at all. We extract the main content, fingerprint it, and surface genuinely new content, so the sources that matter most aren't the ones you miss.
One-way server push over plain HTTP. Reconnects resume exactly where you left off, no gaps. Wikimedia EventStreams is wired in by default. Point us at any SSE endpoint and it flows.
Bidirectional streaming from any WebSocket-based API. Mastodon instances, financial data streams, live dashboards. If it speaks WebSockets, we can listen. Backfill polling closes any gaps a disconnect leaves.
Add an entire domain and we'll crawl it politely, learn its shape, and surface genuinely-new content across every page as one stream.
Build straight on the raw feed. Subscribe to the filtered, normalized stream over plain HTTPS and ship whatever you want on top, no app in the middle.
Every source, whatever its shape, travels the same five steps into one stream.
{
"source_type": "html",
"url": "https://example.org/notice/142",
"title": "Procurement notice #142",
"published_at": "2026-07-02T14:03:00Z",
"content_hash": "e91a..."
}The Engine is built to keep running unattended, without dropping a thing.
A hung or failing source never delays or blocks any other.
Quiet sources are checked less, busy ones more, without you tuning a thing.
A restart or a dropped connection picks up exactly where it left off.
Push, feed, or diffed HTML, the event you receive looks the same.
Every source ends up in the same stream. Here is what actually happens for each kind.
A push protocol delivers an event the moment it happens, over Bluesky's firehose, an SSE stream, or a WebSocket.
An RSS, Atom, or JSON feed you are polling gets a new entry.
A page with no feed changes.
The same normalized event reaches you through whichever transport fits, from a raw HTTP stream you subscribe to in one call to the chat and infrastructure your team already runs.
Every event is pushed to your endpoint as JSON, HMAC-signed so you can verify it, with automatic retries on failure. This is the developer-native path.
Open a live server-sent stream with a single HTTP request, filter to the slice you want, and resume from a cursor after any disconnect with no gaps.
Matches land straight in the channels your team watches. Route any stream into Slack, Microsoft Teams, and Discord without building a bot.
Write events onto Kafka and SQS-style queues so they flow directly into your own pipelines, workers, and data stores at your own pace.
Connect the stream into the products and platforms you already run, so new content shows up where your workflows live without glue code.
Every source you add flows through these six systems, then out as one clean stream you can build on. See how the same care extends to security and trust.