🤖 AI

AgRefactor: Self-Evolving Agentic Workflow for HLS Compatibility and Performance

AgRefactor is a fully-automated, open-source, self-evolving multi-agent workflow that leverages LLMs and automated tools to efficiently refactor complex real-world software into high-performance, synthesizable High-Level Synthesis (HLS) code, outperforming existing state-of-the-art methods in both compatibility and speed.

Original authors: Yang Zou, Zijian Ding, Yizhou Sun, Jason Cong

Published 2026-07-01

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yang Zou, Zijian Ding, Yizhou Sun, Jason Cong

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Translation" Gap

Imagine you have a brilliant recipe written in a complex, modern language (like a high-end software program). You want to turn this recipe into a physical, automated kitchen machine (a hardware chip) that can cook it instantly.

The problem is that the machine only understands very strict, old-fashioned instructions. It can't handle fancy ingredients like "dynamic lists" or "complex pointers." If you try to feed the modern recipe directly to the machine, it breaks.

Currently, human experts have to sit down and manually rewrite the entire recipe, line by line, to make it fit the machine. This takes days and is incredibly tedious.

The Solution: AgRefactor (The "Self-Learning Translator")

The authors built AgRefactor, a team of AI assistants (agents) that automatically translates modern software into hardware-ready code. But unlike previous tools that just follow a rigid rulebook or guess randomly, AgRefactor is special because it learns from its own mistakes and successes.

Think of AgRefactor as a master carpenter with a magical, self-updating notebook.

1. The "Self-Evolving Memory" (The Magical Notebook)

Most AI tools forget what they learned after finishing one job. If they fail to fix a specific type of knot in a piece of wood, they might make the same mistake on the next piece.

AgRefactor is different. Every time it tries to translate a program:

If it succeeds: It writes down exactly how it solved the problem in its "Factual Memory."
If it fails: It writes down why it failed and what the specific error was in its "Strategic Memory."

When a new, difficult program arrives, the AI doesn't start from scratch. It opens its notebook, looks for a similar past job, and says, "Ah, I remember this tricky knot! Last time, I had to cut the wood differently. Let's try that again." This makes it faster and much more accurate on new, unseen tasks.

2. The "Tool-Using" Strategy (The Power Tools vs. The Hammer)

Sometimes, an AI tries to fix a problem by "thinking" (using a Large Language Model), which is slow and expensive. Other times, it's better to just use a specific tool.

AgRefactor is smart enough to know the difference:

The Power Tools: If a problem can be fixed by a standard, automated script (like a power drill), AgRefactor uses that tool immediately. It's fast, cheap, and perfect.
The Hammer (The AI): If the problem is too weird for the power drill (like a custom-shaped piece of wood), the AI steps in to manually hammer it out.

By mixing these two, AgRefactor avoids wasting time "thinking" about problems that a simple tool could solve instantly.

3. The Optimization Agent (The Tuner)

Once the code is translated and the machine can run it, AgRefactor doesn't stop. It has a second team of agents dedicated to tuning the machine.

Imagine you have a car engine that works, but it's running a bit slow. This agent looks at the engine logs, finds the bottlenecks (like a clogged fuel line), and restructures the engine parts to make it go faster. It doesn't just tweak the settings; it actually rewrites the engine design to be more efficient, achieving massive speedups compared to standard tuning methods.

The Results: Why It Matters

The researchers tested AgRefactor on 11 very difficult, real-world software projects (some with over 1,000 lines of code).

Better Success Rate: It successfully translated 9 out of 11 difficult programs, beating both the best automated tools and other AI methods.
Faster & Cheaper: Because it uses tools when possible and learns from past errors, it is much faster and costs less than previous AI methods that just guessed blindly.
Speed Boost: When optimizing the final hardware, it made the designs run 6.5 times faster on average than the best existing tuning tools.

Summary

AgRefactor is like a team of expert translators who:

Keep a notebook of every mistake and success so they never repeat errors.
Know when to use a simple tool and when to think creatively.
Don't just translate the code; they tune the engine to make it run at top speed.

It turns the slow, painful job of manually rewriting software for hardware into a fast, automated process that gets smarter with every job it completes.

Technical Summary: AgRefactor: Self-Evolving Agentic Workflow for HLS Compatibility and Performance

1. Problem Statement

High-Level Synthesis (HLS) aims to streamline the transition from design concepts to silicon by elevating abstraction from Register-Transfer Level (RTL) to C/C++ based designs. However, a significant bottleneck remains: converting real-world software repositories into synthesizable HLS code. This preparatory refactoring phase is labor-intensive, often requiring domain experts days to produce an initial HLS-compatible program due to restrictive language support and the gap between software and hardware programming practices.

Existing automated and Large Language Model (LLM)-based refactoring approaches face three primary challenges:

Generalizability: Rule-based tools often fail on complex data structures (e.g., STL containers, nested pointers) and external libraries. Pure LLM approaches struggle with long programs where invalid patterns span multiple locations or when dealing with non-standard implementations missing from training data.
Scalability: Pure LLM workflows incur high computational costs and exhibit high variance in outputs due to the intrinsic randomness of LLMs.
Cost: Iterative error feedback loops in LLM-based methods are computationally expensive compared to automated tools.

2. Methodology

The authors propose AgRefactor, an LLM-based multi-agent workflow designed to refactor real-world software into synthesizable, high-performance HLS programs. The system is fully automated and open-sourced, built upon the AG2 framework.

A. Framework Overview

The pipeline operates through the following stages:

Test Generation: Before refactoring, a Test Generator creates tests and interface assumptions (e.g., array sizes, function signatures) to serve as high-level constraints.
Diagnosis and Planning:
- Identifiers: Six category-specific agents run in parallel to detect non-synthesizable constructs (e.g., dynamic memory, recursion, system calls, pointer arithmetic).
- Items Organizer: Merges and deduplicates findings from the Identifiers.
- Planner: Generates a comprehensive refactoring plan, enhanced by strategic and factual memory.
Refactoring: A Refactor Worker applies the plan.
Validation and Fixing: The output undergoes synthesis and simulation. If errors occur, an Analyzer-Fixer pair iteratively updates the code or testbench until success or a retry limit is reached.
Optimization: Once synthesizable code is produced, a separate optimization agent iteratively improves hardware performance using a CLI environment with access to EDA tools (Vitis HLS, LightningSim) and source-to-source transformation tools.

B. Self-Evolving Agentic Memory

To address generalizability, AgRefactor incorporates a specialized memory system that accumulates and retrieves knowledge across tasks.

Knowledge Structure: Each memory entry is a tuple $(p_i, I_i, s_i, c_i)$ , representing the initial program, identified incompatible constructs, the refactoring strategy, and a generalized critique.
Retrieval Mechanism: A specialized distance metric combines raw program embeddings ( $e_c$ ) and identified item embeddings ( $e_i$ ) to retrieve relevant past plans and critiques. This allows the system to adapt to the model's specific failure and success modes rather than relying on manually crafted RAG templates.
Evolution: As the system processes diverse tasks, it accumulates factual and strategic knowledge, improving robustness on unseen programs.

C. Tool Integration for Scalability and Cost

To mitigate the high cost and limited scalability of LLMs, AgRefactor integrates HeteroRefactor, a state-of-the-art automated open-source refactoring tool.

Hybrid Workflow: The system employs a greedy strategy, first attempting automated refactoring via HeteroRefactor. If successful, the process terminates immediately.
Tool Specialist: If the tool fails, a dedicated "Tool Specialist" pipeline is triggered. The LLM agents perform lightweight rewrites (e.g., removing problematic headers) to make the code "HeteroRefactor-compatible," delegating the bulk of the transformation back to the efficient tool. This balances LLM-driven flexibility with tool-based efficiency.

D. Performance Optimization Agent

Beyond ensuring synthesizability, an optimization agent iteratively improves hardware performance.

Hierarchy: The agent follows a strict three-phase hierarchy: (1) structural rewrites, (2) scheduling-report analysis to resolve critical-path violations, and (3) fine-grained pragma tuning.
Working Memory: The agent utilizes a tree-based working memory to track synthesized code versions and optimization strategies, preventing context degradation and unproductive loops during multi-hour runs.

3. Key Contributions

AgRefactor Workflow: A fully automated agentic workflow capable of refactoring real-world software into synthesizable, high-performance HLS code. It distinctively addresses structural refactoring, which significantly impacts hardware performance, rather than focusing solely on correctness or pragma insertion.
Self-Evolving Memory System: A specialized agent memory system that continuously accumulates and retrieves both factual and strategic knowledge. This enhances the base LLM's robustness in HLS refactoring with minimal human intervention.
Hybrid Tool Integration: The integration of automated refactoring tools (HeteroRefactor) into the agentic framework creates a hybrid pipeline. This significantly reduces computational costs and improves scalability compared to pure LLM-driven approaches.

4. Experimental Results

The authors evaluated AgRefactor on 11 challenging real-world benchmarks (up to 1,266 lines of code), which are 5–10× longer than cases in prior work.

Refactoring Performance: AgRefactor outperformed or matched the state-of-the-art (SoTA) automated tool (HeteroRefactor) and a strong LLM-based baseline (HLSRewriter-style) on 9 out of 11 benchmarks.
- On benchmarks like encode_one_block and idct_generic, the Tool Specialist successfully rewrote code to enable HeteroRefactor to generate synthesizable versions.
- On simpler benchmarks, the memory mechanism improved success rates to nearly 100%.
Ablation Studies:
- Memory: Adding memory augmentation improved the refactoring success rate across both GPT-5-mini and GPT-5 models. For GPT-5-mini, it improved performance on 10/11 benchmarks.
- Tools: The Tool Specialist significantly improved success rates on complex cases where HeteroRefactor alone failed (e.g., encode_one_block, argon2_fill_segment).
Optimization Performance:
- The optimization agent achieved a 6.51× geometric mean speedup over the SoTA pragma tuning tool (AutoDSE) within a 2-hour budget.
- Improvements stemmed from structural transformations (e.g., replacing $O(n^2)$ sorts with radix sorts, restructuring DFS stacks) inaccessible to pragma-only methods.
- Compared to optimized open-source designs, AgRefactor achieved a 1.20× speedup with less than 20% extra resources.

5. Significance and Claims

The paper claims that AgRefactor represents a significant step forward in automating the HLS design flow by addressing the "labor-intensive" nature of software-to-HLS conversion. Its significance lies in:

Robustness: The self-evolving memory system allows the workflow to adapt to specific failure modes and unseen programs, overcoming the limitations of static RAG systems and manual prompt engineering.
Efficiency: By hybridizing LLM agents with automated tools, the system achieves high scalability and low computational cost, making it viable for real-world, large-scale software repositories.
Performance: The framework does not just produce synthesizable code but actively optimizes it, achieving substantial speedups over existing automated tuning tools through structural code transformations.

The authors emphasize that AgRefactor is fully automated and open-sourced, providing a practical solution to the generalization, scalability, and cost challenges inherent in current HLS refactoring methodologies.