(Why the most valuable AI agent in my reporting process is the one that checks the others)
A report that looks right is the most dangerous kind of wrong.
The report for our Monthly Technical Review was finished when one of the AI agents flagged a problem. It was an error in the way the results were calculated. It was not new either, because the same wrong results had already been presented to our technical leadership twice.
That error closed a year of changes for me. Time saved was what first got my attention, when I generated the report in Claude Code with Jira connected through MCP. What made me sure was where it led. Git, a simple skill and finally agents that found a serious error and later proposed improvements raised quality, stability and repeatability while the time went down. That was my revelation that this is the direction.
The biggest value of AI in engineering reporting is not faster charts. It is the move from preparing a report by hand to a repeatable process in which specialized agents analyze the data, check each other's results and improve the way the work is done. That process is what makes the report trustworthy.
Speed was not the point. Trust was.
One report and a year of changes
Once a month I prepare a report for our Monthly Technical Review, the meeting where technical leadership looks at the state of engineering quality. It shows the bugs reported, their priorities, the numbers for each team and how many of them are being handled.

Preparing it used to take anywhere from a few hours to a few days and it covered only the basic metrics. Over the last year the report went through five versions and each one made it faster to prepare and gave it better charts.
My team and I started with a BI dashboard that showed the core quality metrics. Then I connected Cursor and Claude Code to Jira through MCP. Now AI could fetch the data and analyze it, which gave us far more flexibility than a traditional dashboard. Next I moved the code of the report and its scripts to a Git repository so that other people could use it and run it on their own. After that I turned the whole process into a skill that generates the report. It standardized the process and made the analysis repeatable, so I no longer had to prepare the instructions every time.
The last version split the work between a team of agents with different roles. The Analyst analyzes the data and draws conclusions. The Verifier checks whether the data is correct and the Architect proposes improvements to the process itself. The agent that analyzes the data is never the one that checks it.
Today my part takes from a few minutes to a dozen or so. I ask the agents to run the report, review the Analyst's analysis, read the report and draw my own conclusions. Then I talk to the people responsible for the areas that need to know the results. My job has moved from building the report to judging it.
The illusion of accuracy
Errors like the one the Verifier found are very hard to detect. Finding one used to take a deep dive of several hours. The error stayed hidden behind a finished and convincing report that had already been presented twice.
This is what I call the illusion of accuracy. The more polished a report looks the less anyone questions it. Every new version gave our report better charts and better charts are easier to believe.
Let's be honest. We trusted the report because it looked good.
A repeatable process made the report faster. Separating the roles made it trustworthy.
The four-eyes principle applied to agents

In banking this is called the four-eyes principle and in engineering we call it code review. The person who builds something should not be the only one who checks it. We apply this rule to code every day, yet it is easy to forget when the output is a chart in a leadership meeting.
An agent that analyzes data has the same blind spot as a person because it believes its own story. The fix is the same as with people. You give the checking to someone else.
Separate roles and separate pages
Anthropic recently published research on how agents use memory. In one task an agent wrote a legal brief from its own notes. When the facts were kept in a single shared table the brief kept 41 of 57 of them, but when the notes were split into one page per contract all 57 survived.
That study is about how one agent organizes its memory and not about a team of agents. The lesson still rhymes with mine, because how you separate the work decides what survives.
Who checks the Verifier?
There is a catch, because the Verifier is an agent as well and agents can be confidently wrong.
Anthropic's article on building strong safety evaluations puts it plainly. "Before trusting a grader, have humans label a sample of the transcripts."
My answer so far is tests, because the Verifier has its own tests. Is that enough? I honestly don't know yet whether a better way exists.
A checker you never check is just another author.
What I've learned
- Speed is not the goal. Trust is. A fast report that is wrong is worse than a slow one because people make decisions based on it.
- The author should not verify their own work. That rule holds whether the author is a person or an agent.
- Design agent teams the way you design human teams. Give each agent a clear role and a clear owner and set limits on what it may do.
- Check the checker. A verifying agent needs its own tests and a human who keeps asking whether those tests are enough.
Final Thought
Twice our technical leadership looked at results that were wrong and nobody caught the error. Checking the data used to cost hours of deep dive.
The last version did more than make the report faster, because it made checking a part of every monthly report. The report still looks just as finished as before. The difference is that now someone checks it.
