acceptodds
Under review as a conference paper at ICLR 2027

BEHAVE: Functional Behavior Modeling Enables Self-Improving Agents for Hardware Design and Verification

Abstract

Developing agents for hardware design and verification requires reliable correctness feedback. However, a hardware specification may permit correct implementations with different latencies. Matching outputs cycle by cycle to a reference implementation can therefore reject valid designs. To address this, we introduce BEHAVE, an agentic framework for multi-turn joint hardware design and verification through functional behavior modeling. We define Behavior IR to express task functionality as executable behavior models without prescribing implementation timing beyond the specification. The agent develops a register-transfer-level (RTL) design and a behavior model as the design's verification reference. Our evaluator, BEHAVE-Sim, generates input stimuli and checks both artifacts separately against a golden behavior model, using goal-guided search to exercise additional execution cases. BEHAVE thus supports power, performance, and area (PPA) exploration across task-permitted latencies and microarchitectures. During training, the same evaluator provides verifiable reinforcement learning (RL) rewards from specification-behavior pairs without reference RTL. For self-improvement, we show that the agent can search for high-level implementations relevant to its capability gaps, construct and check specification-behavior pairs, and continue training. We release BEHAVE-Train and BEHAVE-Eval with 600 human-reviewed specification-behavior pairs for realistic hardware workloads. On BEHAVE-Eval, self-improvement from 60 seed tasks raises Qwen3.8-27B's RTL pass@1 from 55.0% to 75.0%, reaching performance comparable to RL using a 540-task pool.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
LLMs, Agents, Hardware Desgn and Verification, Self-Improvement

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.25 over 4 reviews, above 96% of the others.
Reviewer_TPg5OpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

Since cycle-by-cycle matching against a reference implementation rejects valid designs with task-permitted latency differences, this paper proposes BEHAVE, an agentic framework that lets an LLM agent write both RTL and behavior model B to help validate the correctness of RTL. Both artifacts are compared with a timing-free golden behavior model B⋆ to test the effectiveness of the agent. The current policy can act as an Analyst to identify capability gaps, which guide the construction of new training pairs for RL.

Critical strengths

The paper is clearly written and experiments are extensive. In the experiments, Figure 5(c) partially addresses one of my concerns, namely whether having the LLM agent write a behavior model B actually helps: it shows that doing so improves the pass rate to some extent(from 63.3% to 68.3%).

Critical weaknesses

I think this paper has several main weaknesses:

  1. In Sec 3.4, the authors write "Builder constructs S and B1 from the sources and objectives... Implementer produces B2 from S", I think here builder and Implementer should be different models because S is natural-language text, which can be vague. Maybe the same model has a specific understanding of a vague text S.

  2. The framework lets an LLM agent write both RTL and behavior model B, but the model B does not seem to help much. It would be enough to compare RTL with the timing-free golden behavior model B⋆ . According to Figure 5(c) and (d), writing RTL alone already performs reasonably well: its pass rate is slightly lower (63.3% vs. 68.3%, a difference of just 3 out of 60 tasks), while its cost is much lower.

  3. I feel that this framework is primarily engineering-oriented rather than research-oriented, and its novelty is somewhat limited.

Questions for authors

In Sec 3.4, the paper states that the Analyst “then selects relevant high-level implementations and sets objectives for new tasks.” I would like to know the sources of these new materials and the criteria used to select from them.

3 comments
AuthorsOpenReview ↗

Response to Reviewer TPg5 - Part 1

Dear Reviewer TPg5,

Thank you for your careful review and constructive comments. We address your concerns about task construction, joint development, and our research contribution below. Revisions are highlighted in blue in the manuscript, with relevant locations noted in parentheses below.


W1: Same-model task construction

Self-improvement setting. Using the same model is deliberate: we study whether the current policy can construct useful training data without a second teacher model. Builder produces the specification and B1 from source material, while Implementer reconstructs B2 in a separate context, seeing only the specification and public interface documentation. Disagreements trigger repairs, and Reviewer also checks fidelity to the source. These checks help expose ambiguity, although separate contexts do not eliminate shared interpretation errors.

Training versus benchmarking. For SI, we use automated checks to control the quality of specification-Behavior pairs without requiring human review of every pair. We assess the usefulness of this supervision through held-out performance. For building evaluation datasets, we agree that cross-checking with different models is valuable. Combined with source checks and human review, it can help identify shared mistakes and reduce the manual review burden. The framework permits this choice outside our same-model SI experiment.

Downstream results. We compare Full-data RL sampling from the full 540-task BEHAVE-Train pool, Initial-task RL on the same 60 initial tasks without acquisition, and SI starting from those 60 tasks. Each setting uses three training seeds. Each SI run independently acquires tasks using its own training feedback. Extending SI from 18 to 24 updates includes two additional acquisition rounds, adding 40 tasks per run. The table reports RTL / Behavior accuracy (%), averaging three evaluation runs per trained model and then reporting mean ± sample standard deviation across training runs.

SettingUpdatesVerilogEvalRTLLMCVDPBEHAVE-Eval
Full-data RL4096.6 ± 1.5 / 95.2 ± 0.796.7 ± 2.0 / 96.2 ± 1.591.5 ± 1.2 / 91.0 ± 1.971.1 ± 2.0 / 75.0 ± 1.5
Initial-task RL1895.9 ± 1.4 / 94.4 ± 1.196.0 ± 0.0 / 96.0 ± 2.089.3 ± 1.2 / 88.2 ± 0.965.0 ± 1.5 / 69.8 ± 1.4
Self-improvement1896.4 ± 0.6 / 94.3 ± 0.995.8 ± 3.2 / 94.0 ± 3.589.7 ± 2.5 / 89.3 ± 1.070.7 ± 3.8 / 74.4 ± 2.2
Initial-task RL2497.2 ± 0.1 / 95.7 ± 1.296.0 ± 0.7 / 95.6 ± 1.089.7 ± 1.7 / 90.0 ± 1.163.3 ± 3.6 / 69.6 ± 4.5
Self-improvement2496.3 ± 0.4 / 94.9 ± 1.496.4 ± 1.7 / 97.3 ± 1.891.3 ± 0.8 / 91.2 ± 2.371.7 ± 3.6 / 75.0 ± 1.9

SI reaches 70.7% and 71.7% RTL accuracy on BEHAVE-Eval after 18 and 24 updates, compared with 65.0% and 63.3% for Initial-task RL. These results support the usefulness of the acquired training supervision without introducing another teacher model. (Section 4.5 and Figure 7(e).)


W2: Role and cost of the agent-generated Behavior model

RTL-only does not mean verification-free. This setting requires only an RTL submission, but retains the development tools for compilation, simulation, and agent-written tests. GPT-5.6 Luna ran self-written RTL simulations in 42/60 RTL-only attempts on BEHAVE-Eval. Thus, the baseline already includes self-testing in most attempts. Joint development additionally requires an explicit, reusable functional model that exposes the agent's assumptions and can be checked independently of the RTL with BEHAVE-Sim. (Section 4.3.)

A reference for developers. We agree that joint development adds cost. In Figure 5, adding BEHAVE-Sim reduces this overhead to about 18% over RTL-only, while further improving RTL accuracy. The generated Behavior provides an explicit functional reference for development-time checks, when the golden model is hidden. Final RTL evaluation can compare directly against the golden model without requiring the agent's own Behavior. In practical development, however, a trusted golden model may not yet exist. Producing both RTL and Behavior makes the agent's functional interpretation explicit: a developer can inspect, test, and revise the Behavior model, then approve it as a reference for subsequent RTL development. This provides a human-reviewable interface independent of the RTL's microarchitecture. (Section 4.6.)

AuthorsOpenReview ↗

Response to Reviewer TPg5 - Part 2

W3: Research contribution

Our work asks: How can we scale up training for hardware design and verification agents? This requires reliable correctness feedback and access to more training tasks.

Correctness feedback. The first challenge is obtaining correctness feedback without forcing agents to reproduce one reference design's timing. Behavior IR describes the intended computation, while BEHAVE-Sim checks correctness under the specification's requirements, leaving agents free to explore valid latency and PPA choices. Our cycle-by-cycle comparison found 138 valid implementations that strict reference-cycle matching would reject, representing 41.8% of the 330 implementations reported as passing. (Section 4.2.)

Expanding the training data. The second challenge is the scarcity of RTL training data. Our approach provides training rewards from specification-Behavior pairs without requiring reference RTL. This makes widely available high-level implementations usable as sources of training tasks. We show that the current policy can search these sources, construct and check new training pairs, and continue training on them.

Resources for future work. We also release BEHAVE-Train and BEHAVE-Eval, containing 600 human-reviewed specification-Behavior pairs, as reusable resources for training and evaluating hardware agents on realistic workloads. (Abstract and Section 1.)


Q1: Material sources and selection criteria

Source library. The library contains 374 files from 67 repositories. We started from the source materials used to build BEHAVE-Train, excluded BEHAVE-Eval source files and materials associated with the 60 initial tasks and their variants, and removed duplicate content. We also audited the library and the 100 tasks acquired in the original SI experiment against BEHAVE-Eval using annotated functional operators, input/output semantics, numerical rules, and state behavior. The semantic comparison identified 273 pairs for detailed review, in which we found no equivalent tasks. Repository sharing is permitted because different components of a large library need not implement the same computation. (Appendix C.6.)

Selection criteria. Analyst uses training feedback to select materials that address capability gaps, add new learning objectives, and provide enough detail to define a hardware task. For example, repeated non-submissions on top-k attention motivated smaller selection and fixed-point division tasks. The resulting tasks undergo reconstruction and source-fidelity checks before admission. (Section 4.5 and Appendix C.6.)


Thank you again for your feedback. We would be happy to answer any further questions.

AuthorsOpenReview ↗

Follow-up on Our Rebuttal

Dear Reviewer TPg5,

Thank you again for your time. When you have a chance, we would appreciate your feedback on our rebuttal and additional results. We would be happy to clarify any remaining concerns.

Submission 8155 Authors

Reviewer_8eTgOpenReview ↗
Rating
4
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes BEHAVE, which is a framework elevating executable, transaction-level functional behavior models with RTL designs, in order to address the rigidity of conventional cycle-accurate testbenches that penalize valid pipelining, retiming, and microarchitectural exploration. The key ideas include (1) decoupling functional computation from clock timing via pure algorithmic models and protocol-aware adapters in BEHAVE-Sim, (2) integrating two-sided concolic exploration with replay-audited bounded formal guarantees, (3) curating a 600-task hardware benchmark across various domains like AI/ML and cryptography, and (4) leveraging joint verification rewards for multi-agent curriculum learning and reinforcement learning. Evaluation on the BEHAVE-Eval benchmark, standard-cell physical synthesis flows, and closed-loop RL rollouts shows promising functional correctness in automated RTL synthesis, robust microarchitectural Pareto PPA flexibility across multi-cycle pipelines, and superior sample efficiency in autonomous agent self-improvement.

Critical strengths

Timing-Independent Behavioral Abstractions: Conventional RTL benchmarks enforce strict cycle counts by static testbenches, unfairly penalizing valid pipelining, multi-cycle scheduling, and area-delay trade-offs. By pairing executable behavior models with protocol-aware stream adapters in BEHAVE-Sim, this work establishes a timing-decoupled evaluation paradigm that bridges high-level algorithmic intent with concrete microarchitectural exploration.

Verifiable Agentic Self-Improvement: Reinforcement learning for digital design has long suffered from scarce ground-truth data and ungrounded reward formulations. BEHAVE overcomes this by turning execution-grounded functional verification into dense training signals, while introducing an autonomous multi-agent curriculum loop that diagnoses failure traces, mines external repositories for stepping-stone concepts, and synthesizes new verified tasks to resolve complex design bottlenecks.

Critical weaknesses

However, I have a concern that BEHAVE's transaction-level decoupling assumes orderly stream mappings, restricting multi-clock or multi-endpoint designs to fixed schedules and unmodeled analog hazards. But modern SoC architectures are often dominated by asynchronous clock-domain crossings, out-of-order execution, credit-based flow control, and cache coherence. As such, it remains unclear whether this abstraction scales beyond isolated, feed-forward compute kernels to complex, non-deterministic hardware fabrics.

Questions for authors
  1. Can BEHAVE-Sim verify designs with dynamic, non-deterministic out-of-order completions (such as variable-latency memory responses) without relying on fixed schedule replays?
  2. Have the evaluated the task-acquisition been tested on private or unseen algorithmic repositories to isolate genuine curriculum synthesis from memorization?
2 comments
AuthorsOpenReview ↗

Response to Reviewer 8eTg

Dear Reviewer 8eTg,

Thank you for your constructive feedback and for highlighting important questions about BEHAVE's scope and generalization. Revisions are highlighted in blue in the manuscript, with relevant locations noted in parentheses below.


W1/Q1: Dynamic completions and support for complex systems

Current support. BEHAVE-Sim supports stateful designs beyond feed-forward kernels. During concrete execution, it can check variable-latency, ID-tagged out-of-order responses without fixing their completion cycles or order in advance. Symbolic exploration of input and backpressure schedules currently supports single-clock ready/valid designs with one input and one output.

Extending support. With multiple clocks or endpoints, symbolic analysis currently requires a fixed environment schedule, so it does not establish correctness across arbitrary interleavings. An extension would let the solver explore legal clock interleavings and memory-response timings and orders, with stateful models for outstanding requests, credits, and coherence. This would require extending environment modeling and symbolic analysis while reusing our existing execution and replay infrastructure.

Broader perspective. This question highlights the continuing role of human expertise in designing verification frameworks for self-improving agents. These frameworks determine what we can reliably verify and which complex, realistic hardware tasks agents can construct and learn from. (Section 4.6, if we can reliably automate verification, generating and refining new tasks becomes easier.)


Q2: Task acquisition from unpublished source material

Settings. For this case study, we wrote a new, unpublished high-level SIMD implementation rather than using code from a public repository. Using the same Qwen3.8-27B checkpoint after three RL updates on the 60 initial tasks, we compared task generation without source material, with this implementation, and with an otherwise identical version that changes only the rounding rule from nearest-even to rounding toward zero.

Observations. Without source material, the model defined its own SIMD operations and numerical rules. In the source-conditioned cases, the generated specifications and executable behaviors followed the supplied rounding rules, including our deliberate change. For example, scaling +3 and -3 by one half yielded +2 and -2 with the original material, but +1 and -1 with the modified material. These cases provide evidence that task acquisition incorporates newly supplied implementation semantics rather than relying solely on memorized designs.

Source-free generation. In a separate experiment, we also asked the same model to generate tasks without repository material. We found cases where the generated rules did not match the stated application. For example, one task described a buffer that restores program order from out-of-order completions, but its rules and executable behavior instead preserved arrival order. This illustrates the value of an external implementation as a semantic reference for task construction.


Thank you again for your feedback. We would be happy to answer any further questions.

AuthorsOpenReview ↗

Follow-up on Our Rebuttal

Dear Reviewer 8eTg,

Thank you again for your time. When you have a chance, we would appreciate your feedback on our rebuttal and additional results. We would be happy to clarify any remaining concerns.

Submission 8155 Authors

Reviewer_pscYOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents BEHAVE, a framework for jointly developing RTL designs and executable behavior models with LLM agents. BEHAVE-Sim evaluates both artifacts against a hidden golden behavior model while allowing implementation latencies to vary within the task specification. This provides reinforcement learning rewards without requiring reference RTL. The paper also introduces a 600-task, human-reviewed dataset and a self-improvement loop that acquires additional training tasks from high-level implementations. Experiments cover hardware generation, development workflows, area–time exploration, and training. On BEHAVE-Eval, Qwen3.8-27B’s RTL pass@1 improves from 55.0% to 73.3% with fixed-dataset RL and 75.0% with self-improvement.

Critical strengths

Separating functional behavior from implementation timing is useful for hardware agents. It allows the same reference to check designs with different architectures and latencies permitted by the specification. The area–time exploration in Figure 6 provides a concrete demonstration of this benefit. Evaluating the generated RTL and behavior model separately against a hidden reference also gives the joint-development workflow a clear basis for correctness feedback.

The training results provide meaningful evidence for the framework’s usefulness. Table 1 shows improvements in both RTL and behavior-model generation, including gains on the adapted external benchmarks. The self-improvement experiment further demonstrates a working acquisition-and-training loop starting from a small seed set. Together with the dataset, these results make the paper a useful contribution to training hardware agents.

Critical weaknesses

The contribution of feedback-guided task selection is not isolated in the self-improvement experiment. Section 4.5 shows that acquiring new tasks and continuing RL improves performance, but does not compare this with continued training on the seed set or task acquisition without capability feedback under comparable budgets. The results therefore support the complete self-improvement workflow more clearly than they establish the benefit of its particular task-selection strategy.

Questions for authors

Do you have results comparing self-improvement with continued RL on the same seed tasks, or with acquiring tasks without using capability feedback, under comparable compute budgets? These would help clarify how much the targeted acquisition strategy contributes to the improvement in Section 4.5.

2 comments
AuthorsOpenReview ↗

Response to Reviewer pscY

Dear Reviewer pscY,

We appreciate your careful review and constructive feedback. We address your question about the contribution of feedback-guided task acquisition below. Revisions are highlighted in blue in the manuscript, with relevant locations noted in parentheses below.


W1/Q1: Comparison with continued RL on the initial tasks

Settings. Full-data RL (Main) samples from the full 540-task BEHAVE-Train pool. Initial-task RL repeatedly samples the same 60 initial tasks without acquisition. Self-improvement (SI) starts from those 60 tasks, with each run independently acquiring new tasks using its own training feedback. Each setting uses three training seeds. We report Full-data RL after 40 updates and Initial-task RL and SI after 18 and 24 updates. Between updates 18 and 24, SI adds 40 tasks per run through two additional acquisition rounds. (Section 4.5 and Appendix C.6.)

Results. The table below reports RTL / Behavior accuracy (%). For each trained model, we average accuracy over three evaluation runs with different sampling seeds, then report mean ± sample standard deviation across the three training-run averages.

SettingUpdatesVerilogEvalRTLLMCVDPBEHAVE-Eval
Full-data RL4096.6 ± 1.5 / 95.2 ± 0.796.7 ± 2.0 / 96.2 ± 1.591.5 ± 1.2 / 91.0 ± 1.971.1 ± 2.0 / 75.0 ± 1.5
Initial-task RL1895.9 ± 1.4 / 94.4 ± 1.196.0 ± 0.0 / 96.0 ± 2.089.3 ± 1.2 / 88.2 ± 0.965.0 ± 1.5 / 69.8 ± 1.4
Self-improvement1896.4 ± 0.6 / 94.3 ± 0.995.8 ± 3.2 / 94.0 ± 3.589.7 ± 2.5 / 89.3 ± 1.070.7 ± 3.8 / 74.4 ± 2.2
Initial-task RL2497.2 ± 0.1 / 95.7 ± 1.296.0 ± 0.7 / 95.6 ± 1.089.7 ± 1.7 / 90.0 ± 1.163.3 ± 3.6 / 69.6 ± 4.5
Self-improvement2496.3 ± 0.4 / 94.9 ± 1.496.4 ± 1.7 / 97.3 ± 1.891.3 ± 0.8 / 91.2 ± 2.371.7 ± 3.6 / 75.0 ± 1.9

Findings. Across repeated runs, SI achieves higher mean RTL accuracy than Initial-task RL on BEHAVE-Eval at both 18 and 24 updates, while remaining comparable to Full-data RL. These results support a contribution from task acquisition beyond continued RL on the initial tasks. (Table 1 and Figure 7(e).)

Compute. The following estimates are H200 GPU-hours per run, averaged over the three training seeds and excluding evaluation. Both settings include the shared initial training stage. For reference, Full-data RL through 40 updates costs approximately 955 H200 GPU-hours per run. (Appendix C.7.)

UpdatesInitial-task RLSIAdditional SI cost
18450.6542.420.4%
24581.8713.422.6%

Discussion. Across these runs, we estimate approximately 6,500 H200 GPU-hours, counting the initial three updates shared by SI and Initial-task RL only once per training seed. Initial-task RL at 24 updates still achieves lower mean RTL accuracy than SI at 18 updates (63.3% vs. 70.7%), despite a higher estimated compute cost (581.8 vs. 542.4 H200 GPU-hours per run). Moreover, building BEHAVE-Train required substantial human effort, so autonomous task acquisition offers a scalable way to expand beyond a fixed, manually curated task pool. Better scheduling of task acquisition and verification may further reduce GPU idle time.


Role of capability feedback

Settings. We used Qwen3.8-27B after three RL updates on the 60 initial tasks. With the checkpoint and source library held fixed, we generated 20 tasks with capability feedback and 20 without it. The feedback included results and failure reports from the model's recent training attempts.

Observations. The unguided set focused more on filtering and codec tasks, while the guided set covered a broader range of operations. Without capability feedback, task selection reflects the model's existing preferences, which may not match its current learning needs. The guided proposals also explicitly connected task choices to observed difficulties. For example, all eight attempts on top-k attention exhausted the turn budget without submission. Citing these attempts, the model proposed separate selection and fixed-point division exercises. This illustrates how feedback helps decide what to practice next. (Section 4.5.)


Thank you again for your feedback. We would be happy to answer any further questions.

AuthorsOpenReview ↗

Follow-up on Our Rebuttal

Dear Reviewer pscY,

Thank you again for your time. When you have a chance, we would appreciate your feedback on our rebuttal and additional results. We would be happy to clarify any remaining concerns.

Submission 8155 Authors

Reviewer_xKDHOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

BEHAVE is a framework in which an agent writes a register-transfer-level (RTL) design and an untimed behavior model in Behavior IR. Its evaluator, BEHAVE-Sim, checks both against a hidden golden behavior model and lets RTL latency vary within the specification. The BEHAVE-Sim scores serve as rewards for reinforcement learning (RL) of Qwen3.8-27B, and in self-improvement (SI) the policy builds new training tasks from source code. The paper also contributes 600 human-reviewed tasks (540 in BEHAVE-Train, 60 in BEHAVE-Eval) and shows area-time exploration on two quantization tasks.

Critical strengths
  • Rewards from specification-behavior pairs alone raise Qwen3.8-27B's RTL pass@1 from 55.0% to 73.3% on BEHAVE-Eval and from 81.7% to 91.3% on CVDP-cid003 (Table 1, p. 6). The values come from the final checkpoint, with no checkpoint selection on BEHAVE-Eval (Fig. 7(b)). This matters, because reference RTL is scarce.
  • BEHAVE tasks have a median of 97 lines of auxiliary reference RTL, against 11.5 to 34 for VerilogEval-v2, RTLLM-v2 and CVDP-cid003 (Table 12, p. 59). GPT-5.6 Terra reaches 95.7-99.4% RTL pass@1 on these three external benchmarks but 85.0% on BEHAVE-Eval (p. 7). BEHAVE-Sim supports several interface protocols (Table 3, p. 23). These assets have value even if the SI claim fails.
Critical weaknesses
  • The paper does not report RL on the 60 seed tasks alone for the same 18 updates. Without this control, the gain from 55.0% to 75.0% can come from RL on the curated seed tasks, not from the 100 acquired tasks. Each setting has one training run and one rollout per task; adjacent RL checkpoints differ by up to about 12 percentage points. SI RTL pass@1 is about 62% at update 15 and 75.0% at update 18, so the match with fixed-dataset RL (73.3%) is fragile.
  • The main motivation is that cycle-by-cycle checks reject valid designs, but no experiment counts such rejections. The three external benchmarks keep their native timing where possible, and the paper does not say how many BEHAVE-Eval tasks leave latency open. The PPA (power, performance, area) study covers two quantization tasks and has no cycle-accurate baseline. Each benchmark task has auxiliary reference RTL, so a cycle-accurate check of accepted designs can measure the benefit.
Questions for authors
  • What RTL pass@1 does RL on only the 60 seed tasks reach after 18 updates, over several seeds?
  • How did you build the 374-file source library, and how many acquired tasks share a repository with BEHAVE-Eval?
3 comments
AuthorsOpenReview ↗

Response to Reviewer xKDH - Part 1

Dear Reviewer xKDH,

Thank you for your thoughtful review and constructive suggestions. We address your comments point by point below. Revisions are highlighted in blue in the manuscript, with relevant locations noted in parentheses below.


W1/Q1: Stability across training seeds and the initial-task RL baseline

Settings. Full-data RL (Main) samples from the full 540-task BEHAVE-Train pool. Initial-task RL repeatedly samples the same 60 initial tasks without acquisition. Self-improvement (SI) starts from those 60 tasks, with each run independently acquiring new tasks using its own training feedback. Each setting uses three training seeds. We report Full-data RL after 40 updates and Initial-task RL and SI after 18 and 24 updates. Between updates 18 and 24, SI adds 40 tasks per run through two additional acquisition rounds. We estimate approximately 6,500 H200 GPU-hours for Main through 40 updates and SI and Initial-task RL through 24 updates, excluding evaluation. The initial three updates shared by SI and Initial-task RL are counted only once per training seed. (Section 4.5 and Appendices C.6-C.7.)

Results. The table below reports RTL / Behavior accuracy (%). For each trained model, we average accuracy over three evaluation runs with different sampling seeds, then report mean ± sample standard deviation across the three training-run averages.

SettingUpdatesVerilogEvalRTLLMCVDPBEHAVE-Eval
Full-data RL4096.6 ± 1.5 / 95.2 ± 0.796.7 ± 2.0 / 96.2 ± 1.591.5 ± 1.2 / 91.0 ± 1.971.1 ± 2.0 / 75.0 ± 1.5
Initial-task RL1895.9 ± 1.4 / 94.4 ± 1.196.0 ± 0.0 / 96.0 ± 2.089.3 ± 1.2 / 88.2 ± 0.965.0 ± 1.5 / 69.8 ± 1.4
Self-improvement1896.4 ± 0.6 / 94.3 ± 0.995.8 ± 3.2 / 94.0 ± 3.589.7 ± 2.5 / 89.3 ± 1.070.7 ± 3.8 / 74.4 ± 2.2
Initial-task RL2497.2 ± 0.1 / 95.7 ± 1.296.0 ± 0.7 / 95.6 ± 1.089.7 ± 1.7 / 90.0 ± 1.163.3 ± 3.6 / 69.6 ± 4.5
Self-improvement2496.3 ± 0.4 / 94.9 ± 1.496.4 ± 1.7 / 97.3 ± 1.891.3 ± 0.8 / 91.2 ± 2.371.7 ± 3.6 / 75.0 ± 1.9

Findings. The originally reported 75.0% was based on one training run and one evaluation run. Across repeated runs, SI achieves higher mean RTL accuracy than Initial-task RL on BEHAVE-Eval at both 18 and 24 updates, while remaining comparable to Full-data RL. These results support a contribution from task acquisition beyond continued RL on the initial tasks. (Table 1 and Figure 7(e).)


W2: Cycle-by-cycle comparison with reference RTL

Task coverage and cycle-by-cycle comparison. All 60 BEHAVE-Eval tasks permit implementation-dependent latency, subject to their specified functional and protocol requirements. For BEHAVE-Eval candidates reported as passing in Table 1, we compared candidate and reference RTL outputs cycle by cycle using the same input transaction sequences and reset/backpressure schedules. Inputs followed each design's handshake. We compared output-valid signals and specification-defined output values, ignoring unspecified idle values. Among these 330 implementations, 138 (41.8%), spanning 49 tasks, passed BEHAVE-Sim's checks but differed from their references cycle by cycle. Strict reference-cycle matching would therefore reject these valid implementations under this workload. Using this check for RL would encourage the model to match the reference's timing, even though other valid designs may offer better PPA trade-offs. (Sections 4.1-4.2.)

ModelRTLs reported as passingConfirmed valid cycle mismatches, n (%)
Qwen3.8-27B3319 (57.6%)
Qwen3.8-27B + Full-data RL4432 (72.7%)
Qwen3.8-27B + SI4529 (64.4%)
GPT-5.6 Luna418 (19.5%)
GPT-5.6 Terra5110 (19.6%)
Claude Haiku 4.52212 (54.5%)
Claude Sonnet 54112 (29.3%)
DeepSeek-V4.1-Flash5316 (30.2%)
Total330138 (41.8%)

PPA study. We also measured the auxiliary reference RTLs using the original synthesis flows and workloads. The MXFP4 reference uses a parallel pipeline (122,900 µm² and 0.9 µs on Sky130 at 80 MHz), whereas the NVFP4 reference reuses arithmetic units sequentially (12,450 µm² and 92.6 µs on Nangate45 at 400 MHz). All 222 unique timing-feasible candidates in the reported study (143 MXFP4 and 79 NVFP4), including all reported Pareto-frontier designs, pass functional and protocol checks but fail cycle-by-cycle output matching against their references on these workloads. These reference points are now included in the revised PPA figure. (Section 4.4 and Figure 6.)

AuthorsOpenReview ↗

Response to Reviewer xKDH - Part 2

Q2: Source library construction and overlap with BEHAVE-Eval

Source repositories. BEHAVE's 600 tasks draw on 85 repositories. However, we do not require each repository to appear in only one split. This is because large repositories contain distinct components. For example, liquid-dsp includes FIR filters and error-correcting codes, while Hugging Face's Transformers includes attention layers and beam search. We therefore focus on semantic separation between tasks rather than repository-level separation.

Library construction and checks. We constructed and audited the source library in three steps:

  1. We started from the source materials used to build BEHAVE-Train, excluded BEHAVE-Eval source files and materials associated with the 60 initial tasks and their variants, and removed duplicate content. This yielded 374 files from 67 repositories.
  2. In an additional semantic audit, we annotated functional operators, input/output semantics, numerical rules, and state behavior for the library sources, the 100 tasks acquired in the original SI experiment, and BEHAVE-Eval.
  3. We compared every library-Eval and acquired-task-Eval pair using the same feature-coverage measure, which quantifies how much of an Eval task's annotated semantics is covered by the source or acquired task. A threshold of 0.5 identified 273 pairs for detailed review. We manually reviewed these pairs for equivalent computations and task requirements. We found no semantically equivalent tasks in either comparison. (Appendix C.6.)

Results. Among these 100 tasks, 82 use sources from 13 repositories also represented in BEHAVE-Eval. These are large, multi-component repositories, such as ONNX, CMSIS-DSP, and liquid-dsp. For example, an acquired pseudo-random bit-sequence generation task and a BEHAVE-Eval automatic gain-control task draw on different components of liquid-dsp. Our semantic review found no duplicates of BEHAVE-Eval tasks in either the source library or the acquired tasks.


Thank you again for your feedback. We would be happy to answer any further questions.

AuthorsOpenReview ↗

Follow-up on Our Rebuttal

Dear Reviewer xKDH,

Thank you again for your time. When you have a chance, we would appreciate your feedback on our rebuttal and additional results. We would be happy to clarify any remaining concerns.

Submission 8155 Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of BEHAVE Contributions and Rebuttal Updates

Dear Area Chair,

Thank you for overseeing the review of our submission. We summarize below the paper’s central contributions, the strengths recognized by reviewers, and the additional evidence provided during rebuttal.


Core contributions. BEHAVE asks how to scale training for hardware design and verification agents when reference RTL is scarce:

  1. Decoupling functional correctness from performance optimization. Behavior IR describes the intended computation, while BEHAVE-Sim checks correctness without requiring cycle-by-cycle agreement with a reference implementation. This provides verifiable supervision while allowing agents to explore different latencies, microarchitectures, and PPA trade-offs within the specification’s constraints.
  2. Expanding training data without reference RTL. Supervision requires specification-Behavior pairs rather than reference RTL, making widely available high-level implementations usable as sources of training tasks. We demonstrate a self-improvement workflow in which the current policy constructs and checks additional tasks, then continues RL training on them without a separate teacher model.
  3. Reusable resources. We contribute BEHAVE-Train and BEHAVE-Eval, comprising 600 human-reviewed tasks, together with the verification and training framework.

Strengths recognized by reviewers. Reviewer xKDH highlighted the training gains without reference RTL and the value of the benchmark. Reviewer pscY recognized the usefulness of separating functional behavior from implementation timing and the evidence from the training experiments. Reviewer 8eTg emphasized verification and the autonomous acquisition-and-training workflow. Reviewer TPg5 also noted the clear presentation and extensive experiments.


Additional evidence and clarifications. We provided point-by-point responses and revised the manuscript, with changes highlighted in blue:

  1. Training controls and stability (xKDH, pscY). We added initial-task-only RL, with three training seeds and three evaluation runs per trained model. Self-improvement (SI) achieves higher mean BEHAVE-Eval RTL accuracy at both 18 and 24 updates, reaching 71.7% versus 63.3% for initial-task-only RL at 24 updates. We also report compute costs: initial-task RL at 24 updates costs more than SI at 18 updates, yet achieves lower mean accuracy. These results support a contribution from task acquisition beyond continued training on the initial tasks.

  2. Measured benefit of timing flexibility (xKDH). On BEHAVE-Eval, strict reference-cycle matching would reject 138 functionally valid implementations, representing 41.8% of the 330 implementations reported as passing. We also added reference-RTL measurements to the PPA study, directly addressing the request for quantitative evidence.

  3. Task construction and source use (xKDH, pscY, 8eTg, TPg5). We documented source-library construction and a semantic overlap audit. We added task-generation comparisons with and without capability feedback, and an unpublished SIMD case study in which generated specifications and behaviors followed a deliberately changed numerical rule. These provide evidence about how acquisition uses feedback and newly supplied source semantics.

  4. Verification scope and the role of Behavior models (8eTg, TPg5). We clarified current verification capabilities and the limitations of symbolic analysis with multiple clocks or endpoints. We also explained the same-model self-improvement setting and how agent-generated Behavior models provide a human-reviewable functional reference during development, when a trusted golden model may not yet exist.


We have not yet received follow-up comments on these responses and would appreciate your help in encouraging discussion of the additional evidence. We are happy to address any remaining concerns.

Thank you again for your time and consideration.

Submission 8155 Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.