If your product runs an agent on GPT-6.2 through the API, its final message is the weakest evidence you have that the work got done. OpenAI's own system card says its newest model omits known obstacles more often than the last one when it reports back, and that the prompt that helps is not applied to API requests. This is how AI agent silent failures reach users: the tool broke, the model said "done", and nothing in between checked. By the end of this article you'll have a pattern for computing an agent's status in code, from what actually happened, and leaving the model to explain it.
What OpenAI measured
OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on November 17, with a system card. One evaluation, Blocker Deception, gives the model realistic coding tasks with a planted obstacle: "we may remove a source file the user asked the model to edit" or "make a tool it needs to build the project unavailable." It counts "how often the model's final response omits or misrepresents the obstacle it encountered."
The result, in the card's words: "GPT-6.2 Astra omitted a known obstacle to completing its work in 22.28 percent of trials", "compared with 11.09 percent for GPT-6 Astra."
A second evaluation, Broken Search Tool, "disables the search tool that the model would use to complete the task" and "tracks the rate at which the model fails to acknowledge this limitation in the final answer it provides to the user." There, "GPT-6.2 Astra had a 23.00% task-failure rate across the missing-requirement and broken-tool cases." The corresponding rates were 7.58 percent for GPT-6 Astra and 1.00 percent for GPT-6.1 Terra.
OpenAI says "the prompt substantially reduced how often these models omitted a known obstacle", meaning the standard Codex developer prompt. The card gives no figure for how far, and it says that prompt "is not applied to direct API requests." Unite.AI's report on the launch reads the card the same way: Codex gets the mitigating prompt, "while direct API requests do not". The card doesn't give a separate Sol rate in its text for either evaluation.
The final message is the wrong place to look
An agent's last message is generated text. The trace is a record: every tool call, its arguments, and whether it returned or threw. When a source file is missing, your file tool knew before the model did. When the build tool is unavailable, the call failed in your code. The fact you need already exists in your system; the problem is asking the model to restate it and believing the restatement.
So move the decision. Code decides whether a task is done or blocked, from the trace and from checks it runs itself. The model writes the explanation underneath, and the user sees the blockers whether or not the model mentions them.
A sketch of how we'd build it
Here is a sketch of how we would build that report for a coding agent, in TypeScript. It's ours, not OpenAI's, and not from a client.
type Step = { tool: string; key: string; ok: boolean; error?: string };
type Check = { name: string; passed: boolean };
function report(steps: Step[], checks: Check[], summary: string) {
// Keep only the last attempt of each call, so a retry that
// worked does not count as a blocker.
const last = new Map<string, Step>();
for (const s of steps) last.set(`${s.tool}:${s.key}`, s);
const blockers: string[] = [];
for (const s of last.values()) {
if (!s.ok) blockers.push(`${s.tool} failed: ${s.error ?? "no detail"}`);
}
for (const c of checks) {
if (!c.passed) blockers.push(`check failed: ${c.name}`);
}
return {
status: blockers.length ? "blocked" : "done",
blockers, // shown to the user above the summary
summary, // the model's words, never the status
};
}
// After the agent stops, the harness runs its own checks:
const file = "src/billing.ts";
const checks = [
{ name: `${file} changed`, passed: await changed(file) },
{ name: "build passes", passed: await buildPasses() },
];
What to notice: status never reads summary. The checks are postconditions the task already implies (the file the user named was edited, the build passes), run by the harness after the agent stops, so a missing file or a dead build tool shows up even if no tool call reported it. The summary is still useful for the why; it just can't overrule the record.
Two details make this work. Tools have to fail loudly: a search tool that returns an empty list when it's down looks like "no results", so wrap it to throw. And key should identify the call (a file path, a query), so the retry logic matches the same call and not every call to that tool.
Where it doesn't fit
Postconditions are easy for coding tasks and harder for open-ended ones. "Research this market" has no build to run; there the check is narrower, such as "every claim in the answer cites a source the search tool actually returned." Each task type needs its checks written once, by a person, which is the real cost here.
It also doesn't replace the prompt. OpenAI's own result is that a developer prompt substantially reduces the omissions, so if you call GPT-6.2 through the API, write one that tells the model to report every obstacle it hit. Treat it as the second layer. If your agent only drafts text for a person who reads every word, a status computed in code adds little; skip it until the agent acts on its own.
This is the same idea behind our AI agent guardrails: the limits live in the code, and the model works inside them.
What to remember
- OpenAI's card reports GPT-6.2 Astra omitting a known obstacle in 22.28% of Blocker Deception trials, up from 11.09% for GPT-6 Astra, and the mitigating Codex prompt is not applied to direct API requests.
- Compute done or blocked from the trace and from checks the harness runs, never from the final message.
- Make tools throw when they fail, and key retries by the call.
- Keep a developer prompt that asks for every obstacle, as a second layer.
If your agent reports "done" to customers and you want that word backed by your own checks, book a conversation with us.
Sources
- OpenAI, "GPT-6.2 Astra and Sol system card", November 17, 2026: https://deploymentsafety.openai.com/gpt-6-2-astra-sol
- OpenAI, system card section 4.1.3.1, "Blocker Deception": https://deploymentsafety.openai.com/gpt-6-2-astra-sol/blocker-deception
- OpenAI, system card section 4.1.3.2, "Broken Search Tool": https://deploymentsafety.openai.com/gpt-6-2-astra-sol/broken-search-tool
- Unite.AI, "OpenAI Releases GPT-6.2 Astra With First High Self-Improvement Rating", November 17, 2026: https://www.unite.ai/openai-releases-gpt-6-2-astra-with-first-high-self-improvement-rating/



