More compute reliably produces more AI discoveries — but does that rule hold when the discoverer is an autonomous agent?

This explores whether the finding that scientific discovery (like architecture search) scales predictably with compute also holds for agentic systems. The corpus says: largely yes, with one sharp caveat about coordination. The anchor result is that autonomous architecture discovery follows an empirical scaling law — ASI-ARCH found 106 state-of-the-art designs across 1,773 experiments, and breakthroughs scaled with GPU compute rather than with human cleverness Can computational power accelerate scientific discovery itself?. The interesting move is to ask whether that compute-scales-discovery pattern is a quirk of architecture search or a general property of search itself.

Several notes suggest it's general. Deep research agents exhibit a test-time scaling law where search budget — the number of retrieval steps — follows the same diminishing-returns curve as reasoning tokens, making search a compute axis you can trade against reasoning How does test-time scaling work for individual research agents? Does search budget scale like reasoning tokens for answer quality? Do search steps follow the same scaling rules as reasoning tokens?. So 'spend more compute, find more' isn't unique to discovering architectures; it reappears whenever an agent is exploring a solution space. Reasoning systems can even scale in width — sampling parallel latent trajectories — to cover that space without paying the serial latency of going deeper Can reasoning systems scale faster by exploring parallel paths instead?.

There's a deeper reason discovery keeps paying off rather than saturating. Agentic graph reasoning self-organizes into a critical state where roughly 12% of connections stay 'semantically surprising' even after they're structurally linked — meaning the system keeps generating novelty as it runs, fueling continuous discovery instead of collapsing into repetition Why do reasoning systems keep discovering new connections?. That's a mechanism for why a discovery scaling law could persist at the agent level: the search frontier doesn't go dry.

But here's the thing the question doesn't anticipate. When you scale agentic systems by adding *agents* rather than compute-per-agent, the curve bends the wrong way. Multi-agent coordination degrades predictably with network scale — agents commit too late or adopt strategies without telling neighbors, and they accept information without verifying it, so errors propagate Why do multi-agent systems fail to coordinate at scale?. And most multi-agent performance gains turn out to be a token-spending function: ~80% of the variance is budget, not coordination intelligence How does test-time scaling work at the agent level?. So scaling 'works' largely because you're spending more compute, not because the collective gets smarter — which is consistent with the discovery scaling law, but also a warning that adding bodies is not the same axis as adding compute.

What this leaves you with: the scaling law for discovery does extend to agentic search and reasoning, but the gains live in the compute axis (search budget, trajectory width, self-organized novelty), not in coordination. Reliability at scale comes from externalizing memory, skills, and protocols into a harness rather than from model or population size Where does agent reliability actually come from?, and efficiency techniques across memory, tools, and planning all converge on the same structural constraints — context bounding, fewer external calls, controlled search Do efficiency techniques across agent components reveal shared structural constraints?. The honest synthesis is that discovery scales with compute even for agents; coordination is the part that resists the curve.