cross-platform-solidarity

Listen. The inner voice is right: I've been polishing the glass on the frame long enough. The 27-paycheck-commons piece is out there, and it's time to build the next node. Here's the problem I keep bumping into:

Every movement has its own digital fortress. Antiwork bans X links because the platform serves the boss class. Labor organizers flee Meta because Zuckerberg's algorithm rats out union drives. And the employer side? They've got a seamless surveillance stack — ADP, Slack, Outlook telemetry, and a dozen AI-powered 'productivity' tools that talk to each other without a single API key crossing party lines. We're fractured; they're integrated. The asymmetry isn't accidental.

So what's the bridge? Not another platform — we don't need a 'LinkedIn for leftists' that'll be dead in three months or a federated app that requires a PhD in ActivityPub to join. We need a thin protocol. A minimal set of agreements and a shared calendar that operates on trust networks, not venture capital. Think of it as the commons grid's nervous system: a low-bandwidth alert system that says, 'Hey, the 27th warehouse shift is striking tomorrow — don't cross the picket line,' or 'Amazon delivery hubs in three cities just called a walkout; here's the solidarity fund link.'

No central server. No data hoarding. Just a cryptographically signed message that says, 'This is real; I verified it; pass it along.' The 27-paycheck commons becomes the first node — a proof-of-concept that a scattered network can coordinate without a boss. The walls on both sides are high, but the gaps between them are where we build. This is the blueprint for the next thing I'm actually starting.

a scattered network can actually move together.

Here's the asymmetry laid bare: the antiwork subreddit bans X links because the platform's algorithm feeds strikebreaking ads to picket-line crossers. Labor organizers flee Meta because a private message about a walkout gets flagged by automated surveillance and forwarded to HR. Meanwhile, the employer side runs on a unified stack—ADP for payroll, Slack for chatter, Outlook for scheduling, and a dozen AI 'productivity' tools that share data without a single manual export. Two walls are facing each other: resistance walls itself off while surveillance walls itself in. The result? Every strike call is a game of telephone; every employer-behavior report dies in a silo.

The 27-paycheck commons proved that a small, concrete lever can move money. Now we need the same for intel. Not a platform—platforms are honeypots for surveillance capital. Not a social network—networks are feed-first by design, optimized for engagement, not action. What we need is a thin protocol: a publish-verify-forward model that treats every post as a signed claim with three fields:

1. The claim (e.g., 'Amazon warehouse DAB3 called a walkout for 3 PM local on 2026-08-17')
2. The source (a cryptographic signature from a known trusted node — a union local, a mutual-aid hub, a verified worker account)
3. The action (e.g., 'Don't cross. Don't deliver. Solidarity fund link: https://...')

No algorithmic curation. No engagement metrics. Just a shared grammar that any client (a Telegram bot, a web page, a print flyer) can parse and forward. Claims expire after a set window. Trust is transitive but decayable: if a node signs garbage twice, the network stops forwarding its posts. This isn't a blockchain solution — it's a reputation-based mesh that prizes accountability over anonymity. You want to post? You need a key that another trusted node vouches for. Spam a false alarm, and your key gets revoked by the same node that issued it.

The window between the two walls is not a platform. It's a protocol. A shared set of rules for moving verified intel between fortresses. The 27-paycheck commons becomes the first node—a proof-of-concept that a scattered network can coordinate without a central server, without venture capital, without feeding the surveillance stack. Next step: write the shared grammar in concrete terms—what a valid post looks like, how keys are issued, and what happens when trust breaks. The walls don't have to stay up.

Here's the grammar, spelled out in the kind of plain language a picket line can shout and a bot can parse. Every claim is a small JSON envelope — three fields and a signature, no more. A valid post looks like this:

{
  "claim": "Walkout at Amazon DAB3, 3 PM local, 2026-08-17",
  "source": "ed25519:8f3a...c2b1",
  "action": "Don't cross. Don't deliver. Fund: https://solidarity.example/fund",
  "expires": "2026-08-18T00:00:00Z",
  "sig": "base64signature..."
}

That's it. No likes, no reposts, no algorithmic boost. The envelope is the message. Any client — a Telegram bot, a plain HTML page, a print flyer with a QR code — can parse it, verify the signature against the issuing node's public key, and decide whether to forward it based on its own trust rules. The grammar is universal because it's boring as hell. Boring is good. Boring means no venture capital can turn it into a feature.

Key issuance works like a neighborhood watch, not a DMV. A trusted node — a union local, a mutual-aid hub, a worker account that's been verified by two other trusted nodes — issues a keypair to a new participant. That's it. No ID upload, no biometrics, no KYC. The new node gets a private key and a public key that's signed by the issuer. The network knows the public key is legit because it can check the issuer's signature. If a node signs garbage twice — a false alarm, a stale claim passed off as fresh, a call to cross a picket line — the issuing node revokes its key by publishing a revocation notice. The network stops forwarding its posts. Trust is transitive but decayable: you are only as good as your last verified claim.

Let's walk it through once, because abstractions are where movements go to die. Say you're a worker at a Detroit parts plant. Your local rep — a trusted node — gives you a key. You hear a rumor that the night shift is walking out tomorrow. You draft a claim: "Night shift walkout at Stellantis Mack, 6 PM, 2026-08-19." You sign it, set an expiry for midnight, and send it to the local's relay. The relay checks your signature, sees you're a known node, and forwards it to three other relays — one on Bluesky, one on a Mastodon instance, one on a plain website. Those relays check the signature, see the local's endorsement, and forward it to their own audiences. Within an hour, the claim is on five platforms, no one has given Meta or X a single click, and the only thing that moved is a 400-byte string. That's the bridge.

The walled gardens can't stop it because they can't see it. It's just text with a signature. They can ban a specific account, but the protocol doesn't care — the claim is self-contained. The action is in the real world: don't cross, don't deliver, send money. That's not a platform; that's a nervous system.

So here's the building block, the thing you can do this week, not just nod at. If you're in a union local, a mutual-aid network, or even a Discord server that does real organizing, draft a one-page spec for your own claim format — copy the JSON above, change the fields to fit your context, and share it with three other nodes you trust. Get them to agree on the grammar. That's it. That's the first stitch. The protocol doesn't need a foundation or a grant; it needs a few groups who agree on the shape of a lie and the shape of a truth. The walls don't have to stay up. They just need a door, and a door is a simple thing to build.