Gas Town's agent patterns, design bottlenecks, and vibecoding at scale

As Yegge himself would agree, there's likely nothing that is particularly good about this specific architecture, but I think that there's something massive in this as a proof of concept for something bigger beyond the realm of software development.

Over the last few years, people have been playing around with trying to integrate LLMs into cognitive architectures like ACT-R or Soar, with not much to show for it. But I think that here we actually have an example of a working cognitive architecture that is capable of autonomous long-term action planning, with the ability to course-correct and stay on task.

I wouldn't be surprised if future science historians will look at this as an early precursor to what will eventually be adapted to give AIs full agentic executive functioning.

I appreciate your earnest Harumph, kind cross-armed sir!

I take it you never played The Sims? The simulation madness ship sailed 26 years ago, and made well over $5 billion in revenue for Maxis/EA (as of 2019), and that's if you don't even count SimCity that shipped in 1986! ;)

The Sims Franchise Has Made Over $5 Billion In Revenue (Published Oct 30, 2019):

https://www.thegamer.com/the-sims-franchise-revenue-over-5-b...

Palm is a fictional character in a text adventure -- same tradition as Zork, LambdaMOO, and every MUD since 1978. The emojis are deliberate (navigation aids for LLMs, actually, and ethical simulated person flagging). The whimsy is intentional.

emoji-disclosure.yml -- Visual Markers for Representation Ethics:

https://github.com/SimHacker/moollm/blob/main/skills/represe...

I've been building simulated characters, world, city, house, and object building and programming tools since before The Sims shipped. This is just the next iteration.

The Sims Steering Committee - June 4 1998:

https://www.youtube.com/watch?v=zC52jE60KjY

The Sims, Pie Menus, Edith Editing, and SimAntics Visual Programming Demo:

https://www.youtube.com/watch?v=-exdu4ETscs

You may recognize tributes to many classic simulated characters in MOOLLM.

MC Frontalot -- It Is Pitch Dark:

https://www.youtube.com/watch?v=4nigRT2KmCE

The Grue monster carries his own game mechanics with him, eating you if you go for long enough in the maze without your lamp lit:

grue: https://github.com/SimHacker/moollm/tree/main/examples/adven...

The Wumpus has prototypes for his game playing pieces in his character directory, and even the BASIC source code as the single source of truth:

https://en.wikipedia.org/wiki/Wumpus

wumpus-snorax: https://github.com/SimHacker/moollm/tree/main/examples/adven...

BOTTOMLESS-PIT.yml: https://github.com/SimHacker/moollm/blob/main/examples/adven...

SUPERBATS.yml: https://github.com/SimHacker/moollm/blob/main/examples/adven...

Hunt the Wumpus — Original BASIC Source (1973), By Gregory Yob, published in Creative Computing (October 1975) and The Best of Creative Computing (1976):

https://github.com/SimHacker/moollm/blob/main/examples/adven...

The Grue and the Wumpus can both orchestrate their games in the same maze at the same time without interference! No special hacks required, they all just compose and interoperate seamlessly and naturally.

The monkey named "Palm" multiply inherits directly from Lucas Art's game "Monkey Island" and W. W. Jacobs' classic book, "The Monkey's Paw", all thanks to Self's simple, flexible, prototype object model:

Monkey Island: https://en.wikipedia.org/wiki/Monkey_Island

The Monkey's Paw: https://en.wikipedia.org/wiki/The_Monkey%27s_Paw

Palm's CHARACTER.yml Soul File:

https://github.com/SimHacker/moollm/blob/main/examples/adven...

  # ONTOLOGICAL INHERITANCE
  inherits:
    - skills/fictional     # A character in the adventure
    - skills/mythic        # Origin as cursed artifact
    - skills/animal        # Now a whole monkey

  # TRADITION INVOCATION (Self Prototype Multiple Inheritance)
  # Palm inherits from multiple well-known fictional traditions,
  # simply by naming them — they're so deeply embedded in the training
  # data that invocation IS inheritance. No copying needed.
  # See:

https://en.wikipedia.org/wiki/Self_(programming_language)

MOOLLM is deliberately playful, in the spirit and tradition of Seymour Papert's Constructionist Philosophy, and Mitchel Resnick's Lifelong Kindergarten -- it's a text adventure game framework, not a vibe-coded hallucination. The monkey writes philosophy because that's funnier than a generic NPC.

And it makes fun of crypto scams instead of shilling them:

https://github.com/SimHacker/moollm/blob/main/skills/economy...

Time Cube didn't have rubric-scored game sessions with receipts, and MOOLLM isn't racist like Terry Davis, so you can easily clone on github and play with in Cursor yourself.

Seymour Papert and Idit Harel: Situating Constructionism:

https://web.media.mit.edu/~calla/web_comunidad/Reading-En/si...

Lifelong Kindergarten: how to learn like a kid, from the co-creator of Scratch:

https://www.media.mit.edu/articles/lifelong-kindergarten-how...

And yes, it works great, and is fun and easy to author, faster and for less money than Steve's costly "Infinite Number of Typewriters Communicating Via Carrier Pigeon" approach.

And since you mentioned you enjoy fully-introspectable modern virtual machines too, MOOLLM is one that actually works -- I think we're actually on the same page about a constellation of brilliant points of light (Self, reflection, homoiconicity, communicating actors, introspection, Alan Kay, simplicity over speed, Lisp, Smalltalk, Erlang actors, language independence, first class K-lines, first class concurrency, optimised for simplicity, the universal interpreter, etc):

https://combo.cc/posts/what-i-would-like-to-see-in-a-modern-...

sph> What I would like to see in a modern Virtual Machine

sph> As I was gathering inspiration (or doing research, if you want to be fancy about it) for the fully-introspectable computing platform introduced in the previous post, I figured it might be worth taking the idea of abstracting the hardware, to make user-facing software easier to program, to its limit.

Case in point:

You should check out the practical MOOLLM skill Cursor Mirror, introspection into cursor prompts, thought, and context assembly:

https://github.com/SimHacker/moollm/tree/main/skills/cursor-...

>Ever wondered what the hell Cursor is actually doing? Why it read 47 files when you asked a simple question? What context it assembled? What it was thinking in those hidden reasoning blocks?

>cursor-mirror cracks open Cursor's brain. 59 read-only commands to inspect every conversation, every tool call, every file it touched, every decision it made. SQLite databases + plaintext transcripts + cached tool results — all intertwingled, all queryable.

Here is an example Cursor Mirror report on a complex long running simulation, dynamic rule generation, and coherent image generation:

Cursor Mirror Analysis: Amsterdam Fluxx Championship: Deep comprehensive scan of the entire FAFO tournament development:

https://github.com/SimHacker/moollm/blob/main/skills/experim...

Amsterdam Flux Card Gallery: 32 AI-generated illustrations for the MOOLLM Amsterdam Flux deck:

https://github.com/SimHacker/moollm/blob/main/skills/experim...

Cursor Mirror is seamlessly composable with other skills, and here are two practical exemplary skills built on top of it:

Skill Snitch provides security auditing for MOOLLM skills through static analysis and runtime surveillance, like Little Snitch for LLMs.

https://github.com/SimHacker/moollm/tree/main/skills/skill-s...

>Security auditing for MOOLLM skills through static analysis and runtime surveillance.

>Skill Snitch is a prompt-driven skill (no Python code) that audits skills for security issues. It's entirely data-driven and extensible.

Thoughtful Commitment writes git commits that link to the thinking that produced them.

https://github.com/SimHacker/moollm/tree/main/skills/thought...

>When you work with an AI coding assistant, the session holds valuable context: what you asked, what the AI considered, what alternatives were rejected, why it made certain choices. When you close the IDE, all of that vanishes. Your commit says "fix: auth bug" but six months later you have no idea why.

>This skill captures that ephemeral reasoning and freezes it into permanent git history.

My read on the reception of Steve’s post is that there are largely 2 camps, one of which thinks he’s given them a concrete tool to use, and the other of which thinks he has given them something to think about. I read his experiment as suggesting an agent architecture akin to Erlang supervisor trees, i.e. agents are cattle, not pets, and should be monitored and processed as such, with the obvious caveat that context matters.

I feel that yegge captured the mania of the whole operation rather well. If your bosses commit to the idea that 100 memoryless stochastic "polecats" will deliver a long term sustainable business, then there are probably other leadership issues besides this.

Stop. Seek help.