Symbiotic Evolution of Agentic HLS

• The paper demonstrates a closed-loop agentic HLS framework where LLMs iteratively correct and optimize hardware synthesis, significantly improving simulation and verification pass rates.
• It introduces a modular workflow that decomposes behavioral C/C++ descriptions, employs differential verification, and uses ILP for constraint-driven optimization.
• The framework leverages quantitative metrics such as area, power, and latency reductions to achieve near-optimal hardware designs with up to 95% success in benchmark validations.

The symbiotic evolution of agentic high-level synthesis (HLS) represents a paradigm in which LLMs and multi-agent AI systems are tightly integrated with HLS tools, progressively enhancing performance, flexibility, and correctness in hardware design automation. This co-evolution leverages the fast iteration, high-level expressiveness, and verification capabilities of HLS, while exploiting LLMs' reasoning and generative capacity to explore, optimize, and adapt circuit architectures and toolchains. The result is a feedback-driven, autonomous design framework in which responsibility shifts from human engineers to AI agents through a gradated taxonomy, resulting in increasingly sophisticated and efficient hardware solutions (Xu et al., 20 Nov 2025, Zhang et al., 1 Feb 2026, Collini et al., 17 Mar 2025).

1. Foundations and Motivation

The rapid maturation of LLMs and agentic hardware design frameworks prompts a reassessment of HLS in AI-driven workflows. While one might anticipate a move toward fully LLM-generated RTL, core limitations of RTL-first approaches—specifically, prohibitively slow simulation and the absence of a golden executable reference—render them suboptimal for agentic design space exploration (DSE). In contrast, HLS tools translate behavioral C/C++ or SystemC descriptions into efficient RTL while preserving semantic correctness, providing millisecond-scale simulation, regression testing, and a versatile transformation algebra through pragma directives (Zhang et al., 1 Feb 2026).

HLS thus acts as a “golden reference” abstraction layer for agentic optimization. It enables rapid, portable, and permutable development cycles, making it the ideal scaffold for AI-driven hardware co-design (Zhang et al., 1 Feb 2026).

2. Agentic HLS Frameworks and Co-Optimization Loops

Agentic HLS integrates LLMs into closed-loop hardware synthesis environments, orchestrating the following modular workflow (Xu et al., 20 Nov 2025, Collini et al., 17 Mar 2025):

1. Decomposition and Synthesis:
   • Behavioral C/C++ programs are decomposed into semantically clean submodules.
   • LLMs generate initial HDL for each submodule, guided by code snippets, functional specifications, and explicit I/O definitions.
   • Retrieval-Augmented Generation (RAG) is used to repair syntax errors based on compiler feedback.
2. Differential Verification:
   • HLS tools compile C/C++ modules into bit-accurate reference HDL.
   • Both LLM-generated and HLS HDL are simulated and outputs compared; when output vectors mismatch, structured error logs are generated and appended to the LLM prompt for iterative repair.
   • This loop continues until simulation errors $E = \|S_{LLM} - S_{HLS}\|_2 = 0$, or maximum iterations are reached.
3. Integration and Top-Level Verification:
   • Successfully synthesized submodules are instantiated into the top-level design per the original call graph.
   • Differential simulation is repeated at the system level.
   • Integration mismatches are diagnosed via signal boundary tracing; discrepancies again prompt LLM-driven repairs.
4. Optimization via Reasoning and Constraint Solving (Collini et al., 17 Mar 2025):
   • LLM agents apply transformations, pragma insertions, and select design alternatives using chain-of-thought (CoT) reasoning.
   • Global resource allocation is managed via integer-linear programming (ILP), searching across kernel-level Pareto options subject to area and latency constraints.

This framework creates a tight agent-environment feedback loop, with LLMs proposing candidate designs and pragmas, HLS synthesizers yielding performance metrics, and optimization solvers picking globally feasible solutions.

3. Symbiotic Feedback Mechanisms and Co-Adaptation

The symbiosis in agentic HLS emerges via distinct feedback mechanisms:

• Compiler Error Logs: Immediately drive RAG-based syntax repair in LLMs, leading to automated correction using template libraries and similarity retrieval (matching embedded error logs to repair hints) (Xu et al., 20 Nov 2025).
• Waveform Mismatches: Identified via parallel simulations, these drive chain-of-thought reasoning for functional and architectural repairs.
• Performance Metrics: HLS reports area ($A$), power ($P$), and latency ($L$); LLMs adapt microarchitecture or pragma directives in response to concrete efficiency data.

Co-adaptation occurs over repeated iterations. LLMs progressively internalize the constraints imposed by HLS but are not bound to its PPA (power, performance, area) inefficiencies, synthesizing intellectually “released” architectures that often surpass bare HLS output. HLS, in turn, acts as a correctness oracle and functional space constraint, providing deterministic ground-truth feedback (Xu et al., 20 Nov 2025). A plausible implication is that agentic frameworks can continually discover microarchitectures unattainable by either traditional HLS or unrestrained LLM generation.

4. Taxonomies of Autonomy in Symbiotic Agentic HLS

A six-level taxonomy (L0–L5) structures the evolution of agentic autonomy within HLS workflows (Zhang et al., 1 Feb 2026):

Level	Description	Human Role
L0	Manual DSE	Direct control, iteration
L1	HLS Copilot	Human applies suggestions
L2	Autotuning Agent	Human reviews results
L3	Guardrailed Agents	High-level oversight
L4	Domain Architect	Intent specification
L5	Silicon Partner	End-to-end automation

Responsibility shifts monotonically from manual, human-driven DSE (L0) to fully autonomous silicon partners (L5) that can internally evolve the toolchain itself—e.g., adapting compiler heuristics or trace infrastructures. Critical enablers for ascending this hierarchy include agent-friendly performance feedback and flexible interface synthesis.

5. Limitations of Legacy HLS and Agentic Remedies

Contemporary HLS tools pose significant limitations for agentic workflows:

• Inadequate Performance Feedback: Estimated cycle and resource reports are coarse and often inaccurate (estimation errors $\epsilon_L, \epsilon_U$ can reach 50% for complex kernels). Mixed-fidelity models, constructed by mining detailed schedule data, can give agents actionable, line-referenced feedback.
• Rigid Interfaces: Custom IP integration is laborious due to fixed standard protocols; agents can parse target specifications and synthesize adapter logic automatically, reducing code complexity $C_b$ from hundreds of lines to near-zero.
• Debuggability: There lacks seamless tracing from RTL failures back to source code. Agent-driven assertion synthesis and counterexample analysis at the HLS level closes this gap, improving root-cause diagnostics and interpretability (Zhang et al., 1 Feb 2026).

Hierarchical, bottom-up optimization approaches—such as kernel-level Pareto harvesting followed by system-level ILP—constrain otherwise intractable search spaces, mirroring established expert practices (Collini et al., 17 Mar 2025).

6. Quantitative Outcomes and Emergent Behaviors

Empirical results across benchmarks substantiate the quality and efficiency of symbiotic agentic HLS frameworks:

• Syntax compilation pass rates increase by 15.5% with RAG vs. vanilla LLM, while functional pass rates improve by 28.1–38.5% over direct LLM baselines.
• Area and power reductions reach approximately 25% and 27% versus pure HLS, often approaching or surpassing human-engineered baselines (Xu et al., 20 Nov 2025).
• On AES and other benchmarks, LLM-based agents consistently achieve smaller area footprints than naïve manual designs; in some cases, advanced reasoning models (e.g., DeepSeek-R1) approach near-perfect global optima (success rates up to 95%) but at modestly higher computational cost (Collini et al., 17 Mar 2025).

Emergent phenomena include:

• Multi-step reasoning and constraint relaxation strategies (e.g., Lagrangian penalty) arise in reasoning LLMs but not non-reasoning models.
• Exposing chain-of-thought tokens debugs model misapprehensions of pipelining and parallelism.
• Adaptive trade-offs in cost, runtime, and design quality suggest future hybrid strategies tuned to resource and latency budgets.

7. Research Extensions and Future Directions

Key avenues for advancing symbiotic agentic HLS include:

• Mixed-Fidelity Performance Libraries: Extraction of detailed execution traces and loop histograms to inform agentic reasoning.
• Protocol-Aware Interface Synthesis: APIs for agent-driven generation of custom bus adapters.
• Cross-Stack Debugging: Agent-mediated integration of high-level ML testbenches, HLS simulation, and RTL-level co-simulation.
• Autonomous Toolchain Evolution: L5 agents instrument, analyze, and tune the inner workings of the HLS compiler itself, enabling continual learning and cross-project adaptation (Zhang et al., 1 Feb 2026).

Continued progress in overcoming feedback and interface bottlenecks is expected to facilitate the transition from L1/L2 tools to higher autonomy levels. The explicit transformation of HLS pragmas into a shared “lingua franca” of human-AI hardware co-design signals an ongoing, recursive co-evolution of both HLS and agentic AI capacities (Zhang et al., 1 Feb 2026).