[Experiment 5] I built an AI Agent Tycoon Game to Learn about OpenClaw, LangChain and Hermes Agents
This one closes a loop I have been circling around since the beginning. Experiment 3 was the data center game where I learned about the hardware, the GPUs, power, cooling and bandwidth. Experiment 4 was the AI lab game where I learned how the models are actually trained on top of that hardware. But hardware and models are still not the thing people actually use (except for some exceptional X people). The thing people use is the layer on top: agents. And that layer has exploded lately with frameworks like LangChain, OpenClaw and Hermes (Nous Research).
Funny enough, I already used a Hermes agent in experiment 1 for my job search (still running on my Hetzner VPS by the way). But I set it up by following instructions, I never really understood the landscape. Why does OpenClaw exist if Hermes exists? When would a company pay for a LangChain build instead? What is actually inside one of these agents?
In fact, I am still not sure about those but at least I got to play a new game :)
So same logic as always. I learn best by playing games about the subject (Codingame.com for coding, I built PlaySupplyChain.com for supply chain), so I built a game, with the help of Fable 5, about running an AI agent company.
The game is called AI Agent Lab and it is free to play in the browser, no signup and no email needed: https://www.buildlooplabs.com/agentlab/
The Game
Same setup as always. Django backend, HTML/JS/CSS frontend, built with Cursor AI and Fable 5. And same disclaimer as always, the game logic is all in the frontend with almost no validation in the backend, so it is rather easy to cheat on the high score I would guess. The game is about learning, not competition.
You start an agent agency with a laptop, a few dollars and a hunch that agents are the next big thing. The loop is basically the life of a small AI consultancy: Learn skills, Take client projects, Earn Money and Build credibility, Reinvest in better infrastructure or capabilities
General image below:
Some details:
Learn skills. There are three skill trees, one per framework, with 30 skills each. And this is where the learning happens, because every skill is a real documented feature (normally from the docs of the three projects).
The LangChain tree goes from the create_agent harness and tool calling, through RAG, LangGraph orchestration and checkpointer memory, all the way to middleware like PII redaction and prompt caching.
The OpenClaw tree is about the gateway: channel plugins for WhatsApp/Telegram/Slack, session isolation, SOUL.md personas, allowFrom security, multi-agent routing, the live Canvas.
The Hermes tree is the self-improving autonomous agent: persistent memory, session search, skill documents the agent writes for itself, execute_code, subagent delegation, sandboxed backends. Every purchase pops up a small card explaining what the thing actually is in the real world.
Take client projects. Clients appear with requirements. In fact they get kind of repetitive in the end but anyway :) A bakery wants a FAQ bot. A law firm wants a contract-review pipeline with approval gates. Some clients require a framework while others don’t care. Projects need capabilities, so if the client needs browser automation or memory and you never learned it, you can’t take the job.
Build credibility. Delivered projects pay money and credibility, and credibility unlocks bigger clients. Typically consulting stuff. Nobody gives the government helpdesk contract to an agency that has only built bakery bots so as a player I need to grind some before I get the good stuff.
Choose your infrastructure. Two decisions I found really interesting to turn into game mechanics. First hosting: your agents are always-on processes, so the laptop at home randomly goes offline (and your agents die mid-task) until you get a proper VPS, later a GPU server, Kubernetes, and eventually a server-less fleet. Second the model stack: frontier API models give the best quality but every step of every agent loop is a metered API call (experiment 2 all over again), local open-weights models are free but noticeably worse, and the hybrid router sends easy steps to the cheap local model and hard reasoning to the API. If your money hits zero mid-project on the API stack, delivery halts and you have to debug by hand.
Specialize or generalize. Twenty skills in one tree makes you a framework expert with premium rates. Ten skills in every tree makes you a generalist that never turns work away. You cannot really do both fast, which feel like a real thing
The Key Learnings
Like always, this is what I want to remember:
An agent is just a model calling tools in a loop until the task is done. Everything else, all three frameworks, is machinery around that loop.
The three frameworks are not really competitors, they answer different questions. LangChain is for developers building agent products in code. OpenClaw is a self-hosted gateway that puts an always-on assistant inside the chat apps you already use. Hermes is an autonomous agent that lives on your server and improves itself. Knowing which question a client is asking tells you which stack to reach for.
Concepts transfer, APIs don’t. Memory is a LangGraph checkpointer, an OpenClaw workspace file, or Hermes curated memory. Same idea, three implementations. Once I understood memory, subagents and approval gates as concepts, every framework became an implementation detail. This is probably my biggest takeaway.
Security is not optional. An always-on agent with tool access that answers any stranger who finds its number is a disaster waiting to happen. allowFrom whitelists, approval gates before risky actions, Docker sandboxing so the agent can’t rm -rf the wrong machine. The frameworks all ship these for a reason.
Agents run all day and so does the meter. The token economics from experiment 2 hit differently when the thing spending the tokens is not you typing questions but a process running 24/7. The hybrid pattern (cheap local model for easy steps, frontier API for hard reasoning) seems to be where everything converges. High quality only for the most important tasks.
The $5 VPS is the real agent home. Laptops sleep and home internet can break. Datacenter uptime and a static IP for webhooks is cheap compared to a missed message from a paying client. Obviously in a game like this it doesn’t matter, but pretty important in real life.
Suggestions for next version
The projects complete a bit too automatically. It would be more educational if projects could actually fail, wrong tool called, prompt injection through a retrieved document, memory leaking between clients, and you had to debug from a trace. That is the daily life of agent builders and the game skips it.
Rival agencies bidding on the same contracts would create urgency. Right now, like the previous games, a patient player can idle forever.
And as usual, graphics are basic and it is not really mobile compatible. Same story every time, maybe one day I do a graphics experiment.
Conclusion
With this one I feel the stack is complete in my head: experiment 3 was the physical layer, experiment 4 was how the models are made, and this one is how models become useful workers. Gateway, harness, checkpointer, subagent, allowFrom, SOUL.md, these were words I had scrolled past on X many times and now they are game mechanics I have clicked on a hundred times. It sticks better this way, at least for me.
And again, building a learning game like this takes about a morning with Cursor. The knowledge is already inside the model, the game is just a more fun way to pull it out than reading three documentation sites.
Now let’s see if anyone beats my high score.
Thanks for reading
Andreas