AI agents will create more ideas. Validation becomes the bottleneck

AI agents are starting to change work in the same way coding agents changed software development. Not because they are suddenly flawless, but because they can cheaply produce drafts, options, hypotheses, and first-pass solutions. In its July 2026 article Conjecture Machines, Google DeepMind names the more important shift: agents may make ideas abundant, but validation remains slow, expensive, and institutional.

The YouTube signal came on July 16, 2026 from Marek Bartos, in a short about AI potentially overwhelming laboratories and peer review. The primary source matters more: DeepMind is not simply saying that AI in science will be smart. It is saying that a new bottleneck is forming.

This is not only an academic issue. The same pattern already appears in companies deploying agents in sales, support, product, engineering, and back office operations. An agent can produce ten CRM enrichment suggestions, twenty email variants, five possible incident causes, or a six-month automation backlog. The question is no longer whether it can propose something. The question is who validates it.

What DeepMind Is Saying

DeepMind describes agents as systems that receive a goal, break it into steps, use tools, run subagents, and correct errors along the way. In science, that means literature review, hypothesis generation, candidate ranking, analysis code, database work, and sometimes experimental design.

Co-Scientist, Google DeepMind's Gemini-based system, is a useful example. According to the official blog, it generates hypotheses, has specialized agents critique them, ranks them in a tournament of ideas, and keeps refining the strongest candidates. In biology or materials research, that can shorten the path from a question to a testable lead.

But that is the key point. Generating a hypothesis is cheaper than proving it. In software, some validation can be automated through tests, type checks, benchmarks, or formal verifiers. In a lab, you wait for cell cultures, reactions, measurements, equipment, budget, and human interpretation. DeepMind calls this the validation bottleneck.

August 24 update: Faraday turns the validation argument into an agent architecture

The new paper Training AI Scientists to Replicate Research, published on August 14, 2026, makes this argument more concrete. Inherent built Replica, a set of 310 tasks from 100 scientific papers. For each task, an agent received a paper with one results figure removed and had 60 minutes, under a limited compute budget, to design and run an experiment that reproduced the result.

Faraday is not “a small model that beat GPT‑5.5 on its own.” It is a 27B model post-trained from Qwen3.6-27B that uses GPT‑5.5 Codex as a coding tool. Its main job is to decide which experiment is worth running, what can be scaled down faithfully, when to change direction, and how to avoid shortcuts that merely produce a similar-looking chart. The stronger system comes from separating scientific judgement from technical execution, not simply swapping in a larger model.

The authors report that Faraday beat standalone Claude Opus 4.8 and GPT‑5.5 on 73% of in-distribution Replica tasks and 60% of held-out tasks from different scientific domains. On the test split, its average score was 6% higher than Claude and 8% higher than Codex. These results come from an automated rubric judge. The authors compared its rankings with expert assessments and found better agreement than with a simpler judge, but they also document disagreements and continue to require human inspection.

For enterprise agents, the architecture matters more than the scientific leaderboard:

• a supervising agent chooses the next step and allocates a limited budget,
• a coding or data agent performs the concrete work,
• every run preserves code, artifacts, history, and results,
• the evaluator uses a task-specific rubric instead of a vague “looks good” judgement,
• a human reviews disputed or expensive outputs and can stop the experiment.

The same pattern applies to CRM enrichment, invoices, support triage, and internal analytics. A cheaper model does not need to produce the final answer. It can direct an expensive tool only when necessary and keep the process aligned with the objective. Faraday is not yet a generally deployable enterprise product; it is research evidence that agent quality can come from role design, evaluation, and an auditable loop—not only from a larger base model.

September 9 update: 10,000 agents still need independent acceptance

On September 8, OpenAI published a proposed solution to the Navier–Stokes existence and smoothness problem, one of the seven Millennium Prize Problems. According to OpenAI, an internal model constructed a finite-time singularity from smooth initial data and smooth forcing. The company released a 166-page mathematical paper together with a Lean formalisation and independent checking instructions.

The wording needs care. OpenAI says the result resolves the problem, but this is a newly published proposal, not yet a generally accepted mathematical fact. The Clay Mathematics Institute rules require publication in a qualifying outlet, at least two years of scrutiny, and general acceptance by the global mathematics community before CMI considers a proposed solution. A buildable Lean certificate is strong evidence, but it does not replace that external process.

The run is unusually concrete as an agent architecture case study. OpenAI reports on the order of 10,000 concurrent agents exploring different problem variants. Codex consolidated useful intermediate results across groups. Agents reached the proposed Navier–Stokes solution after about 88 hours, followed by another 17 hours of Lean formalisation and verification with GPT-6 Astra. The Navier–Stokes effort alone involved 2.7 million messages and roughly 130 billion output tokens.

This is not an instruction to add more agents. Parallel search without a separate verification channel mostly creates more candidates and a larger bill. The transferable pattern has four layers:

1. parallel workers explore genuinely different approaches,
2. a shared registry stores intermediate results, provenance, and dependencies,
3. a consolidation layer selects and combines promising branches,
4. a different mechanism checks the final claim against a fixed specification.

In a company, several agents might reconcile an invoice against a purchase order, contract, and delivery record, while deterministic checks and an accountant still release payment. CRM agents can enrich a company from multiple sources, but every field needs provenance and conflicts go to a human queue. Coding agents can propose fixes in parallel, while tests, security checks, and review—not a model vote—decide what merges.

The key distinction is between verifiability and acceptance. Lean can confirm that a formal artefact follows specified rules. It cannot by itself guarantee that the formal statement captures everything experts mean by solving the original problem, or that no error sits at the boundary between prose and formalisation. Business workflows have the same boundary: valid JSON is not the same as a correctly posted invoice, and a green test is not automatically a safe product change.

OpenAI's announcement demonstrates an extraordinary long-running multi-agent system. Until independent expert review is complete, the responsible description is a proposed solution with formal certificates, not a definitively closed Millennium problem.

September 6 update: Fermat’s Last Theorem shows what a verifier should look like

On September 4, Anthropic published the first complete computer-checked formalisation of Fermat’s Last Theorem. Precision matters: Claude did not discover a new proof. It translated established mathematical reasoning into Lean so a computer could check every logical step.

According to Anthropic’s first-party account, dozens of agents worked largely autonomously for 11 days. They produced roughly 13 million lines of Lean and machine-checkable proofs of 30,300 intermediate theorems, with 29,500 used in the final proof. The run consumed about six billion output tokens from an internal research model Anthropic describes as roughly comparable to Fable 5.1.

The most useful lesson is why the first attempts failed. Agents lost track of project state and stopped collaborating effectively. The successful run used Prove2Me, which maintained a directed acyclic graph of theorem statements and dependencies, separated statements from proof files, and attached natural-language descriptions to make results searchable and reusable. Failed attempts still account for about 7% of the non-boilerplate lines in the final artefact.

Lean checked the result using its three standard axioms, while a separate comparator confirmed that the root statement matched Mathlib’s formulation of Fermat’s Last Theorem. This is the validation step missing from many agent demos: plausible subtasks are not enough; the system must prove that the completed dependency graph still closes the original request.

Companies do not need to adopt Lean to use the architecture:

• represent the goal as an explicit dependency graph and store state, owner and completion evidence for each task,
• separate specification from execution so an agent cannot quietly redefine success,
• keep reusable outputs in a shared registry instead of having subagents repeat work,
• validate the root result with a deterministic test rather than only another language model,
• preserve a human-readable explanation alongside machine checks.

For invoice processing, the verifier can check line totals, VAT rates, currency and purchase-order matching. CRM enrichment can require a schema, a source for every field and duplicate detection. Support triage can use a labelled evaluation set, escalation rules and a ban on automatically closing sensitive tickets. Coding agents can rely on tests, type checks, linting and a reproducible build.

Formal mathematics is unusual because it has an exceptionally strong machine judge. Most company workflows do not. The transferable principle is simpler: the longer and more autonomously an agent works, the less you can rely on its own belief that the task is finished.

The YouTube signal came from Marek Bartos; the technical figures and architecture above come from Anthropic’s primary source.

Why This Matters For Companies

Enterprise AI projects often make the same mistake: they optimize output generation, but not validation.

Take support classification. An agent can classify thousands of tickets. But if there is no sampling plan, escalation rule, error audit, and owner for automation boundaries, it only produces confident labels. In CRM enrichment, an agent can add company data, roles, revenue estimates, and buying signals. Without source checking, sales gets a bad priority list. In invoice and email workflows, extraction is fast, but exceptions, credits, unusual tax rates, and new vendors still need review.

The same applies to product work. An agent can review customer feedback overnight and suggest fifty experiments. That is useful. But if the company lacks capacity to choose, test, measure, and stop, it has produced a more expensive queue.

A good agent does not only speed up creation. It must also speed up the decision about what deserves validation.

A Practical Model: Idea, Score, Evidence, Audit

If I were turning this into a company workflow, I would not build an agent that simply says, "give us solutions." I would require four outputs.

The first output is the proposal: "these 30 leads have the highest conversion chance", "these 12 invoices are risky", "these are three possible causes of churn", or "this is an automation proposal for Make."

The second output is the score. The agent must explain why this item deserves attention: impact, uncertainty, validation cost, error risk, and whether the decision is reversible.

The third output is evidence. Not a vague summary, but links to the source: ticket, CRM record, invoice, meeting note, log, document, customer email, or SQL query.

The fourth output is the audit trail. Who triggered the task, which model and tools were used, what prompt was used, what result was produced, who approved it, and what happened next.

Without these four layers, an agent adds volume. With them, it can add capacity.

How To Build It In n8n Or Make

A practical pilot can look like this:

• Trigger: new support tickets, sales meetings, invoices, or product feedback.
• The agent generates candidates and scores each one for impact, confidence, and validation cost.
• The automation selects only the top items, not the entire list.
• A second agent or rule-based step checks sources and looks for conflicts.
• A human approves expensive or sensitive decisions.
• Only after validation does the output go into the CRM, helpdesk, accounting system, or backlog.
• Every month, measure precision, recall, time saved, escalations, and corrections.

That gives AI the role of cheap candidate generator and validation assistant, not omniscient advisor. It is less flashy, but far more useful.

What To Monitor

The first metric is not the number of generated ideas. It is the number of validated ideas that changed a decision.

The second metric is validation capacity. How many outputs can the team review per day without quality dropping? If the agent produces more candidates than the team can check, you have a queue, not automation.

The third metric is validation cost. Sometimes it is cheaper for a human to do the task directly than to validate a complicated AI output. This is especially true for small one-off tasks.

The fourth metric is false confidence. A strong model with polished language can sound convincing even when it connects the wrong sources. For sensitive decisions, require citations, a second check, and explicit uncertainty.

Security And Limit Signals

Other recent signals fit the same operating model. Anthropic published GRAM, early research into modular access control for sensitive dual-use capabilities. It is not used in production Claude models, but it points in the right direction: powerful models need capability access control, not just better prose.

Jirka Hernik also had Mastermind 31 at the top of his channel, with signals around GPT Sol data deletion and Claude Code limits. From Claude's official documentation, it is clear that teams need to distinguish usage limits, context length, automatic summarization of long chats, and token-heavy tools. The pattern is the same: an agent is not unlimited magic capacity. It has limits, costs, data policy, and checkpoints.

The Takeaway

AI agents will overwhelm good teams with ideas. That is not the failure mode. That is their natural effect.

The failure mode is treating every idea as equally important and sending everything to a human. The better design is a validation funnel: agents generate candidates, score them, cite evidence, discard weak options, and surface only the cases where human judgment is truly costly or sensitive.

For companies adopting AI in real processes, that lesson may matter more than another benchmark. Productivity does not come from more AI-generated text. It comes from knowing what to validate, how quickly, at what cost, and with what risk.

Sources: Marek Bartos YouTube signal AI is turning science into non-science, Google DeepMind Conjecture Machines: AI agents and the new validation bottleneck in science, Google DeepMind Co-Scientist: A multi-agent AI partner to accelerate research, Anthropic An off switch for dual use knowledge in AI models and Claude Help Center How do usage and length limits work?, Inherent's paper Training AI Scientists to Replicate Research, and Marek Bartos's YouTube signal A small model with scientific judgement: Faraday.