Skip to content

AnalogAgent: Self-Improving Analog Circuit Design Automation with LLM Agents

🕒 Published (v1): 2026-03-25 03:59 UTC · Source: Arxiv · link

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

AnalogAgent is a training-free multi-agent framework for analog circuit design automation that couples a three-agent pipeline (Code Generator, Design Optimizer, Knowledge Curator) with a Self-Evolving Memory (SEM) module storing an Adaptive Design Playbook. It addresses context attrition—the progressive loss of technical detail as LLMs compress iterative feedback into summaries—by externalizing accumulated knowledge into a persistent, incrementally updated store. With GPT-5, it achieves 97.4% Pass@1 on a 30-task benchmark, a ~12.5% Hard-task gain over the prior best.

Problem

Single-LLM analog design pipelines suffer from (1) context attrition: iterative refinement causes the model to compress prior findings into shorter summaries, eroding critical SPICE/simulation details; (2) monolithic coupling: generation, diagnosis, and correction compete within one context window; and (3) library dependence: most methods require external topology databases or circuit textbooks unavailable in proprietary settings.

Method

AnalogAgent decomposes the design loop into three specialized LLM agents operating over a shared Self-Evolving Memory (SEM):

  • Code Generator constructs SPICE/Python scripts by augmenting the task instruction \(P_t = P_\text{task}(x) \oplus r_t\) with knowledge \(r_t = \mathcal{R}(M_t, \tau)\) retrieved from the Adaptive Design Playbook by circuit-type \(\tau\).
  • Design Optimizer runs five-stage simulation checks (requirement compliance, DC feasibility, DC-sweep transfer, functional tests, waveform sanity) and applies an optional bias-injection step \(\tilde{c}_t = \mathcal{T}(c_t, \mathcal{B}(\mathcal{D}(c_t)))\) for transfer-curve tasks.
  • Knowledge Curator distills execution feedback \(f_t = (x, c_t, e_t, s_t, \ell_t, z_t, \text{PASS}(c_t))\) into structured rules \(\Delta_t = \phi(f_t)\), then updates the playbook via dedup-filtered merge: \(M_{t+1} = \text{DedupFilter}(M_t \| \Delta_t; \Omega)\).

Retrieval uses exact task-type key match with substring fallback. After a valid circuit is found, Bayesian optimization via Optuna/TPE tunes device parameters. The closed loop is: generate → simulate → curate → retrieve → regenerate.

Key Contributions

  • Training-free agentic framework requiring no external circuit libraries or topology databases.
  • Self-Evolving Memory (SEM) with an Adaptive Design Playbook that performs incremental, deduplicated knowledge updates to explicitly counter context attrition.
  • Three-agent decomposition separating code generation, simulation-driven optimization, and knowledge curation into distinct roles.
  • Cross-task knowledge transfer: rules distilled from one circuit type are retrieved to bootstrap related tasks.
  • Demonstrated strong gains on compact open-weight models (Qwen-8B: +48.8% average Pass@1).

Results

  • GPT-5 backbone: 97.4% / 100.0% Pass@1 / Pass@5; Hard-task Pass@1 ~12.5% above AnalogCoder-Pro (88.6% overall Pass@1).
  • Gemini-2.5-Flash backbone: 92.0% / 99.9% Pass@1 / Pass@5.
  • Compact model (Qwen-8B): +48.8% average Pass@1 gain; 72.1% overall Pass@1.
  • Efficiency: 1.3 min average time-to-first-success vs. 2.6 min (SPICEPilot) and 2.1 min (AnalogCoder-Pro); ~32K tokens vs. ~40K (AnalogCoder-Pro).
  • Ablation (Gemini): Full model 92.0/99.9 vs. MAS-only 81.6/95.0 vs. SEM-only 73.3/90.1 vs. baseline 63.8/76.8 on Avg Pass@1/Pass@5; Hard-task Pass@1 drops from 89.8 → 68.8 (MAS-only) → 43.7 (baseline).
  • SPICEPilot achieves 50.1% Pass@1 but 96.5% Pass@5, indicating poor first-attempt reliability.
  • AnalogCoder-Pro with GPT-5: 88.6/98.2 Pass@1/Pass@5, fails on Tasks 24–25.

Limitations

  • Benchmark is limited to 30 tasks; generalization to richer or real-world analog design spaces is untested.
  • Pass@\(k\) evaluated with \(n=30\) candidates; stochastic variance still reported across only five trials.
  • The playbook retrieval is type-matched or substring-based—no semantic embedding search—which may miss cross-domain reuse opportunities.
  • The paper does not report human-expert baselines or compare wall-clock cost against conventional EDA tools on identical specifications.
  • Context attrition is mitigated, not eliminated; the framework still relies on an LLM context window for intra-iteration reasoning.

Relevance to Harnesses / Meta-Harnesses

AnalogAgent is a domain-specific instantiation of the meta-harness pattern: a controller layer that orchestrates specialized subagents, routes execution signals, and maintains a persistent external memory that accumulates and retrieves structured knowledge across task boundaries. The Adaptive Design Playbook with its dedup-filtered incremental update protocol (\(M_{t+1} = \text{DedupFilter}(M_t \| \Delta_t; \Omega)\)) is essentially a self-managing knowledge store that the harness reads and writes—analogous to how meta-harnesses manage prompt libraries or tool registries. The explicit closed-loop (generate → simulate → curate → retrieve) mirrors harness architectures that convert tool-execution feedback into reusable harness-level configuration. The +48.8% gain on compact models from cross-task knowledge transfer demonstrates a core meta-harness benefit: amortizing learning across agent invocations rather than treating each as a stateless call.