Nothing works until the reading does

The first agent I tried to build, early on at Akarii, did not work. Not in a small way. It was unusable. And the reason surprised me, because it had nothing to do with the part I had been worried about.

I assumed the hard part would be the writing. Getting the model to produce good code, good answers, the actual output. That part was mostly fine. The model could write. What it could not do was know the right things before it wrote.

The failure was upstream of the output. It did not matter how well the model could write, because it was writing on top of a thin or wrong or missing picture of the situation. Nothing downstream can fix a bad read.

Where the hallucinations came from

That was the first time I saw model hallucination seriously, and it changed how I think about it. The model was not being stupid. It was doing what any of us would do if we had to answer with half the context missing. It filled the gap, and it filled it with confidence.

Give a capable model the wrong context and it will not stop to tell you it is lost. It writes something plausible on top of what it was handed. The hallucination was not really a writing failure. It was a reading failure one step upstream.

Why the good products feel like magic

This is the part that stuck with me. When something built on a model feels magic, it is usually not because the model is special. It is because someone did the reading well. They got the right context in front of it at the right moment, and the output mostly followed.

As a user it is easy to think the model is just good. Most of that feeling is the system reading the right things for you behind the scenes. The work you do not see is the work that made it feel effortless.

The reading is the part you build

So most of building a good agent, at least for me, has been about reading rather than writing. Deciding what the model gets to see, and when, and how much of it. Which files, which memory, which slice of the situation. That is the harness, and it is where most of the real design lives.

Models help with this more than they used to. One that is better at using its tools reads better on its own, goes and finds what it needs, and writes better because of it. But you are still the one who decides what is even reachable. Good reading is designed, not wished for.

The writing is not free either

None of this means the output looks after itself. A fluent model will also, just as fluently, do the wrong thing, take an action you did not ask for, delete a file, run a command it should not have. So the writing has its own work, and it is a different kind from the reading. Not making the model capable, it already is, but guarding what it does with that capability. Reading is where the quality comes from. Guardrails are how you keep it from doing damage. You need both.

The line you cross by building one

I do not think anyone who has actually built an agent would tell you the writing is the hard part. You learn it in the first week. The generation was never the mountain. The work was getting it to know the right things, and keeping it from doing the wrong ones.

That is one of the cleaner lines I know between having built one of these and having only pictured it. Once you have shipped an agent, you stop being impressed that it can write, and start spending your attention on what it reads and what you let it do.