Agentic Architect: An Agentic AI Framework for Architecture Design Exploration and Optimization

1. Problem Statement

Computer architecture design is facing a bottleneck due to the slowdown of Moore's Law. Modern microarchitectures operate in vast, combinatorial design spaces where performance depends on complex interactions between policies (e.g., cache replacement, prefetching, branch prediction).

• The Challenge: Traditional design relies on manual human effort to iterate through policies, implement them, simulate them, and refine them. This process is slow, relies heavily on expert intuition, and often leaves significant performance gains unexplored because the design space is too large to search exhaustively by hand.
• The Gap: While Large Language Models (LLMs) have shown promise in code generation, their application to systematic microarchitectural design exploration—specifically combining LLMs with cycle-accurate simulation and evolutionary search in an open, modular framework—has been limited.

2. Methodology: Agentic Architect

The authors introduce Agentic Architect, an end-to-end open-source framework that couples LLM-driven code evolution with cycle-accurate simulation. It operates as a co-design system where the human architect defines the search space, and the AI agent explores it.

Core Workflow

1. Human Inputs: The architect provides:
   • Seed Policy: An initial implementation to start the search.
   • System Prompt: Defines the domain, hardware constraints, and function interfaces.
   • Scoring Function: A metric to evaluate performance (e.g., IPC, miss rates).
   • Trace Database: Split into training (for evolution) and held-out (for generalization) sets.
2. Evolutionary Loop:
   • Mutation: An LLM (e.g., Claude Opus, Gemini) takes the current best candidate and generates a mutated version of the code.
   • Compilation-Gated Evolution: Candidates are compiled first. Syntax errors or type mismatches are caught immediately, and the error is fed back to the LLM to prevent wasting simulation time.
   • Simulation: Valid candidates are executed on a cycle-accurate simulator (e.g., ChampSim) using training traces.
   • Evaluation: A scoring function aggregates metrics (IPC, MPKI, etc.) into a scalar fitness score.
   • Selection: The solution database maintains a diverse population of high-fitness candidates for the next iteration.
3. Modularity: The framework is designed to be agnostic to the specific simulator, LLM, or evolutionary strategy (e.g., OpenEvolve, AdaEvolve), allowing flexible experimentation.

3. Key Contributions

1. First End-to-End Framework: Agentic Architect is the first open-source framework specifically for agentic AI-driven CPU microarchitecture optimization, integrating LLMs, evolutionary search, and simulators.
2. State-of-the-Art (SOTA) Results: The framework successfully evolved designs that match or exceed human-designed SOTA policies across three distinct domains with varying constraint levels.
3. Systematic Analysis of Design Factors: The paper provides a deep dive into how human decisions (seed selection, prompt strategy, trace selection) impact the quality of the evolved design.
4. Discovery of "Learned Ensemble Patterns": The authors identify that LLMs do not invent fundamentally new algorithms from scratch but rather synthesize known techniques into novel, tightly coordinated architectures with runtime adaptivity.

4. Key Results

The framework was evaluated on three microarchitectural domains:

A. Cache Replacement

• Baseline: LRU and Mockingjay (SOTA reuse-distance predictor).
• Result: The evolved policy achieved a 1.062× geometric mean IPC speedup over LRU.
• Improvement: It surpassed the Mockingjay seed by an additional 0.6% (Mockingjay was 1.056×).
• Mechanism: The evolved design combined a 3-way ensemble predictor (Reuse Distance, PC-transition, Set-context) with dynamic arbitration and eviction regret tracking.

B. Data Prefetching

• Baseline: No prefetching and VA/AMPM Lite (seed).
• Result: The evolved prefetcher achieved a 1.76× geometric mean IPC speedup over no prefetching.
• Improvement: It outperformed the VA/AMPM Lite seed by 17% and the reference SOTA design (SMS) by 21%.
• Mechanism: It evolved a six-engine architecture with runtime adaptivity (re-evaluating engine accuracy every 256 accesses) and MSHR-aware throttling, dominating across diverse access patterns.

C. Branch Prediction

• Baseline: Bimodal and Hashed Perceptron (seed).
• Result: The evolved predictor achieved a 1.100× geometric mean IPC speedup over Bimodal.
• Improvement: It improved upon the Hashed Perceptron seed by 1.5%.
• Mechanism: The design integrated a TAGE-SC-L backbone with a multiperspective perceptron, discovering local-history correlations that the seed missed, particularly on the gobmk trace (39% reduction in mispredictions).

Generalization & Sensitivity Findings

• Seed Quality is Critical: Evolution refines and extends a seed but cannot compensate for a weak foundation. Stronger seeds consistently produced stronger final designs.
• Prompt Strategy: Minimal prompts (defining the problem without naming specific techniques) outperformed prescriptive prompts (naming specific algorithms). Prescriptive prompts often led to overfitting or complex, timeout-prone code.
• Trace Selection: Training on diverse traces is essential for generalization. Over-specializing on a single sensitive trace (e.g., xalancbmk) hurt performance on the broader benchmark suite.
• Model Choice: While more capable models (Opus 4.6) yielded better results, they came with significantly higher API costs.

5. Significance and Future Directions

• Reframing the Architect's Role: The paper argues that the human architect's role is shifting from implementing policies to structuring the search. The architect defines the seed, the scoring function, and the constraints, while the AI handles the exploration.
• Synthesis over Invention: The primary value of LLMs in this context is synthesis—discovering novel combinations of existing techniques and runtime coordination strategies that humans might overlook due to the complexity of the search space.
• Scalability: Agentic Architect opens a new direction for research, suggesting that future frameworks could co-evolve interacting components, incorporate physical constraints (area/power) directly into the fitness function, and eventually automate parts of the search strategy itself.

In conclusion, Agentic Architect demonstrates that agentic AI, when guided by human expertise in defining the search space, can autonomously discover microarchitectural policies that surpass years of manual human research, particularly in complex, multi-component design problems.