If you're building anything with AI agents, the default solution is always the same: bolt on a chat. And it works, at first. The user types, the agent replies, edits things, generates content, it feels like magic. But as soon as the task gets long and structured (drafting a full document with many parts, say) the chat starts falling apart. And the problem isn't the model, it's the interface.
The real problem with chat
No matter how sharp the agent is, when it drafts something long in one go it can't hold everything in mind at once. It forgets something in one part, and that gap drags through the rest of the document. You end up correcting by hand, checking for hallucinations (that's a post on its own), and, more than anything, chat forces serial work: one prompt, one reply, the next prompt. If you want several parts to move forward at the same time, you either launch each one yourself, one by one, or keep one endless conversation slowly generating everything.
And that's the real issue: parallelizing well with agents is a skill. An expert user knows how, and for that user chat is still great for reviewing and fine-tuning at the end. But if your product is for people who aren't AI experts, they won't know how to parallelize, and they shouldn't have to learn. They'll end up with fifteen loose prompts or one endless conversation, and the feeling that the AI is creating more work than it saves.
The alternative: the agent matrix
Companies like Harvey and Legora, in the legal world, use a pattern that solves this: a table instead of a chat. The rows are the parts of the document that need to get written. The columns are state variables: what phase each part is in, which sources it maps to, what details and analysis are attached to it.
The process runs in three phases:
Matching. Before anything gets written, a sweep of agents connects sources to document parts. And the order here matters: if you ask an agent "which sources do I need for this part?", it has to read every source, which gets expensive fast. If instead you give a single source to an agent and ask "which parts does this apply to?", you get one agent per source working in parallel, much cheaper and much faster.
Verification. Once the table is filled in, the user can scan it at a glance and check whether the matching makes sense: is something there that shouldn't be, is something missing, is anything mapped wrong. All with clicks, no typing.
Drafting. One click spins up a subagent per row, and each one drafts that part using the information assigned to it. The user can still leave a short comment on a row to add nuance, but they need to less and less: with a shared memory and context layer (another topic for another post) the system increasingly learns from your inputs rather than your prompts.
Why this beats one long document
Going part by part instead of generating everything in one pass solves three problems at once: no single agent doing all the work, no single agent carrying the full context, and by parallelizing the whole system, the process is much faster.
But the real reason the matrix wins is a product reason, not just an architecture one: it forces parallelization and specialization without the user having to think about it. They see the whole matrix at a glance, understand what state each part is in, and steer the process instead of executing it. That's exactly what someone who doesn't know how to run agents in parallel needs: a system that parallelizes the work for them without being asked.
Chat doesn't disappear
It still has a place, just as a final layer instead of the main engine. Once the matrix has drafted each part, chat is where you connect two sections better by hand, or ask for a general review. There can also be an agent that reviews the entire document as an extra step, at a global level, once everything is drafted.
The difference is that chat is now the fine-tuning step, not the whole process. And that shift, from engine to fine-tuning, is what actually makes a product stop feeling like a chatbot on steroids and start feeling like a real work tool.
Where I'm applying this
I built all of this for Fórmular, the product I'm working on: a platform that lets institutional real estate firms generate technical due diligence and monitoring reports with AI agents. The agent matrix is exactly the piece that replaced chat as the primary way of drafting a report, and chat became the fine-tuning layer I described above. If you want to see how this works in a real case, that's it.