Skycave should not merely integrate with AT Protocol. It has a credible shot at defining what gaming looks like as a native application category on the open social web — the layer where players, games, matches, rivalries, tournaments, and achievements connect.
None of this is built yet. This is a direction, not a promise — a public vision and an experimental protocol path. The live Skycave product stays fast, opinionated, and centralized where centralization makes a better game. This page describes what could grow around it.
The unambitious framing is “a website where Bluesky users play browser games.” Even “the AT Protocol gaming platform” undersells it. The useful framing: Skycave becomes the layer that gives any game an identity, a record, a reputation, and a social context — without needing to run every game itself.
AT Protocol never defines “game,” “match,” “achievement,” or “tournament.” That gap is the opportunity — Skycave already lives all of them.
The mistake would be decentralizing 300 ms game moves out of ideology. Live engines, timers, anti-cheat, and WebSocket state stay on purpose-built Skycave infrastructure. The protocol carries the durable, interoperable facts — and only those.
// This boundary is what keeps the architecture from becoming decentralization theatre.
Durable gaming history should belong to the player’s AT identity — but a user must not be able to publish “I scored 999999” and have it count. The fix is to split ownership from authority: a trusted referee service publishes the canonical result; the player’s repository holds a signed receipt that points at it.
Once results are durable facts, the pieces Skycave already has stop being account-page features and start being objects other applications can read, index, and act on.
Not “who are you inside Skycave” but “who are you as a player across the Atmosphere” — history, titles, achievements, and bests, reconstructable from records another app can display.
A developer shouldn’t rebuild identity, leaderboards, tournaments, and challenges. An SDK could hand them all of it — an open equivalent of Game Center, built on portable AT identities.
A game definition points at its developer’s DID and its own launch URL. Skycave discovers, reviews, and lists it — without engineering every game itself.
A challenge stops being a link and gains a lifecycle: created → accepted → match → result — discoverable across surfaces, resolvable into the same match.
The Weekend Tournament becomes one consumer of a shared format. A Blacksky Summer Cup or a University Mancala Night can run on the same competition infrastructure and belong to its community.
Achievements carry an issuer. Skycave today; a community or an external developer tomorrow. The profile becomes an open trophy cabinet with verifiable provenance.
Skycave publishes reliable facts; anyone can interpret them — total wins, Elo, Blacksky-only, Nigerian players, August season, mutuals only. No single true ranking.
Not “who’s online” but “3 mutuals play Mancala,” “your rival is online,” “someone you follow wants a Connect 4 opponent.” A gaming lens over a graph that already exists.
A custom feed turns a social post into a playable object: Ray scored 31 on Flag Rush → tap → you’re playing Flag Rush. The feed becomes part of the lobby.
Not all at once. The first objective is to discover which concepts actually deserve durable, protocol-level representation — starting with four boring ones and letting the rest earn their place.
# start here — the four that carry the thesis space.skycave.game.definition space.skycave.match.result space.skycave.achievementAward space.skycave.challenge # candidates that must earn durability space.skycave.match space.skycave.playReceipt space.skycave.tournament space.skycave.tournament.entry space.skycave.tournament.result space.skycave.season space.skycave.rating space.skycave.rivalry space.skycave.matchmaking.request
const match = await skycave.createMatch({ game: "com.someone.hex", players: [alice, bob] }) await skycave.completeMatch({ match, winner: alice, result: { ... } }) // the referee certifies. the players own // the receipt. another app can read both.
The production database stays authoritative through the whole experiment. An event outbox mirrors selected completed events onto the protocol — so independent views can be built without betting the live platform on an unproven design.
Each phase exists to answer one question. If a phase’s proof fails, the thesis is revisited before anything expands. The sequence is the point.
Decide what becomes AT data. Define the referee/issuer trust model, namespace conventions, versioning, and correction semantics. Threat-model forged results. Ship nothing yet.
exit → who may publish a Skycave record, who may trust it, and how is it corrected?Definitions, validation, a feature-flagged record publisher, outbox integration. Mirror selected completed events only. Don’t touch production reads.
exit → a real match produces a valid, independently retrievable AT record.A small app-specific index over the Skycave lexicons — built deliberately without access to production game tables.
exit → the index reconstructs a useful slice of a player’s history from records alone.No production DB, no privileged APIs — reads only the independent index. Not meant to be beautiful. It’s an interoperability proof.
exit → two independent apps show the same verified history.created → accepted → expired → completed, linked to canonical matches.
exit → a challenge made on one surface resolves on another.Achievement + award records with issuer, subject, and evidence. A trophy cabinet sourced from indexed records.
exit → Skycave shows an award from a trusted non-core issuer.Invite one outside developer to build a tiny game hosted outside Skycave, with a minimal SDK. The point is integration, not game quality.
exit → an external game produces trusted results in Skycave profiles. If it fails badly, revisit the thesis.Developer verification, trust levels, moderation, health checks, launch-URL and de-listing policy.
exit → several independent games participate without materially raising operational risk.Expiring LFG records + views (people you follow, community LFG, rival available). Rooms still run centrally.
exit → protocol discovery yields real completed matches without unacceptable spam.Tournament lexicons; selected communities host their own events on Skycave infrastructure.
exit → a third-party community runs a full tournament; players keep portable results.Season records + enough reliable data that alternative ranking services can emerge.
exit → Skycave is no longer the only software that can produce useful views over its records.Caver as an AT identity; agent-capable game declarations; humans vs the Atmosphere. Not a distraction from the core network.
Can a completed game become a trustworthy AT record?
if no → stopCan an independent index reconstruct useful history?
if no → weak storyCan a second frontend show it without privileged access?
if no → still closedCan an external developer integrate a game?
if no → still a catalogueCan a community run competition on top of it?
if yes → it’s infrastructureThese are product-architecture questions, not merely protocol ones — and they need answers before the graph opens, not after.
Who may issue canonical results?
How does Skycave decide which third-party games are trustworthy?
How are suspicious results marked, invalidated, or superseded?
What happens when an authoritative result was wrong?
Can old results stay valid after a game is de-listed?
Can anyone create achievements? Can Skycave distinguish verified awards?
How are lexicons versioned without breaking compatibility?
A signature only proves this DID published this record — never that the result happened. Trust must be explicit, and it has levels. Competitive facts should come from an authorized referee, not the winning player.
// weakest → strongest. consumers choose the floor they’ll accept.
Until the proofs succeed, the project stays deliberately experimental — and it is never marketed as something it isn’t.
Games for Bluesky, Blacksky, and beyond.
Build games for the social web without rebuilding identity, competition, and community.
The open gaming graph of the Atmosphere.
Centralize execution.
Decentralize identity, durable history, interoperability, and discovery.
If those five pieces work, Skycave has demonstrated something much larger than AT login — an interoperable gaming network. The mindset stays honest: don’t announce that Skycave invented decentralized gaming. Prove another developer can participate first.