What was the strongest AI engineering research this week?

AREX, a family of recursively self-improving deep-research agents built on the observation that verifying a candidate answer is much cheaper than discovering one, and CodeNib, a system that serves repository context to coding agents as reusable per-commit views with measured quality-cost tradeoffs. Both are verification-and-state infrastructure rather than new model capability.

Why does the discovery-verification asymmetry matter for building agents?

Because it tells you where to spend. If checking an intermediate result costs a fraction of producing it, then the cheapest way to make an agent more reliable is not a bigger model or a longer search — it is a check after every step, with the verified part carried forward. That is the same argument as putting your gates in code rather than prose: you get the reliability from structure, not from the model getting smarter.

This Week in AI: Verifying Got Cheap, Finding Still Isn't

Every result worth reading this week came from the verification side of the loop, not the discovery side. A research agent that improves by checking its own intermediate answers. A security model that broke a post-quantum signature scheme NIST had already vetted through two rounds. A benchmark score that tripled on two API settings and no new model. The field is converging on something you can act on Monday: finding an answer and confirming one are two different economies, and only one of them is getting cheap.

The asymmetry, named

AREX: Towards a Recursively Self-Improving Agent for Deep Research (148 upvotes) starts from a plain observation. Finding an answer that satisfies many constraints at once is expensive; checking a candidate answer usually decomposes into cheap constraint-wise tests. AREX builds on that gap directly — an inner loop gathers evidence and drafts a provisional answer, an outer loop verifies intermediate results and uses the partially verified state to steer the next refinement. The point is not “search longer.” The point is that the verified fragment is the thing worth carrying forward.

That is The Intelligence Loop stated as an architecture rather than a discipline: a failure or a partial result becomes permanent capability only if something captures it. AREX makes the capture step the load-bearing part of the agent, which is exactly the move most production harnesses skip. If your agent re-derives the same three facts on every retry, you are paying discovery prices for work you already verified once.

Repository context, finally measured

CodeNib: A Multi-View Data System for Serving Repository Context to Coding Agents (63 upvotes) is the week’s most immediately useful paper for anyone running coding agents against a real codebase. It treats repository context as a served artifact with a lifecycle: reusable lexical, dense, and structural views built per commit, mapped back to repository-relative source ranges, maintained across edits, and exposed through one runtime for ranked search, symbol navigation, and bounded context.

The number that matters is the honest one. Across 100 snapshots the authors map quality-cost frontiers for the whole repository-context lifecycle, and where their output matches an independent rebuild, graph and vector updates run 8.7x and 25.4x faster at the median. Not “our retrieval is better” — here is the cost curve, pick your point on it. That is the Context Tiering Spectrum argument with a price tag attached: what your agent needs to know is a tiered engineering decision with a measurable bill, not a prompt you paste and hope about.

A tripled score with no new model

OpenAI’s How enabling two settings tripled our scores on the ARC-AGI-3 benchmark is a short post with an uncomfortable implication. The gain came from two API settings — retaining reasoning across turns and enabling compaction — improving both score and efficiency on GPT-5.6.

Read that as a configuration finding, because that is what it is. A 3x on a hard benchmark sat unclaimed behind two flags about what the model keeps between turns. If you have ever argued that your agent needs a stronger model, this is the week to first check what your harness is throwing away at every turn boundary. State handling is not a tuning detail; it is most of the result.

What agents still can’t do, stated plainly

Import AI 466 covers MirrorCode, a new Epoch and METR benchmark for long-horizon programming — tasks that take humans a long time. Two findings ship together: systems can now complete week-long programming tasks, and they still cannot solve the hardest ones. The newsletter’s parenthetical on that second half is “(good!)”, and that is the right reaction — a benchmark with headroom is a benchmark that can still teach you something.

Both halves are load-bearing for planning. Week-long autonomy is real enough to design for. It is also not uniform, which means task selection is now an engineering skill: knowing which of your long tasks are in the completable band, and which will burn a day producing confident wrong output.

Verification lands somewhere that counts

The week’s most consequential story is not about agents at all. Ars Technica reports that a post-quantum signature scheme has been taken out of NIST’s running after an Anthropic security model helped find a flaw that broke it. HAWK had already survived two rounds of NIST evaluation. Cryptographer Matthew Green, quoted by Simon Willison, notes the timing: the industry is mid-migration to exactly this class of algorithm, which makes a new public cryptanalysis capability arriving right now a very mixed gift.

Set the security implications aside for a moment and look at the shape. A machine was pointed at an artifact that human experts had reviewed twice, and it found something real. That is the same asymmetry AREX formalized, running at the highest difficulty setting available.

And the capability side, briefly

Kimi K3 took the week’s upvote crown (353) — a 2.8T-parameter mixture-of-experts model with 104B activated parameters, native vision, a 1M-token context window, and a claimed ~2.5x improvement in scaling efficiency over K2, published with a public repo. Real work. But note what it does not do: a bigger window changes what you can put in front of a model, never what your system does with what comes back.

What the week is confirming

Verification is getting cheap faster than generation is getting reliable. Every item above is a variation on that: check the intermediate result, serve the context you already computed, keep the reasoning between turns, measure where autonomy actually ends. None of it arrives by upgrading a model. All of it arrives by building the structure around one — which is why the reliability you can bank is the kind that lives in code rather than in prose you hope gets followed.

If you want the framework version — context tiering, explicit gates, and an observability layer that makes agent behavior auditable — start at curiochat.ai/software-engineer.