Why a Better AI Model Can Still Do the Wrong Work
Why a Better AI Model Can Still Do the Wrong Work
Say you run product at a software company, and the pricing review is next month. You ask an AI agent to research your competitors' pricing.
The report comes back long and confident. It compares eight companies, including three you never lose deals to. It quotes one competitor's price from an old deck in your shared drive, though that competitor has changed its price since. It ends by recommending a free tier, which your leadership team ruled out last quarter.
So you switch to a stronger model and run it again. The writing is better and the plan is longer. The free tier is still there.
When an agent's work misses, it's tempting to start with the model. Sometimes that's the right repair, because a task can be beyond what a model can do. But nothing this agent was missing lived inside the model. Nobody told it which competitors matter, which prices are current, what decision the report is for, or that the free tier is closed. A stronger model can't know those things. It can only write around them more convincingly.
Engineers at Anthropic and OpenAI call the software around their coding agents a harness: the tools the agent can call, what it's shown and the checks on its output. Every organization builds a second one around its agents, whether it means to or not. The pricing report already shows you three parts of it: the assignment, the documents in the shared drive, and whoever decides what's off the table. All three let it down.
A failed run can fail in different places
Microsoft Research's AgentRx project went through 115 failed agent runs by hand and sorted the failures into nine categories. Some are the model's own mistakes, like inventing information or misreading what a tool returned. But two arrived with the request itself: it was under-specified, or the available tools couldn't support it. AgentRx is built to find the exact step where a run became unrecoverable, because when several agents work together, a failure can pass from one to the next and hide where it started.
Those two groups need different repairs. In the pricing report, the wrong competitors and the free tier came from the assignment, so the repair is a clearer assignment. The old price came from the shared drive, so the repair is telling the agent which pages count as current. You already tried the stronger model, and it fixed neither. If every miss becomes a reason to change models, the team never learns which of these it had.
Say what the work is for
"Research our competitors' pricing" describes an activity. It doesn't say what the result is for. Compare it with this: "Write a two-page brief for the pricing review comparing the current public plans of these five competitors, and end with one recommendation on our mid-tier price. The free tier is off the table."
The second version lets the agent plan, and it lets you judge what comes back. You can see whether it covered the five competitors, used current plans and answered the question about the mid-tier price.
Before the agent starts, the assignment should answer a few questions:
- Who will use the result, and for what decision?
- Which choices are already made and shouldn't be reopened?
- Which constraints matter more than speed or completeness?
- What has to be true before you accept the work?
- What should the agent do if the brief can't be met?
The last one is easy to skip. If two of the five competitors don't publish their prices, you want the agent to say so, not estimate them.
The assignment also tells you whether an agent is the right tool. OpenAI's practical guide to building agents suggests starting with work that involves complex decisions, rules that are hard to maintain, or a lot of unstructured information like documents and conversation. Otherwise, it says, "a deterministic solution may suffice." Copying list prices into a table every week may be a job for a script. Working out what a competitor's new plan means for yours is the kind of judgment an agent can help with.
What the agent knows and what it can touch
Pointing the agent at the whole shared drive doesn't help as much as it sounds. The drive with that old pricing deck also holds the brainstorm where someone floated a free tier, and the agent has no way to know which ideas became decisions. Somebody has to mark which documents are approved and current, and which are drafts, guesses or still open, before the agent reads them.
There's also what the agent never sees. An OpenAI team spent five months building an internal product without writing any code by hand. The Neuron's report on that work quotes OpenAI's post on harness engineering: "From the agent's point of view, anything it can't access in-context while running effectively doesn't exist." If the decision to drop the free tier lives in a meeting and a few people's heads, the agent writing the pricing brief can't use it.
Access is the same problem pointed outward. The agent can read competitors' websites and draft the brief, but sending it to the leadership team or changing your own pricing page is someone else's call. If it can edit that page anyway, a wrong number can reach customers. The opposite mistake is quieter: without a tool it needs, it may guess a competitor's price instead of telling you it couldn't get one.
OpenAI's guide says actions that are "sensitive, irreversible, or have high stakes" should "trigger human oversight until confidence in the agent's reliability grows." For the pricing brief, someone has to say which actions those are before the agent starts, so it doesn't have to guess.
The answer changes with the work, too. If the pricing brief later becomes the public comparison page on your website, it needs stricter sources, a different reviewer and a sign-off before it goes live.
Handoffs have to carry decisions, not just files
Longer work often passes between agents, or between sessions of the same agent. Say one agent gathers the competitor plans and another writes the brief. If the writer gets the spreadsheet but not the note that the free tier is closed, it may reopen the question, and nobody notices until the review.
Anthropic's engineers ran into this with long-running coding agents. They found that even Claude Opus 4.5, running in a loop across several context windows, would fall short of a production-quality web app if all it had was a high-level prompt. It tried to do too much at once and ran out of context mid-feature, leaving the work "half-implemented and undocumented" for the next session. A later session might see that progress had been made and "declare the job done." The fix wasn't a different model. A first agent writes out every feature and starts a progress log, and each session after that builds one feature, commits it and updates the log.
Your pricing brief needs the same thing on a smaller scale. Whoever picks it up next, agent or person, should be able to answer:
- What's been finished and checked?
- Which version is current?
- Which decisions are fixed, and what evidence settled them?
- What's still unknown or disputed?
- What exactly should the next step produce, and who reviews it?
Then decide what happens when something breaks. If a competitor's site blocks the agent, the brief should say that price is missing, not fill it in. If two sources disagree, it should show both and ask which one counts. A page that fails to load once can be tried again. Starting the whole brief over fixes none of these.
Checking the work has to change the next run
Finishing isn't the same as being right. The pricing brief can arrive with every section filled in and still quote the old price, and a check that only looks for the sections will pass it.
The checks can be wrong too. Anthropic's guide to evaluating agents describes a grader that rejected "96.12" because it expected "96.124991…", and a test Claude "failed" as written because it found a better solution for the user. The team's answer is to use more than one kind of check: "automated evals for fast iteration, production monitoring for ground truth, and periodic human review for calibration."
Then the lesson has to go somewhere. If you correct the old price in a comment and nothing else changes, next month's brief can make the same mistake. Put each correction where the next run will see it: the five competitors in the assignment, the current pricing pages named as the sources, and the free-tier decision in every handoff. The OpenAI team did the same with code. When its agent kept writing duplicate copies of one helper function, The Neuron reports, the team had the agent write a rule that lets the function live in only one place.
Someone has to own the result
None of these decisions belong to the model. It doesn't decide which pricing page is authoritative, who can approve a price change, how much error the brief can carry, or whether it was useful enough to run again next month. People decide those things.
NIST's AI Risk Management Framework describes AI systems as "inherently socio-technical in nature, meaning they are influenced by societal dynamics and human behavior." Put plainly, the people around a system shape what it does. Among the outcomes NIST asks organizations to reach are written-down roles and responsibilities and a defined process for people to oversee the system.
For the pricing brief, both come down to one named person who settles what the assignment left open, decides what happens when the agent gets stuck, approves anything that leaves the company, and decides whether the brief runs again next month.
When an agent keeps missing, check in this order
Start from the first point where the work went wrong and couldn't recover, the same step AgentRx looks for. Then go through these questions before you change the model:
- Did the agent know the outcome, the audience, the constraints and what finished looks like?
- Did it have current, trustworthy sources and the decisions already made?
- Could the work be split up, handed on, finished and recovered when something broke?
- Did the tools it needed work, and was its access narrow enough to act safely?
- Did the checks catch the mistake that mattered, or only record that the work finished?
- Did earlier corrections change the assignment, the sources, the tools or the checks?
- Was a named person responsible for open questions, approvals and upkeep?
- After all that, was the task still beyond what the model has shown it can do?
Run the pricing report through it and it fails the first question, because nobody named the competitors or ruled out the free tier, and the second catches the old price. On another task, the first seven might come back clean, and then changing the model is the right call. The order just keeps you from replacing the one part you knew how to name while the real cause stays put.
The same brief, on Supanova
Say the pricing brief ran on Supanova's autonomous workforce. You'd describe the project the way the second assignment does: the five competitors, the mid-tier question, the free tier already ruled out. Your atoms do the work, and finished work comes back for your review. That puts you in the owner's seat: you check the brief against what you asked for and decide whether it's ready for the pricing meeting.
Before you upgrade the model on an agent that keeps missing, reread the assignment you gave it. Would a new hire know what to do with it?
Start with a project of your own at supanova.team.
Sources
- Microsoft Research: Systematic debugging for AI agents: Introducing the AgentRx framework (March 12, 2026)
- OpenAI: A practical guide to building agents (April 2025)
- The Neuron: OpenAI's Harness Engineering Playbook (March 12, 2026), quoting OpenAI's Harness engineering post and reporting Ryan Lopopolo's OpenAI Build Hour session
- Anthropic: Effective harnesses for long-running agents (November 26, 2025)
- Anthropic: Demystifying evals for AI agents (January 9, 2026)
- NIST: Artificial Intelligence Risk Management Framework (AI RMF 1.0), NIST AI 100-1 (January 2023)