Electronic design automation multi-agent cooperation system and method based on large language model

Abstract

The invention discloses an electronic design automation multi-agent collaboration system and method based on a large language model. A collaboration architecture of a task analysis agent, a divergent thinking agent and a decision agent is adopted, wherein the task analysis agent analyzes natural language task description through an improved weighted cosine similarity algorithm and extracts key constraints; the divergent thinking agent generates a plurality of cross-platform compatible EDA script schemes based on few-sample chained thinking prompts and layered random sampling; and the decision-making agent dynamically selects an optimal solution from the candidate scripts and injects a fault-tolerant instruction by fusing a Bayesian probability model and a Laplace approximation uncertainty calibration mechanism. According to the method, the planning reliability of a complex EDA task is remarkably enhanced, seamless adaptation of a heterogeneous EDA tool chain is achieved in a breakthrough mode, meanwhile, the cascade failure risk is fundamentally blocked through a multi-agent error isolation mechanism, and efficient and robust full-process automation support is provided for integrated circuit design.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of electronic design automation and artificial intelligence, and particularly relates to an electronic design automation multi-agent collaboration system and method based on a large language model. BACKGROUND

[0002] Electronic design automation (EDA) is an indispensable tool for modern integrated circuit (IC) design, which controls the design process through complex processes and programming interfaces, realizing the automation of key steps such as logic synthesis, layout planning, and routing. With the increasing complexity and scale of IC design, the role of EDA tools becomes increasingly important. Traditional EDA tools are complex to operate, requiring designers to have deep domain knowledge and programming skills, which not only increases the design cycle but also limits the flexibility and innovation of design. In recent years, large language models (LLM) have shown excellent capabilities in natural language understanding and task planning, providing new possibilities for the automation of EDA processes. Through the interaction of LLM and EDA tool APIs, the automation of EDA processes can be realized, reducing the workload of engineers, reducing errors, and improving design efficiency.

[0003] Although LLM shows potential in the automation of EDA processes, existing methods still face many challenges. First, LLM performs well in understanding natural language, but lacks specialized knowledge in using EDA tools, making it difficult to accurately generate EDA scripts in actual applications. Second, the interfaces of different EDA platforms differ greatly, making it difficult for LLM to be cross-platform, limiting its effectiveness in actual scenarios. In addition, EDA processes usually involve a series of intermediate steps, and any step error can cause the entire process to fail, while the randomness of LLM can exacerbate this problem, leading to error accumulation and increasing the risk of process failure. SUMMARY

[0004] The present application provides an electronic design automation multi-agent collaboration system and method based on a large language model to address the shortcomings of the prior art. Through multi-agent collaboration, the automation of EDA processes is realized, ensuring the stability and success rate of EDA processes.

[0005] To achieve the above application purposes, the technical solutions adopted by the present application are as follows:

[0006] An electronic design automation multi-agent collaboration system based on a large language model, comprising:

[0007] A task analysis agent for receiving natural language description of EDA task input, extracting task key information and generating vector embedding;

[0008] A divergent thinking agent for generating multiple task planning paths and corresponding EDA scripts based on similar task examples;

[0009] A decision-making agent for evaluating the success probability of multiple EDA scripts and selecting the optimal script;

[0010] The system improves cross-platform compatibility and task success rate through multi-agent collaboration.

[0011] Further, the task analysis agent further comprises:

[0012] An input processing unit for accessing EDA task descriptions and EDA tool API documents;

[0013] A key information extraction unit for extracting task parameters using natural language processing techniques and named entity recognition techniques;

[0014] A vector embedding generation unit for encoding the task description and key information into high-dimensional vectors;

[0015] A similar task retrieval unit for calculating the similarity of the generated embedding vectors with task vectors in the EDA tool demonstration database and retrieving the K most relevant examples and their tuples.

[0016] Further, the task analysis agent performs: calculating the cosine similarity of the task description vector A and the database task vector B:

[0017]

[0018] Where: A represents the embedding vector of the task description, B represents the embedding vector of the task in the database, Σ -1 represents the inverse matrix of the database covariance matrix, which is calculated as:

[0019]

[0020] Where: T j represents the jth task vector in the database, represents the mean of the task vector, and N is the total number of database tasks.

[0021] Further, the divergent thinking agent further comprises:

[0022] An example group generation unit for randomly selecting instances from the K retrieved relevant examples to create N example groups, using a hierarchical random sampling strategy to ensure task type diversity;

[0023] A few-shot chain thinking prompt template unit for connecting the example groups with prompt templates to generate a prompt group containing task decomposition, solution steps, and verification;

[0024] a task planning step generation unit configured to generate a sequence of task planning steps according to the prompt using a ChipLlama model, each step comprising an EDA tool API function call and parameter settings;

[0025] an EDA script generation unit configured to initialize a script template according to the task planning steps, fill in parameters, splice scripts, and verify script correctness through static code analysis or simulation execution.

[0026] Further, the step parameters generated by the task planning step generation unit include component model, library symbol name, package type and library path, network node, component attribute, power rating and temperature coefficient, position and layout, connection rule, script execution context, and error handling and log options.

[0027] Further, the EDA script generation unit generates scripts using the following process:

[0028] Initialize script template: Template i = API i (parameters i );

[0029] Fill in parameter to generate script code Script i = Template i (parameters i )

[0030] Where: Template i represents the i-th step script template, API i represents the EDA tool API function corresponding to the i-th step, parameters i represents the i-th step parameter setting;

[0031] Splice all script codes in order and perform multi-dimensional optimization, including code formatting, library loading, parameter verification, error capture, log recording and performance profiling.

[0032] Further, the decision-making agent further comprises:

[0033] a candidate scheme evaluation unit configured to analyze the feature vector of each candidate EDA script, including logical structure, completeness and potential errors;

[0034] a probability calculation unit configured to calculate the probability of each script successfully completing the EDA task;

[0035] an optimal script selection unit configured to compare the probability values and select the highest probability script, and consider execution efficiency and readability when the probability is close;

[0036] A result packaging unit is configured to output a final EDA script and an execution suggestion.

[0037] Further, the probability calculation unit calculates the probability using the following formula:

[0038]

[0039] wherein: φ(A i ) represents a script feature vector, μ represents a posterior distribution mean, ∑ represents a posterior distribution covariance, b represents an evaluation model bias, and σ represents a sigmoid activation function.

[0040] The application further discloses an electronic design automation multi-agent cooperation method based on the system, and has the characteristics that the method comprises the following steps:

[0041] Receiving an EDA task input described in natural language and an EDA tool API document;

[0042] Extracting key information, generating vector embedding, and retrieving similar task examples by a task analysis agent;

[0043] Generating multiple task planning paths and EDA scripts by a divergent thinking agent, using a few-shot chain thinking prompt template and a ChipLlama model;

[0044] Evaluating the success probability of each EDA script by a decision-making agent, and selecting an optimal script;

[0045] Executing the selected EDA script to complete EDA process automation, and feeding back the result.

[0046] Further, the step of retrieving similar task examples comprises the following steps: converting the task description into a vector representation; calculating the cosine similarity; and retrieving K most relevant instances and their (Q, C, A) tuples.

[0047] The step of generating an EDA script comprises the following steps: randomly creating an example group from the retrieved examples; connecting a few-shot chain thinking prompt template; generating a task planning step sequence, each step corresponding to an EDA tool API call; initializing and filling a script template, and verifying the correctness of the script after splicing.

[0048] The step of evaluating and selecting an optimal script comprises the following steps: extracting a candidate script feature vector; calculating the success probability; selecting the script with the highest probability, and optimizing the execution efficiency and readability based on the probability when the probability is close.

[0049] Compared with the prior art, the application has the following advantages:

[0050] I. Enhancing task planning and reasoning ability

[0051] Through the deep integration of multi-agent collaborative architecture and few-shot chain-of-thought (CoT) prompting methods, the system significantly improves the logical reasoning capabilities of complex EDA tasks:

[0052] Deep task decomposition: Task analysis agents accurately extract design constraints (such as timing requirements and power consumption limitations), and divergent thinking agents generate diversified task planning paths through hierarchical sampling, breaking down high-level design requirements into atomic operation steps (such as cell layout and clock tree synthesis);

[0053] Dynamic knowledge fusion: By combining real-time retrieval of similar task instances and expert-level language models (ChipLlama), the system automatically embeds domain best practices in script generation, ensuring compliance of key operations (such as antenna effect repair and cross-clock domain checks);

[0054] Self-iterative optimization: The closed-loop evaluation of planning paths by decision-making agents forms knowledge sedimentation, continuously enhancing the system's adaptability to unconventional scenarios (such as heterogeneous integration and near-threshold design).

[0055] II. Enhancing cross-platform compatibility and stability

[0056] The system breaks through the platform barriers of traditional EDA automation through a three-layer mechanism:

[0057] Heterogeneous interface adaptation: Task analysis agents dynamically analyze the semantic differences of API documents from different EDA vendors (such as Synopsys, Cadence, and Siemens EDA), generating platform-independent intermediate representation layers;

[0058] Fault-tolerant script generation: Divergent thinking agents output multiple versions of scripts (such as Tcl / Python) for the same task in parallel, and through static analysis, they pre-check platform-specific error patterns (such as version-dependent parameters and license invocation conflicts);

[0059] Dynamic optimal execution: Decision-making agents evaluate script robustness based on Bayesian probability models, and when the probability boundary is ambiguous, they initiate a hybrid optimization strategy (such as sacrificing local efficiency for interface compatibility), essentially eliminating the risk of process interruption caused by single-platform dependence.

[0060] III. Optimizing the reliability of full-process automation

[0061] The multi-agent collaboration mechanism builds a global reliability barrier:

[0062] Error propagation blocking: Through the multi-solution redundant generation of divergent thinking agents, the system isolates single-point errors within independent candidate branches, avoiding the cascading failure of traditional chain processes;

[0063] Self-healing decision: the decision-making agent fuses historical failure sample features (such as parameter out-of-bound, resource deadlock) in the probability evaluation, and automatically injects repair instructions (such as increasing sandbox pre-check, inserting rollback breakpoint) for high-risk scripts.

[0064] Interpretability enhancement: the EDA script of the final output is accompanied by a readability report, which explicitly shows the basis for generating key operation nodes (such as high-speed path optimization, cross-voltage domain isolation), greatly reducing the debugging cost of engineers. BRIEF DESCRIPTION OF DRAWINGS

[0065] Figure 1 is the overall architecture diagram of the electronic design automation multi-agent collaboration system of the embodiment of the present application;

[0066] Figure 2 is the task analysis agent architecture diagram of the embodiment of the present application;

[0067] Figure 3 is the divergent thinking agent architecture diagram of the embodiment of the present application;

[0068] Figure 4 is the decision-making agent architecture diagram of the embodiment of the present application;

[0069] Figure 5 is the flow of the electronic design automation multi-agent collaboration method of the embodiment of the present application. DETAILED DESCRIPTION

[0070] In order to make the purpose, technical scheme and advantages of the present application clearer, the following will be further described in detail according to the drawings and examples.

[0071] As shown in Figure 1 , the application provides an electronic design automation multi-agent collaboration system based on a large language model, which is used for receiving an EDA task input described in natural language;

[0072] The task analysis agent extracts key information of the task and generates vector embedding;

[0073] The divergent thinking agent is used for generating a plurality of task planning paths and corresponding EDA scripts based on similar task examples;

[0074] The decision-making agent is used for evaluating the success probability of a plurality of EDA scripts and selecting the optimal script;

[0075] The system improves cross-platform compatibility and task success rate through multi-agent collaboration.

[0076] I. Task analysis agent Figure 2

[0077] 1) Input processing:

[0078] ​Receive EDA task descriptions provided in natural language.

[0079] Access the EDA tool API documentation to obtain programming interface information.

[0080] 2) Extraction of key information:

[0081] Semantic analysis of EDA task descriptions is performed using natural language processing techniques.

[0082] Use regular expressions or named entity recognition technology to extract key parameters such as task type, objective, and constraints.

[0083] 3) Vector embedding generation:

[0084] The extracted key information and task description are converted into a vector representation.

[0085] The text is encoded into a high-dimensional vector using a pre-trained embedding model.

[0086] 4) Similar task retrieval:

[0087] The embedding vectors {T1, T2, ..., T} of all N tasks in the database are used to... N Extract all of them and calculate the mean vector:

[0088]

[0089] The sample covariance matrix is ​​obtained by calculating the covariance using the mean vector:

[0090]

[0091] Calculate the cosine similarity between the generated embedding vector and the task vectors in the EDA tool demo database:

[0092]

[0093] Where A and B represent the task description and the embedding vector of the task in the database, respectively, Σ -1 Given the inverse of the database covariance matrix, determine the most similar tasks and retrieve the K most relevant instances and their respective tuples.

[0094] 2. Divergent thinking intelligent agent ( Figure 3 )

[0095] 1) Example group generation:

[0096] Several instances are randomly selected from the retrieved K relevant example pools to create example groups. A stratified random sampling strategy is used to ensure that each example group contains diverse task types. The random selection process is repeated multiple times to generate N different example groups.

[0097] 2) Few-shot CoT prompt templates:

[0098] Design chain-of-thought prompt templates containing task decomposition, solution steps, and verification. Connect each example set with the prompt template to form N different prompt groups.

[0099] 3) Task planning step generation:

[0100] Generate task planning steps from prompts using the ChipLlama model. Break down the task into a series of ordered steps, each including specific EDA tool calls and parameter settings. Carefully determine the required parameters for each step to reduce the likelihood of incorrect parameter usage.

[0101] 4) EDA script generation:

[0102] Select the appropriate EDA tool API functions based on the task planning steps. Initialize the script template and fill in the parameters. Concatenate all generated EDA script code in order to form a complete script. Use static code analysis tools or simulation execution environments to verify the correctness and stability of the script.

[0103] 3. Decision-making agent Figure 4 )

[0104] 1) Candidate solution evaluation:

[0105] Receive multiple results from the divergent thinking agent in the format (C i ,A i ), where i = 1, 2…N. Perform feature extraction on each candidate EDA script to analyze its logical structure, completeness, and potential errors.

[0106] 2) Probability calculation:

[0107] Specify Gaussian priors for weights and biases: Observe training data where each A i is a candidate script, and φ(Ai) is the vector obtained through embedding / feature extractor. Each y i ∈{0,1} is a label (0 represents "unsuccessful" and 1 represents "successful").

[0108] Use Laplace approximation to obtain the mean μ and covariance Σ of the posterior weights. For a new script A i , its posterior predictive probability can be expressed as the marginalization of parameters:

[0109]

[0110] Use the evaluation model to calculate the probability of each candidate script successfully completing the EDA task:

[0111]

[0112] Where φ(Ai) is script A i The feature vectors are w and b, which are the weights and biases of the evaluation model, and μ and Σ are the posterior distributions, respectively. The mean and covariance.

[0113] 3) Optimal script selection:

[0114] Compare the probability values ​​of all candidate scripts and select the script with the highest probability as the final output. When the probabilities are close, consider other characteristics of the script, such as execution efficiency and readability.

[0115] 4) Result encapsulation:

[0116] Output the final selected EDA script, along with task planning steps and execution suggestions, and generate a readable report explaining the key parts of the script and execution expectations.

[0117] like Figure 5 As shown, a multi-agent collaborative method for electronic design automation based on the above system includes the following steps:

[0118] (1) Receive EDA task descriptions provided in natural language form and obtain data containing EDA tool programming interface documents through EDA tool API documents, which describe in detail the function, parameters and usage of each API.

[0119] (2) Use natural language processing technology to perform semantic analysis on the EDA task description to extract key information such as task type, objectives, and constraints. For key information extraction, key parameters and requirements are extracted from the task description using regular expressions or named entity recognition technology.

[0120] (3) The extracted key information and task description are embedded together to generate a vector representation of the natural language description.

[0121] (4) Extract the embedding vectors {T1, T2, ..., T...} of all N tasks in the database. N Extract all of them and calculate the mean vector:

[0122]

[0123] (5) Calculate the covariance using the mean vector to obtain the sample covariance matrix:

[0124]

[0125] (6) Calculate the cosine similarity between the generated embedding vector and the task vectors in the demonstration database used by the EDA tool:

[0126]

[0127] where A and B represent the embedding vectors of the task description and the tasks in the database, respectively, and Σ -1 is the inverse of the database covariance matrix.

[0128] (7) Determine the most similar tasks and map their corresponding IDs back to the demonstration database to retrieve the K most relevant instances and their respective tuples.

[0129] (8) Example set generation: Randomly select several instances from the pool of K relevant instances retrieved to create an example set. This random selection process is repeated to generate multiple example sets.

[0130] (9) Prompt template connection: Each example set is connected to the few-shot CoT prompt template, resulting in several sets with different prompts.

[0131] (10) Task planning step C generation based on the few-shot prompt T. The model decomposes the task into a series of ordered steps V according to the guidelines outlined in the API documentation in the prompt. Each step includes specific EDA tool calls and parameter settings.

[0132] (11) In the task planning phase, the generated task planning steps C are a structured sequence of steps, each corresponding to an EDA tool call and the corresponding parameter settings, including: component model, library symbol name, package type and library path, network node, component properties, power rating and temperature coefficient, position and layout, connection rules, script execution context, and error handling and log options. These steps will serve as the basis for subsequent EDA script generation.

[0133] (12) Receive the task planning steps C generated in step 1, each corresponding to an EDA tool call and the corresponding parameter settings. Obtain data containing EDA tool programming interface documents, which describe the functions, parameters and usage methods of each API in detail.

[0134] (13) According to each step in the task planning steps C, select the corresponding EDA tool API function and initialize the script template. Template initialization formula:

[0135] Template i = API i (parameters i )

[0136] where Templatei Template i API i parameters

[0137] (14) According to the parameter settings in task planning step C, fill in the specific parameter values into the script template. Code generation formula:

[0138] Script i =Template i (parameters i )

[0139] where Script i represents the EDA script code generated by the i-th step.

[0140] (15) Concatenate all generated EDA script codes into a complete EDA script according to the order of task planning step C. Perform multi-dimensional optimization on the concatenated EDA script, first perform code formatting and style unification, then load libraries in batches and extract public constants. Then add parameter verification and pre-check to ensure that the path, version and type are correct, then supplement error capture and rollback mechanism after each API call, and through centralized log recording and tracking, facilitate debugging. Use cProfile and other performance profiling tools to optimize loops and requests for bottlenecks. Finally, refactor the script for scalability with clear functions or classes to ensure script readability and execution efficiency.

[0141] (16) Use static code analysis tools or simulation execution environments to verify the generated EDA script to ensure its correctness and stability. Output the EDA script that passes the verification as the input of the subsequent EDA tool execution.

[0142] (17) Receive EDA task descriptions provided in natural language form, and obtain data containing EDA tool programming interface documents. EDA tools use demonstration databases containing multiple EDA tool usage instances, each instance containing a (Q, C, A) tuple.

[0143] (18) Convert the EDA task description into a vector representation, and use an embedding model to encode the task description into a vector q.

[0144] Similarity calculation: Calculate the cosine similarity between the task description vector q and all task vectors q i in the EDA tool usage demonstration database:

[0145]

[0146] Determine the most similar tasks and map their corresponding IDs back to the demo database to retrieve the K most relevant instances and their respective (Q, C, A) tuples.

[0147] (19) Divergent thinking agents generate: task planning steps are generated by each divergent thinking agent according to the few-shot prompt T to generate task planning steps C. According to the task planning steps C and the EDA tool API document, the corresponding EDA script A is generated.

[0148] Result packaging: the generated task planning steps C and EDA script A are packaged in a message:

[0149] m = {O1, O2, …, O N}

[0150] where O i = (C i , A i ).

[0151] (20) Decision agent receives message m from divergent thinking agent. Analyze each result: decision agent analyzes each Oi, calculates the probability of each candidate EDA script A i to be the answer at the end of the answer

[0152] P(yes | A i ).

[0153] (21) Select the optimal result: select the candidate answer O best with the highest probability as the representative output of the multi-agent system.

[0154] (22) Output the final result: the decision agent outputs the final EDA script A best .

[0155] (23) Receive multiple results from divergent thinking agents, each containing a task planning path and the corresponding EDA script, denoted as O i = (C i , A i ), where i = 1, 2, …, N.

[0156] (24) Specify the Gaussian prior for weights and biases: Observe training data where each A i is a candidate script, and the vector φ(Ai) is obtained through embedding / feature extractor, and each y i ∈ {0, 1} is the label (0 represents "unsuccessful" and 1 represents "successful"). Use Laplace approximation to obtain the mean μ and covariance Σ of the posterior weight. For a new script A iThe posterior predictive probability of A can be expressed as marginalization over parameters:

[0157]

[0158] where φ(Ai) is the feature vector of script A i , w and b are the weight and bias of the evaluation model, is the training data.

[0159] (25) For each candidate EDA script A i , the decision agent needs to determine whether it can successfully complete the EDA task. The decision agent computes the probability P(yes|A i ) of each candidate script choosing the "yes" label at the end, which can be achieved by the evaluation model:

[0160]

[0161] where φ(Ai) is the feature vector of script A i , b is the bias of the evaluation model, μ and Σ are the mean and covariance of the posterior distribution , respectively.

[0162] (26) Compare the probabilities P(yes|A i ) of all candidate scripts, and select the script with the highest probability as the optimal script.

[0163]

[0164] (27) Output the corresponding EDA script A best , which is the optimal script selected by the decision agent, for subsequent EDA process automation execution.

[0165] The above-described methods according to the present application can be implemented in hardware, firmware, or as software, which can be stored in a recording medium such as a CD ROM, RAM, floppy disk, hard disk, or magneto-optical disk, or be implemented through computer codes stored in a remote recording medium or non-transitory machine-readable medium originally stored in a remote recording medium and downloaded to a local recording medium, so that the methods described herein can be processed by such software on a recording medium using a general-purpose computer, a special-purpose processor, or programmable or special-purpose hardware such as an ASIC or FPGA. It can be understood that the computer, processor, microprocessor controller, or programmable hardware includes a storage component (e.g., RAM, ROM, flash memory, etc.) that can store or receive software or computer codes, which, when accessed and executed by the computer, processor, or hardware, implement the electronic design automation multi-agent collaboration methods described herein. Furthermore, when a general-purpose computer accesses the codes for implementing the processes shown herein, the execution of the codes will convert the general-purpose computer into a special-purpose computer for executing the processes shown herein.

[0166] Those skilled in the art will understand that the embodiments described herein are for the purpose of helping the reader understand the method of implementing the present application, and should be understood as the scope of protection of the present application not being limited to such specific descriptions and embodiments. Those skilled in the art can make various other specific modifications and combinations according to the technical inspiration disclosed in the present application without departing from the essence of the present application, and these modifications and combinations are still within the scope of protection of the present application.

Claims

1. A multi-agent collaborative system for electronic design automation based on a large language model, characterized in that, include: The task analysis agent is used to receive EDA task inputs in natural language description, extract key task information and generate vector embeddings. A divergent thinking agent is used to generate multiple task planning paths and corresponding EDA scripts based on similar task examples. A decision-making agent is used to evaluate the success probability of multiple EDA scripts and select the optimal script.

2. The system according to claim 1, characterized in that, The task analysis agent further includes: The input processing unit is used to access EDA task descriptions and EDA tool API documentation. The key information extraction unit uses natural language processing and named entity recognition technologies to extract task parameters. The vector embedding generation unit encodes the task description and key information into a high-dimensional vector; The similarity task retrieval unit calculates the similarity between the generated embedding vector and the task vectors in the EDA tool demonstration database, and retrieves the K most relevant instances and their tuples.

3. The system according to claim 2, characterized in that, The task analysis agent performs the following: calculates the cosine similarity between task description vector A and database task vector B: Where: A represents the embedding vector of the task description, B represents the embedding vector of the task in the database, Σ -1 This represents the inverse of the database covariance matrix, and the formula for calculating the covariance matrix Σ is as follows: Wherein: T j This represents the j-th task vector in the database. This represents the mean of the task vector, where N is the total number of tasks in the database.

4. The system according to claim 1, characterized in that, The divergent thinking agent further includes: The example group generation unit is used to randomly select instances from the K relevant examples retrieved to create N example groups, and a stratified random sampling strategy is used to ensure the diversity of task types; A few-sample chain-like thinking prompt template unit is used to connect the example group with the prompt template to generate a prompt group containing task decomposition, solution steps and verification. The task planning step generation unit uses the ChipLlama model to generate a sequence of task planning steps based on prompts. Each step includes EDA tool API function calls and parameter settings. The EDA script generation unit is used to initialize script templates, fill in parameters, and assemble scripts according to task planning steps, and to verify the correctness of scripts through static code analysis or simulated execution.

5. The system according to claim 4, characterized in that, The step parameters generated by the task planning step generation unit include component model, library symbol name, package type and library path, network node, component attributes, power rating and temperature coefficient, location and layout, connection rules, script execution context, and error handling and logging options.

6. The system according to claim 4, characterized in that, The EDA script generation unit generates scripts using the following process: Initialization script template: Template i =API i (parameters i ); Script code for filling parameters i =Template i (parameters i ) Where: Template i This represents the script template for step i, API. i This represents the EDA tool API function corresponding to the i-th step, parameters. i This indicates the parameter settings for step i; All script code is concatenated in sequence and optimized in multiple dimensions, including code formatting, library loading, parameter validation, error capture, logging, and performance profiling.

7. The system according to claim 1, characterized in that, The decision-making agent further includes: The candidate solution evaluation unit is used to analyze the feature vector of each candidate EDA script, including logical structure, completeness, and potential errors; The probability calculation unit is used to calculate the probability that each script will successfully complete the EDA task; The optimal script selection unit is used to compare probability values ​​and select the script with the highest probability, taking into account execution efficiency and readability when the probabilities are close. The result encapsulation unit is used to output the final EDA script and execution suggestions.

8. The system according to claim 7, characterized in that, The probability calculation unit calculates the probability using the following formula: Where: φ(A) i ) represents the script feature vector, μ represents the posterior distribution mean, ∑ represents the posterior distribution covariance, b represents the evaluation model bias, and σ represents the sigmoid activation function.

9. A multi-agent collaborative method for electronic design automation based on any one of claims 1 to 8, characterized in that, include: It receives EDA task inputs in natural language description and EDA tool API documentation; The task analysis agent extracts key information, generates vector embeddings, and retrieves similar task examples. Multiple task planning paths and EDA scripts are generated through a divergent thinking agent, using a few-sample chained thinking prompt template and the ChipLlama model. The decision-making agent evaluates the success probability of each EDA script and selects the optimal script. Execute the selected EDA script to automate the EDA process and provide feedback on the results.

10. The method according to claim 9, characterized in that, The steps for retrieving similar task examples include: converting the task description into a vector representation; calculating the cosine similarity; and retrieving the K most relevant instances and their (Q,C,A) tuples. The steps for generating the EDA script include: randomly creating an example group from the retrieved examples; connecting a few-sample chain-like thinking prompt template; generating a task planning step sequence, with each step corresponding to an EDA tool API call; initializing and filling the script template, and verifying the script's correctness after splicing them together; The steps for evaluating and selecting the optimal script include: extracting feature vectors of candidate scripts; calculating the success probability; selecting the script with the highest probability, and optimizing based on execution efficiency and readability when the probabilities are close.

Images