The world doesn’t poll.
When a company gets acquired, it doesn’t wait for your cron job. When a cloud region degrades, it doesn’t care that your script checks the status page every five minutes. Things happen exactly once, at a moment nobody scheduled — and then the world spends hours or days repeating them: articles, updates, retries, reposts.
Software, meanwhile, has spent decades pretending otherwise. We poll. We scrape. We re-check pages that haven’t changed and re-process updates we’ve already handled, because our tools could only ask “anything new?” over and over — and could never be told “yes: this, now, once.”
Where the event bus ends
Inside our own systems, we solved this long ago. No engineer builds a payment flow that scrapes a bank’s website. We use events: typed, deduplicated, delivered as they’re verified. Stripe fires a webhook. Your code acts. Done.
But the moment software needs to know about the world outside its own database — a funding round, an outage, an insolvency, a filing — the event bus ends. What’s out there instead is a mess of channels: news that says everything forty times, status pages that stutter out five updates for one incident, APIs that each speak their own dialect. The information exists. The event doesn’t.
We think everything that happens deserves the same treatment as a payment.
The event layer for the real world
That’s Evinor: the event layer for the real world. You declare what matters — an acquisition touching your portfolio, an insolvency in your supply chain, an outage in your critical path — and when it actually happens, one clean, typed, corroborated event lands in your workflow. Whether it surfaced through a wire story, a filing, a status page, or an API, it arrives to you the same way: one happening, one schema, once.(If you want that sentence made concrete — the exact JSON that arrives, the signature on it, what “once” means mechanically — we’ve walked the payload field by field.)
No handshake required
And notice what’s missing from that sentence: a counterparty. You didn’t call anyone. Nobody issued you an API key, approved your access, or agreed on a payload format with you. The parties whose actions trigger your workflows don’t know your workflows exist. For as long as software has integrated with software, connection has meant a handshake — keys exchanged, schemas negotiated, maintained forever, once per pair. We think that’s backwards. You shouldn’t have to agree with each counterparty; you should only have to agree on what things mean — the types, the entities, the shape of a happening. Subscribe to the shape, and it doesn’t matter who acts or which channel carries it.
Pub/sub for reality
The subscription belongs to the receiver, entirely. You define what you care about; you set how corroborated an event must be before it’s allowed to act — nudge a Slack channel at one source, write to your CRM only when three agree. Trust stops living in the connection and starts living in the event, where you can actually inspect it.
Why this matters for agents
This matters more now than ever, because software is no longer just displaying information to humans who can shrug off noise. It’s acting. Agents write to CRMs, reroute orders, draft outreach, move money. An agent that acts on duplicated, unresolved, unverified inputs isn’t autonomous — it’s a liability with an API key.
The missing primitive
The internet gave documents a primitive, and messages, and names, and places. It never gave one to what just happened. That’s the primitive we’re building: canonical, typed events — so that anything that occurs can trigger anything that cares, once, the moment it’s real, with no introduction required.
Autonomy runs on facts. We’re building the pipe that delivers them.
The world doesn’t poll. Soon, neither will your software — and it won’t need a handshake, either.