Pith. sign in

REVIEW 4 major objections 5 minor 49 references

PICopilot: An LLM-based Agentic Framework for Assisting Photonic Integrated Circuit Design via Script Generation

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper introduces PICopilot, a multi-agent LLM framework that reports solving all 48 photonic design scripting tasks in its benchmark, with Pass@1 of 93.9% and Pass@5 of 99.9%.

desk verdict A useful, first-of-its-kind LLM agent for PIC design scripting, but the headline 'solves all 48 tasks' is not verifiable because the execution-based success criterion is never precisely defined. read the letter →

arxiv 2608.01791 v3 pith:MMR4ZXAR submitted 2026-08-03 cs.ET cs.AI

Xiaohan Jiang , Zeyu Li , Wei Zhang , Jiang Xu This is my paper · ORCID
classification cs.ETcs.AI
keywords photonicintegratedcircuitsdesignscriptgenerationlargelanguagemodelsretrieval-augmentedmulti-agentframeworkautomationcodeLLMagents
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

PICopilot is a proposed framework that turns a designer's natural-language description of a photonic integrated circuit (PIC) scripting task into an executable Python script, automating a step that currently costs designers hours of manual API and tool work. The paper's central claim is that its multi-agent architecture, combined with a retrieval-augmented generation (RAG) pipeline tailored to PIC tool manuals, solves all 48 tasks in a benchmark spanning layout, DRC, simulation, and data processing, while direct LLM prompts and general RAG methods solve at most 27. If the claim holds, script-based PIC design could shift from a programmer bottleneck to a review task, with designers correcting generated code rather than writing it from scratch. The paper also reports that the added machinery costs under one cent per task on average and adds no large latency penalty, arguing that automation is practical today.

What carries the argument

The load-bearing mechanism is the combination of a multi-agent architecture with a RAG pipeline that mimics a human PIC designer's retrieval process. A Task Planner Agent decomposes each request into subtasks and routes them to Function-specific Script Generator Agents; each generator's Query Generator Agent turns the task into targeted queries, which are matched against LLM-generated summaries of tool-manual chunks in a multi-database structure, using a hybrid retriever that fuses dense embedding similarity and BM25 keyword scores with reciprocal-rank fusion. The retrieved chunks are passed to a Programmer Agent, and a Script Synthesizer merges the results while a Script Evaluator applies a static checker and custom check library in a feedback loop that iterates until the script is accepted. The RAG pipeline's distinctive move is query-to-summary matching: instead of matching task text to raw manual pages, it matches generated queries to concise summaries, which is intended to bridge the semantic gap between natural language and API code and to filter redundant manual content.

What would settle it

Take a held-out set of tasks drawn from tool-manual examples or a fresh PIC design flow, have a different designer write the ground truths, and run PICopilot's generated scripts through the real layout, DRC, and simulation tools; if the outputs diverge from the reference outputs, or if Pass@1 falls appreciably below 93.9% on this held-out set, the reported all-48 result is tied to the original benchmark rather than to general PIC script-generation ability.

Watch

Extended reading notes

Core claim

The central discovery, stated on the paper's own terms, is that a training-free LLM agentic framework can generate functionally correct PIC design scripts from natural language descriptions across the whole design flow. The paper's evaluation reports Pass@1 of 93.9% and Pass@5 of 99.9% on its 48-task benchmark, with all 48 tasks solved under the #Solved criterion (at least 3 successful trials in 15), and a maximum of 27 tasks solved by the strongest baseline (GPT-5 with ICL and a general RAG pipeline). The ablation shows that removing the tailored RAG pipeline drops Pass@1 on advanced tasks from 90.6% to 60.3%, and removing the multi-agent architecture drops it to 54.4%, so both components are claimed to be essential. The framework's own cost profile is negligible, under one cent per task, and faster than the manual writing time recorded during benchmark construction.

Load-bearing premise

The result rests on the 48 benchmark tasks being representative of real PIC scripting work, and on the execution check for 'functionally identical' outputs (Section 4.1.4) being strict enough to reject plausible but wrong scripts for layout and simulation tasks.

Editorial extensions

If this is right

  • If the benchmark result transfers, natural-language-to-script conversion becomes reliable enough to embed in PIC design flows, letting designers request layout generation, DRC, and simulation in one sentence.
  • The general RAG pipeline used by existing EDA tools is a bottleneck: the ablation attributes about 30 percentage points of Pass@1 on advanced tasks to the tailored query-summary retrieval, implying that other API-heavy code-generation domains could improve by adopting the same retrieval pattern.
  • The multi-agent decomposition plus evaluator feedback loop directly reduces LLM hallucination and randomness, so reliability gains do not require expensive training data or fine-tuning.
  • The reported cost and latency profile makes the framework usable on ordinary workstations with API access, in contrast to training-based approaches that need high-performance servers.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • My inference beyond the paper: the query-summary retrieval paradigm is general and could transfer to any domain where code must be generated against fragmented vendor APIs, such as electronic EDA, scientific simulation, or CAD, but PICopilot's experiments only demonstrate it on PIC tools.
  • My inference: the 'functionally identical' success criterion in Section 4.1.4 is not specified for tasks whose ground truth is a layout or simulation result; until an execution-based comparison is defined and applied to a held-out task set, the all-48 number should be read as a benchmark result rather than a field guarantee.
  • My inference: the human-expert verification step for database summaries means each new tool manual has a one-time curation cost; scaling to the full, rapidly evolving PIC tool ecosystem may shift the bottleneck from script writing to database maintenance.
  • My inference: because the framework stores prior messages and supports iterative feedback, it could be extended to interactive design sessions where a designer's mid-course corrections guide the generated script, which the current no-feedback evaluation does not test.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper presents PICopilot, a multi-agent LLM framework that generates Python scripts for photonic integrated circuit (PIC) design from natural language task descriptions. The framework consists of a Task Planner Agent, function-specific Script Generator Agents with a tailored retrieval-augmented generation (RAG) pipeline using summary-based hybrid retrieval over multiple tool-manual databases, a Script Synthesizer Agent, and a Script Evaluator Agent with an iterative feedback loop. The experiments on a self-constructed 48-task benchmark claim that PICopilot solves all 48 tasks with Pass@1=93.9 and Pass@5=99.9, outperforming zero-shot and ICL+RAG baselines based on GPT-5, DeepSeek-V3.2, and Qwen3-Coder, at negligible absolute cost. The ablation study attributes the gains to the tailored RAG pipeline and the multi-agent architecture.

Significance. If the reported results are reproducible under a well-defined evaluation protocol, PICopilot is a useful contribution to photonic design automation, addressing a real bottleneck in script-based PIC design. The framework is training-free, uses modular databases that can be extended to new tools, and reports overhead and ablation data. The demonstrated large gap over strong baselines suggests that the architecture and retrieval design matter. However, the quantitative claims are currently not fully verifiable because the execution-equivalence criterion is underspecified and several design choices were tuned on the same benchmark; the significance of the work hinges on closing this gap.

major comments (4)
  1. [§4.1.4] The definition of a successful trial is load-bearing but not operationalized. The paper states that a script is successful if its execution result is 'functionally identical' to the ground truth, but for tasks whose output is a GDS layout file or a set of simulation results, no equivalence criterion is given: byte-level equality, geometric comparison, and numerical tolerance would all give different answers. Moreover, the Script Evaluator Agent described in §3.6 does not execute scripts, so the execution-based verdicts must come from an evaluation harness that is never described. Please specify the exact comparison for each task type, including tolerances and output schemas, and state whether the comparison is automated or human-mediated; without this, the all-48 result is not independently checkable.
  2. [§3.4.3 and §4.1.1] The retrieval weights (w_dense=0.7, w_sparse=0.3), k=5, N_f=3, and the custom check library were selected on the same 48-task benchmark used for the final evaluation. This creates a selection-bias risk: the reported Pass@1 numbers may be optimistic for new tasks. Please provide a sensitivity analysis over these hyperparameters and, ideally, an additional held-out set of tasks or a cross-validation-style split; at minimum, report per-task results so the community can judge the stability of the all-48 claim.
  3. [§4.2 and Table 2] No uncertainty quantification is reported. With n=15 independent trials per task, the Pass@1 estimates (e.g., 93.9 overall) have nontrivial sampling variance, and the ablation differences in Table 5 are not accompanied by confidence intervals or significance tests. Please report bootstrap confidence intervals or per-task success counts, and state the generation temperature and any seed control; otherwise the magnitude of the improvements over baselines cannot be assessed statistically.
  4. [§4.1.3] The benchmark is self-constructed, and the paper does not state whether the benchmark tasks, ground-truth scripts, or evaluation harness will be released. Given that the benchmark is self-constructed and the central claim is an all-48 success rate, release of these artifacts is necessary for the community to validate the claims. Please include an availability statement or explain any restrictions on release.
minor comments (5)
  1. [§3.4.3] The phrase 'based on actual testing' for the RRF weights is vague; specify the testing procedure or provide evidence that the chosen weights are stable across tasks.
  2. [§4.3 and Table 4] The 'Designer' reference times in Table 4 are given as approximate averages and maxima, but the conditions under which they were measured are not described; clarify whether these are from one designer, on which tasks, and whether they include manual lookup of documentation.
  3. [§4.1.1] All LLM calls are via APIs, but the paper does not report the API versions or the sampling temperature; state these details to enable replication and to allow assessment of the variance in Pass@k.
  4. [References] Reference [47] lists only 'Mark Chen' as the author; use the full author list for the GPT-3 code evaluation paper.
  5. [§1] The claim of being 'the first tool to pioneer script generation in the PDA domain' is strong; consider tempering it to 'to our knowledge' and explicitly contrast the scripting focus with the design-generation focus of references [30] and [31].

Circularity Check

1 steps flagged · score 4.0 of 10

Central all-48 result is partly in-sample: retrieval weights, k, and N_f were chosen using outcomes from the same 48-task benchmark later reported as the headline evaluation.

  1. fitted input called prediction [Section 3.4.3 (Eq. 3), Section 4.1.1, with the headline claim in Section 4.2]
    "w_r is the importance weight and we set (w_dense,w_sparse)=(0.7,0.3) based on actual testing. ... We set the top-k retrieved documents per query to k=5, and the maximum iteration count N_f=3. ... It successfully solves all 48 tasks and achieves the highest scores in both 'Pass@1' and 'Pass@5' metrics."

    The RRF fusion weights are set '(0.7,0.3) based on actual testing,' and k=5 and N_f=3 are set in Section 4.1.1 without any reported held-out development set; the final evaluation in Section 4.2 then reports the all-48 Pass@1/Pass@5 result on the same 48-task benchmark. Because the benchmark outcomes were available while choosing these design parameters, the headline result is an in-sample measurement, not an out-of-sample prediction. The all-48 claim therefore cannot independently validate the choices that produced it. This is co-adaptation (partial circularity), not an equation-level identity; the tool manuals and execution-verified ground truths are external, so the rest of the pipeline is not self-referential.

full rationale

The framework's derivation chain is otherwise self-contained: the RAG databases are built from external tool manuals, retrieval is specified algorithmically (cosine + BM25 + RRF), and ground-truth scripts are authored by a PIC designer and verified by execution. No load-bearing step is justified solely by a self-citation; reference [18] is background and not used to forbid alternatives. The only substantive circularity concern is that several system parameters were empirically chosen on the same 48-task benchmark that then yields the headline 'solves all 48 tasks,' so the central quantitative claim is partly in-sample. The paper also leaves the 'functionally identical' execution comparison unspecified (Section 4.1.4), which is a reproducibility and verification gap rather than a circular reduction. Score 4 reflects one partial co-adaptation in the central evaluation while acknowledging the framework itself has independent algorithmic content.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The reported performance depends on three categories of unverified input: a self-constructed benchmark with single-author ground truth, an underspecified functional-equivalence judge, and system hyperparameters tuned on that same benchmark. The RAG databases and prompts are not released, so the all-48 result cannot be separated from these choices.

free parameters (5)
  • RRF fusion weights (w_dense, w_sparse) = 0.7, 0.3
    Set 'based on actual testing' in Section 3.4.3; affects which manual chunks are retrieved and hence script quality.
  • Top-k retrieved documents per query = 5
    Chosen in Section 4.1.1; controls the amount of reference material given to the Programmer Agent.
  • Maximum feedback iterations N_f = 3
    Set in Section 4.1.1; caps the revision loop that contributes to the high solve rate.
  • Task-solved threshold for #Solved metric = at least 3 successes in 15 trials
    Defined in Section 4.1.4; the all-48 claim depends on this arbitrary consistency threshold.
  • BM25 parameters k1, b and RRF constant c = 1.5, 0.75, 60
    Empirical defaults kept from Algorithm 1; they affect ranking but were not tuned for this paper.
assumptions (4)
  • domain assumption The 48-task benchmark is representative of real PIC design script writing and its ground-truth scripts are correct.
    Section 4.1.3 states tasks are 'carefully selected from actual PIC design flows', but representativeness is asserted, not externally validated.
  • domain assumption Executing a generated script and comparing its output to ground truth as 'functionally identical' is a valid measure of success.
    Section 4.1.4 defines success this way without specifying the comparison procedure for layout files or simulation outputs.
  • domain assumption LLM-generated summaries of tool manual chunks preserve all information needed to retrieve correct API content.
    Section 3.4.2 uses summaries as the retrieval index; any information lost in summarization is unavailable to the Programmer Agent.
  • domain assumption Static checking (AST + Pyflakes) plus LLM evaluation is sufficient to evaluate generated scripts in the feedback loop.
    Section 3.6 avoids script execution because simulations are slow; the evaluator may pass scripts that fail at execution time.

how reviews work

0 comments
Cite this review

Pith. "Pith review of PICopilot: An LLM-based Agentic Framework for Assisting Photonic Integrated Circuit Design via Script Generation." pith.science (2026). https://pith.science/paper/MMR4ZXAR

@misc{pith2026260801791,
  author       = {Pith},
  title        = {Pith review of: PICopilot: An LLM-based Agentic Framework for Assisting Photonic Integrated Circuit Design via Script Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/MMR4ZXAR}},
  note         = {Machine review of arXiv:2608.01791}
}
read the original abstract

The rapid development of photonic integrated circuits (PICs) is shifting the design flow from traditional graphical user interface (GUI)-based methods to script-based methods for higher flexibility, portability, and maintainability. However, script-based design introduces new challenges, requiring designers to possess additional proficiency in tool application programming interfaces (APIs) and programming. It also demands greater effort and time because it is inherently less intuitive and more complex than GUI-based methods. As PICs grow in scale and complexity, the productivity gap between design needs and manual scripting capabilities continues to widen. To address this gap, we introduce PICopilot, the first large language model (LLM)-based agentic framework that assists in PIC design via automated design script generation from natural language instructions. PICopilot leverages a multi-agent architecture with a feedback mechanism and a specifically designed retrieval-augmented generation (RAG) pipeline, achieving a high success rate and reliability. Experimental results on a benchmark of diverse PIC scripting tasks demonstrate that PICopilot successfully completes all 48 tasks and outperforms other LLM-based approaches without incurring substantial extra latency or cost, even solving 21 more tasks than the advanced GPT-5 model with a general RAG pipeline.

Figures

Figures reproduced from arXiv: 2608.01791 by the authors.

Figure 1
Figure 1. An illustration of the GUI-based PIC design and the [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Overview of PICopilot. retrieval-augmented generation (RAG) [35] are widely adopted and proven effective. ICL enables LLMs to infer task-specific patterns through representative examples embedded in prompts, allowing the model to mimic the desired output without additional training. RAG, on the other hand, augments the LLM’s domain knowledge by retrieving relevant references from curated external databases and integ… view at source ↗
Figure 3
Figure 3. An illustration of our agent design techniques. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: An illustration of the retrieval paradigm of the PIC [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: An illustration of the retrieval process in the general RAG pipeline and our RAG pipeline. [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]

Review history (3 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

49 extracted references · 10 linked inside Pith

  1. [1]

    Shupeng Ning, Hanqing Zhu, Chenghao Feng, Jiaqi Gu, Zhixing Jiang, Zhoufeng Ying, Jason Midkiff, Sourabh Jain, May H Hlaing, David Z Pan, et al . 2024. Photonic-electronic integrated circuits for high-performance computing and ai accelerators.Journal of Lightwave Technology(2024)

    2024

  2. [2]

    Shawn Yohanes Siew, Bo Li, Feng Gao, Hai Yang Zheng, Wenle Zhang, Pengfei Guo, Shawn Wu Xie, Apu Song, Bin Dong, Lian Wee Luo, et al. 2021. Review of silicon photonics technology and platform development.Journal of Lightwave Technology39, 13 (2021), 4374–4389

    2021

  3. [3]

    Farshid Ashtiani, Alexander J Geers, and Firooz Aflatouni. 2022. An on-chip photonic deep neural network for image classification.Nature606, 7914 (2022), 501–506

    2022

  4. [4]

    Zhihao Xu, Tiankuang Zhou, Muzhou Ma, ChenChen Deng, Qionghai Dai, and Lu Fang. 2024. Large-scale photonic chiplet Taichi empowers 160-TOPS/W artificial general intelligence.Science384, 6692 (2024), 202–209

    2024

  5. [5]

    Saumil Bandyopadhyay, Alexander Sludds, Stefan Krastanov, Ryan Hamerly, Nicholas Harris, Darius Bunandar, Matthew Streshinsky, Michael Hochberg, and Dirk Englund. 2024. Single-chip photonic deep neural network with forward-only training.Nature Photonics18, 12 (2024), 1335–1343

    2024

  6. [6]

    Sufi R Ahmed, Reza Baghdadi, Mikhail Bernadskiy, Nate Bowman, Ryan Braid, Jim Carr, Chen Chen, Pietro Ciccarella, Matthew Cole, John Cooke, et al. 2025. Universal photonic artificial intelligence acceleration.Nature640, 8058 (2025), 368–374

    2025

  7. [7]

    Gdsfactory. 2023. GDSFactory 9.20.6. https://gdsfactory.github.io/gdsfactory/

    2023

  8. [8]

    Luceda. 2025. Luceda IPKISS. https://www.lucedaphotonics.com/luceda- photonics-design-platform

    2025

Show all 49 references
  1. [9]

    Siemens. 2025. L-Edit Photonics. https://eda.sw.siemens.com/en-US/ic/ic- custom/photonic/l-edit-photonics/

    2025

  2. [10]

    Matthias Köfferlein. 2020. KLayout

    2020

  3. [11]

    Spark Photonics. 2025. Check Mate DRC. https://www.sparkphotonics.com/ checkmatedrc

    2025

  4. [12]

    ANSYS Inc. 2025. Ansys Lumerical INTERCONNECT. https://www.ansys.com/ products/optics/interconnect

    2025

  5. [13]

    ANSYS Inc. 2025. Ansys Lumerical FDTD. https://www.ansys.com/products/ optics/fdtd

    2025

  6. [14]

    ANSYS Inc. 2025. Ansys Lumerical MODE. https://www.ansys.com/products/ optics/mode

    2025

  7. [15]

    Flexcompute. 2025. FAST, MODERN PHOTONIC SIMULATIONS. https://www. flexcompute.com/tidy3d/

    2025

  8. [16]

    Synopsys Inc. 2025. Synopsys OptSim. https://www.synopsys.com/photonic- solutions/optocompiler/optsim-photonic-ic.html

    2025

  9. [17]

    Yinyi Liu, Bohan Hu, Zhenguo Liu, Peiyu Chen, Linfeng Du, Jiaqi Liu, Xianbin Li, Wei Zhang, and Jiang Xu. 2023. FIONA: Photonic-Electronic CoSimulation Frame- work and Transferable Prototyping for Photonic Accelerator. In2023 IEEE/ACM International Conference on Computer Aided...

    2023

  10. [18]

    Xiaohan Jiang, Yinyi Liu, Peiyu Chen, Wei Zhang, and Jiang Xu. 2025. PICELF: An Automatic Electronic Layer Layout Generation Framework for Photonic Integrated Circuits. In2025 Design, Automation & Test in Europe Conference (DATE). IEEE, 1–7

    2025

  11. [19]

    Hao Chen, Yuzhe Ma, and Yeyu Tong. 2025. Bi-Level Optimization Accelerated DRC-Aware Physical Design Automation for Photonic Devices. In2025 Design, Automation & Test in Europe Conference (DATE). IEEE, 1–7

    2025

  12. [20]

    Yuchao Wu, Xiaofei Yu, Xianyi Feng, Yeyu Tong, and Yuzhe Ma. 2025. Constraints- aware Adaptive Routing with Hybrid Waveguides for Photonic Integrated Cir- cuits. In2025 IEEE/ACM International Conference on Computer Aided Design (ICCAD). IEEE, 1–8

    2025

  13. [21]

    Jingyu Pan, Guanglei Zhou, Chen-Chia Chang, Isaac Jacobson, Jiang Hu, and Yiran Chen. 2025. A survey of research in large language models for electronic design automation.ACM Transactions on Design Automation of Electronic Systems 30, 3 (2025), 1–21

    2025

  14. [22]

    Mingjie Liu, Teodor-Dumitru Ene, Robert Kirby, Chris Cheng, Nathaniel Pinckney, Rongjian Liang, Jonah Alben, Himyanshu Anand, Sanmitra Banerjee, Ismet Bayraktaroglu, et al. 2023. Chipnemo: Domain-adapted llms for chip design. arXiv preprint arXiv:2311.00176(2023)

    2023 arXiv

  15. [23]

    Haoyuan Wu, Zhuolun He, Xinyun Zhang, Xufeng Yao, Su Zheng, Haisheng Zheng, and Bei Yu. 2024. Chateda: A large language model powered autonomous agent for eda.IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems43, 10 (2024), 3184–3197

    2024

  16. [24]

    Wenzhao Sun, Yanan Han, Bijian Lan, Qing Peng, and Jing Wan. 2025. Ana- sizecoder: Code generator for analog integrated circuit sizing automation via large language model. In2025 International Symposium of Electronics Design Automation (ISEDA). IEEE, 817–822

    2025

  17. [25]

    Yiting Wang, Wanghao Ye, Yexiao He, Yiran Chen, Gang Qu, and Ang Li. 2025. MCP4EDA: LLM-Powered Model Context Protocol RTL-to-GDSII Automation with Backend Aware Synthesis Optimization.arXiv preprint arXiv:2507.19570 (2025)

    2025 arXiv

  18. [26]

    Bingyang Liu, Haoyi Zhang, Xiaohan Gao, Zichen Kong, Xiyuan Tang, Yibo Lin, Runsheng Wang, and Ru Huang. 2025. Layoutcopilot: An llm-powered multi-agent collaborative framework for interactive analog layout design.IEEE Transactions on Computer-Aided Design of Integrated Circui...

    2025

  19. [27]

    Yao Lai, Sungyoung Lee, Guojin Chen, Souradip Poddar, Mengkang Hu, David Z Pan, and Ping Luo. 2025. Analogcoder: Analog circuit design via training-free code generation. InProceedings of the AAAI Conference on Artificial Intelligence, Vol. 39. 379–387

    2025

  20. [28]

    Yao Lai, Souradip Poddar, Sungyoung Lee, Guojin Chen, Mengkang Hu, Bei Yu, Ping Luo, and David Z Pan. 2025. Analogcoder-pro: Unifying analog circuit generation and optimization via multi-modal llms.arXiv preprint arXiv:2508.02518 (2025)

    2025 arXiv

  21. [29]

    Jason Liu, Ankita Sharma, Cheick Doumbia, and Joyce KS Poon. 2024. Towards large-language model assisted layout of silicon photonic integrated circuits. In European Conference on Integrated Optics. Springer, 441–447

    2024

  22. [30]

    Yuchao Wu, Xiaofei Yu, Hao Chen, Yang Luo, Yeyu Tong, and Yuzhe Ma. 2025. PICBench: Benchmarking LLMs for Photonic Integrated Circuits Design. In2025 Design, Automation & Test in Europe Conference (DATE). IEEE, 1–6

    2025

  23. [31]

    Ankita Sharma, YuQi Fu, Vahid Ansari, Rishabh Iyer, Fiona Kuang, Kashish Mistry, Raisa Islam Aishy, Sara Ahmad, Joaquin Matres, Dirk R Englund, et al

  24. [32]

    Chen-Chia Chang, Chia-Tung Ho, Yaguang Li, Yiran Chen, and Haoxing Ren

  25. [33]

    Ansys Canada Ltd. 2025. Lumerical scripting language. https://optics.ansys.com/ hc/en-us/articles/360037228834-Lumerical-scripting-language-By-category

    2025

  26. [34]

    InProceedings of the 2025 International Symposium on Physical Design

    Drc-coder: Automated drc checker code generation using llm autonomous agent. InProceedings of the 2025 International Symposium on Physical Design. 143–151

    2025

  27. [35]

    Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in neural information processing s...

    2020

  28. [36]

    Qingxiu Dong, Lei Li, Damai Dai, Ce Zheng, Jingyuan Ma, Rui Li, Heming Xia, Jingjing Xu, Zhiyong Wu, Baobao Chang, et al . 2024. A survey on in-context learning. InProceedings of the 2024 conference on empirical methods in natural language processing. 1107–1128

    2024

  29. [37]

    Daoguang Zan, Zhirong Huang, Wei Liu, Hanwu Chen, Linhao Zhang, Shulin Xin, Lu Chen, Qi Liu, Xiaojian Zhong, Aoyan Li, et al. 2025. Multi-swe-bench: A multilingual benchmark for issue resolving.arXiv preprint arXiv:2504.02605 (2025)

    2025 arXiv

  30. [38]

    John K Ousterhout. 1993. An Introduction to TCL and TK

    1993

  31. [39]

    Python Software Foundation. 2001. ast — Abstract syntax trees. https://docs. python.org/3/library/ast.html

    2001

  32. [40]

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. 2022. Chain-of-thought prompting elicits reasoning in large language models.Advances in neural information processing systems35 (2022), 24824–24837

    2022

  33. [41]

    LangChain. 2025. LangChain. https://www.langchain.com/langchain

    2025

  34. [42]

    Python Software Foundation. 2026. pyflakes 3.4.0. https://pypi.org/project/ pyflakes/

    2026

  35. [43]

    Aixin Liu DeepSeek-AI, Aoxue Mei, Bangcai Lin, Bing Xue, Bingxuan Wang, Bingzheng Xu, Bochao Wu, Bowei Zhang, Chaofan Lin, Chen Dong, et al. 2025. DeepSeek-V3. 2: Pushing the Frontier of Open Large Language Models.arXiv preprint arXiv:2512.02556(2025)

    2025 arXiv

  36. [44]

    Qwen Team. 2025. Qwen3 Technical Report. arXiv:2505.09388 [cs.CL] https: //arxiv.org/abs/2505.09388

    2025 arXiv

  37. [45]

    Xiangyang Li, Kuicai Dong, Yi Quan Lee, Wei Xia, Yichun Yin, Hao Zhang, Yong Liu, Yasheng Wang, and Ruiming Tang. 2024. Coir: A comprehensive benchmark for code information retrieval models.URL https://arxiv. org/abs/2407.02883 (2024)

    2024 arXiv

  38. [46]

    Henrique Schechter Vera, Sahil Dua, Biao Zhang, Daniel Salz, Ryan Mullins, Sindhu Raghuram Panyam, Sara Smoot, Iftekhar Naim, Joe Zou, Feiyang Chen, et al. 2025. Embeddinggemma: Powerful and lightweight text representations. arXiv preprint arXiv:2509.20354(2025)

    2025 arXiv

  39. [47]

    Mark Chen. 2021. Evaluating large language models trained on code.arXiv preprint arXiv:2107.03374(2021)

    2021 arXiv

  40. [48]

    OpenAI. 2025. Introducing GPT-5. https://openai.com/index/introducing-gpt-5/

    2025

  41. [2025]

    AI Agents for Photonic Integrated Circuit Design Automation.arXiv preprint arXiv:2508.14123(2025)

    2025 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.