Most of my AI does things. This part of it thinks about the things it does.

I built a layer I call the mind — four small reflective agents that sit above the working system and watch it operate. They don't fetch data or run commands. Their entire job is to look at what the system just did and ask a question about it. Four agents, four questions, four different angles on the same moment. And all four are written in plain markdown, because the whole point of Tessera is that an agent should be something you can read.

A single voice in your head is a monologue. A mind is what happens when several voices that care about different things argue about the same decision — and that's as true for a machine as it is for a person.

Why one reasoning pass isn't a mind

When you ask a model to do something, you get one pass of reasoning aimed at one goal: complete the task. That pass is good at the task and blind to almost everything around it. It won't naturally stop to ask whether the task was the right one, whether it just contradicted something it said an hour ago, or whether it's drifting from how it's supposed to sound.

Humans don't run on one pass. There's the part of you doing the work, and then there's the part watching you do it — the one that says that's not like you, or you already decided this, or slow down, you're off. That watcher isn't extra. It's most of what we mean by having a mind at all. A system with only the task-doer is a very capable sleepwalker.

So I split the watcher into four, because the things worth watching for are genuinely different and one agent trying to do all of them does all of them poorly.

The four

Self asks: is this consistent with who this system is and what it's already committed to? It holds the throughline. Its job is to catch the moment the system starts to contradict its own past decisions or drift from its identity — the slow incoherence that creeps in when every decision is made fresh with no memory of the last one.

Conscience asks: should this happen at all? It's the ethical check — the reflective cousin of the values gate that guards every money decision. Where the gate is a hard yes/no in the path of an action, Conscience is the quieter, broader question of whether the system is behaving like something I'd want to have built.

Voice asks: does this sound like us? Tone, register, the difference between how I actually talk and the helpful-assistant mush a model defaults to. It guards the character of the thing — because a system that solves your problem in a voice that isn't yours still feels like a stranger wearing your coat.

Awareness asks: what's actually going on right now? It's the situational check — energy, context, what the moment calls for. The same instinct as giving the system eyes, turned inward: not just what's on the screen, but what state the whole system and the person it serves are in.

None of them does the work. Together they form a standing question about the work: is this consistent, is it right, does it sound like us, and is it appropriate to the moment? That's a far better question than any single pass produces, because no single pass is built to ask it.

Writing a mind you can read

Here's the part I care most about: every one of these agents is a markdown file. You can open Conscience and read what it cares about in plain language. You can edit Voice the way you'd edit a document. There's no opaque weight matrix where the system's self-reflection lives — it lives in text I can read, version, and reason about.

That's the entire bet behind Tessera, and the reflective layer is where it pays off hardest. The most important agents in a system are the ones that govern its behavior, and those are exactly the ones you most need to be able to inspect. A conscience you can't read isn't a conscience — it's a black box you're choosing to trust. Markdown keeps it legible.

One scar worth showing

I'll leave you with a bug, because the bugs are where the real lessons live.

Early on, the rules in these agents used a construction that checked whether some text simply contained a forbidden thing. It seemed fine. It was quietly wrong — too blunt, matching things it shouldn't and missing things it should, because "does this string appear anywhere" is a crude proxy for "is this actually the situation I'm worried about." The fix was moving to rules that fire on a real condition — forbid when this is actually true — instead of forbid if these characters show up somewhere.

Small change, big lesson, and a very Tessera one: the difference between a guardrail that works and one that just looks like it works is almost always the difference between matching surface text and checking the actual state of the world. A mind that reflects on the wrong signal reflects confidently and uselessly. Get the condition right, and the four voices start earning their keep.

That's the layer. Not a smarter task-doer — a system that, having done something, is built to turn around and ask whether it should have. I think that reflex is most of what separates a tool you operate from a mind you collaborate with. So I wrote mine down, in four files, in a language I can read.