Think about what it takes, today, for two automations owned by different organizations to react to each other.
Someone makes a phone call. API keys get issued. A payload format gets agreed on, documented, and inevitably violated. Both sides build, both sides test, and from that day on, both sides maintain a bilateral integration that breaks whenever either party changes anything.
Call it the handshake. Every pair of workflows that wants to coordinate needs one, and the cost compounds: connect ten organizations and you’re maintaining up to forty-five separate agreements. But the deeper cost isn’t effort. The handshake defines the boundary of what’s possible: your automation can only react to parties it already knows.
Here’s the question this essay is about:
What if workflows didn’t subscribe to each other at all? What if they subscribed to reality?
Let’s be precise immediately, because the precision is the point: reality doesn’t publish events. A happening surfaces as forty articles, a filing, a status-page update — and someone has to reconcile all of that into one entity, one happening, one structured record. What you subscribe to is a canonical account of reality, not reality itself.
Which yields the honest form of the thesis — the one sentence this essay exists to unpack: workflows should subscribe to meaning, not to producers. Every event bus ever built standardizes transport and leaves meaning bilateral; invert that — standardize the meaning: the types, the entities, what counts as one happening — and the counterparties stop mattering.
One thesis, then — subscribe to meaning, and coordination between strangers, parties with no bilateral relationship, simply falls out; some of it already works today — and one consequence that gives it stakes: strangers aren’t the edge case, they’re almost everyone. Behind both sits an observation we’ll return to at the end: the internet standardized documents, then messages, then names. It never standardized happenings.
The handshake you never made
Start with a thing that already works, and pause on how odd it is.
A company you’ve never contacted announces an acquisition. Within minutes, your workflow fires — the deal team is pinged, the tracker updated, the outreach drafted. The acquirer issued you no API key. They agreed on no payload format. They don’t know your workflow exists. There was no handshake, and yet their action triggered your automation, reliably, in a format your tools could parse without guessing.
What replaced the handshake? Two shared things, neither of which required the two parties to meet.
A shared type system. You didn’t subscribe to a sender; you subscribed to a shape — type: Acquisition, entity in your watchlist. Any happening that fits the shape reaches every subscriber of the shape, no matter who caused it or which channel carried it.
Shared keys. Canonical entities mean your workflow and a stranger’s workflow key on the same stable ID for the same company — even though one encountered it as “DBX” and the other as “Databricks, Inc.” You’ve never met, but you already agree on what you’re talking about. That agreement is the part of every integration kickoff that takes the longest, and here it’s inherited.
So workflow A never messages workflow B. Organization A does something in the world — acquires, files, raises, ships, breaks — and every workflow subscribed to that shape reacts. Biology has a one-word name for this pattern — stigmergy: coordination through a shared, readable environment rather than direct communication, the way ants coordinate through pheromone trails without any ant knowing another ant’s API. An event layer does the same for software — with one honest difference: the ants’ environment is self-describing, and ours isn’t. The world needs canonicalizing before it can be a coordination surface, and that work — resolving, deduplicating, typing — is where all the difficulty lives.
Almost everyone is a stranger
Here’s the part the handshake model gets quietly, catastrophically wrong: it assumes the parties that matter to you are parties you can meet.
Count the organizations whose actions could genuinely affect your business this quarter. Your direct partners — the ones you could plausibly handshake with — are a dozen, maybe fifty. But the full set? Every company in your portfolio’s competitive orbit. Every supplier of your suppliers. Every customer of your competitors. The regulator you’ve never interacted with. It’s thousands of parties, and the distribution has a brutal shape: a tiny head of known relationships worth a kickoff call, and a long tail of strangers for whom no bilateral integration could ever justify its cost. Nobody sets up a handshake to learn that a company four steps removed in their supply chain filed for insolvency. The handshake economy prices the long tail out of existence — so software simply never reacts to it, and humans find out from newsletters, late.
A shape subscription prices the tail at one line. Insolvency(entity ∈ supply-chain graph)covers the supplier’s supplier’s supplier exactly as cheaply as it covers your biggest partner.
And there’s a stranger even the most diligent handshaker can never reach: the future. You cannot exchange API keys with a company that doesn’t exist yet. But the startup that launches next quarter into your portfolio’s space is already covered by the shape you subscribed to today.
That’s why “stranger workflows” is the right name for this, and not just a cute one: strangerhood was unreachable before for a precise reason — reaching a party used to require a producer to subscribe to, and strangers, by definition, aren’t offering one.
No, this is not Kafka
Infrastructure people will have been muttering for several paragraphs: this is pub/sub. This is Kafka. This is EventBridge with better marketing.
The distinction is the thesis from the top — meaning versus transport — so let’s make it concrete.
Every event bus you’ve used requires agreement on the producer. Someone provisions the topic. The producer decides what gets published, in what schema, and who may connect. Subscribing to a Kafka topic is a handshake — with the topic’s owner. The bus moves messages between parties that have, one way or another, already met. Kafka standardizes the pipe; meaning remains bilateral.
This layer requires agreement only on the ontology. Nobody provisions the topic Acquisition. There is no producer to be introduced to, because the “producer” is whatever actually happened, observed through whichever channels happened to carry it. You subscribe to Acquisition(entity ∈ my watchlist) — regardless of who acted, who reported it, or whether either has ever heard of you.
One fairness note, because sharp readers will raise it: we haven’t eliminated ownership, we’ve moved it. In Kafka, each producer owns its topic; here, whoever maintains the ontology and the canonicalization pipeline owns the definitions — when an Acquisition “exists,” what its fields mean, which entity IDs are canonical. That’s a concentration of a different kind, and it creates obligations rather than dissolving them. We’ll come back to it, because it’s the hardest problem in this whole proposal and it deserves more than a nod.
Strangers can’t trust each other. They don’t have to.
The obvious objection: handshakes exist because they establish trust. If any stranger’s action can trigger my workflow, what stops garbage from triggering it?
Recall what we admitted up front: events here are made, not transmitted. And the making has two distinct parts. One part is reconciliation — deciding that “DBX” and “Databricks, Inc.” are one entity, that forty tellings are one happening. That work converges on a fact. The other part is genuine interpretation — deciding what type this happening is, and how sure to be. That work carries judgment, and an honest layer must say so in the payload itself.
Which is exactly what the confidence and corroboration fields are: how sure, how many independent sources, which ones. They aren’t a bonus feature; they’re the schema telling the truth about its own epistemology. And look at what they enable: the receiver doesn’t have to trust the sender, because the receiver trusts the event — to a degree the receiver chooses. A Slack nudge can fire on a single source. A CRM write can demand three. An autonomous agent that spends money can require a regulatory filing. Trust isn’t negotiated bilaterally in a kickoff call; it’s declared unilaterally, per subscription, by the party bearing the risk. (For the concrete version of this paragraph — the exact fields, the signature, the delivery guarantees — see Anatomy of an Evinor event.)
That inversion is the whole trick. Handshake integrations put trust at the connection — establish it once, then hope. Receiver-gated events put it at the event, evaluated fresh, every time. The question stops being “do I trust this counterparty?” and becomes “do I trust this event enough for this action?” — which was always the real question. Strangers stay strangers. The workflow still fires.
Where this goes
Today, an organization “publishes” to this event space the only way reality allows: by doing something publicly observable, which the canonicalization layer reads from the channels that carried it — wire stories, filings, status pages.
But to the engine, sources are adapters, and there’s no architectural reason an adapter must be a news wire. A happening could enter as a structured report from a party close to it — and come out the other side the way everything does: typed, canonically resolved, corroboration counted, gated by each receiver’s own bar. The subscriber’s side doesn’t change at all. That’s the trajectory: from strangers reacting to each other’s public actions, toward strangers coordinating through published, typed events. The trust model needs no reinvention for that future; it’s the same model, which is how you know the foundation is right.
The hard problem is governance, and we’d rather say so
Three objections deserve more than acknowledgment.
Schemas are power — and edge cases are politics. “Everyone agrees on Acquisition” sounds clean until you meet the real world. Is an acquihire an Acquisition? A reverse merger? A 51% stake? An asset purchase out of bankruptcy? A hostile bid that hasn’t closed? Each answer changes which workflows fire and which stay silent — which means ontology decisions are governance decisions wearing a schema’s clothes. This is precisely where the interpretation half of the pipeline lives, and anyone who tells you these are implementation details is selling something. Our working stance: types are versioned and stable (a thousand workflows building on a schema is a promise, not a feature); edge-case policies are documented and public, so a subscriber can know in advance whether an acquihire will fire their rule; and the boundary cases get explicit subtypes rather than silent judgment calls, so the ontology’s opinions are inspectable instead of embedded. Longer term, an ontology like this only deserves broad adoption if its evolution stops being one company’s private decision — a standards-like process is the destination, and we say that out loud precisely so we can be held to it. We concentrated the ownership; the obligations that come with that concentration are ours until they’re shared.
And why would anyone converge on ours? The sharpest version of the governance question isn’t “who governs the schema” — it’s “why this schema at all.” A shared ontology is a coordination problem, and coordination problems don’t resolve because a vendor asks nicely. Our answer: convergence is not a precondition; it’s a possible consequence. A subscriber gets full value on day one with zero ecosystem adoption — resolved entities, deduplicated happenings, receiver-gated delivery — because what you’re buying is canonicalized events, not access to a network. Nobody has to believe in the standard for the subscription to pay for itself. If a shared ontology does emerge, it will emerge the way de facto standards always have: by accumulation, not argument — enough workflows keyed to the same types and entity IDs that the switching cost points one way. And if competing ontologies run in parallel for a while, fine; formats competed before the web settled. Requiring convergence would be a bet. Not requiring it is the strategy.
Strangers can stampede. When automations react to events that other parties’ actions produce, feedback loops become possible — finance learned this the expensive way. This is precisely why receiver-side gating isn’t an optional nicety. Corroboration thresholds, confidence gates, and one-happening-one-event deduplication are dampeners built into the medium itself. A coordination layer for strangers has to make not overreacting the default — and dedup is the first line of that defense: whatever echoes, your workflow fires once.
A gap, not a trophy
Now the observation we flagged at the start.
The internet’s biggest unlocks have each been a shared primitive that removed a bilateral agreement. Hyperlinks standardized how we reference documents — cite any page without asking. Email standardized messages — reach any inbox without a pact. DNS standardized names — refer to anything without a phone call. Documents, then messages, then names: each time, one shared standard replaced N² arrangements, and connections came to exist that would never have justified a phone call.
Happenings never got their turn. What just happened still travels as prose and echo, still gets integrated bilaterally, feed by feed, handshake by handshake — which is why the long tail of strangers has stayed dark. That’s an observation about a gap, not a boast about filling it. The world has grown a great deal more automated since those primitives were laid down, and it doesn’t seem strange to ask whether the set is finished. We’d put the question no more grandly than this: why shouldn’t happenings be next?
And honesty requires one more distinction. The primitives above are protocols; Evinor, today, is a product — a service that canonicalizes the world and emits events, with all the ownership that implies. Those aren’t the same thing, and pretending otherwise would be the fastest way to lose the readers we most want. But primitives are never declared — they’re ratified. The web was one strange server at CERN before adoption made it infrastructure; nothing becomes a primitive by calling itself one. So our claim is deliberately smaller: the gap is real, subscribing to meaning instead of producers is a credible way to fill it, and we’re an early, opinionated attempt — product first, and protocol if we earn it.
What we’re sure of is the smaller thing that already works: a subscription to a shape is one line, it reaches the strangers no handshake could ever be worth — including the ones that don’t exist yet — and when something actually happens, your workflow fires. Once.
The handshake had a good run. The world doesn’t poll — and it no longer needs to be introduced, either.