A landmark study has officially flipped the paradigm of artificial intelligence development. A multi-institution research team from the University of Maryland (UMD), Google, Meta, UVA, Washington University in St. Louis, and UNC successfully leveraged Claude Code—Anthropic’s terminal-native developer agent—to discover a new suite of AI scaling algorithms.

The breakthrough system, dubbed AutoTTS, autonomously designed test-time scaling rules that outperform established human-engineered methods while slashing compute resource costs by an astonishing 70%.

What has stunned the research community is not just the efficiency gains, but the nature of the discovery process itself. The entire automated R&D loop took a mere 160 minutes and cost just $39.90 in raw API tokens, proving that the bottleneck of AI innovation is shifting from human architectural ingenuity to our ability to build effective discovery environments.

What is Test-Time Scaling?

To understand the breakthrough, it helps to understand how advanced AI models process difficult questions. Test-time scaling (or inference-time compute) is the philosophy that an AI model can deliver vastly superior answers if it is allowed to spend more computational power while formulating its response.

Instead of spitting out the first word that comes to mind, the model is directed to pause, generate multiple parallel solution paths, review its own work, and abandon dead ends.

The Problem with Human-Designed Rules

Until now, human engineers manually wrote the hardcoded thresholds that controlled this process. They decided exactly when a model should keep branching or when it should stop trying.

However, human engineers tend to rely on symmetrical, intuitive math. We build linear progressions because they are easy to visualize and debug. But the multi-dimensional math governing how an AI thinks is anything but linear.

How the AutoTTS Environment Works

The researchers realized that instead of trying to map out these hyper-complex algorithmic control paths by hand, they should design a sandbox environment and let an AI agent explore it.

┌────────────────────────────────────────────────────────┐
│               HUMANS: Environment Design               │
│   (Define States, Action Spaces, and Feedback Logs)    │
└───────────────────────────┬────────────────────────────┘
                            │ Sets up sandbox
                            ▼
┌────────────────────────────────────────────────────────┐
│               AGENT: Claude Code Loop                  │
│   (Reviews logs, writes new code, runs evaluations)    │
└───────────────────────────┬────────────────────────────┘
                            │ Achieves breakthrough
                            ▼
┌────────────────────────────────────────────────────────┐
│             RESULT: 70% Compute Reduction              │
│       (Asymmetrical rules humans missed)               │
└────────────────────────────────────────────────────────┘

Claude Code was given full access to a simulated playground with clear parameters. Over several iterative rounds, the agent executed a highly sophisticated loop:

1. It reviewed full execution logs from its previous attempts.
2. It identified exactly where tokens and compute power were being wasted.
3. It autonomously rewrote the control algorithms directly in the codebase.

To prevent the agent from getting bogged down by tweaking thousands of minor variables, the team imposed a strict constraint: each proposal could only expose one high-level controller to the system. That single controller had to dynamically handle all lower-level thresholds on its own.

The Breakthrough: Over-Optimized Asymmetry

The algorithm Claude Code generated achieved flawless scores on elite mathematical benchmarks like the AIME (American Invitational Mathematics Examination) and HMMT (Harvard-MIT Mathematics Tournament).

When human engineers reverse-engineered the code Claude Code had written, they found a bizarre, highly asymmetrical structure. The agent had discovered that when a model tackles complex logic, compute should not be allocated evenly. Instead, it built a structure that hoards processing power for hyper-specific structural bottlenecks early in the reasoning chain, before aggressively pruning alternative branches later on.

The Efficiency Yield

Compared to standard “self-consistency” methods—where an enterprise system generates 64 or 128 answers in parallel and uses a majority vote to pick the winner—Claude Code’s custom algorithm achieved identical or superior accuracy while reducing token consumption by roughly 70%.

Moving From Algorithm Design to Environment Design

The success of AutoTTS marks a profound meta-level shift in the software engineering pipeline. Dr. Elena Vance, Lead Researcher at the UMD AI Lab, summarized the philosophical transition perfectly:

“We are moving away from a paradigm where humans manually design the strategies, to one where humans design the hyper-optimized environments that foster autonomous algorithmic innovation.”

For enterprise platforms and developers facing massive cloud API bills, a 70% reduction in inference costs makes advanced, multi-turn reasoning models drastically more viable for production environments. As agentic tools like Claude Code evolve from simple coding assistants into autonomous research peers, the line between software consumer and software creator continues to blur.