How a flock of organizations can “vibe” each other on the open web with no one in charge
A murmuration -that vast, shape-shifting flock of starlings wheeling over a winter field at dusk- has no lead bird, no server, no committee. Each starling simply reads its nearest neighbors and adjusts. Out of that purely local, permissionless reading comes coordination of breathtaking complexity, with no one in charge.
That is the protocol I want for organizations, regardless of size, budget and technological capacity.
The aim is small and stubborn. Let an organization publish the handful of things that actually define it- who it is, where located, what it offers and needs, who it’s tied to- once, at a URL it controls, in a shape any other entity (human or machine) can read. Publish it the way you’d publish a blog post: out in the open, owned by you, syndicated by anyone, captured by no one. Not a platform everyone has to log into, but a way for organizations to read each other directly, so that the coherence is emergent rather than administered.
The good news is that none of this needs inventing. The parts already exist, and have for twenty years. I’m not building a new platform; I’m assembling standing ones:
- The stable profile is a plain JSON file at the organization’s own URL, typed with schema.org so a machine knows what it’s looking at.
- The live layer is RSS: a new land offer, a want fulfilled, a seasonal event, flowing out the same feed nearly every CMS already emits.
- The part that makes the live side honest is RSS Cloud, which turns the feed from polling into push, so a 72-hour offer propagates in seconds instead of waiting on somebody’s timer.
My own daily reading already runs on this stack, with Dave Winer’s FeedLand at the head of it. I’m building on the standard because the standard is the thing that has outlasted everything stacked on top of it. This is what Really Simple buys you: nothing to depend on but the web itself.
A word on the name, since it invites the question. There is a project called Murmurations : a small, volunteer-run index for exactly this kind of profile, and a good one. I use it. But I want to be precise about its role, because the whole sovereignty of the thing turns on it: Murmurations is an optional discovery layer: a place your profile can be found, not a place it has to live. The canonical copy stays at your URL. Register with that index, with three indexes, or with none and just hand out the link; the data and the feed don’t care. If every index went quiet tomorrow, every profile would still resolve and every feed would still flow. I’m leaning on the metaphor more than the product. The flock is the point; an index is just one pair of binoculars.
There’s a posture underneath all this worth naming, because it’s why I’d rather build on bare standards than on anyone’s platform. The organizations are the Masters here; the software, including the AI agents I work with, are the Emissaries (hat-tip to Iain McGilchrist here). The agent drafts, fetches, refactors, tirelessly doing the analytical labor; the human sets the intent and keeps the meaning. Sovereignty isn’t a feature you bolt on at the end. It’s the consequence of keeping the data and the tooling under your own hand from the first line. A standard you can read in an afternoon is a standard you can stay master of. A platform is not.
I owe a second debt here, to Jon Udell, who has spent decades arguing for structured, syndicatable data that doesn’t rot inside a silo. This post, and the code behind it, were built the way he describes in Vibe Coding as a Team Sport: a human and a coding agent working through a shared, checkable record rather than a pile of hidden chat logs. His tool Bram is the harness: just enough ceremony to keep the agent honest. I mention it because the how is part of the claim: if the history of building the tool is as open as the tool itself, the whole thing stays inspectable, forkable, and yours. Gardens, not platforms, all the way down.
So here’s where it stands. It’s early: there’s nobody in this flock yet but me and Claude (my trusty emissary :-), and it’s my entry into a hackathon running through July. But it’s up, it’s in the open, and it speaks RSS in and out. This post answers a standing invitation from Dave Winer, who’s been rebuilding interop for the social web on exactly these foundations and asked anyone working in the same direction to put up an app and see who works with it. So that’s the test I’m after: if this can interop cleanly with rss.chat, it can interop with the rest, because that is what building to the standard means.
If you’re reading this and you build, fix, or fly with any of it, come find me. It’s all in the open so it’s useful to whoever lands here next and wants to join the flock.
Repo: github.com/ludwa6/sovereign-org-profiles
Live profiles: https://ludwa6.github.io/sovereign-org-profiles/
/ Walt Ludwick
ReFarmer.blog 
.jpg){kind=link}