Skip to content
Back to search

analog-agents

12 agentic skills for analog IC design — architecture, sizing, verification, cross-model review, knowledge graph, and self-evolution. Works with or without EDA.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/arcadia-1--analog-agents/badge.svg)](/listings/arcadia-1--analog-agents)

HTML

<a href="/listings/arcadia-1--analog-agents"><img src="/api/listings/arcadia-1--analog-agents/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**1. Clone the repo** (include the `virtuoso-bridge-lite` submodule)

git clone --recurse-submodules https://github.com/Arcadia-1/analog-agents.git
# or, if you already cloned without --recurse-submodules:
# git submodule update --init

**2. Register skills with your coding agent**

For the full pipeline (recommended):

ln -s /path/to/analog-agents/skills/analog-pipeline ~/.claude/skills/analog-pipeline

Or symlink individual skills as needed:

ln -s /path/to/analog-agents/skills/analog-design ~/.claude/skills/analog-design
ln -s /path/to/analog-agents/skills/analog-verify ~/.claude/skills/analog-verify
# ... etc

Chinese users can also search and install skills through [Skills宝](https://skilery.com).

**3. (Optional) Enable cross-model review**

cp config/reviewers.example.yml config/reviewers.yml
# Edit with your API keys for minimax, qwen, kimi, glm

**4. Configure your servers**

cp config/servers.example.yml config/servers.yml
# Edit with your host, user, and SSH key

**5. Create a spec sheet in your project directory**

cat > spec.yml << 'EOF'
block: my-ota
process: tsmc28nm
supply: 1.8V
specs:
  dc_gain:      { min: 60, unit: dB  }
  phase_margin: { min: 45, unit: deg }
  power:        { max: 1.0, unit: mW }
EOF

**6. Invoke the skill**

Use the analog-pipeline skill. Design an OTA for spec.yml.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 462 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="https://img.shields.io/badge/analog--agents-12%20skills%20for%20analog%20IC%20design-00d4aa?style=for-the-badge&labelColor=0a0a0a" alt="analog-agents"/>
  3. </p>
  4. <p align="center">
  5. <strong>Agentic analog IC design framework — with or without EDA.</strong><br/>
  6. 12 skills. 4 agents. Knowledge graph. Cross-model review. Self-evolution.
  7. </p>
  8. <p align="center">
  9. <!-- GitHub -->
  10. <a href="https://github.com/Arcadia-1/analog-agents/stargazers"><img src="https://img.shields.io/github/stars/Arcadia-1/analog-agents?style=flat-square&logo=github&color=f5c542" alt="GitHub Stars"/></a>
  11. <a href="https://github.com/Arcadia-1/analog-agents/network/members"><img src="https://img.shields.io/github/forks/Arcadia-1/analog-agents?style=flat-square&logo=github&color=8b949e" alt="GitHub Forks"/></a>
  12. <a href="https://github.com/Arcadia-1/analog-agents/issues"><img src="https://img.shields.io/github/issues/Arcadia-1/analog-agents?style=flat-square&logo=github&color=3fb950" alt="Open Issues"/></a>
  13. <a href="https://github.com/Arcadia-1/analog-agents/commits/main"><img src="https://img.shields.io/github/last-commit/Arcadia-1/analog-agents?style=flat-square&logo=git&color=3fb950" alt="Last Commit"/></a>
  14. </p>
  15. <p align="center">
  16. <!-- Built for -->
  17. <img src="https://img.shields.io/badge/built%20for-agentic%20design-ff6b35?style=flat-square" alt="Built for Agentic Design"/>
  18. <img src="https://img.shields.io/badge/works%20with-any%20coding%20agent-blueviolet?style=flat-square" alt="Any Coding Agent"/>
  19. <img src="https://img.shields.io/badge/format-skill%20library-64748b?style=flat-square" alt="Skill Library"/>
  20. </p>
  21. <p align="center">
  22. <!-- Tech stack -->
  23. <img src="https://img.shields.io/badge/Spectre-simulator-1e3a5f?style=flat-square&logo=cadence&logoColor=white" alt="Spectre"/>
  24. <img src="https://img.shields.io/badge/Virtuoso-schematic-0057a8?style=flat-square" alt="Virtuoso"/>
  25. <img src="https://img.shields.io/badge/Python-3.9%2B-3776ab?style=flat-square&logo=python&logoColor=white" alt="Python"/>
  26. <img src="https://img.shields.io/badge/SPICE%2FSpectre-netlist-orange?style=flat-square" alt="SPICE Netlist"/>
  27. <img src="https://img.shields.io/badge/PVT-corner%20aware-9b59b6?style=flat-square" alt="PVT Corners"/>
  28. </p>
  29. <p align="center">
  30. <!-- v2 capabilities -->
  31. <img src="https://img.shields.io/badge/skills-12-00d4aa?style=flat-square" alt="12 Skills"/>
  32. <img src="https://img.shields.io/badge/EDA-optional-ff6b35?style=flat-square" alt="EDA Optional"/>
  33. <img src="https://img.shields.io/badge/cross--model-4%20LLMs-6c5ce7?style=flat-square" alt="4 LLM Reviewers"/>
  34. <img src="https://img.shields.io/badge/self--evolving-wiki%20%2B%20checklists-f59e0b?style=flat-square" alt="Self-Evolving"/>
  35. </p>
  36. <p align="center">
  37. <!-- License & contribution -->
  38. <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-22c55e?style=flat-square" alt="MIT License"/></a>
  39. <a href="https://github.com/Arcadia-1/analog-agents/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen?style=flat-square" alt="PRs Welcome"/></a>
  40. <img src="https://img.shields.io/badge/skill%20library-markdown%20only-64748b?style=flat-square" alt="No Runtime Dependencies"/>
  41. </p>
  42. ---
  43. ## What Is This?
  44. **analog-agents** is a federated skill framework for AI-native analog IC design. 12 independently executable skills cover the full lifecycle — from architecture exploration to post-layout audit — with or without EDA tools. It works with any coding agent that supports skill files.
  45. Most AI tools treat analog design like software: write some code, run some tests, ship it. That misses everything that makes analog hard — the architecture tradeoffs, the spec budgeting across sub-blocks, the PVT corner matrix, the sizing rationale, the convergence loop between design and simulation, the sign-off gate before delivering a verified schematic.
  46. analog-agents doesn't miss any of that.
  47. **v2** adds four new capabilities: a **design knowledge graph** that captures anti-patterns, strategies, and topology lessons as a searchable wiki; **cross-model review** that dispatches circuit audits to external models (minimax, qwen, kimi, glm) for independent verification; **topology-specific checklists** that enforce mandatory checks per circuit type; and **effort levels** that scale verification depth from lite to exhaustive.
  48. It dispatches four agents — a **librarian**, an **architect**, a **designer**, and a **verifier** — with distinct roles, strict permissions, and defined handoff contracts. The librarian surveys existing Virtuoso libraries. The architect decomposes the system, writes testbenches, and validates the architecture with behavioral models. The designer produces transistor-level netlists. The verifier reviews both the circuit and testbench before simulating. They iterate until every spec passes with margin.
  49. ```
  50. top-level spec.yml
  51. |
  52. |-- librarian (background, optional)
  53. | survey existing Virtuoso library
  54. | output: survey-report.md + library-index.md
  55. |
  56. v
  57. architect agent (Phase 1: decompose)
  58. |-- select architecture, tradeoff analysis
  59. |-- derive sub-block specs + budget allocation
  60. |-- write testbenches + verification plans
  61. |-- output: architecture.md + budget.md + blocks/*/spec.yml + testbenches
  62. |
  63. v
  64. architect agent (Phase 2: behavioral validation)
  65. |-- Verilog-A model per sub-block
  66. |-- system-level behavioral simulation
  67. |-- confirm top-level specs achievable
  68. |
  69. v
  70. +------------------------------------------------------+
  71. | For each sub-block: |
  72. | |
  73. | designer (circuit) + architect (testbench) |
  74. | | |
  75. | v |
  76. | verifier: review both --> approve? --> simulate |
  77. | | | |
  78. | FAIL REJECT |
  79. | | (no sim run) |
  80. | v | |
  81. | designer revises architect or designer fixes |
  82. | |
  83. | (max 3 design iterations per sub-block) |
  84. +------------------------------------------------------+
  85. |
  86. v
  87. architect agent (Phase 3: integration)
  88. |-- replace behavioral models with verified netlists
  89. |-- top-level integration verification
  90. |
  91. v
  92. sign-off gate --> L3 PVT required
  93. |
  94. v
  95. verified schematic delivered
  96. ```
  97. ## The Four Agents
  98. ### Librarian
  99. Surveys and manages Virtuoso design libraries. Runs in the background.
  100. - Scans Virtuoso libraries, exports netlists, identifies circuit topologies
  101. - Produces `survey-report.md` (detailed) and `library-index.md` (quick-reference)
  102. - Assesses reusability of existing blocks against current project specs
  103. - Can write back to Virtuoso: create schematics from netlists, update parameters
  104. - Uses `virtuoso-bridge` for all Virtuoso interactions
  105. - Long-running — dispatched in background, parallel with architect
  106. ### Architect
  107. Owns the system architecture and all testbenches.
  108. - Selects architecture (e.g., SAR vs pipeline vs sigma-delta) with tradeoff analysis
  109. - Breaks system into sub-blocks, derives each sub-block's spec from top-level requirements
  110. - Allocates power/noise/timing budgets (must close before proceeding)
  111. - Builds Verilog-A behavioral models to validate architecture before transistor design
  112. - **Writes all testbenches** — the designer does not write testbenches
  113. - Defines verification plans — what to verify, which analyses, what extraction method
  114. - Integrates verified sub-blocks and runs system-level verification
  115. - Writes `lessons_learned` at project completion for future design knowledge
  116. ### Designer
  117. Owns the circuit netlist. Thinks in small-signal equations. Shows their math.
  118. - Reads sub-block `spec.yml`, produces `<block>.scs` + `rationale.md`
  119. - Every `.param` value comes with a design equation
  120. - Responds to verifier failures with calculated adjustments, not guesses
  121. - Can invoke the **optimizer** skill when specs conflict or margins are tight
  122. - Writes **custom post-simulation hooks** per block to track what matters during iteration
  123. - Delivers verified netlist ready for next design stage
  124. ### Verifier
  125. Reviews before simulating. Never touches the netlist. Always quantifies.
  126. - **Reviews both circuit netlist and testbench before simulating** — catches errors before they burn simulation cycles
  127. - Circuit problem → rejects, routes feedback to designer
  128. - Testbench problem → rejects, routes feedback to architect
  129. - If both are sound → runs Spectre, writes `margin-report.md`
  130. - Every result includes: measured value, target, margin, corner
  131. - Every failure includes: shortfall, likely cause, suggested fix
  132. ## Verification Levels
  133. Escalate verification deliberately. Don't run full PVT corners just to check if the circuit turns on.
  134. | Level | When | What Runs | Purpose |
  135. |-------|------|-----------|---------|
  136. | **L1 Functional** | Every iteration (default) | `.op` + `.tran`/`.ac` at TT/27C | Does the circuit perform its basic function? |
  137. | **L2 Performance** | When L1 passes | All spec analyses at TT | Do all spec targets pass at typical corner? |
  138. | **L3 Robustness** | Before sign-off (mandatory) | Full corner matrix | Does the design hold across process/voltage/temperature? |
  139. L1 is not just a DC operating point check. It confirms the circuit does what it's supposed to do: an ADC produces output codes, a comparator resolves correctly, a bootstrap switch tracks the input, an amplifier amplifies.
  140. ## Pre-Simulation Review
  141. The verifier reviews both the circuit netlist and testbench **before** running any simulation:
  142. 1. **Circuit review** — missing connections? pin mismatches? parameterization errors?
  143. 2. **Testbench review** — correct stimulus node? proper load? right analysis type? common pitfalls (PSRR/CMRR/PM setup)?
  144. If either has issues, the verifier rejects without simulating and routes feedback to the responsible agent. This saves simulation time and catches errors that would otherwise produce misleading results.
  145. ## Iteration Tracking
  146. Every design run produces `iteration-log.yml` with:
  147. - Per-sub-block iteration history (what parameters changed, why)
  148. - Pre-simulation rejections by verifier
  149. - Optimizer invocation records
  150. - Lessons learned at project completion
  151. Parameter changes are auto-recorded by hooks whenever a netlist is modified. The architect writes `lessons_learned` at sign-off — these insights make the next project's architect smarter.
  152. ## Designer's Custom Hooks
  153. At the start of each block's design, the designer writes `blocks/<name>/post-sim-hook.py` — a custom script that runs automatically after every simulation for that block. The designer decides what it does: plot optimization trends, track parameter sensitivities, flag operating point drift. It's the designer's tool — modified, rewritten, or discarded as iteration focus shifts.
  154. ## Spec Sheet
  155. The `spec.yml` is the central contract. Every agent reads it. Nothing ships without it.
  156. ```yaml
  157. block: folded-cascode-ota
  158. process: tsmc28nm
  159. supply: 1.8V
  160. specs:
  161. dc_gain: { min: 60, unit: dB }
  162. ugbw: { min: 100, unit: MHz }
  163. phase_margin: { min: 45, unit: deg }
  164. noise_input: { max: 5, unit: nV/rtHz }
  165. power: { max: 1.0, unit: mW }
  166. corners: # used for L3 PVT
  167. - { name: tt_27c, process: tt, voltage: 1.8, temp: 27 }
  168. - { name: ss_125c, process: ss, voltage: 1.62, temp: 125 }
  169. - { name: ff_m40c, process: ff, voltage: 1.98, temp: -40 }
  170. ```
  171. ## Simulation Hooks
  172. After every Spectre run, a `PostToolUse` hook fires automatically:
  173. 1. Finds the most recent PSF output directory
  174. 2. Parses results via `virtuoso-bridge`
  175. 3. Checks every value against `spec.yml` targets
  176. 4. Appends a timestamped entry to `sim-log.yml`
  177. 5. Injects a margin table into context — the agent sees pass/fail immediately
  178. 6. Runs designer's custom per-block hook (if present)
  179. After every netlist edit, a separate hook:
  180. 1. Runs `spectre -check` for syntax validation
  181. 2. Diffs `.param` changes and records them to `iteration-log.yml`
  182. ## Multi-Server Support
  183. Teams with dedicated EDA infrastructure can map roles to separate servers and accounts:
  184. ```yaml
  185. # config/servers.yml
  186. servers:
  187. design-server:
  188. host: eda01.company.com
  189. user: designer_bot
  190. key: ~/.ssh/id_design
  191. tools: [virtuoso, spectre]
  192. sim-server:
  193. host: hpc02.company.com
  194. user: sim_bot
  195. key: ~/.ssh/id_sim
  196. tools: [spectre]
  197. role_mapping:
  198. librarian: design-server # needs Virtuoso read/write
  199. architect: design-server
  200. designer: design-server # read/write Virtuoso
  201. verifier: sim-server # simulation only
  202. ```
  203. Single-server teams: just define a `default` entry and skip `role_mapping`.
  204. ## Installation
  205. **1. Clone the repo** (include the `virtuoso-bridge-lite` submodule)
  206. ```bash
  207. git clone --recurse-submodules https://github.com/Arcadia-1/analog-agents.git
  208. # or, if you already cloned without --recurse-submodules:
  209. # git submodule update --init
  210. ```
  211. **2. Register skills with your coding agent**
  212. For the full pipeline (recommended):
  213. ```bash
  214. ln -s /path/to/analog-agents/skills/analog-pipeline ~/.claude/skills/analog-pipeline
  215. ```
  216. Or symlink individual skills as needed:
  217. ```bash
  218. ln -s /path/to/analog-agents/skills/analog-design ~/.claude/skills/analog-design
  219. ln -s /path/to/analog-agents/skills/analog-verify ~/.claude/skills/analog-verify
  220. # ... etc
  221. ```
  222. Chinese users can also search and install skills through [Skills宝](https://skilery.com).
  223. **3. (Optional) Enable cross-model review**
  224. ```bash
  225. cp config/reviewers.example.yml config/reviewers.yml
  226. # Edit with your API keys for minimax, qwen, kimi, glm
  227. ```
  228. **4. Configure your servers**
  229. ```bash
  230. cp config/servers.example.yml config/servers.yml
  231. # Edit with your host, user, and SSH key
  232. ```
  233. **5. Create a spec sheet in your project directory**
  234. ```bash
  235. cat > spec.yml << 'EOF'
  236. block: my-ota
  237. process: tsmc28nm
  238. supply: 1.8V
  239. specs:
  240. dc_gain: { min: 60, unit: dB }
  241. phase_margin: { min: 45, unit: deg }
  242. power: { max: 1.0, unit: mW }
  243. EOF
  244. ```
  245. **6. Invoke the skill**
  246. ```
  247. Use the analog-pipeline skill. Design an OTA for spec.yml.
  248. ```
  249. ## What's Inside
  250. ```
  251. analog-agents/
  252. ├── skills/
  253. │ ├── analog-pipeline/ # Full design pipeline orchestrator
  254. │ ├── analog-decompose/ # Architecture decomposition and budgeting
  255. │ ├── analog-behavioral/ # Behavioral model validation
  256. │ ├── analog-design/ # Transistor-level netlist design
  257. │ ├── analog-verify/ # Pre-sim review and simulation
  258. │ ├── analog-integrate/ # Integration verification and sign-off
  259. │ ├── analog-review/ # Cross-model circuit audit
  260. │ ├── analog-wiki/ # Design knowledge graph
  261. │ ├── analog-learn/ # Interactive design teaching companion
  262. │ ├── analog-explore/ # Design space exploration
  263. │ ├── analog-audit/ # Static netlist audit service
  264. │ └── analog-evolve/ # Self-evolution engine
  265. ├── prompts/
  266. │ ├── architect-prompt.md # Architect agent template
  267. │ ├── designer-prompt.md # Designer agent template
  268. │ ├── librarian-prompt.md # Librarian agent template
  269. │ └── verifier-prompt.md # Verifier agent template
  270. ├── shared-references/
  271. │ ├── checklist-schema.md # Checklist format spec
  272. │ ├── cmfb.md # CMFB design reference
  273. │ ├── effort-contract.md # Effort level definitions
  274. │ ├── handoff-contracts.md # Agent handoff protocols
  275. │ ├── review-protocol.md # Cross-model review protocol
  276. │ └── wiki-schema.md # Wiki entry schema
  277. ├── checklists/ # Topology-specific verification checklists
  278. │ ├── common.yml # Universal checks (all circuits)
  279. │ ├── amplifier.yml # OTA / amplifier checks
  280. │ ├── folded_cascode.yml # Folded cascode specific
  281. │ ├── differential.yml # Fully-differential checks
  282. │ ├── comparator.yml # Comparator checks
  283. │ ├── adc.yml # ADC checks
  284. │ ├── current-mirror.yml # Current mirror checks
  285. │ ├── bandgap.yml # Bandgap reference checks
  286. │ ├── ldo.yml # LDO regulator checks
  287. │ └── pll.yml # PLL checks
  288. ├── wiki/ # Design knowledge graph
  289. │ ├── index.yml # Entry index
  290. │ ├── edges.jsonl # Relationship edges
  291. │ ├── anti-patterns/ # Known failure modes
  292. │ ├── strategies/ # Design strategies
  293. │ ├── topologies/ # Topology knowledge
  294. │ └── corner-lessons/ # PVT corner lessons
  295. ├── config/
  296. │ ├── servers.example.yml # Multi-server config template
  297. │ ├── reviewers.example.yml # Cross-model reviewer config
  298. │ └── effort.yml # Default effort level
  299. ├── tools/
  300. │ ├── review_bridge.py # Cross-model review dispatcher
  301. │ └── wiki_ops.py # Wiki search/add/consult operations
  302. ├── hooks/
  303. │ ├── hooks.json # Hook event registration
  304. │ ├── session-start # Inject skill + check bridge + read spec on startup
  305. │ ├── post-sim.sh # Triggered after every Spectre run
  306. │ ├── post_sim_check.py # PSF parser -> spec checker -> sim-log writer
  307. │ ├── post-netlist-check.sh # Syntax check + param change recording
  308. │ └── session-summary.sh # End-of-session summary
  309. └── docs/specs/ # Design documents
  310. ```
  311. ## Skills
  312. | Skill | Description |
  313. |-------|-------------|
  314. | `/analog-pipeline` | Full design pipeline orchestrator |
  315. | `/analog-decompose` | Architecture decomposition and budgeting |
  316. | `/analog-behavioral` | Behavioral model validation |
  317. | `/analog-design` | Transistor-level netlist design |
  318. | `/analog-verify` | Pre-sim review and simulation |
  319. | `/analog-integrate` | Integration verification and sign-off |
  320. | `/analog-review` | Cross-model circuit audit (minimax, qwen, kimi, glm) |
  321. | `/analog-wiki` | Design knowledge graph |
  322. | `/analog-learn` | Interactive design teaching companion (no EDA needed) |
  323. | `/analog-explore` | Design space exploration with hand calculations (no EDA needed) |
  324. | `/analog-audit` | Static netlist audit service (no EDA needed) |
  325. | `/analog-evolve` | Self-evolution engine: learns from each design session |
  326. ## Effort Levels
  327. Scale verification depth to match your design phase:
  328. | Level | When | Scope |
  329. |-------|------|-------|
  330. | **lite** | Quick sanity check | DC op + basic function at TT only |
  331. | **standard** | Normal design iteration | L1 + L2 at TT, key specs |
  332. | **intensive** | Pre-tapeout review | Full L1-L3 with PVT corners |
  333. | **exhaustive** | Sign-off | All corners, Monte Carlo, mismatch, cross-model review |
  334. See `shared-references/effort-contract.md` for full definitions.
  335. ## Cross-Model Review
  336. Independent circuit audits dispatched to external models for a second opinion. Supported models: **minimax**, **qwen**, **kimi**, **glm**.
  337. The review bridge (`tools/review_bridge.py`) sends the netlist, spec, and rationale to one or more external models and collects structured findings. Each reviewer scores independently, and findings are merged into a unified report.
  338. Copy `config/reviewers.example.yml` to `config/reviewers.yml` and add your API keys to enable cross-model review.
  339. ## Knowledge Graph
  340. The `wiki/` directory is a persistent design knowledge base — anti-patterns, strategies, topology lessons, and corner-case gotchas captured as structured YAML entries with typed edges between them.
  341. Following Polanyi's principle, the wiki captures tacit design knowledge that experienced engineers carry but rarely document — the kind of knowledge that prevents a team from repeating the same mistakes across projects.
  342. Use the `/analog-wiki` skill to search, consult, and contribute to the knowledge graph.
  343. ## Philosophy
  344. **Spec-driven, not vibe-driven.** Every design decision traces back to a quantitative target. The spec sheet is not documentation — it is the contract.
  345. **Survey before you design.** The librarian scans existing libraries for reusable blocks before anyone writes a new transistor. Don't redesign what already exists.
  346. **Architect before designer.** Don't jump to transistors before validating the architecture. Decompose, budget, model behaviorally, then design.
  347. **Review before you simulate.** The verifier checks both circuit and testbench before running Spectre. A bad testbench produces bad numbers — catch it before it wastes simulation time.
  348. **Margin, not just pass/fail.** A design that passes at TT/27C and fails at SS/125C is not done. Verification reports numbers, not verdicts.
  349. **Rationale is a deliverable.** A netlist without hand-calc justification is a guess. The designer documents the equation behind every parameter.
  350. **Three iterations maximum.** If the design hasn't converged after three designer-verifier loops, the problem is topology, not tuning. Escalate to architect or human.
  351. **Agents build their own tools.** Predefined templates limit what agents can do. The designer writes custom hooks, scripts, and plots as needed — no fixed formats.
  352. **Learn from every project.** Iteration logs and lessons learned accumulate design knowledge that makes the next project's architect smarter.
  353. ## Related Skills
  354. analog-agents orchestrates workflow. For domain knowledge:
  355. | Skill | What It Does |
  356. |-------|-------------|
  357. | `spectre` | Run Spectre simulations from a netlist file |
  358. | `virtuoso` | Cadence Virtuoso schematic operations via virtuoso-bridge |
  359. | `veriloga` | Write Verilog-A behavioral models |
  360. | `evas-sim` | Behavioral simulation with EVAS Verilog-A simulator |
  361. | `sar-adc` | SAR ADC architecture, design, and budgeting |
  362. | `optimizer` | Bayesian optimization of circuit parameters |
  363. ## License
  364. MIT — see [LICENSE](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.