About
Data is not
the hard part.
The hard part is what comes after: turning files, feeds, and documents into structured representations that smaller, specialized models can process — and that larger models can reason about without reconstructing the world from scratch on every call.
The problem
Everyone is sending raw data to the most expensive model available.
The default architecture for most AI-powered products looks the same: collect files or feeds, send them directly to a frontier model, pay for the output. It works well enough to ship. It doesn't work well enough to scale — and it skips the step that would make the model dramatically more useful.
Embedding, extraction, classification, deduplication, clustering — these are not large model problems. They're small model problems. Fast, cheap, purpose-built models do this work better than a general-purpose frontier model does, and they do it at a fraction of the cost. The frontier model's job is to reason about structure, not to construct it from scratch on every call.
Polari is that pre-processing layer. Bring your data — documents, feeds, files, records — and the pipeline returns structured representations: entities, embeddings, clusters, relationship graphs. The large model gets clean input. You get results that are faster, cheaper, and more consistent than if you'd skipped straight to the expensive step.
The ecosystem
Five products. One pipeline underneath.
The reference implementation. A news reader built entirely on the Polari pipeline — articles arrive as raw text, the pipeline processes them into structured clusters, and what surfaces to the reader is organized by meaning rather than recency. Two years in production, real users. It's how we know the architecture works before we ask anyone else to build on it.
LiveThe pipeline, opened as an API. Send documents, feeds, or files. Get back embeddings, extracted entities, semantic clusters, sentiment scores, and relationship graphs — structured representations that a large model can reason about directly, or that your application can query without involving a model at all. The processing runs on purpose-built small models. You pay for the output, not the overhead.
LiveA live rendering of the intelligence layer's relationship graph — entities, stories, and the connections between them, navigable in three dimensions. Not a dashboard. A window into the shape of what's being reported right now, and how the pieces fit together.
LiveThe same pipeline, positioned as a grounding layer for enterprise LLM deployments. A language model trained on last year's world reasons poorly about this one. Atlas delivers continuously updated, typed, relational intelligence — public world state and your own processed documents, unified in the same schema — directly into your inference context. The model stops reconstructing reality from frozen training data and starts reasoning from current ground truth.
Coming soonA delivery standard for structured intelligence payloads — transport-agnostic by design. The same OSP payload reaches a Slack channel, an enterprise inference pipeline, a mobile application, or an e-ink device on a four-day battery over cellular. The computation lives at the gateway. The endpoint renders what it's told. Cheap hardware, any network, cloud intelligence. The protocol is open because infrastructure standards shouldn't have owners.
In developmentHow we think
A few things we've decided not to compromise on.
Small models do most of the work.
Embedding, extraction, classification, clustering — none of this requires a frontier model. Purpose-built small models are faster, cheaper, and more consistent for these tasks. We use them. The large model gets the structured result, which is what it's actually good at reasoning about.
Structure is the product.
Raw data is not useful. A well-structured representation of that data — entities extracted, relationships mapped, similar records clustered — is something a model or an application can act on directly. We treat structure as the deliverable, not a side effect.
The pipeline doesn't care what the data is.
We built this on news because it's a hard, high-volume test case. But the architecture — ingest, filter, embed, extract, cluster, graph — applies to documents, records, research, communications, or any corpus where the relationships between things matter as much as the things themselves.
Grounding is not retrieval.
Handing a model a pile of retrieved documents is not the same as giving it a structured world model. Retrieval delivers text. Grounding delivers typed entities, resolved relationships, narrative state, confidence, and explicit markers for what remains uncertain. The difference shows up in answer quality. We build for the latter.
Intelligence should reach any endpoint.
The assumption that every AI endpoint is a well-connected device with abundant compute is wrong outside a narrow set of environments. OSP is designed so the gateway holds the intelligence and the endpoint renders what it can — from an analyst's workstation to a ruggedized field device on a cellular connection. Reach is a design requirement, not an afterthought.
Infrastructure compounds. Products deprecate.
Every product we ship runs on the same core pipeline. Improvements made for Digestr go into the API. API improvements make Atlas more capable. Atlas enriches the annotation corpus that makes the pipeline smarter over time. We invest in the layer because the layer is what lasts — and because a better pipeline makes every product built on top of it better automatically.
Contact
Get in touch
For API access, partnerships, or to talk through what you're building.