The best part is the part I understand least

Every agent is a split between two things. A model that decides, and the deterministic code you write around it. The question that never goes away is how much to hand to each, and I keep landing on the same lean: give the model more than feels comfortable.

The reason is easy to say and hard to accept. Given room, a good model makes better judgments than the rules I would write for it. It is not that it is smarter in some grand sense. It can hold the whole messy situation at once and weigh it, where my rules only ever capture the few cases I thought of in advance. Every time I have pinned its behavior to what I already understood, the output got narrower and flatter. Every time I gave it room, it surprised me, usually for the better.

That is an uncomfortable thing to sit with, because it means the most valuable part of the system is the part I understand least. I cannot fully write down what makes its judgment good. I can only watch that it is.

Why I keep the deterministic parts anyway

If the model is the better judge, why write any deterministic structure at all? Two reasons, and neither is about making it dumber. The first is that I need to see what happened. Determinism is the part that stays inspectable, the part I can look at, reproduce, and change one piece at a time. You cannot improve what you cannot inspect. The second is cost. A model free to weigh everything is slow and expensive, so you do the cheap, predictable work in plain code and save the model for the moments that actually need it. The deterministic parts are there to make the smart part affordable and legible.

The hardest constraint is not about the model

The thing that took me longest to learn is that the hardest constraints have nothing to do with what the model can do. They are about the person on the other end. A model will happily do more than the experience can bear, more clever, more thorough, more present than anyone actually wants. So the real work is rarely about getting the model to do something. It is about deciding how much of what it can do should reach the person at all.

I can see this idea in both things I have built. In Akarii, an agent that lives in a team’s chat, the model decides on its own when to speak. It turned out to be good at knowing when it could help, and the real design problem was teaching it when not to jump in. In Omaru, where the model shapes real work for a person building a business, the hard part was the same, keeping it to what genuinely serves them rather than everything it could produce. Two different products, the same instinct underneath: let the model do the judging, and spend your control on the human at the other end.

Where I keep the dial

So the dial I reach for looks like this. Let the model make the judgment, because that is its real edge. Keep deterministic structure for what you must be able to see, and what would otherwise cost too much to run. Then spend your hardest constraints on what the experience can bear, which is a different question from what the model can do.

Most of my mistakes sit at the ends. I have written rules where I should have trusted the model, usually because I wanted to feel in control. And I have let it run where I should have held a hard line, because I was impressed by how well it was doing.

I still lean toward giving it room. The part I am sure of is smaller than I would like. The judgment, I am glad to hand over. The decision about what the experience can bear, I am keeping.