RFAmpDesigner: A Two-Level LLM-guided Optimization Framework for Automated Differential CMOS RF Amplifier Sizing
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "RFAmpDesigner: A Two-Level LLM-guided Optimization Framework for Automated Differential CMOS RF Amplifier Sizing".
Title and authors: Tom: So we’re looking at this paper called "RFAmpDesigner: A Two-Level LLM-guided Optimization Framework for Automated Differential CMOS RF Amplifier Sizing," and it tackles the problem of designing these amplifiers automatically. It seems like they're trying to solve the curse of dimensionality when you're sizing components in radio frequency design.
Jane: That sounds intense. So, what exactly is this paper proposing? It’s about making the whole process of sizing these amps happen automatically, which used to be really hard because there are so many variables involved and existing methods don't use domain knowledge well.
Lu: Essentially, they propose a multi-agent framework called RFAmpDesigner that automates the sizing of radio frequency amplifiers. The core idea is to use this resource allocation middleware to turn the high-dimensional parameter tuning into something lower dimensional, making it easier for general large language models to handle sizing knowledge.
Meng: A low-dimensional problem sounds promising if we’re talking about things that need to be deployed, but I wonder how much domain knowledge they actually manage to inject into a general LLM without breaking something important.
Lalam: The paper summarizes RFAmpDesigner as a framework that automates RF amplifier sizing using an LLM-driven approach. It specifically introduces this resource-allocation middleware which reframes the tuning problem into a low-dimensional resource distribution task, which lets the language model use design knowledge better <ref:2605.10093#pg1>.
Tom: So it’s not just one big LLM doing everything, but a framework that breaks down the sizing job. It follows standard circuit design practices to make sure things like active sizing and impedance matching get done in stages, which is important for keeping it grounded in reality.
Jane: That sounds structured. When you look at the workflow they describe on page three, it goes through active sizing and biasing first, then load and source pull, search tool selection, band planning, simulation, and finally refinement using that tool middleware <ref:2605.10093#pg3>.
Lu: The improvement they point out is that this structure lets the LLMs distinguish between high-cost actions and low-cost actions, so they can search in parallel instead of doing everything sequentially, which is a big change from older methods <ref:2605.10093#pg2>.
Meng: Parallel searching sounds efficient for computation time, but what about the reliability? If the LLM misjudges a low-cost action, how does that affect the whole design outcome when you're trying to ship it?
Lalam: They use retrieval augmented generation or RAG to reuse past knowledge and experience from a memory base to create a self-evolving optimization process, which means it learns from its own mistakes during exploration <ref:2605.10093#pg2>.
Tom: That self-evolution part is interesting. It suggests the system can adapt over time, which is key when you don't have perfect training data for every possible amplifier configuration. But how does it actually manage that memory?
Jane: They describe two operational modes: an autonomous search mode where agents decompose tasks and delegate subtasks, and a self-evolving retrieve-and-refine mode where it keeps a knowledge base to record factual design knowledge during exploration <ref:2605.10093#pg3>.
Lu: The paper suggests that this dual approach lets the framework balance exhaustive searching with lightweight refinement, which is smart because it avoids getting stuck in local optima too early <ref:2605.10093#pg2>.
Meng: If we’re talking about deployment, what does "self-evolving" mean for the cost of running this system at scale? I need to know if we're adding a massive inference overhead just for better quality.
Lalam: They claim runtime stability is capped at twenty-five percent deviation relative to other methods like Bayesian optimization or Genetic algorithms, and they maintain the lowest average completion time on most tasks <ref:2605.10093#pg2>.
Tom: That's a solid number. Reducing dimensionality by using this tool middleware seems to be the main driver for that stability and speed, especially when you look at how they compare the eighteen-dimensional search space of vanilla BO/GA against their more constrained versions <ref:2605.10093#pg2>.
Jane: So, the main takeaway is that by reframing it as a resource allocation problem—distributing current across devices and gain across passive networks—they manage to reduce the problem's dimensionality and make it work with models of varying scales <ref:2605.10093#pg3>.
Lu: Exactly. By encoding design heuristics into deterministic rules and illustrative examples within that middleware, you enable models of different sizes to function effectively in this vertical domain, which is what they call <ref:2605.10093#pg3>.
Meng: So it's about making the problem smaller so it doesn't crash our production pipeline when we try to use an LLM for it, right? What’s the actual cost of running this whole thing compared to a traditional simulation run?
Lalam: They say this approach effectively mitigates reward sparsity, which is particularly bad when dealing with the wideband "frequencyshaping" requirements that amplifiers often have <ref:2605.10093#pg2>.
Tom: So the paper suggests that even though it’s a proof of concept for low-noise amplifiers, the same abstraction should apply to other amplifier types and topologies, which is what they are hinting at <ref:2605.10093#pg1>.
Jane: It sounds like they’re showing how you can use these LLM-driven optimization techniques to handle the complexity that makes traditional methods struggle with data scarcity in RF design.
Lu: That's the real implication for research. It shows that instead of just treating netlists as text and trying to force an LLM to read them directly, this approach focuses on design concepts instead <ref:2605.10093#pg1>.
Meng: If we take what they did here—the tool middleware turning sizing into resource allocation—can we use that same idea for something else in our deployment pipeline? What’s the actual next step for applying this?
Lalam: They state that this work is a proof of concept, but the same abstraction is applicable to other amplifier types and can be extended toward more diverse topologies and more complete design flows <ref:2605.10093#pg1>.
Tom: So we’re looking at a system where the agent decides on current and gain distribution for different stages, which sounds like a very granular control mechanism <ref:2605.10093#pg3>.
Jane: It seems like they’ve shown that reward sparsity fundamentally limits conventional optimizers in RF design, and this tool middleware improves both robustness and efficiency across difficulty regimes <ref:2605.10093#pg2>.
Lu: And the whole point is that this framework provides measurable gains in robustness and convergence with only modest additional inference overhead, making it economically viable for iterative RF design workflows <ref:2605.10093#pg2>.
Meng: Modest overhead is crucial. If we can get high-quality sizing with just a little extra runtime, that’s the kind of thing that actually gets adopted in production environments, not just in a lab setting.
Lalam: The overall results highlight how reward sparsity fundamentally limits conventional optimizers in RF design and demonstrate that the proposed tool middleware improves both robustness and efficiency across difficulty regimes <ref:2605.10093#pg2>.
Tom: So, to wrap up, RFAmpDesigner is an end-to-end framework for automated RF amplifier parameter sizing. It uses a multi-fidelity tool middleware to turn sizing into a resource allocation problem, making domain knowledge easier for LLMs and improving optimization in high-dimensional settings <ref:2605.10093#pg1>.
Jane: It’s a proof of concept for sizing low-noise amplifiers from specifications right down to schematics, showing how you can use this LLM-based framework to handle the complexity of circuit optimization <ref:2605.10093#pg1>.
Lu: The key idea is that this abstraction is applicable to other amplifier types and can be extended toward more diverse topologies and more complete design flows, showing a path forward for broader application <ref:2605.10093#pg1>.
Meng: It’s definitely a direction worth watching as we try to integrate these kinds of reasoning capabilities into our own design tools, provided we can manage that inference cost effectively <ref:2605.10093#pg2>.
Lalam: The paper shows that stronger reasoning and tool-use capabilities are crucial for stable agent-environment interaction when dealing with these complex optimization problems <ref:2605.10093#pg2>.
The paper's summary: Tom: So, RFAmpDesigner is this multi-agent framework that automates sizing differential CMOS radio frequency amplifiers by turning it into a resource allocation problem to handle that high dimensionality <ref:2605.10093#pg1>.
Jane: That sounds like they're trying to make the design process less of a guessing game and more of a structured distribution of resources across components, which is what makes the framework interesting <ref:2605.10093#pg3>.
Lu: Yeah, they use this tool middleware to take those complex sizing steps—like active biasing or impedance matching—and turn them into a six-dimensional resource allocation problem <ref:2605.10093#pg3>.
Meng: So the point there is that by reframing it this way, they reduce the dimensionality of the problem, which means smaller models can actually handle it instead of needing massive compute power <ref:2605.10093#pg3>.
Tom: Exactly. And they follow standard circuit design practice, so you still get those things like active sizing and gain distribution done in a way that makes sense for the hardware <ref:2605.10093#pg2>.
Jane: They also have two modes, an autonomous search mode and this self-evolving retrieve-and-refine mode, which means it can either explore widely or use memory to refine its best ideas <ref:2605.10093#pg3>.
Lu: The self-evolving part is where they use retrieval augmented generation, or RAG, to look at past design points in a knowledge base and reuse that experience for the next attempt, which is how it builds its own optimization process <ref:2605.10093#pg2>.
Meng: So if it's learning from its own past attempts, what does that mean for us when we try to deploy these things in production? It sounds like a lot of exploration before you get to the actual solution <ref:2605.10093#pg2>.
Tom: The results show that this method is actually very stable, with deviations capped at twenty-five percent compared to other methods like Bayesian optimization or Genetic algorithms <ref:2605.10093#pg2>.
Jane: That stability is important because when you're dealing with hardware design, a huge deviation in the final result means the whole design might fail, so this consistency is a big win <ref:2605.10093#pg2>.
Lu: It shows that by reducing dimensionality and densifying rewards, you actually get better success rates and shorter completion times as you move from a simple search space to one with more tools <ref:2605.10093#pg2>.
Tom: And they specifically highlight how this tool middleware helps mitigate reward sparsity, which is a huge issue when you're dealing with wideband requirements where the feedback signal is really thin <ref:2605.10093#pg2>.
Jane: It's showing that these methods can handle those sparse feedback settings much better than older optimizers, which is what makes it a practical tool for RF design, not just theoretical research <ref:2605.10093#pg2>.
Meng: So it’s basically a framework that takes the headache out of sizing by making the math manageable and injecting real engineering rules into the AI's decision-making process <ref:2605.10093#pg1>.
Lu: Right. And they suggest this same approach could work for other amplifier types and more complex design flows, which is where the real ambition of this research lies <ref:2605.10093#pg1>.
Tom: It sounds like the next step is really seeing if we can use this same abstraction for different types of circuits, not just low-noise amplifiers <ref:2605.10093#pg1>.
The paper's improvements: Tom: So, they're showing that by using this tool middleware to turn sizing into a resource allocation problem, they can actually reduce the dimensionality of what an AI has to figure out <ref:2605.10093#pg3>.
Jane: That means the AI doesn't have to sift through every single tiny detail of the design all at once, which is a big deal for making it run on current hardware <ref:2605.10093#pg3>.
Lu: And because they use this structure, models of different sizes can actually function effectively in this vertical domain, which is what they call the scaling effect <ref:2605.10093#pg3>.
Meng: So if we think about deployment, it means we might be able to use smaller AI models for optimization tasks without sacrificing the quality of the design decision <ref:2605.10093#pg3>.
Tom: And they also show how this framework helps mitigate reward sparsity, which is a big problem when you're trying to get a wideband amplifier to work right <ref:2605.10093#pg2>.
Jane: That reward sparsity thing, it means the AI doesn't just get stuck on one bad answer; it keeps exploring and refining based on what it learns over time <ref:2605.10093#pg2>.
Lu: The self-evolution mechanism lets the AI alternate between exploring new possibilities when things are constrained and exploiting known good solutions when it sees something promising <ref:two thousand six hundred five point one zero zero nine three#pg2.
Meng: That sounds like a smart way to handle the trade-off between finding something totally new versus just polishing what you already have <ref:2605.10093#pg2>.
Tom: And the performance numbers back this up, showing that they maintain the lowest average completion time on most tasks even when you add all those tool capabilities <ref:two thousand six hundred five point one zero zero nine three#pg2.
Jane: It's not just about speed; it’s about robustness, because they cap their deviation from other methods at twenty-five percent across the board <ref:two thousand six hundred five point one zero zero nine three#pg2.
Lu: That stability is what you want when you are trying to build reliable systems where every single design choice has to hold up under real-world conditions <ref:two thousand six hundred five point one zero zero nine three#pg2.
Meng: So for us in the production world, this means we get a more predictable sizing process with less risk of a wild outcome popping up <ref:two thousand six hundred five point one zero zero nine three#pg2.
Tom: And they're basically saying that even though it’s a proof of concept for one type of amplifier, the underlying idea is strong enough to apply to other circuit types and more complex flows <ref:two thousand six hundred five point one zero zero nine three#pg1.
Jane: It suggests that we can take this abstraction and use it for sizing other components or even entirely different types of amplifiers down the road <ref:two thousand six hundred five point one zero zero nine three#pg1.
Lu: The main thing is proving that you don't need to treat netlists as just raw text for an AI to learn design concepts; treating it as a resource allocation task works better <ref:two thousand six hundred five point one zero zero nine three#pg1.
Tom: It’s about making the AI use its knowledge better instead of just guessing based on a huge amount of input data, which is what we need for real engineering tasks <ref:two thousand six hundred five point one zero zero nine three#pg1.
Conclusion: Tom: So, to wrap up, RFAmpDesigner is this end to end framework for automated radio frequency amplifier sizing that uses a tool middleware to turn sizing into a resource allocation problem <ref:2605.10093#pg1>.
Jane: It’s basically showing how you can use an LLM-based approach to handle the complexity of designing low noise amplifiers from their initial specs all the way down to the final schematics <ref:2605.10093#pg1>.
Lu: The main idea is that this tool middleware turns sizing into a resource allocation problem, making domain knowledge easier for LLMs and improving optimization in high dimensional settings <ref:2605.10093#pg3>.
Meng: It’s a proof of concept right now, but they say this same abstraction can be used for other amplifier types and more diverse design flows <ref:2605.10093#pg1>.
Tom: That’s the key point; it shows that even for something specific like low noise amplifiers, you can use this structure to manage high dimensionality and get better results <ref:2605.10093#pg2>.
Jane: The big implication is that this helps overcome the issue of reward sparsity in RF design, which is a problem conventional optimizers really struggle with <ref:2605.10093#pg2>.
Lu: Because they show that this tool middleware improves both robustness and efficiency across different difficulty levels, it suggests a path forward for applying these AI methods to other complex engineering problems <ref:2605.10093#pg2>.
Meng: So if we look at what this means for deployment, it’s that you can get measurable gains in stability and convergence without needing massive amounts of extra compute overhead <ref:2605.10093#pg2>.
Tom: And they point out that the framework remains reliable even across frontier LLMs, which suggests stronger reasoning and tool use are crucial for stable agent interaction <ref:2605.10093#pg2>.
Jane: It’s a solid proof of concept for how these LLM-driven optimization techniques can be applied to real hardware design tasks <ref:2605.10093#pg1>.
Lu: The real ambition is extending this abstraction toward more complete design flows and different amplifier topologies, which is where the future work lies <ref:2605.10093#pg1>.
Meng: I just wonder how much of that extra inference overhead we can actually afford when you’re trying to iterate quickly in a production environment <ref:2605.10093#pg2>.
Tom: Well, the results show this approach is economically viable for iterative design workflows because it doesn't require massive additional overhead <ref:2605.10093#pg2>.
Jane: It’s a big step showing how we can use these reasoning capabilities to tackle the data scarcity issues that limit traditional optimization methods in RF design <ref:2605.10093#pg1>.
Hang Lu, Guochang Li, Qianyu Chen, Huiyan Gao, Shaogang Wang, Xuanyu He, Yiwei Liu, Gaopeng Chen, Nayu Li, Xiaokang Qi, Chunyi Song, Zhiwei Xu
Zhejiang University
cs.AR
Submitted: 2026-05-11
Updated: 2026-11-18
Comments: 29 pages, 17 figures, 10 tables. Accepted version on TODAES
Journal ref: ACM Trans. Des. Autom. Electron. Syst., 2026
DOI: 10.1145/3863955
Code: https://github.com/bayesian-optimization/BayesianOptimization
License: http://creativecommons.org/licenses/by-nc-nd/4.0/
The gist: Automating radio frequency (RF) amplifier design remains challenging because existing methods suffer from the curse of dimensionality, weak use of domain knowledge, and poor transferability…
Key concepts
- Resource-allocation middleware
- This layer acts as an abstraction, turning complex RF design into distributing resources like current across devices. It simplifies the problem by reducing its dimensionality, making it easier for large language models to handle sizing knowledge effectively.
- Multi-agent framework
- The system uses three collaborating agents working in two modes: Autonomous Search or Self-Evolving Retrieve-and-Refine. This structure allows for parallel execution of design tasks and efficient searching through specialized subtasks.
- Self-evolving Retrieve-and-Refine Mode
- This mode maintains a Knowledge Base to store past successful designs. When facing new challenges, the agents retrieve similar prior solutions to use as starting points for refinement, improving both efficiency and solution quality over time.
- Six-dimensional resource allocation problem
- The tool middleware reformulates the entire sizing process into managing six key resources: active sizing, biasing, impedance matching, band planning, and full-chain evaluation. This structured view helps models manage complexity by treating design as a distribution challenge.
Terminology
Summary
Automating radio frequency (RF) amplifier design remains challenging because existing methods suffer from the curse of dimensionality, weak use of domain knowledge, and poor transferability, leading to low data efficiency To address this, this paper proposes RFAmpDesigner, a multi-agent framework that automates RF amplifier sizing The experimental results show that it can automatically synthesize designs with fractional bandwidths ranging from 10% to 80% and center frequencies from 10 GHz to 50 GHz To the best of our knowledge, this work develops the first LLM-driven approach for RF amplifier sizing that operates on design concepts instead of treating netlists as text, offering a novel solution to mitigate data scarcity in RF design
Framework Architecture
The framework introduces a resource-allocation middleware that reframes high-dimensional parameter tuning as a low-dimensional resource distribution problem, making it easier to inject sizing knowledge into general-purpose LLMs The framework also follows standard design practice, enabling LLMs to distinguish between high- and low-cost actions and search in parallel It employs retrieval-augmented generation (RAG) to reuse past knowledge and experience from memory base to realize a self-evolving optimization process The framework consists of three agents collaborating in a two-tier workflow aligned with established circuit design pipelines, which enables parallel execution and efficient searching and refining
Tool Middleware Functionality
The resource-allocation multi-fidelity tool middleware acts as an abstraction layer between the LLM and commercial EDA tools, reformulating RF amplifier design as a resource-allocation problem—distributing current across active devices and gain across passive networks This formulation reduces problem dimensionality enables models of varying scales to function effectively within this vertical domain The middleware decouples the problem and reformulates it as a Six-dimensional resource allocation problem, allowing domain knowledge and design heuristics to be encoded as deterministic rules and illustrative examples The toolset provides a systematic overview of each tool’s functionality together with its input–output specifications, such as Active sizing & biasing, Impedance matching, Band planning, and Fullchain evaluation
Agentic Workflow Modes
The framework introduces two operational modes: Autonomous Search and Self-Evolving Retrieve-and-Refine Mode 1, Autonomous Search Mode, involves three agents where the primary agent acts as an orchestrator decomposing the task into specialized subtasks and delegating them to stateless sub-agents The RFAmpManager decomposes the design task into searching for promising candidates for critical stages and continuously refining a selected candidate Mode 2, Self-Evolving Retrieve-and-Refine Mode, maintains persistent memory in a Knowledge Base (KB) to record factual design knowledge accumulated during exploration This mode utilizes the KB to retrieve top-k design points most similar to the target specifications as priors for refinement
Performance and Comparison
The framework exhibits the best runtime stability, with deviations capped at 25% (relative to BO, GA, and ADO-LLM), while maintaining the highest success rates and the lowest average completion time on most tasks The proposed tool middleware effectively mitigates reward sparsity, which is particularly severe under the wideband “frequencyshaping” requirements Across methods, the progression from vanilla BO/GA search (18-D) to sub-tool-equipped BO/GA search (16-D), and finally to our full tool middleware shows a consistent trend: reducing dimensionality and densifying rewards improves success rates while shortening completion time The self-evolution mechanism improves both efficiency and solution quality by enabling more effective reuse of accumulated experience when navigating the Pareto front
Conclusion
RFAmpDesigner presents an end-to-end LLM-based framework for automated RF amplifier parameter sizing, demonstrated on low-noise amplifiers from specifications to schematics The key idea is a multi-fidelity tool middleware that turns sizing into a resource-allocation problem, making domain knowledge easier to apply for LLMs and improving optimization in high-dimensional, sparse-feedback settings This work is a proof of concept, but the same abstraction is applicable to other amplifier types and can be extended toward more diverse topologies and more complete design flows The framework provides measurable gains in robustness and convergence with only modest additional inference overhead, making it economically viable for iterative RF design workflows The overall results highlight how reward sparsity fundamentally limits conventional optimizers in RF design, and demonstrate that the proposed tool middleware improves both robustness and efficiency across difficulty regimes The framework remains reliable across frontier LLMs, suggesting that stronger reasoning and tool-use capabilities are crucial for stable agent–environment interaction
References
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Resource-allocation middleware can be used to
reframe high-dimensional parameter tuning as a low-dimensional resource distribution problem, making it easier to inject sizing knowledge into general-purpose LLMs.
This allows general LLMs to handle RF design by treating circuit optimization as a resource allocation task rather than direct netlist manipulation. -
Multi-agent frameworks can be implemented with two operational modes:
Autonomous Search and Self-Evolving Retrieve-and-Refine,
which balancesexhaustive searching with lightweight refinement
for efficient design. -
The framework supports a self-improving loop through retrieval augmented generation (RAG), where it uses a knowledge base to reuse past solutions, enhancing the efficiency of data utilization during optimization.
-
The system can perform specification-driven RF amplifier parameter sizing by decomposing tasks into specialized subtasks delegated to agents, allowing for
parallel execution and efficient searching and refining.
-
The tool middleware abstracts circuit optimization as a
Six-dimensional resource allocation problem,
whichreduces problem dimensionality enables models of varying scales to function effectively within this vertical domain.
-
Agents can utilize structured templates for knowledge storage, such as the Knowledge Base for design points and the Experience Base for derived indicators, enabling them to
recall prior solutions
and provideactionable guidance when high-fidelity evaluation is unavailable or cost-prohibitive.
-
The system can perform iterative refinement based on simulation feedback by employing a staged backtracking policy where agents decide whether to re-run stages or escalate to other design steps if constraints are unmet.
-
The self-evolution mechanism enables the agent to alternate between
exploration (peaks when encountering new constraints) and exploitation (valleys enabled by memory reuse)
during sequential design challenges, leading to anear-linear in cumulative cost
progression.
Abstract
Automated RF amplifier sizing is challenging because the design process is inherently hierarchical, the parameter space is high-dimensional and strongly coupled, and high-fidelity circuit simulation is expensive. Conventional optimization and reinforcement learning methods typically require many iterations and make limited use of RF domain knowledge, making them costly under tight simulation budgets. Large language models (LLMs) provide broad prior knowledge and reasoning capabilities, but are unreliable for direct numerical optimization. This paper presents RFAmpDesigner, a two-level optimization framework for automated schematic-level sizing of differential CMOS RF amplifiers. At the outer level, the circuit-parameter space is abstracted into a resource-allocation space, where LLMs make high-level allocation decisions and adjust them according to feedback from the inner level. At the inner level, RF design knowledge is used to decompose the flat sizing problem into a sequence of low-dimensional subproblems. Conventional optimizers then solve these subproblems to find circuit implementations consistent with the assigned resources. This structure allows numerical optimizers to focus on low-dimensional searches in the circuit-parameter space, while the LLM reasons and acts over a physically meaningful design space using simulation feedback. The main evaluation covers low-noise amplifier (LNA), driver amplifier (DA), and power amplifier (PA) designs within the target differential CMOS RF amplifier family. Experimental results show that it achieves a higher success rate under a limited simulation budget in both easy and hard regimes.
Sources
- MenTeR: A fully-automated Multi-agenT workflow for end-to-end RF/Analog Circuits Netlist Design
- LEDRO: LLM-Enhanced Design Space Reduction and Optimization for Analog Circuits
- A Large Language Model-based Multi-Agent Framework for Analog Circuits' Sizing Relationships Extraction
- AnaFlow: Agentic LLM-based Workflow for Reasoning-Driven Explainable and Sample-Efficient Analog Circuit Sizing
- LayoutCopilot: An LLM-powered Multi-agent Collaborative Framework for Interactive Analog Layout Design
- ReAct: Synergizing Reasoning and Acting in Language Models
- Qwen3 Technical Report
Related papers
- Embedded Arena: Iterative Optimization via Hardware Feedback
- WitCert: Sound Runtime Risk Observability and Gating for KV-Cache Quantization
- SparsePixels: Efficient Convolution for Sparse Data on FPGAs
- Golden Ruler: A Numeric Format Catalog with Bit-Exact Conformance Vectors for FP8, BF16, MXFP4, and Microscaling Formats
- AMMA: A Multi-Chiplet Memory-Centric Architecture for Low-Latency 1M Context Attention Serving
- RFChipAgent: Multi-Agentic AI Flow for Analog/RF Chip Design