GBG Is the Game That Makes Games

Perplexity launched Computer in February 2026. It orchestrates 19 AI models, runs async tasks in the cloud while you sleep, spawns sub-agents, connects to 400+ apps. It is genuinely impressive. And understanding exactly why GBG is different from it — and from Claude's desktop control — forced me to clarify something I hadn't put into words yet.

The question that cracked it open: what do you call a complete composed set of beads, scores, and resources assembled for a specific purpose? A project? A package? A module?

No. A Game.

The Taxonomy

GBG has always had beads. Beads are atomic knowledge units — formalized patterns, architectural decisions, implementation approaches, error-handling signatures — encoded in a form any capable model can reconstruct from. Not documentation. Not prompts. Reconstructive knowledge.

But beads don't operate alone. They get sequenced. A Score is the ordering logic — load architecture beads first, then domain knowledge, then implementation patterns, then edge cases. Different models might receive different Score sequences optimized for their strengths. The Score is the conductor. The beads are the orchestra.

And when you assemble beads + scores + resources into a complete, self-contained, portable unit built for a specific purpose — that's a Game.

GBG — the system, the Game Maker

└── Game — complete composed set, self-contained + portable

└── Score — sequencing logic, how beads are played

└── Bead — atomic knowledge unit

└── Resource — raw material beads reference

Every major thing I've built has a Game: Game:Wire, Game:FundingGuard, Game:KurkaLabs, Game:MemoryOS. Games can reference other Games. Beads can reference other beads. This is not a flat prompt — it's a composable knowledge grammar. Beads are vocabulary. Scores are syntax. Agents are interpreters. Games are complete compositions.

Languages compound in a way that task runners never do. This is the structural reason GBG accrues value over time while Perplexity Computer — which starts every task from zero — cannot.

Then the Real Insight

Every Game produces something: software, a system, a document, a product. But GBG produces Games.

GBG is the only thing in the system that doesn't build things. It builds the knowledge to build things. That makes it a different ontological type from everything it creates.

A compiler is a program that makes programs. GBG is a Game that makes Games.
— and like a compiler, once it's good enough, you can feed it through itself

GBG can play GBG to improve GBG. That recursive moment — when the system can encode its own patterns into beads, write its own Score, compose itself as a Game — is when it becomes something qualitatively different from every other AI tool I know of.

The product map

Thing	Type	Built by
The Wire	A Game	GBG
FundingGuard	A Game	GBG
MemoryOS	A Game	GBG
TTL	A Game	GBG
GBG	The Game Maker	itself (recursively)

The Evolutionary Angle

Here's where it gets interesting. The original GBG was built before GBG existed as a methodology. It was hand-crafted, intuitive, pre-bead — a primitive organism assembled from raw materials with no genetic code to guide replication.

Now GBG can extract beads from itself. Formalize its own patterns. Write its own Score. Compose itself as a Game. The new version isn't just better. It's a different kind of thing — built by a mechanism that didn't exist when the original was made.

The original GBG is RNA. The bead-encoded GBG is DNA.
Same information. New encoding mechanism. Qualitatively different fidelity, portability, and capacity to evolve.

This is called a substrate transition in biology. And the properties that follow are real: the bead-encoded version replicates with higher fidelity across models, teams, and time. It can mutate intentionally — beads updated, composed, evolved. Weak beads pruned, strong beads propagated.

But here's the difference that actually matters. Biology evolves blindly. Mutations are random, selection is environmental pressure over generations. GBG evolves with a designer in the loop. I can look at a bead, decide it's weak, strengthen it, replay it. The selection pressure is conscious. The mutation is directed.

This is Lamarckian evolution — acquired characteristics directly encoded and inherited by the next generation. Every pattern learned from building Wire, FundingGuard, MemoryOS goes into the corpus. The next build starts smarter than the last. Biology couldn't do this. GBG can.

vs. The Competition

With this framing, the competitive picture gets clean fast.

System	What it does	Compounds?
Perplexity Computer	Routes tasks to best model, runs async	No — starts fresh every time
Claude Computer Use	Desktop / browser control	No — a robotic arm with no blueprint
GBG	Encodes knowledge, directs both	Yes — every Game makes the next smarter

Perplexity Computer is a smart factory with no blueprint. Claude Computer Use is a robotic arm with no brain. GBG is the architect — and then it encodes what it learned from being the architect, so the next project starts from a higher floor.

The full stack looks like this:

GBG Score — what to build, how, with what patterns

↓

LEXX Swarm / Agent Teams — execution (Perplexity Computer equivalent)

↓

Actuators — code execution · API calls · desktop control · browser

The One-Liners

Sometimes a session produces a sentence worth keeping. This one produced three.

GBG is the Game that makes Games.

Every other system builds things. GBG builds the knowledge to build things — including itself.

GBG is the first knowledge system that evolves like life but learns like a mind.

The Manifesto will go deeper. But this is where that thinking started — trying to explain what GBG isn't, and accidentally discovering what it is.