Early on April 29, 2026, Bailey Townsend posted a skeet that turned out to be prophetic for what would happen later in the day:
I think people forget sometimes that the "credible exit" part of atproto is not just for user accounts.
Your atproto apps can have a credible exit as well.
— Bailey Townsend 🦀 (@pds.dad) April 29, 2026 at 6:48 PM
Less than nine hours later, Rudy Fraser stood up Blacksky Forge — Blacksky’s own knot, its own spindle, its own appview, all wired into Tangled’s lexicons.
He called the deployment ”anarchist calisthenics”, and stated that his interest was — among other things — to demonstrate how easy it is “to run atproto things”.
- wanted to - want to like Tangled; to like Tangled I need to run Tangled - running things is what I'm here for and what I'm interested in, solely - publicly demonstrates how easy it is for Blacksky to run atproto things - I take "Every online community should control its own destiny" to an extreme
— Rudolph Fraser. (@rude1.blacksky.team) April 30, 2026 at 2:57 AM
Now, here’s where things get real cool: Tangled raised $4.5M just two months ago from investors that included Bain Capital Crypto and Antler. You don’t raise that kind of money without a business strategy and, even if they were to sit on their hands and do nothing for a year, Tangled is poised to get traction due to GitHub’s recent woes.
How did they react?
Anirudh Oppiliappan, Tangled’s co-founder, replied that “we had no idea this was planned (we never spoke!)” — and meant it as praise.
Very stoked about this because 1. it lights a fire under our butts to achieve AT compliance ASAP (repos 🥴) and 2. we can point to Blacksky Forge as a "hey look Tangled can be credibly exited!"
We also had no idea this was planned (we never spoke!)—great example of a potential adversarial scenario.
— Anirudh Oppiliappan (@anirudh.fi) April 30, 2026 at 8:31 AM
[image or embed]
Within a handful of hours, ATProto app-layer credible exit stopped being a thought experiment. And the taxonomy I sketched earlier this month needs a footnote.
Three layers, all open
Tangled is what the taxonomy calls a Cuckoo: ATProto-native infrastructure arbitrage. About a year ago, Boris Mann described it as (iirc, because sadly I don’t have the link on hand) “a project that recognizes that Github is merely a developer-coordination layer”.
It scans at first glance like “GitHub, but on ATProto.” Underneath, it’s three layers, all designed to be self-hostable.
- Knots: lightweight self-hostable git servers. They hold the code. Run one on a Raspberry Pi if you like.
- Spindles: CI/CD runners that subscribe to knot events, spin up Docker containers, expose Nixpkgs.
- Appview: the web UI / indexer that federates knots into something that looks like a forge — if you are coming from tradweb, think a materialized view.
All three are wired together via public lexicons — sh.tangled.knot, sh.tangled.spindle, sh.tangled.repo — and the records live on user PDSes, not on Tangled’s servers.
What Blacksky stood up at forge.blacksky.community is its own instance of all three layers. An irrefutable example of the appview being independent comes from Roscoe Rubin-Rottenberg, who noticed that edits made via pdsls to a repo record propagate correctly to Blacksky Forge but not to Tangled’s official appview. Different propagation behavior means different indexing pipeline. Same lexicons, different appview.
No fork, no protocol dispute, no announcement. Just a parallel deployment and a wave from the steward saying: nice.
An Offshoot of a Cuckoo
This is where the taxonomy needs the footnote.
Quick recap of the three categories: Symbionts (live alongside Bluesky, depend on its restraint), Offshoots (start in Bluesky’s pond, evolve their own community), and Cuckoos (lay eggs in ATProto’s nest, build their own thing in an orthogonal category). Tangled is a Cuckoo by that definition — it scans Bluesky-shaped, or maybe Bluesky-adjacent, but it is an independent project that can take advantage of its infrastructure.
So what is Blacksky Forge? At first glance it looks like a Cuckoo of its own — it competes with Tangled in the same forge category. It isn’t. It’s an Offshoot of a Cuckoo, and the differences matter:
- The lexicons are the parent, not Tangled’s codebase or its brand.
- Tangled is celebrating, not defending.
- Blacksky’s framing is independence, not replacement.
Cuckoos can spawn Offshoots without losing their Cuckoo status, because the thing the Cuckoo is doing — opening lexicons in a fresh category — is exactly the thing that enables Offshoots in that category. The recursion is a feature of the protocol-first design, not a bug. Each new Cuckoo opens a fresh evolutionary surface.
The ones that don’t keep their lexicons open, documented, and stable won’t get to claim that property, and I expect the next batch of Cuckoos to be evaluated, in part, on whether they meet the same bar Tangled just set.
Which is also part of a pattern worth naming.
Backlash Technology
(Slaps ATProto roof) This baby can fit so much Backlash Technology in it.
I won’t get into the concept of Backlash Technology here. It’s an idea by Peter Watts. My piece on it, and how it can impact adoption both ways, is short — go read it.
Blacksky: backlash against Bluesky’s moderation defaults. Eurosky: backlash against US tech jurisdiction. Tangled: backlash against GitHub’s gravitational pull and Microsoft’s shoddy stewardship.
Blacksky and Eurosky are friendly coopetition for Bluesky, and also tools their users can wield to lash back at some of its properties. Blacksky Forge plays the same role against the idea that even on ATProto, somebody else gets to be the single appview for a topic.
ATProto is turning out to be sensational at absorbing this energy without fragmenting under it. It doesn’t seem to be an accident — it’s what protocol-level data sovereignty does when the social layer cooperates.
The credible exit nobody talks about
User-level credible exit has been ATProto’s calling card since 2023: move your DID and data off bsky.social, keep your social graph, prove the platform-power dynamic has actually changed. Useful, well-rehearsed, increasingly demonstrable. Last year’s news.
App-level credible exit is the deeper guarantee and, other than standard.site, I don’t think we had any practical examples. If Tangled has an enshittification turn next year, the users’ repo records still sit on their own PDSes. Anyone with the lexicons and the appetite can stand up a competing appview that indexes them. The user does nothing. Continuity drops out of the model.
Compare what an exit from GitHub looks like. Every user manually exports every repo. Issues, PR threads, discussions, releases — each in its own brittle format. The destination has to rebuild discovery, identity, and the social graph from scratch. Nobody migrates. Lock-in is the default state of the system.
Blacksky didn’t need to migrate users — they stood up a second indexer over the same data. For a user, the migration cost is approximately zero, because the data was already on the protocol.
This is the thing that’s hard to feel until somebody demonstrates it. And I am fascinated by how quickly it happened.
The social contract is half the trick
Anirudh’s “we never spoke!” line is easy to overlook. The protocol allowed an uncoordinated parallel deployment. The social response decided whether it felt like fragmentation or like a healthy ecosystem. If Tangled had reacted defensively — “we should be informed before forks” — the option to credibly exit would still technically exist, but the social cost of using one of them would have spiked, and the option would slowly stop being an option.
The Mastodon and ActivityPub history is right there. Forks and parallel implementations were technically possible from day one (Pleroma, Akkoma, Glitch-soc), but the social temperature was often colder, and forks routinely came with their own charged narratives. The ATmosphere has, so far, defaulted to celebration. I don’t expect that’s an accident of personalities — it’s a cultural pattern that early protocol-side actors are actively setting.
It reminds me of when someone said, years ago, that on Git — unlike in Subversion — forking was an act of love. ATProto seems to be singing off the same hymnal.
(I’m sorry, whomever it was — it was so long ago that SVN was still a thing, and the line stuck with me but the name didn’t.)
Credible exit at the app layer isn’t only a technical property. It’s a social practice. I’m glad Blacksky and Tangled are demonstrating a working version of it.
What we need to watch
A few open questions, none of which I think break the framing, all of which will shape how this matures.
- Cross-appview UX. Click a repo link — does the application choose the appview the link’s author used, or the reader’s preferred one?
- PRs and collaboration. If a maintainer is on Tangled’s appview and a contributor is on Blacksky’s, does the PR thread render coherently for both? Same lexicons make this tractable; UI conventions, and the question of where an appview accepts data from, are where it’ll drift.
- Lexicon governance. Tangled defines
sh.tangled.knot. That makes them the BDFL of the forge category, de facto. Probably fine for now, and likely the right outcome — but worth naming explicitly rather than pretending otherwise. - AT-compliance for repo data. Anirudh’s “repos 🥴” parenthetical hints that the repo lexicon itself isn’t fully AT-compliant yet. I am not familiar enough with Tangled to comment (and, at the speed the ATmosphere is moving, I’m not sure I’m ever going to catch up). Appviews are exitable, but we need to make sure the data layer underneath is as well.
What yesterday actually proved
The protocol delivered. Tangled’s response is what made it count. And the taxonomy turns out to have graph-like connections between categories, because being protocol-open is what makes something a healthy Cuckoo in the first place.
What Blacksky Forge demonstrates is not that Tangled is replaceable. It’s that Tangled is exitable — which is what made it worth showing up to in the first place.
And, on top of that, both teams struck loud beats on a drum I have been banging for years:
If there is one thing that the software industry has learned, it is that it is always a bad idea to bet against openness.