I was testing the business agent I built for Otian on something real: drafting an email with an agenda and action items for a client. The agent came back almost immediately. Professional tone, clear structure, specific-sounding deliverables. It looked great.

It was also completely made up.

The action plan it wrote wasn’t for that client. It wasn’t even close. The agent had invented a generic, plausible-sounding plan and presented it with total confidence, as if it had known the client for months.

The Client’s Files Never Loaded

An AI model doesn’t store knowledge the way you do. The model itself carries nothing between runs. What it knows depends on what is loaded at the start. In Archie, that includes what your agent has learned about you and a list of the files you gave it, which it opens when it needs them.

In the agent I was testing, those startup files are called bootstrap files. They work as the agent’s briefing document: who the client is, what the project involves, what’s already been decided, what’s still open. Before the agent does anything, it reads those files and builds a working picture of the situation.

The routing is what tells the agent which files to load and when.

On that test run, the routing had a gap. The bootstrap files for that client either weren’t loaded or were skipped entirely. So when the agent went to write the email, it had nothing real to work from: no client name, no project context, no actual action items, only a prompt asking it to draft something professional.

So it did what language models do when they don’t have what they need, and filled in the gaps with confidence.

The agent had no way to know that it didn’t know.

The Confidence Is the Dangerous Part

This is what makes hallucination actually tricky. If the agent had said “I don’t have enough information to write this,” you’d fix the problem. But it didn’t. It produced something that looked completely real: professional formatting, specific language, the right structure. Nothing in the output signaled that any of it was invented.

That’s how these models work. They don’t experience uncertainty the way you do. They reason from what’s in front of them, and if what’s in front of them is incomplete, they complete the picture themselves, with no drop in polish or confidence.

What This Taught Me About Building Agents

After that draft, I went back and tightened the routing. Every client context, every project file, every relevant document loads before the agent touches anything else. The agent doesn’t get to write a single word until it’s been properly briefed.

But the deeper lesson was that the agent’s decision was reasonable. Given what it had, it did exactly what it was supposed to do: write a professional email with an agenda and action items. The inputs were what broke.

Building a good agent is mostly about getting the inputs right.

It’s natural to judge an agent by its output: did it do what I asked? The more useful question is whether it had what it needed to do it correctly. That’s the part you build, and it decides whether you get a real plan or a convincing fiction.

Why We Build the Context With You

When we set an agent up with you, we build its context with you: the documents, the routing and the information it has access to. Anything after that is scoped and priced before we start.

An agent with the context it needs is wrong much less often. One running on incomplete context still sounds sure, and that is the dangerous case. In my experience, the setup makes more of the difference than the model.

If you’ve tried an AI tool that seemed to make things up, missing context is the first thing I’d check. It’s fixable once you know what to fix.