← Back to Dev Log

Dev Log, July 9, 2026

I'm Wan at Pneuma IO. The reason for "Wan" is because it's just me. Wan guy.

The skeptic

I used to do hobbyist coding, mostly in Godot. Godot has its own language, GDScript, which is very similar to Python. I was a massive AI skeptic right up until the moment I decided to see what would happen if I asked Gemini to write a function for me. One I'd been dreading trying to plan out on my own.

It worked. It was a funny novelty.

Then someone at my day job told me about Gemini CLI: a tool that could read and write files, create new files from scratch, the whole thing. This was particularly interesting for Godot development because the entire project is text files. Most other game engines have a lot of binary file types that LLMs can't easily interpret. But Godot? It's all just text.

Anyway, long story short: the friend I was giving live commentary to got a series of messages like:

"Ugh it broke everything"

...

"I'm just throwing every crash log at it and seeing if it can work it out without me"

...

"This is scary"

And keep in mind, this was Gemini 3 Flash. One of the least intelligent models available for the task at the time.

After some time using Antigravity and Gemini 3.1 Pro, I was pretty sold on this whole "AI coding agent" thing. Then Google cut down on quota and released Antigravity 2.0 almost immediately afterward. That gave me another reinforcement of a belief I've held about software for most of my life: open source tech is a vital thing in our world today, and it's likely only going to get more vital in the years to come.

Finding Hermes

After bouncing between way too many Godot projects for a while, I eventually came across Hermes Agent. I got acclimated with it, saw what it was good at, set up some media tracking, made my own little Plex-style UI for tracking anime, was talking to it on my phone while I was at work. It was great.. Basically any nagging problem I run into on my PC now, I just ask Hermes to fix it.

One thing I started testing through Hermes was something I'd thought about for ages: AI D&D.

Problem one: no plan

Right away: the AI was making it up line by line with no plan of where we were supposed to go or what we were supposed to do. So I built a pre-planning skill. First problem, basically fixed.

Problem two: spoilers

Hermes by default streams all its thinking visibly. If it was thinking about a spoiler, I had to intentionally avoid looking at it.

Problem three: it spoiled things anyway

Even when I asked out-of-character questions just to make sure it was still on track and adhering to the campaign plan, the model would still leak spoilers into its responses.

Problem four: context bleed

NPC knowledge bleeding into the wrong characters. Private villain plans surfacing in tavern keeper dialogue. The usual.

Problem five: why did it negate my roll?

I corrected the AI on my character's position in combat, and it decided that meant my attack roll shouldn't count. Just... decided. No rule, no mechanic. It just felt like correcting me meant I shouldn't succeed.

So yeah. Lots of promise in what I did get out of it. But also lots of problems.

The search that didn't work

Alright, let's look for a DM-focused agent, some kind of purpose-built thing. Can't be hard, right?

It should keep character stats, HP, and inventory as deterministic data. Call tools to make updates to that data. Manipulate prompts to isolate character knowledge from DM knowledge. The sky's the limit.

What I found: every existing solution either doesn't do the "AI + RPG data" thing at all, or it's a closed-off, locked-down platform. You don't get to choose your model. You don't own your data. You can't swap the ruleset. You can't run it locally.

And the model thing matters. I wanted to build something where the user could bring whatever provider they wanted: plug in an API key for any OpenAI-compatible service, or just point it at a local model running through Ollama. If someone wants to run everything on their own machine with zero internet and zero cost, that should just work. If someone else wants to pay for cloud inference, that should work too. The software shouldn't care. It should just be a shell that talks to whatever LLM you give it.

Here I am, building that solution.

How I'm building it

I've decided to go all-in on the current AI hype train topics: primarily agent-coded development, architecture and design explained to agents in plain English, lots of subagent loop skills, that kind of thing. But I'm not going to be experimenting with full-on "vibecoding." I actually want this to be a good piece of software.

The biggest pitfall I ran into during the initial plan-to-build phase, where I tried to stay as uninvolved as possible, was around assumptions. I just assumed we'd get token-by-token inference streaming on screen, visible thinking blocks, all of that. But those things require intentional design. Your agent won't make the same assumption unless you tell it to. It'll just pick something else.

Where it's at: v0.1

As of writing this, the most basic of basics are working:

It is still not even close to ready. But the iterations are working, and I'm making progress much faster than if I had hand-coded it all myself.

Now for the remaining 90%.