The mind that writes the model
I. The question the last essay left open
The last essay argued that the durable thing an AI should author isn't code and isn't a flow in someone's fixed vocabulary — it's the typed model the application is generated from. Validate the model, generate the disposable code, keep the escape hatches. I stand by all of it.
But stating it that cleanly leaves a question hanging that I've been circling for a while, and it's the one this essay is about. Who writes the model? In essay four the author is "the LLM" — one forward pass, one shot at getting the declaration right. That's fine for a one-time scaffold. It is nowhere near enough for what I actually want, which is software that an AI can build, and then keep evolving as it learns what works. A single stateless model call can author a model once. It cannot maintain one. It forgets everything the moment it returns.
So this essay is the other half of the bet, and it's more of a hint at where I'm headed than a victory lap on something finished. If metadata is the durable model, the interesting frontier isn't just generating it once — it's putting a system in the author's seat that has memory, that learns from outcomes, and that reasons about what it knows. That's the project I've been building alongside MetaObjects. It's called Draagon AI, and the two together are the actual thing.
II. What everyone is actually building
Look at the current generation of "AI builds your app" tools through this lens and a pattern jumps out: they all author once and forget.
The code-gen builders (essay four's Camp A) generate a pile of code from a prompt and discard the reasoning that produced it. The flow builders (Camp B) assemble a graph of fixed nodes and discard everything except the graph. Even the agent frameworks — the AutoGPT lineage, the plan-and-execute loops — mostly spin up a fresh context, run a task, and throw the working state away when they're done. There's no persistent model of what was built, no memory of what failed last time, no mechanism to notice that two decisions contradict each other, no way for the system to get better at building the next thing because it built the last one.
The artifact survives; the mind that made it evaporates. And so every build starts from zero, every mistake is available to be made again, and "the AI built it" means "the AI emitted it once and walked away." That's not how anything that has to improve over time actually works.
III. The two halves I've been building
I've spent twenty-five years on one half of this without realizing it was half of anything: MetaObjects — the typed-metadata spine, the codegen across five languages, the runtime, the drift verify, the prompt pillar. The governable model. The thing essay four says the AI should author.
The other half is the part I'd been treating as a separate problem: a cognitive layer that sits between an application and the LLM and gives it the things a raw model call lacks — persistent memory that learns from outcomes, a belief system that reconciles contradictions instead of storing both, and principled action selection that reasons about uncertainty rather than pattern-matching a plausible next step. (I'll keep the inside of that layer for another essay — there's real machinery in there, and some of it is the part I'm least interested in handing to competitors. The point for now is the shape, not the internals.) It turns a stateless text generator into something that maintains a model of the world and updates it as it goes.
For a long time I built those two as if they were unrelated — one's a metadata framework, one's an agent architecture. They're not unrelated. One is the model; the other is the mind that authors and maintains the model. Essay four is the seam between them.
IV. Mastery: the AI builds a capability, as a model
Here's the concrete version, and it starts where most of my concrete versions start — with the game I've been building characters for.
A developer says: "Build me a D&D game master." In the system I'm describing, that isn't a code-gen prompt. It kicks off a loop that researches the domain, designs the behavior, generates the prompts, validates them, and iterates until the system's own model says the thing is coherent and mature — not until a single pass returns. I've been calling the result a mastery: a complete, self-contained capability — its behaviors, its prompts, its tools, its knowledge, its tests — composed from a natural-language description.
And the part that makes it fit this series: what the loop produces isn't an opaque blob. It's typed metadata — the same kind of declared model MetaObjects already generates databases, APIs, and prompts from. So a mastery is verify-able before it runs. It's diffable. It's portable. It's regenerable into idiomatic code in any of five languages. The cognitive system is the author; the metadata is the artifact; verify is the gate. When the developer later says "the combat damage rules are wrong," the system doesn't need to be told what to re-edit — it detects the conflict against what it believed, figures out what cascades from the correction, and the next iteration flows toward the disturbance on its own.
That is dynamic, metadata-driven app creation: not "type a prompt, get a frozen app," but a cognitive agent that authors a living model, validates it, generates from it, and keeps evolving it as it learns — with a governable spine underneath the whole time so the evolution is bounded and inspectable instead of a black box drifting in production.
V. Why the two together is the bet
Either half alone is interesting. Together they're the thing I actually believe in.
MetaObjects without the cognitive author is a very good metadata framework that a human (or a one-shot LLM) drives. Draagon AI without the governable model is a clever agent that builds things you can't fully inspect, validate, or regenerate — Camp A's chaos with a better memory. But a cognitive system authoring a typed, validatable model is the combination that has the property I care about most: schema-safe evolution. The AI gets to remember, learn, and rebuild — and every change it proposes passes through verify against a typed model before it touches anything real. The mind is free to evolve the system; the spine keeps the evolution honest.
That's the autonomy slider from essay four made concrete. You can turn the AI's authority up — let it research, design, and compose a whole capability unsupervised — because what it produces is a small, typed, reviewable model gated by validation, sitting on top of regenerable code. Crank it down and the cost is near zero, because the durable thing was the model all along. You can't run that slider over a pile of generated code or a frozen flow. You can run it over a model a mind maintains.
VI. Where this is heading
I want to be honest about what's shipped and what's horizon. MetaObjects is real and in production — the model, the codegen, the runtime, the prompt pillar, the drift gate. The cognitive layer is further along than a sketch and earlier than a launch. And "a cognitive system that authors and continuously evolves a governable metadata model" is the direction I'm building toward, not a box you can buy today. This essay is the hint, not the announcement.
But I've stopped thinking of MetaObjects and Draagon AI as two projects. They're the two halves of one bet: that the future of software isn't an AI that writes code you can't govern, and isn't a tool that fills in blanks it can't escape — it's a mind that authors a model, where the mind can learn and the model can be trusted. The model is the asset. The mind is the author. Validation is the contract between them.
That's where I'm headed. The next essays will get more specific about how the mind half actually works — the work, as always, not the rhetoric.
This is the fifth essay in a series. The first was the drift problem; the second placed the metadata layer against the AI stack; the third showed the prompt is the same spine; the fourth argued the AI should author the model. This one names the mind I want in the author's seat. My writing lives at dougmealing.com/writing, and I'm always up for a conversation about any of this — drop me a note.