Paper deep dive
Physics-Grounded Multi-Agent Architecture for Traceable, Risk-Aware Human-AI Decision Support in Manufacturing
Danny Hoang, Ryan Matthiessen, Christopher Miller, Nasir Mannan, Ruby ElKharboutly, David Gorsich, Matthew P. Castanier, Farhad Imani
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 7/8/2026, 9:39:04 AM
Summary
The paper introduces MAKA (Multi-Agent Knowledge Analysis), a physics-grounded, human-in-the-loop decision-support architecture for CNC manufacturing. MAKA decomposes LLM-driven pipelines into specialized agents (Central, Analysis, Knowledge Graph, and Critic) to route intent, perform deterministic quantitative analysis, retrieve domain knowledge, and verify physical plausibility and safety bounds. Applied to Ti-6Al-4V rotor blade machining, MAKA fuses virtual machining error fields, deflection simulations, and 3D inspection maps to decompose geometric deviations and generate traceable compensation strategies. Benchmarks show an 87.5% improvement in multi-step tool execution reliability over unstructured LLM interactions, while digital twin simulations demonstrate a reduction in predicted surface deviation from ~10^-2 in to ~±10^-3 in, providing a verified, risk-aware baseline for human decision-making.
Entities (8)
Relation Signals (10)
MAKA → composedof → Knowledge Graph Agent
confidence 95% · The multi agent knowledge analysis framework comprises four agents (Central, Knowledge Graph, Analysis, and Critic)
MAKA → composedof → Critic Agent
confidence 95% · The multi agent knowledge analysis framework comprises four agents (Central, Knowledge Graph, Analysis, and Critic)
MAKA → composedof → Analysis Agent
confidence 95% · The multi agent knowledge analysis framework comprises four agents (Central, Knowledge Graph, Analysis, and Critic)
MAKA → composedof → Central Agent
confidence 95% · The multi agent knowledge analysis framework comprises four agents (Central, Knowledge Graph, Analysis, and Critic)
Critic Agent → verifies → Physical Plausibility
confidence 94% · The CRA checks logical coherence, physical plausibility, compliance with safety bounds
MAKA → appliedto → Ti-6Al-4V Rotor Blade
confidence 93% · MAKA is instantiated on a Ti-6Al-4V rotor blade machining testbed
Central Agent → routesto → Knowledge Graph Agent
confidence 92% · The CA constructs a plan and routes sub-tasks to either the Analysis agent (AA) for tool-grounded quantitative computation or the Knowledge Graph agent (KGA) for evidence retrieval
Central Agent → →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:High-precision CNC machining of free-form aerospace components requires bounded compensations informed by inspection, simulation, and process knowledge. Off-the-shelf large language model (LLM) assistants can generate text, but they do not reliably execute risk-constrained multi-step numerical workflows or provide auditable provenance for high-stakes decisions. We present multi-agent knowledge analysis (MAKA), a human-in-the-loop decision-support architecture that separates intent routing, tools-only quantitative analysis, knowledge graph retrieval, and critic-based verification that enforces physical plausibility, safety bounds, and provenance completeness before recommendations are surfaced for human approval. MAKA is instantiated on a Ti-6Al-4V rotor blade machining testbed by fusing virtual-machining path-tracking error fields, cutting-force and deflection simulations, and scan-based 3D inspection deviation maps from 16 blades. The analysis decomposes deviation into an evidence-linked pathing component, a drift-based wear proxy capturing systematic evolution across parts, a residual systematic compliance term, and a variability proxy for instability-aware escalation. In a three-level tool-orchestration benchmark (single-step through $\geq$3-step stateful sequences), MAKA improves successful tool execution by up to 87.5 percentage points relative to an unstructured single-model interaction pattern with identical tool access. Digital twin what-if studies show MAKA can coordinate traceable compensation candidates that reduce predicted surface deviation from order $10^{-2}$in to approximately $\pm 10^{-3}$in over most of the blade within the simulation environment, providing a pre-deployment verification signal for risk-aware human decision-making.
Tags
Links
- Source: https://arxiv.org/abs/2605.04003v1
- Canonical: https://arxiv.org/abs/2605.04003v1
Trouble viewing inline? Open PDF directly →
Full Text
91,670 characters extracted from source content.
Expand or collapse full text
Physics-Grounded Multi-Agent Architecture for Traceable, Risk-Aware Human–AI Decision Support in Manufacturing Danny Hoang1 Ryan Matthiessen2 Christopher Miller2 Nasir Mannan2 Ruby ElKharboutly3 David Gorsich4 Matthew P. Castanier4 Farhad Imani1 1School of Mechanical, Aerospace, and Manufacturing Engineering, University of Connecticut, Storrs, CT, USA 2Connecticut Center for Advanced Technology, East Hartford, CT, USA 3Quinnipiac University, Hamden, CT, USA 4DEVCOM Ground Vehicle Systems Center, Warren, MI, USA Corresponding author: farhad.imani@uconn.edu DISTRIBUTION STATEMENT A. Approved for public release; distribution is unlimited. OPSEC9768 Abstract High-precision CNC machining of free-form aerospace components requires bounded compensations informed by inspection, simulation, and process knowledge. Off-the-shelf large language model (LLM) assistants can generate text, but they do not reliably execute risk-constrained multi-step numerical workflows or provide auditable provenance for high-stakes decisions. We present multi-agent knowledge analysis (MAKA), a human-in-the-loop decision-support architecture that separates intent routing, tools-only quantitative analysis, knowledge graph retrieval, and critic-based verification that enforces physical plausibility, safety bounds, and provenance completeness before recommendations are surfaced for human approval. MAKA is instantiated on a Ti-6Al-4V rotor blade machining testbed by fusing virtual-machining path-tracking error fields, cutting-force and deflection simulations, and scan-based 3D inspection deviation maps from 16 blades. The analysis decomposes deviation into an evidence-linked pathing component, a drift-based wear proxy capturing systematic evolution across parts, a residual systematic compliance term, and a variability proxy for instability-aware escalation. In a three-level tool-orchestration benchmark (single-step through ≥ 3-step stateful sequences), MAKA improves successful tool execution by up to 87.5 percentage points relative to an unstructured single-model interaction pattern with identical tool access. Digital twin what-if studies show MAKA can coordinate traceable compensation candidates that reduce predicted surface deviation from order 10−210^-2 in to approximately ±10−3± 10^-3 in over most of the blade within the simulation environment, providing a pre-deployment verification signal for risk-aware human decision-making. 1 Introduction Advanced computer numerical control (CNC) manufacturing systems are increasingly embedded in complex production environments in which cutting mechanics, structural compliance, servo control, fixturing, sensing, and part geometry interact in strongly nonlinear and state dependent ways [41, 3, 35]. Achieving consistent part quality in this setting requires decisions that reconcile heterogeneous evidence streams under stringent tolerance, throughput, and safety constraints. Micrometer level requirements are often specified for critical free form surfaces, yet the limiting factor in many industrial workflows is not the availability of data. The limiting factor is the lack of integrated and accountable interpretation that converts multi source evidence into bounded actions with explicit justification. Conventional process planning pipelines and basic statistical monitoring typically treat operations or features in isolation and therefore provide no unified view of simulation outputs, inspection metrology, and prior machining knowledge [27]. This fragmentation is increasingly misaligned with modern manufacturing practice where engineering decisions must be justified, auditable, and robust to uncertainty. In standard industrial practice, tool paths are generated and verified offline in computer aided manufacturing (CAM) and virtual machining environments [24], while process parameters are tuned using a combination of design of experiments studies, empirical rules, and shop floor experience [2, 28]. Quality control is then performed downstream via sparse inspection and statistical process control charts, which summarize deviations at a limited set of features but provide only coarse diagnostics of underlying error mechanisms [9]. These stages are typically connected through manual interpretation rather than through a formal evidence fusion and verification pipeline. As a result, rich multimodal information available in modern CNC manufacturing systems [12, 7], including deflection simulations, virtual machine path tracking predictions, dense scan derived deviation fields, machine telemetry, and documented best practices remains distributed across software tools and data silos. The absence of a consistent mechanism for coordinate consistent fusion, provenance tracking, and risk bounded recommendation makes it difficult to deploy automated decision support that humans can rely on in high consequence settings. These limitations become more pronounced for non prismatic, free-form components where local geometry [34], tool engagement [32], and fixture stiffness vary continuously along the tool path [21]. In such settings, offline one shot planning struggles to keep up with variability introduced by changes in machines, tooling, materials, and fixturing configurations across production systems. Even small modifications to any of these elements can invalidate previously calibrated parameter sets and degrade transferability of best settings between nominally similar setups. Engineers are therefore often forced into iterative trial and error adjustment of offsets, tool paths, and parameters [20, 11]. At the same time, attributing observed geometric deviation to specific contributors such as path tracking error, tool wear, or workpiece compliance requires combining imperfect models and noisy measurements [5]. Incorrect attribution directly leads to incorrect compensation and costs that include scrap, rework, tool damage, and schedule disruption. Large language models (LLMs) offer capabilities that are attractive for industrial decision support, including natural language interaction for operators [40, 13], automated organization and summarization of heterogeneous artifacts [8, 6], and coordination across multiple software tools through tool calling patterns [30, 38]. In principle, an LLM enabled assistant could read simulation reports [22], interpret metrology outputs [10], consult machining studies, and propose targeted updates to tool paths and process parameters [17]. In practice, off the shelf LLMs are not designed for high stakes industrial workflows. They lack explicit representations of machine kinematics, cutting mechanics, and CAM and CNC constraints, are vulnerable to hallucination and inconsistent numerical reasoning, and provide weak guarantees of provenance, repeatability, and bounded action, which are central requirements for trustworthy human AI collaboration in production environments [4]. These limitations are amplified by resource and security constraints at or near the edge, where extensive retraining and unconstrained multimodal reasoning are impractical. Effective human AI symbiosis in CNC manufacturing therefore requires architectures that constrain machining critical computation to deterministic tools, retrieve domain knowledge with traceable evidence, and verify candidate actions against physical plausibility and safety bounds before they are presented for human decision making. We introduce the multi agent knowledge analysis (MAKA) framework as an LLM driven agentic decision support layer for CNC manufacturing systems. Rather than treating the LLM as a monolithic generator of machining strategies, MAKA decomposes the evidence to recommendation pipeline into specialized auditable roles aligned with risk aware industrial symbiosis. A Central agent performs intent interpretation and task routing. An Analysis agent is constrained to tools only quantitative computation. A Knowledge Graph agent performs evidence linked retrieval over domain knowledge constructs. A Critic agent evaluates whether candidate outputs are coherent, physically plausible, within safety bounds, and supported by explicit provenance before they are surfaced for human review. This separation of concerns supports accountable operation because machining critical quantities are produced through deterministic tool calls and traceable retrieval rather than through unconstrained text generation. By offloading bound checking, consistency checks, and provenance completeness to the Critic agent, MAKA reduces the cognitive burden of multi modal evidence synthesis and enables the human expert to focus on higher level tradeoffs such as quality, tool life, and cycle time. We instantiate MAKA on an aerospace application, the production of Ti-6Al-4V titanium rotor blades on industrial CNC equipment. MAKA fuses evidence across the manufacturing digital thread, including virtual machining outputs for path tracking deviation, cutting force and workpiece deflection simulations, and dense scan based inspection deviation maps acquired across multiple manufactured blades, together with a machining knowledge graph derived from a curated corpus of technical literature capturing machining mechanisms and constraints across multiple CNC manufacturing systems. The agents structure this evidence into interpretable deviation attributions including pathing, a tool wear proxy, and a residual compliance term, then synthesize candidate compensation strategies expressed as tool path modifications, tool length and radius offsets, and process parameter adjustments with provenance linked explanations and verification checks. The contributions of this work are threefold. First, we present a physics grounded adaptation of LLM based decision support for CNC manufacturing via explicit tool interfaces and knowledge graph integration that operationalizes accountable human oversight. Second, we propose an agent based architecture that improves reliability of multi step industrial tool orchestration under resource constraints through separation of intent routing, computation, retrieval, and verification. Third, we demonstrate within an industrial digital twin toolchain, using virtual machining and physics based simulation environments, that multimodal data fusion combining simulation outputs, scan derived deviation fields, and symbolic machining knowledge can be executed within a single traceable decision support workflow that provides a verified pre deployment baseline for risk aware human decision making. The remainder of the paper is organized as follows. Section 2 brief review of related work in manufacturing knowledge systems, LLM-based decision support, CNC automation, and geometric error modeling, along with their limitations. Section 3 presents the MAKA architecture as an agentic layer for CNC manufacturing systems, detailing the roles of the central, analysis, knowledge, and critic agents and the associated agentic tools. Section 4 describes the experimental setup used to evaluate MAKA on rotor blade machining. Section 5 reports the results on physics-based deviation decomposition, automated parameter selection, and toolpath compensation. Finally, Section 6 discusses limitations and opportunities for deploying such agentic LLM frameworks in broader CNC manufacturing environments. 2 Research Background In industrial systems, human–AI decision support is not achieved by adding a conversational interface alone; it requires that the AI system (i) integrate heterogeneous evidence across the manufacturing digital thread, (i) remain grounded in validated physics and deterministic computation where required, (i) expose provenance and uncertainty in forms that support human oversight, and (iv) enforce bounded autonomy through verification and safety checks before recommendations are acted upon. We organize the background along four main axes: (i) knowledge graph, ontology, and skill-based infrastructures for representing manufacturing knowledge capabilities; (i) LLM-based knowledge assistants and multi-agent frameworks for tool-using decision support in production systems; (i) LLM-based CNC programming and monitoring, where reliability and verification are central; and (iv) data-driven models of geometric error in aero-engine blades and related thin-walled, free-form parts. A long-standing response to fragmentation in manufacturing knowledge is to formalize process knowledge and system capabilities into explicit, machine-interpretable structures. Knowledge graph-based process planning frameworks encode parts, operations, resources, and precedence constraints as symbolic graphs and use graph reasoning to support computer-aided process planning, reuse, and consistency checking [37]. These representations help capture best practices and make dependencies explicit, which is valuable for interoperability and lifecycle management; however, they typically operate at the level of discrete operations and resources rather than spatially resolved process physics, and they rarely represent dense simulation fields, scan-derived deviation maps, or uncertainty in a way that directly supports high-stakes compensation decisions on free-form geometries. In parallel, skill-based architectures for production systems expose machine capabilities as standardized skills that can be orchestrated at runtime across heterogeneous equipment [15]. Skill-based approaches advance modularity and reconfigurability, but they often treat the internal machining process as a black box and provide limited support for fusing simulation, metrology, and expert heuristics into an auditable causal account of why a part deviates and which bounded interventions are appropriate. This creates a gap between what a system can do (skills, operations) and why a particular action is recommended (evidence, provenance, physical plausibility), a gap that becomes acute when decisions must be justified to human experts and recorded for accountability. More recently, LLMs have been explored as a way to unlock unstructured manufacturing knowledge and provide conversational interfaces to complex production systems. Survey work on LLMs for manufacturing highlights opportunities across the product lifecycle, including design assistance, documentation mining, and decision support, and emphasizes retrieval augmented generation (RAG) and tool use as key patterns for integrating domain knowledge and software systems [23]. Empirical studies of LLM-powered knowledge sharing on the shop floor demonstrate that operators can query manuals, procedures, and historical reports more effectively than with keyword search alone [19]. These contributions are important for human-centric industrial interaction, but most remain predominantly text-centric; they reason over documents and structured tables rather than over the multimodal artifacts that dominate machining decisions (e.g., CAM outputs, virtual machining fields, scan-derived deviation maps, or CNC telemetry). Moreover, they typically do not enforce bounded autonomy or provide systematic mechanisms for provenance completeness (linking each numeric or procedural recommendation to a verifiable source) and risk-aware verification (rejecting or escalating recommendations that violate physical plausibility or safety constraints). A complementary strand of work embeds LLMs into multi-agent or agent-based manufacturing architectures. In such systems, language models interpret human instructions, decompose tasks, and coordinate agents that ultimately execute operations and may emit machine control programs [25]. Other frameworks translate informal textual specifications into structured process plans using LLM-based pipelines for task decomposition and workflow synthesis, sometimes combined with verification layers (e.g., state-machine checking) to ensure basic logical correctness before deployment on industrial platforms [29]. These approaches are promising for interoperability and adaptive autonomy, but their support for risk-aware symbiosis is often limited by two factors: (i) numerical and physical computations are still frequently performed within the language model loop without strong deterministic guarantees, and (i) verification focuses on syntactic or logical consistency rather than on physically grounded plausibility, bounded action constraints, and provenance completeness over heterogeneous manufacturing evidence. To improve numerical reliability and transparency, several systems couple LLMs with structured manufacturing knowledge. Knowledge graph-augmented frameworks build machining knowledge graphs from technical documents, vendor datasheets, and prior process plans, and use RAG over these graphs to answer CNC process planning queries with traceable numerical recommendations [13]. Multi-agent retrieval frameworks further decompose retrieval, ranking, and answer generation into specialized agents to integrate information from diverse manufacturing sources [26]. In mechanical engineering more broadly, multimodal systems such as MechRAG integrate CAD and computer aided engineering (CAE) assets into LLM responses, enabling conversational access to simulation results and model artifacts [22]. CNC-focused assistants like ChatCNC attach LLMs to real-time machine data streams to provide conversational monitoring and diagnostics [17]. Collectively, these works demonstrate that LLMs can be grounded in structured knowledge, multimodal engineering artifacts, and live telemetry. Nonetheless, they often stop short of (i) performing physics-aware decomposition of geometric error into interpretable contributors under explicit assumptions, (i) orchestrating deterministic analysis tools through an auditable tool-call interface, and (i) enforcing a verification gate that manages risk by bounding recommendations and escalating ambiguous cases to human experts. Table 1: Capabilities of representative related work compared with MAKA framework. Model KG / Skills LLM Multi Agent Physics Decomposition Digital Twin Verification Tool Orchestration Xiao et al. [37] ✓ × × × × × Hossfeld & Wortmann [15] ✓ × × × × × Li et al. [23] × ✓ × × × × Freire et al. [19] × ✓ × × × × Lim et al. [25] × ✓ ✓ × × ✓ Ni et al. [29] × ✓ × × × ✓ Hoang et al. [13] ✓ ✓ × × × × Mao et al. [26] × ✓ ✓ × × ✓ Li & Corney [22] × ✓ × × × × Jeon et al. [17] × ✓ × × × × Šket et al.; Abdelaal et al. [33, 1] × ✓ × × × × Yang et al. [39] × × × ✓ × × MAKA (Ours) ✓ ✓ ✓ ✓ ✓ ✓ At the same time, several studies have evaluated or proposed LLM-based generation of CNC programs directly from natural language descriptions or simple geometric sketches, highlighting both the promise and the risks of treating toolpath synthesis as a pure text generation task [18, 17]. Comparative evaluations show that general purpose LLMs can emit syntactically valid G-code, but that the resulting programs often require nontrivial human correction and verification, particularly for complex geometries or nonstandard machine configurations [33]. More specialized frameworks introduce domain-specific fine-tuning, retrieval, and self-correction loops, along with syntactic and geometric validation [1], yet they still operate largely outside of physics-based digital twin environments and often rely on a single language model to make intertwined geometric, physical, and process decisions. The AI system should not be treated as an unconstrained generator of machining strategies, but as an orchestrator of validated planning and physics tools, equipped with explicit verification and provenance mechanisms that reduce automation bias and support accountable human approval. In parallel to these LLM-centric developments, there is a rich body of work on data-driven modeling of error distributions in thin-walled aero-engine blades and similar components. For example, Gaussian-mixture-model-based frameworks have been proposed to predict full-field milling error distributions for blades and impellers across different process conditions, using experimental data to characterize complex spatial patterns of deviation [39]. Such models capture important aspects of the underlying process behavior and can provide informative priors for compensation. However, they are usually developed as standalone prediction tools, with limited integration into broader decision-making pipelines that also incorporate virtual machining, physics-based deflection simulation, and symbolic knowledge of machining constraints. They also rarely expose an evidence-linked explanation of how contributors such as path-tracking error, tool wear (or wear proxies), and compliance effects combine to yield observed deviation patterns on a specific production system. Table 1 summarizes representative contributions, emphasizing their implementation focus and the resulting limitations for risk-aware decision support on complex free-form geometries. As the table indicates, prior approaches either (i) emphasize symbolic knowledge representations modularity without deeply engaging with multi-modal machining physics and inspection evidence, (i) focus on text-centric or monitoring-oriented use of LLMs that do not translate detailed geometric analysis into bounded, auditable modifications to tool paths or offsets, or (i) treat CNC programming itself as a text generation problem with limited physics grounding and incomplete reliability guarantees. 3 Methodology Figure 1: Multi-agent knowledge framework for CNC manufacturing. The Central, Knowledge Graph, Analysis, and Critic agents collaborate in an eight-step loop: (1) user query, (2 to 3) central planning and routing, (4) downstream analysis and knowledge retrieval, (5 to 7) critic evaluation and refinement, and (8) recommendation returned for human review and downstream CAM implementation. The multi agent knowledge analysis framework comprises four agents (Central, Knowledge Graph, Analysis, and Critic) that collaborate to answer and execute decision-support queries arising within a CNC manufacturing workflow. Figure 1 summarizes the procedure as an eight-step loop. [baseline=(char.base)] [shape=circle,draw,inner sep=0.5pt] (char) 1; A natural language query is provided by a user or a higher-level planning system. [baseline=(char.base)] [shape=circle,draw,inner sep=0.5pt] (char) 2; The Central agent (CA) interprets the query in the context of the current manufacturing state, such as the active machine, toolpath, datasets, and previously computed summaries. [baseline=(char.base)] [shape=circle,draw,inner sep=0.5pt] (char) 3; The CA constructs a plan and routes sub-tasks to either the Analysis agent (A) for tool-grounded quantitative computation or the Knowledge Graph agent (KGA) for evidence retrieval from the machining knowledge graph. [baseline=(char.base)] [shape=circle,draw,inner sep=0.5pt] (char) 4; The downstream agents execute their sub-tasks using deterministic tools and retrieval operators to produce intermediate results, such as deviation attributions, compensation candidates, and evidence-linked constraints. [baseline=(char.base)] [shape=circle,draw,inner sep=0.5pt] (char) 5; These candidate outputs are passed to the Critic agent (CRA). [baseline=(char.base)] [shape=circle,draw,inner sep=0.5pt] (char) 6; The CRA checks logical coherence, physical plausibility, compliance with safety bounds, and provenance completeness. [baseline=(char.base)] [shape=circle,draw,inner sep=0.5pt] (char) 7; If any check fails, the CRA issues a revised instruction for refinement or escalates to the human when verification is insufficient. [baseline=(char.base)] [shape=circle,draw,inner sep=0.5pt] (char) 8; Otherwise, the accepted recommendation and its audit trail are returned to the CA and surfaced to the user for review prior to downstream CAM implementation. This loop implements an iterative decision-support workflow from a natural language intent to tool-grounded analysis and traceable recommendations. The subsections below define each agent and the constraints that enforce deterministic computation, evidence grounding, and risk-aware escalation. 3.1 Central Agent The Central agent is the interface between the user and downstream agents. At turn t, the CA receives the user query qtq_t and the internal state sts_t, where sts_t contains references to loaded resources, cached intermediate results, and agent invocation history. Let Q denote the space of user queries, S the state space, A the set of available downstream agents, and ~ Q the space of structured agent-specific instructions. The CA implements a routing policy (at,q~t,st+)=πC(qt,st)(a_t, q_t,s_t^+)= _C(q_t,s_t) (1) where at∈a_t specifies the next agent, q~t∈~ q_t∈ Q is a structured instruction tailored to that agent, and st+∈s_t^+ is the updated state. In implementation, πC _C combines a language-model router with schema validation and a deterministic fallback. The router is constrained to emit a JSON object with fields that include the selected agent identifier, a normalized instruction string, required input references (files, part indices, tool identifiers), and an explicit list of requested tool categories. A JSON-schema validator defines the condition under which the output is considered valid. If validation fails, the CA falls back to a deterministic heuristic πD _D based on task keywords and available resources. Prior to routing, the CA applies a preprocessing update stp=uC(qt,st)s_t^p=u_C(q_t,s_t) to extract structured entities (e.g., part ranges, file paths, reset flags) so routing is evaluated on (qt,stp)(q_t,s_t^p). 3.2 Analysis Agent The Analysis agent performs data- and tool-centric reasoning. At turn t, the A receives the routed instruction q~t q_t, the current state sts_t, and external resources rtr_t (data handles, tool APIs, simulation artifacts). The A is constrained so that any non-trivial numerical quantity included in its output must be produced by deterministic tools. Let =T1,…,TMT=\T_1,…,T_M\ be the tool library. The A selects a finite tool-call sequence τ1:K=((j1,x1),…,(jK,xK)) _1:K=((j_1,x_1),…,(j_K,x_K)) and executes it to obtain outputs zk=Tjk(xk)z_k=T_j_k(x_k), k=1,…,Kk=1,…,K. The A returns a structured result ytAy_t^A together with an updated state st+1s_t+1 that caches reusable artifacts and provenance metadata. To enforce tool grounding, ytAy_t^A includes (i) a list of tool calls with arguments, (i) tool outputs, and (i) a provenance map that assigns each reported scalar or vector quantity to a specific tool output identifier. The CRA (Section 3.4) verifies that any numeric quantity in the final recommendation can be traced to this provenance map. 3.3 Knowledge Graph Agent The Knowledge Graph agent answers conceptual, relational, and constraint queries over a symbolic graph t=(t,ℰt,ℛt)G_t=(V_t,E_t,R_t) of entities, typed relations, and labeled edges. Given q~t q_t and sts_t, the KGA performs retrieval to build a context ct=ℛK(q~t,t)c_t=R_K( q_t,G_t) and then produces an answer ytKy_t^K using the retrieved evidence together with any relevant observations carried in sts_t. Retrieval uses semantic embedding matching over graph triples and associated textual contexts. Let f(⋅)∈ℝdf(·) ^d be a shared embedding model. Each stored item i is a quadruple τi=(si,ri,oi,ci) _i=(s_i,r_i,o_i,c_i) with a triple text representation and an associated context cic_i. For query embedding t=f(q~t)q_t=f( q_t), each item receives a combined score si=cos(t,i)+λcos(t,i)s_i= (q_t,v_i)+λ\, (q_t,u_i) where iv_i embeds the concatenation (si,ri,oi,ci)(s_i,r_i,o_i,c_i), iu_i embeds cic_i, and λ∈[0,1]λ∈[0,1] weights contextual alignment. To control computation, an initial pre-pool P is formed by selecting the top p=min(N,max(m,⌊αN⌋))p= (N, (m, α N )) items under the base triple similarity cos(t,i) (q_t,v_i), where N is the number of stored items, α is a pruning fraction, and m is a minimum retained count. Within P, a data-adaptive inclusion floor τ=μ+zστ=μ+zσ is computed from the mean μ and standard deviation σ of si:i∈\s_i:i \. The initial candidate set 0C_0 is formed from items with si≥τs_i≥τ, with a fallback to a fixed top-k0k_0 if empty and with k bounded within [kℓ,ku][k_ ,k_u]. To capture multi-hop evidence, a bounded neighborhood expansion is applied to 0C_0 using depth dMd_M and a capped beam width bMb_M, with a visited set to prevent revisiting the same triple. The retrieved context ctc_t is the set of selected triples and their supporting contexts. For synthesis, the KGA returns (i) a structured answer and (i) an evidence list of triple identifiers that support each claim. The CRA verifies that claims presented as constraints or best practices are supported by retrieved evidence identifiers, otherwise they are flagged for refinement or escalation. 3.4 Critic Agent The Critic agent evaluates candidate outputs from downstream agents and enforces risk-aware acceptance criteria before recommendations are surfaced. After an agent produces a candidate answer yty_t, the CRA receives (qt,yt,st)(q_t,y_t,s_t) and returns a decision together with a possible refinement instruction. We model the critic output as (dt,at+1,q~t+1,st+)=πR(qt,yt,st),(d_t,a_t+1, q_t+1,s_t^+)= _R(q_t,y_t,s_t), (2) where dt∈accept,revise,escalated_t∈\accept,revise,escalate\. If dt=acceptd_t=accept, the system returns yty_t together with its audit trail. If dt=revised_t=revise, the CRA selects at+1∈a_t+1 and emits q~t+1 q_t+1 for refinement. If dt=escalated_t=escalate, the system returns a structured report that includes the candidate recommendation, the failed checks, and the minimal additional information required from a human operator or engineer. The CRA evaluates four classes of checks: intent alignment with qtq_t, tool-grounding completeness (every numeric quantity must map to an A tool output identifier), evidence grounding for retrieved constraints (every KG claim must cite retrieved triple identifiers), and safety checks that enforce physical plausibility and bounded action constraints (for example, maximum allowable offset magnitudes and sign consistency with declared coordinate conventions). A scalar quality score J(qt,yt,st)∈[0,1]J(q_t,y_t,s_t)∈[0,1] may be computed internally, but acceptance is not determined by J alone; acceptance requires that the explicit checks above pass. To guarantee termination, a critic budget L∈ℕL limits the number of refinement iterations per user query. Let ntn_t denote the number of CRA invocations for the current query. If nt≥Ln_t≥ L and the candidate answer has not satisfied the acceptance criteria, the CRA returns dt=escalated_t=escalate rather than forcing acceptance. In deployments that support interactive symbiosis, the CRA decision can be overridden by an explicit human approval signal, which is recorded as part of the audit trail. 3.5 Agentic Tools Within the rotor blade case study, the MAKA system predicts and compensates geometric deviation by integrating three classes of evidence: virtual machining path-tracking error, inspection-derived deviation fields, and process knowledge constraints. The analysis separates systematic contributors that can be linked to explicit evidence from a residual term that captures compliance and other unmodeled systematic effects. The tool library as shown in Table 2 exposes deterministic functions that load data, compute statistics, map simulation fields to inspection locations, estimate drift and variability proxies from multi-part data, and compute compensation offsets under a simplified tool-geometry model. While the tool implementation in this case study utilizes rotor blade specific nomenclature (e.g., rb prefixes), the MAKA architecture treats these as modular skills adhering to a generic geometric interface. The agents reason over standardized inputs (point clouds, deviation vectors, metadata) rather than hard-coded geometry logic. Consequently, adapting this framework to a different component (e.g., an engine casing) requires only the substitution of the underlying computational libraries (the tool layer) without retraining the agentic reasoning or restructuring the orchestration logic. Inspection and simulation alignment. For each inspection pair k and part n∈1,…,Nn∈\1,…,N\, let δk,nPδ^P_k,n and δk,nSδ^S_k,n denote the signed normal deviations measured on the pressure and suction surfaces after scan-based registration to the nominal CAD model. The paired measurement is summarized as the combined thickness-direction deviation vk,n=δk,nP+δk,nSv_k,n=δ^P_k,n+δ^S_k,n. Under the paired-surface sign convention, the corresponding per-surface deviation is sk,n=vk,n/2s_k,n=v_k,n/2. The tool compute_inspection_pairs constructs the set of matched pairs and provides δk,nP,δk,nSk,n\δ^P_k,n,δ^S_k,n\_k,n together with the derived vk,nv_k,n and sk,ns_k,n. The tool fetch_inspection_slices returns selected subsets and caches normalized representations. Run MyVirtual Machine provides a simulated path-tracking error field that is projected onto the same inspection keys k through a deterministic mapping operator that aligns simulation outputs and inspection locations in the CAD frame. Let rkr_k denote the simulated combined deviation at pair k as vk,nv_k,n, and define the per-surface pathing deviation as pk=rk/2p_k=r_k/2. The tool rb_compute_pathing_dev implements this projection and returns pkp_k. Multi-part decomposition using drift and variability proxies. For each pair k, define the non-pathing deviation for part n as uk,n=sk,n−pku_k,n=s_k,n-p_k. To separate systematic drift from dispersion, we fit a per-pair affine model over part index, uk,n=ck+bk(n−1)+ϵk,nu_k,n=c_k+b_k(n-1)+ _k,n, where ckc_k is a baseline systematic term, bkb_k is a drift rate per part, and ϵk,n _k,n is a zero-mean residual. The least-squares drift estimator is bk=∑n=1N(n−n¯)(uk,n−u¯k)∑n=1N(n−n¯)2b_k= _n=1^N(n- n)(u_k,n- u_k) _n=1^N(n- n)^2, with n¯=(N+1)/2 n=(N+1)/2 and u¯k=1N∑n=1Nuk,n u_k= 1N _n=1^Nu_k,n, and the baseline term is ck=u¯k−bk(n¯−1)c_k= u_k-b_k( n-1). The drift magnitude at the last observed part is wkd=bk(N−1)w_k^d=b_k(N-1). The residual dispersion is quantified as wkv=1N−2∑n=1Nϵk,n2w_k^v= 1N-2 _n=1^N _k,n^2 for N≥3N≥ 3, where ϵk,n=uk,n−ck−bk(n−1) _k,n=u_k,n-c_k-b_k(n-1). In this decomposition, wkdw_k^d is a drift proxy that is consistent with systematic evolution across part index, and wkvw_k^v is a variability proxy that captures process instability and unmodeled fluctuations. The methodology does not equate wkvw_k^v with a physical wear state. Instead, wkvw_k^v is used as a risk indicator for verification and escalation. The tools rb_compute_wear_drift and rb_compute_process_variability implement these estimators, while rb_compute_residual_systematic returns the baseline term ckc_k. For reporting and downstream reasoning, the mean surface deviation is s¯k=1N∑n=1Nsk,n s_k= 1N _n=1^Ns_k,n and the predicted surface deviation for a target part index n⋆n is s^k(n⋆)=pk+ck+bk(n⋆−1) s_k(n )=p_k+c_k+b_k(n -1). The residual term ckc_k is interpreted as a residual systematic compliance term that includes stiffness-related effects and other systematic deviations not captured by rigid-body path-tracking simulation and drift. It is not uniquely identifiable as deflection alone. Stable attribution ratios for decision support. To avoid numerical instability in ratio metrics, attribution uses magnitudes and an ϵε-floor. For a target part n⋆n , define the component magnitudes pka=|pk|p_k^a=|p_k|, cka=|ck|c_k^a=|c_k|, and wka=|bk(n⋆−1)|w_k^a=|b_k(n -1)|, and define the total magnitude ak=pka+cka+wka+ϵa_k=p_k^a+c_k^a+w_k^a+ε with small ϵ>0ε>0. The corresponding attribution fractions are ϕkp=pka/ak _k^p=p_k^a/a_k, ϕkc=cka/ak _k^c=c_k^a/a_k, and ϕkd=wka/ak _k^d=w_k^a/a_k. The variability proxy is summarized separately as ψkv=wkv/(|s^k(n⋆)|+ϵ) _k^v=w_k^v/(| s_k(n )|+ε) and is used by the CRA to flag low-confidence locations where compensation should be conservative or escalated for human judgment. Compensation geometry under fixed tool tilt. The tool is mounted at a fixed tilt angle θ=25∘θ=25 relative to the local reference axis used for compensation. Let Δk _k denote a signed equivalent correction along the tool axis required at pair k for a selected component (for example, the drift component at n⋆n , or a bounded correction derived from ckc_k). Under the fixed-tilt model, the corresponding axial and radial offset components are tl,k=Δkcosθt_l,k= _k θ and tr,k=Δksinθt_r,k= _k θ. The tools rb_compute_tool_length, rb_compute_radius_offset, and rb_compute_pair_tool_comp implement this mapping and return compensation vectors k=[tr,k,tl,k]⊤t_k=[t_r,k,t_l,k] that are then applied as radius and length offsets within the CAM environment. The CRA enforces bounds on |tr,k||t_r,k| and |tl,k||t_l,k| using knowledge graph-derived constraints and shop-floor limits before any recommendation is accepted. Knowledge retrieval for constraints and best practices. The knowledge graph tools kg_initial and kg_retrieve provide evidence-linked constraints, empirical rules, and known failure modes relevant to titanium machining and offset application. Retrieved constraints are represented as triple identifiers with supporting text spans. The CRA verifies that any constraint referenced in an accepted recommendation is backed by retrieved evidence identifiers, and otherwise triggers refinement or escalation. Table 2: Main tool categories exposed to MAKA for rotor blade analysis and compensation. Implementation identifiers are provided to support reproducibility. Category Tool Description Data loading compute_inspection_pairs, fetch_inspection_slices Load scan-based inspection measurements, construct paired pressure and suction statistics, and return cached normalized subsets for selected parts and pair keys. Statistics and indexing rb_compute_values, rb_compute_average, rb_compute_std_dev, rb_compute_level, rb_compute_position_in_level Provide per-pair values and summary statistics and assign spanwise level and within-level position indices used for aggregation. Pathing projection rb_compute_pathing_dev Project RMVM path-tracking error onto inspection keys in a common CAD frame and return per-surface pathing deviation pkp_k. Drift and variability proxies rb_compute_wear_drift, rb_compute_process_variability, rb_compute_residual_systematic Estimate drift bkb_k and derived drift magnitude wkdw_k^d, residual dispersion wkvw_k^v, and baseline systematic term ckc_k from multi-part non-pathing deviations. Attribution metrics rb_compute_attribution_fractions Compute numerically stable attribution fractions and variability indicators used for risk-aware verification and summarization. Compensation geometry rb_compute_tool_length, rb_compute_radius_offset, rb_compute_pair_tool_comp Map a selected signed correction Δk _k to axial and radial offsets under the fixed-tilt model and return k=[tr,k,tl,k]⊤t_k=[t_r,k,t_l,k] . Knowledge retrieval kg_initial, kg_retrieve Build and query the machining knowledge graph and return evidence-linked constraints and best practices for verification and bounded action. 4 Experimental Design Figure 2: Illustration of the experimental workflow from part design, to manufacturing simulation, manufacturing using a 4-axis Trak VMC10si, and inspection measurements using a GOM ATOS ScanBox. We evaluate the MAKA framework along four axes that map directly to the results section. First, we measure tool-orchestration reliability on rotor blade analytics tasks, where the agent must select and sequence domain tools to compute deviation components and compensations from inspection data. Second, we isolate the marginal contribution of MAKA’s critic module using paired runs with and without critic-mediated repair under controlled routing degradation. Third, we quantify the impact of knowledge graph (KG) grounding on quantitative machining question answering using paired KG versus no-KG trials in both open-ended and multiple-choice formats. Finally, we present an end-to-end case study in which inspection-derived boundary conditions and digital twin signals are converted into staged compensation actions that are verified in the digital twin before deployment. 4.1 Manufacturing case study and inspection data The MAKA framework was evaluated using an experiment on the manufacturing of a rotor blade conducted at the Connecticut Center for Advanced Technology (CCAT). Figure 2 summarizes the overall fabrication, simulation, and inspection workflow. Ti-6Al-V titanium rods with a diameter of 1 1/4 in (31.75 m) were used to manufacture a rotor blade with a length of 3 in (76.2 m) designed at CCAT. Siemens NX CAM was used to generate baseline tool paths required to manufacture the rotor blade on a 4-axis Trak VMC10si. As shown in Figure 3, ten operations are required to manufacture the blade: (1) tip engage, (2) top half rough, (3) top half semi-finish, (4) bottom half rough, (5) bottom half semi-finish, (6) platform outer rough, (7) platform outer finish, (8) platform top finish, (9) blade finish, and (10) tip finish. From these operations, four test cuts were selected to modify tool usage and update tool paths based on expert observations to minimize tool wear and improve surface finish. A four-flute 1/2 in TiAlN-coated carbide ball end mill was selected for all roughing and semi-finishing operations, and a six-flute 1/4 in solid carbide undercutting end mill was used for finishing operations. The tool was offset at an angle of 25 degrees relative to the part during machining (Figure 3a). Figure 3: Experimental setup where (a) the spindle is set at an angle of 25∘25 relative to the blade and (b) all ten operations required to manufacture the rotor blade. A total of 16 rotor blades were created and measured for geometric deviation relative to the nominal CAD model using a GOM ATOS ScanBox. For each blade, surface scans were registered to the nominal model and deviation measurements were recorded at labeled inspection points. We defined 30 inspection points distributed across the blade surface and arranged them into matched pairs across the pressure and suction sides using a consistent pair-key convention of the form i+(i+15)i+(i+15) (e.g., 2+17, 3+18, …, 16+31) so corresponding locations on the two sides could be directly compared. After measuring deviations, inspection data for all blades were exported to CSV and aggregated for subsequent analysis. These inspection deviations serve as the ground-truth geometric error signal that MAKA analyzes and attempts to reduce via compensation. 4.2 Digital twin signals and deviation decomposition MAKA forms an aggregate estimate of total geometric deviation by combining three complementary error signals with a residual term. The first signal captures cutting-induced workpiece deflection, the second captures machine path-tracking deviation, and the third captures systematic drift across parts as a proxy for wear-related evolution. Together, these signals provide a structured decomposition that separates deformation-driven effects, kinematic execution errors, and time-varying changes that accumulate over a production run. Workpiece deflection is estimated using ThirdWave simulations that model how the blade deforms as the tool engages the pressure and suction sides under candidate process parameters such as spindle speed, feed rate, and surface feet per minute. The resulting deflection fields provide a physics-based estimate of deformation-induced deviation along the tool path, which allows MAKA to screen parameter sets toward reduced deflection sensitivity and to prioritize corrective actions in regions predicted to be most compliant. Path-tracking deviation is estimated using Siemens Run MyVirtual Machine by comparing the predicted executed tool motion to the nominal G-code trajectory. These virtual machining results capture systematic tracking errors that arise from machine kinematics and controller behavior, and they provide a trajectory-following deviation field that MAKA can use to propose toolpath compensations aimed at counteracting repeatable execution bias. Wear-related evolution is inferred directly from inspection measurements by tracking systematic drift in deviation patterns across the sequence of manufactured blades at fixed inspection pairs. Persistent, progressive changes across parts are treated as a proxy for wear-driven changes in effective tool geometry and engagement conditions. This drift-based signal is useful because it summarizes time-dependent behavior that is not captured by a single static simulation or a single part, and it provides a basis for wear-aware updates and conservative bounding when the process becomes less stable. After accounting for predicted path-tracking effects and deflection trends and estimating drift-based evolution, any remaining systematic structure is treated as a residual compliance contribution. This residual term is intended to absorb unmodeled or partially calibrated effects and to prevent the decomposition from forcing all unexplained structure into one of the explicit contributors, which would otherwise lead to overconfident or misdirected compensations. Within MAKA, these components are computed through the rotor blade analysis tool suite, including rb_compute_pathing_dev, rb_compute_surface_dev, rb_compute_wear_drift, rb_compute_process_variability, and rb_compute_residual_systematic, and then combined into the decomposed representation used to generate compensation actions through modified tool paths and adjusted process parameters. Although direct point-to-point numerical agreement between simulation outputs and physical scans is not the primary objective, we observed strong topological alignment between the simulated and measured error distributions. ThirdWave consistently highlights the blade tip and leading edge as regions of maximum deflection, which matches the high-deviation zones observed in inspection across the 16 blades. This qualitative spatial agreement supports use of the digital twin as a directional guide for decision-making, while the residual term provides flexibility to reconcile absolute magnitudes and remaining systematic effects. 4.3 Knowledge graph construction The knowledge graph used in this experiment was constructed from a curated set of technical documents on machining Ti-6Al-4V (Table 3), spanning cutting temperature and surface roughness optimization, tool wear mechanisms, sustainable cutting fluids, and machining deformation control in near-net-shaped jet engine blades. Together, these sources cover process parameters (cutting speed, feed, depth of cut, rake angle), performance measures (surface roughness, tool wear, tool life, cutting temperature), coolant strategies (including sustainable cutting fluids), and fixturing and deformation behavior in adaptive machining. The integrated KG contains 2701 triples over 3401 unique entities and 1151 unique relation types. The KG was constructed automatically using the open-sourced gpt-oss-120b model served locally via an OpenAI-compatible HTTP API (LM Studio). Each paper was converted to Markdown and processed by a Python pipeline that splits text into overlapping windows (up to 1000 characters with a 500-character overlap). For each window, a prompt marks a central extraction region (CHUNK_MAIN) and surrounding context windows, and specifies a strict five-field triple format: ENTITY_1 <TAB> RELATIONSHIP_TYPE <TAB> ENTITY_2 <TAB> "RELATIONSHIP_DESCRIPTION" <TAB> FIGURE_REFERENCE. Triples are extracted from CHUNK_MAIN only; surrounding context is used solely to resolve references to tables/figures. A post-processing stage enforces TSV consistency, repairs minor formatting errors, and propagates table references to related cell triples using schema triples. Triples are written per-document and then aggregated into the global KG used in subsequent experiments. Table 3: Overview of source documents and their corresponding knowledge graph sizes. Document Description Knowledge Graph Size Optimization of cutting temperature and surface roughness in CNC turning of Ti-6Al-4V alloy using response surface methodology [14] Introduced Response Surface Methodology to optimize cutting speed, feed rate, and depth of cut in dry CNC turning of Ti-6Al-4V alloy, aiming to minimize tool-chip interface temperature and surface roughness. # of triples: 827 # of unique entities: 978 # of unique relations: 324 Evaluation of tool wears mechanism considering machining parameters and performance parameters for titanium alloy in turning operation on CNC [16] Experimentally studies CNC turning of Ti-6Al-4V to evaluate how machining parameters (cutting speed, feed, depth of cut, and rake angle) affect tool wear, tool life, and surface roughness. # of triples: 673 # of unique entities: 802 # of unique relations: 249 Sustainable green cutting fluid for interpreting optimization of process variables while machining on various CNC manufacturing systems—an experimental approach for exploring [31] Compares several eco-friendly cutting fluids and finds that aerosol-mist neem oil is the most sustainable and effective choice for machining Ti-6Al-4V on CNC lathe and turn-mill systems, improving surface finish and reducing temperatures, especially in 4-axis turn-milling. # of triples: 541 # of unique entities: 707 # of unique relations: 239 Analysis of machining deformation for adaptive CNC machining technology of near-net-shaped jet engine blade [36] Develops and validates a rigid–flexible coupling fixture using PEEK-GF30 multi-point supports and an empirical cutting force model to analyze and control machining deformation of near-net-shaped TC4 jet engine blades in adaptive CNC machining. # of triples: 660 # of unique entities: 914 # of unique relations: 339 4.4 Evaluation protocols 4.4.1 Tool-use depth protocol (L1/L2/L3) To quantify tool-orchestration reliability on rotor blade analytics, we constructed 75 natural language questions that require computing deviation components and/or compensation values from inspection-derived signals. We group these into three tool-use depths: L1 requires a single correct tool invocation; L2 requires exactly two dependent tool calls with correct intermediate-result propagation; and L3 requires three or more calls, stressing longer-horizon planning, state tracking, and dependency management. For each question, we compare the agent’s called-tool sequence (tools, order, and arguments) against a reference implementation derived from expert-designed CCAT scripts. We report tool-selection pass rate (%) as the fraction of queries where the required tools are invoked with valid arguments and dependency ordering. 4.4.2 Critic agent evaluation To quantify the contribution of the critic module within MAKA, we conducted a paired controlled evaluation in which each query was executed twice under matched conditions using the same base model family, question prompt, and initialization: one run with critic-mediated control and one run without critic mediation. In the critic-enabled condition, the execution path permits iterative validation and repair through critic decisions (e.g., retry or routing actions) before termination, whereas in the no-critic condition execution proceeds directly from routing and task agents to finalization without an explicit repair stage. This design isolates the marginal effect of critic intervention from confounds due to model choice or prompt variation. To test robustness to orchestration faults, we introduce controlled degradation at the first routing stage by deterministically removing a fixed fraction of required tool hints (default drop probability 0.3). Each trial is assessed against the query-specific required-tool specification (excluding infrastructure-only helper calls), and performance is recorded using tool-selection precision, recall, and F1. In addition to mean F1, we report improved-tool rate (fraction of paired queries where critic-enabled F1 exceeds no-critic F1), reduced-missing rate (fraction where critic reduces the count of missing required tools), and full-recovery rate over degraded cases (fraction of degraded trials where no-critic misses at least one required tool but the critic-enabled run recovers to zero missing required tools). 4.4.3 Knowledge graph agent evaluation protocol Knowledge graph (KG) agent performance was evaluated in two linked phases using paired KG versus no-KG runs with the same base model family and identical question prompts: an open-ended quantitative phase and a multiple-choice phase derived from the same underlying items. The open-ended bank of 75 questions was programmatically constructed from the titanium machining sources and contains quantitative decision-style questions that require selecting operating points under thermal, roughness, wear, and throughput constraints, together with boundary and extrapolation checks, fixture-force reasoning, and speed-window compliance. Each item includes explicit ground-truth numeric targets, required terms, and scoring tolerances. The multiple-choice bank was generated from the same items by converting each ground-truth answer into one correct option and creating deterministic distractors via seeded numeric perturbations that remain outside acceptance tolerances. Performance reporting focuses on average numerical score versus average time per question for open-ended responses, and accuracy versus average time per question for multiple-choice responses, where time per question quantifies the inference-time overhead of KG retrieval relative to its corresponding gain in answer quality. 5 Experimental Results MAKA was implemented in Python with a PostgreSQL backend used to store and query the machining knowledge graph. We report results in the same order as the experimental design: (i) tool-use reliability on rotor blade analytics tools, (i) critic ablation under degraded routing, (i) KG grounding ablation on quantitative machining QA, and (iv) an end-to-end case study demonstrating how inspection- and twin-derived signals are translated into staged compensation actions verified in the digital twin. We first evaluate whether the agent can correctly select and sequence rotor blade analysis tools needed to compute deviation components and compensation values from inspection data. Queries require composing tools such as rb_compute_surface_dev, rb_compute_pathing_dev, rb_compute_wear_drift, rb_compute_process_variability, and rb_compute_residual_systematic under increasing tool-chain depth (L1–L3). Tool-use pass rate (%) is computed against expert reference scripts, counting a query as correct only when required tools are called with valid arguments and in dependency-consistent order. Figure 4: Comparison between MAKA and a single large language model in terms of pass rate (%) for correct tool usage. Figure 4 summarizes pass rates across three levels of tool-use depth (25 questions per level) and multiple open-source tool-trained models (GPT-OSS-20b, Granite-4H-Tiny, Ministral3-14b, Qwen3-VL-30b, Qwen3-VL-4b, and Qwen3-VL-8b). For L1 questions requiring a single tool invocation, both MAKA and single-LLM baselines achieve high pass rates, including perfect performance for stronger models such as GPT-OSS-20b and Ministral3-14b, while MAKA provides additional uplifts for weaker models (up to 20% for Qwen3-VL-8b). As tool-use depth increases, differences become more pronounced: MAKA provides substantially larger gains on L2 (two dependent calls with correct intermediate propagation) and L3 (three or more calls with longer-horizon state tracking), where single-LLM baselines more frequently fail due to incorrect sequencing, invalid arguments, or loss of intermediate state. Overall, these results indicate that MAKA’s coordination and cross-step verification primarily reduce orchestration failures in compositional tool-use tasks rather than simply improving single-step tool execution. Table 4: Example of querying tool compensation using the MAKA framework. Execution (CLI): gray!15 Central Agent --- What would you like to do? > load ’./Inspection_Aggregated.csv’ and give me compensation for parts 4 to 16 Model analysis: The file Inspection_Aggregated.csv is loaded, pairwise statistics are computed, and tool compensation values are returned for inspection pairs 4–16. Here, Trc denotes tool radius compensation and Tlc denotes tool length compensation: gray!15 Pair Key Trc Tlc 2+17 0.001164 0.002497 3+18 0.001030 0.002209 4+19 0.001063 0.002280 5+20 0.001104 0.002367 6+21 0.001138 0.002440 7+22 0.001253 0.002686 8+23 0.001466 0.003144 9+24 0.001290 0.002766 10+25 0.001356 0.002909 11+26 0.001513 0.003245 12+27 0.001475 0.003163 13+28 0.001556 0.003337 14+29 0.001670 0.003581 15+30 0.001528 0.003278 16+31 0.001620 0.003474 Table 4 shows an example interaction in which the user requests compensation values over a selected part window. MAKA loads the aggregated inspection file, computes required pairwise statistics, and returns compensation values at each inspection pair key. This example is representative of the tool-use setting evaluated in Figure 4: the agent must map a high-level request onto the correct rotor blade tools, respect dependencies among intermediate computations, and return numerically valid outputs in the expected format. Figure 5: Critic agent ablation across six base models comparing critic-enabled and no-critic execution. (a) Average tool-selection F1 for each model with critic versus without critic. (b) Critic-value metrics from paired runs: improved tools (%), reduced missing required tools (%), and full recovery (%) under degraded routing conditions. Figure 5 reports the critic-agent evaluation described in Section 4.4.2. Each query is executed twice under matched conditions (critic-enabled vs no-critic), and deterministic first-step degradation removes a fraction of tool hints to probe recovery under orchestration stress. Across GPT-OSS-20b, Granite-4H-Tiny, Ministral3-14b, Qwen3-VL-30b, Qwen3-VL-4b, and Qwen3-VL-8b, each model is tested on 75 paired queries (450 paired trials total). Of these, 423 trials are degraded (some queries have no removable hints under the perturbation rule), enabling direct measurement of repair behavior under missing-dependency conditions. As shown in Figure 5a), the no-critic condition remains confined to a low F1 band between 0.2492 and 0.3137, whereas the critic-enabled condition rises to 0.5722 through 0.7511, and mean F1 increases from 0.2919 to 0.6697 across models. Absolute F1 gains are +0.2690 (Granite-4H-Tiny), +0.4360 (Ministral3-14b), +0.4079 (GPT-OSS-20b), +0.4374 (Qwen3-VL-30b), +0.3469 (Qwen3-VL-4b), and +0.3696 (Qwen3-VL-8b). Figure 5b) clarifies the mechanism: critic-enabled runs improve tool quality on 58.67% of paired trials on average, reduce missing required tools on 62.22%, and achieve full recovery on 61.19% of degraded trials. Qwen3-VL-30b exhibits the strongest recovery profile (78.67% improved tools, 84.00% reduced missing, 81.08% full recovery), while even the weakest recovery profile remains positive (GPT-OSS-20b at 34.67%, 38.67%, and 45.00%). These results show that the critic functions as an explicit reliability layer that repairs missing dependencies, corrects incomplete tool chains, and prevents early routing errors from propagating into final answers. Figure 6: Knowledge graph evaluation across six base models using paired runs with and without KG retrieval. (a) Open-ended quantitative performance: average numerical score versus average time per question. (b) Multiple-choice performance: accuracy versus average time per question. Connected pairs show the shift from no-KG to with-KG, illustrating quality gains and inference-time overhead. Figure 6 summarizes paired KG versus no-KG evaluation across the same six base models using 75 questions per model in each task format. In Figure 6a), every model moves from the no-KG point to a higher numeric score with KG enabled, increasing the cross-model mean from 0.3462 to 0.4736 (+0.1274), while average time per question increases from 0.7305 s to 2.6496 s (+1.9191 s). The largest open-ended gains occur for GPT-OSS-20b (+0.2418), Qwen3-VL-4b (+0.2262), and Qwen3-VL-8b (+0.1829). Granite-4H-Tiny improves moderately (+0.0911), while Qwen3-VL-30b and Ministral3-14b show smaller but still positive gains (+0.0048 and +0.0175), consistent with stronger no-KG baselines and diminishing marginal returns when parametric knowledge is already strong. In Figure 6b), the same trend appears for multiple-choice accuracy: mean accuracy rises from 0.4733 to 0.5733 (+0.1000), with average latency increasing from 0.2413 s to 1.6002 s (+1.3588 s). The largest MCQ uplifts are Qwen3-VL-4b and Qwen3-VL-8b (+0.1600 each), and GPT-OSS-20b both improves (+0.1200) and achieves the highest with-KG accuracy (0.7067). Overall, KG grounding provides reliable average gains in quantitative correctness and answer selection, with the largest benefits concentrated in models that most need external numeric evidence integration, and with a stable and interpretable latency tradeoff. We close with an end-to-end case study that follows a complete MAKA loop from digital twin evidence and inspection measurements to a staged compensation plan that is verified in a high-fidelity digital twin prior to any shop-floor deployment. The intent is not to claim that any single simulation output numerically reproduces the scan data point by point. Instead, this case study shows that MAKA can extract directional guidance from physics-based simulation, reconcile that guidance with measured deviation structure and its evolution across parts, and translate the combined evidence into compensation actions that are auditable and bounded by uncertainty. In this case study, MAKA receives three complementary inputs. ThirdWave provides deflection fields that indicate where the blade is most compliant and how sensitive that compliance is to changes in spindle speed and feed. The inspection scans provide the ground-truth geometric error signal relative to the nominal model at paired locations across the pressure and suction sides, revealing where systematic shape bias concentrates on the blade. Multi-part statistics derived from the inspection history summarize systematic evolution and dispersion at each inspection pair. MAKA uses these as proxies for wear-driven changes and process instability. These signals serve distinct roles. Simulation supplies a physics-based sensitivity map. Inspection supplies the realized error topology. Drift and variability provide a confidence and risk envelope that governs how aggressively compensation should be applied. Figure 7 shows ThirdWave deflection simulations for two representative parameter sets selected to contrast an original Siemens NX recommendation with an alternative derived from expert machinist practice. Tool geometry, engagement conditions, and fixturing are held constant so the differences in the predicted fields are primarily attributable to spindle speed and feed. Beyond identifying a single minimum-displacement value, the simulations act as a screening mechanism that localizes deformation hot spots along the blade and establishes which parameter regimes are likely to reduce compliance-driven error. In thin-walled blade regions that behave like a cantilever, reductions in feed per tooth typically reduce cutting force peaks and can suppress elastic deflection, while increases in cutting speed can introduce thermal and wear considerations that must be evaluated in parallel. For this reason, MAKA treats the best-performing parameter set in the simulation as a candidate operating point that must be contextualized against stability, tool life, coolant strategy, and machine capability rather than as a universally optimal choice. Table 5 illustrates how MAKA converts the deflection visualization into an actionable recommendation in response to a natural language request. The agent identifies the minimum-displacement candidate across the shown parameter grid and then enumerates deployment considerations that are consistent with machining constraints. This step is important for closing the loop between physics and process engineering. The twin narrows the candidate space toward lower deformation sensitivity, and the KG-grounded considerations make explicit the failure modes that can negate those gains in practice, including accelerated wear at higher SFM, chatter margins, surface integrity effects, and coolant demands. MAKA therefore does not stop at ranking parameter sets. It surfaces the trade-offs that an engineer would normally check before committing to an update. Figure 7: Deflection results. (a) The location where force calculations are applied. (b) Blade deflection for a spindle speed of 917 rpm and feed rate of 22.8 ipm. (c) Blade deflection for a spindle speed of 3667 rpm and feed rate of 15.4 ipm. Table 5: Example of analyzing simulation results using the MAKA framework. Execution (CLI) gray!15 Central Agent - What would you like to do > analyze the simulation results and give the process parameters with the lowest deviation and then list any potential considerations when using these parameters ’./data/Simulation_results.png’ gray!15 Model analysis gray!15 Final answer Based on the simulation results shown in the image, the process parameters with the lowest deviation, meaning the smallest displacement magnitude, are as follows. Top Row (SFM 60) • Feed per tooth 0.0041 • Spindle Speed 917 rpm • Feed Rate 22.8 ipm • Lowest Displacement 0.00089 (seen in the 5th image from the left) Bottom Row (SFM 240) • Feed per tooth 0.0007 • Spindle Speed 3667 rpm • Feed Rate 15.4 ipm • Lowest Displacement 0.00010 (seen in the 2nd image from the left) Conclusion The parameters in the bottom row (SFM 240), specifically Feed per tooth 0.0007, Spindle Speed 3667 rpm, Feed Rate 15.4 ipm, result in the lowest overall displacement magnitude (0.00010), indicating the most stable simulation outcome. Potential considerations when using these parameters 1. Tool wear and life. Operating at higher SFM and spindle speed increases heat and can accelerate wear. 2. Machine tool capability. Ensure the machine can sustain the spindle speed and feed without vibration. 3. Material removal rate. Higher SFM changes MRR. Manage chip load and cutting forces accordingly. 4. Surface finish. Lower deflection does not guarantee better finish. Verify with roughness checks. 5. Coolant requirements. Higher cutting speeds may require more aggressive cooling. 6. Process stability. Higher-speed regimes may be more chatter-sensitive if the system is not tuned. While deflection screening addresses deformation sensitivity, inspection history is required to separate stable, compensable bias from evolving behavior that should be handled conservatively. Table 6 shows how MAKA analyzes a wear-percentage envelope derived from inspection deviations over a selected part window. The key analytical signal is the envelope shape across inspection pairs. A narrow separation between minimum and maximum curves indicates that evolution is relatively consistent and can be treated as bounded drift. Widening separation indicates growing instability or mixed contributors that are not captured by a single drift trajectory. Envelope widening is a warning flag. It reduces confidence in applying aggressive offsets at those locations and instead favors bounded compensation, increased inspection frequency, or earlier tool-change thresholds. This drift and variability analysis therefore provides the gating logic that prevents MAKA from over-correcting regions where the process is no longer stable. Table 6: Example of analyzing tool wear results using the MAKA framework. Execution (CLI) gray!15 Central Agent - What would you like to do > analyze the tool wear percentage ranges and explain what can be shown by the plot (parts 4 to 20) gray!15 Model analysis gray!15 Wear percentage envelope metrics are computed and displayed for the selected part window. All values are calculated and non-NULL. Final answer Based on the plot titled “Tool Wear % (Min/Max) by Inspection Pair”, here is what can be inferred. 1. What is being summarized • The vertical axis represents a normalized wear indicator expressed as a percentage contribution relative to the local deviation baseline used in the analysis. • The horizontal axis lists inspection pair keys (for example “2+17” and “3+18”) that correspond to fixed locations on the blade where multi-part deviations were tracked. 2. How the two series should be interpreted under the drift and variability methodology • The two curves can be interpreted as an envelope over the evaluated part window that summarizes systematic evolution across parts. • The separation between the curves provides an empirical indication of instability because a widening envelope implies that deviation evolution is not explained by a single tightly bounded drift trajectory. 3. Key trends visible in the plot • Drift envelope growth. The envelope generally increases moving from left to right, indicating larger systematic evolution at later inspection locations. • Instability signature. The gap between the envelope bounds becomes larger for later pairs, consistent with increasing process instability or unmodeled variation. • Peak location. The largest envelope values occur near inspection pair “15+30”, suggesting a wear-sensitive region for tighter monitoring or conservative offset bounds. Summary. The plot summarizes a drift-based wear envelope across inspection pairs and indicates where envelope widening suggests instability, supporting maintenance thresholds and conservative compensation decisions. In addition to producing numeric recommendations, MAKA is designed to provide explanations that a process engineer can audit. Table 7 illustrates this interpretability pathway. The agent takes a deflection trend summary and retrieves supporting causal relationships from the machining KG to produce a mechanism-level narrative for why deformation occurs. The retrieved factors include cutting deformation as the primary mechanism, sensitivity to cutting-force dynamics, low stiffness due to thin-walled cantilever geometry, stress concentration near clamping heads, and interactions between speed and wear. These factors justify why parameter tuning is a plausible corrective lever when deformation dominates, and they also highlight conditions under which the same parameter changes could increase risk, including higher wear rates or reduced stability margin. This makes the resulting compensation plan less of a black box because the system attaches physical and empirical rationale that explains why a given corrective action is being proposed. Table 7: Example of using a knowledge graph to explain rotor blade deflection. Execution (CLI) gray!15 Central Agent - What would you like to do > causes of this deflection for the rotor blade gray!15 Model analysis (KG-enhanced) gray!15 Based on the retrieved knowledge and the analysis summary, the primary cause of rotor blade deflection is cutting deformation, which directly leads to the final deformation of the blade. This deformation is influenced by several factors. 1. Cutting force frequency. Deflection increases significantly when the cutting force frequency exceeds 1500 Hz. At frequencies between 800 and 1500 Hz, the deformation is relatively small. 2. Blade structure. The blade’s complex structure, including its thin-walled body, free surface, and large curvature changes, makes it susceptible to deformation. Its stiffness is low due to its cantilever beam structure. 3. Stress distribution. Stress is higher near the clamping heads, which can lead to localized deformation or stress concentration. 4. Rotational speed and tool wear. While increasing rotational speed slightly reduces cutting forces, it can also increase tool wear, which may indirectly affect blade deformation. The observed trends in the deflection chart, such as high deflection at the start (for example pair 2+17) and more negative deflection later (for example pair 12+27), likely reflect variations in cutting conditions such as force frequency, spindle speed, or tool wear across inspection pairs. Taken together, the deflection screening, drift and variability bounding, and KG-grounded explanations provide the evidence needed to justify staged compensation rather than a single monolithic correction. Toolpath updates are most effective when the observed error is spatially consistent and aligns with kinematic or path-tracking signatures. Parameter updates are most effective when the digital twin indicates high compliance sensitivity and the inspection error topology matches predicted deformation hot spots. Wear-aware bounding becomes critical when drift and variability indicate evolving behavior that would otherwise cause over-correction. This staged structure is reflected in the subsequent compensation verification (Figure 8), where successive steps reduce predicted deviation magnitude from the 10−210^-2 in range toward the 10−310^-3 in level by targeting distinct contributors in sequence, while using drift and variability as a safeguard against applying aggressive offsets in unstable regions. Figure 8: Successive MAKA-driven compensations for toolpath adjustment, deflection-focused parameter tuning, and tool-wear-aware updates, verified in the high-fidelity digital twin. 6 Conclusion This paper introduces the multi agent knowledge analysis (MAKA) framework as a physics-grounded, LLM-driven decision-support layer for CNC manufacturing, in which a Central agent, Analysis agent, Knowledge Graph agent, and Critic agent translate natural language intent into verifiable tool use, evidence-linked retrieval, and risk-aware recommendations suitable for human approval prior to downstream CAM implementation. The architectural separation of intent routing, deterministic computation, knowledge retrieval, and verification is designed to support human–AI symbiosis in high-stakes manufacturing by reducing the cognitive burden of multimodal data synthesis while preserving auditability, bounded action, and provenance. In the rotor blade case study, MAKA reliably orchestrated domain tools to align scan-based inspection deviations and virtual machining outputs at common inspection keys and to construct a physically interpretable decomposition consistent with the updated methodology. Specifically, pathing deviation was obtained from Run MyVirtual Machine projections, systematic evolution across parts was captured through a drift-based wear proxy estimated from multi-part inspection sequences, and the remaining systematic term was treated as a residual compliance contribution rather than being uniquely attributed to deflection. A variability proxy was also computed to characterize instability and to inform conservative recommendation and escalation when confidence was insufficient. This tool-grounded decomposition reproduces the structure of expert workflows while making the assumptions explicit and inspectable by the human operator and by the Critic agent verification gate. Beyond the case study demonstration, controlled ablations show that MAKA’s multi-agent decomposition is necessary for reliable performance once tasks require compositional tool use. In the multi-agent versus single-LLM evaluation, single-LLM baselines performed competitively on L1 queries that require only one tool call, but their performance degraded as soon as questions required dependent tool chains. MAKA delivered substantially larger gains on L2 and L3 queries, including uplifts up to 87.5% on L2 and at least 32% on L3, where failures are dominated by orchestration errors rather than missing domain knowledge. These results indicate that separating intent routing, deterministic computation, and stateful multi-step execution is not an implementation convenience. It directly reduces invalid argument bindings, incorrect call ordering, and intermediate-state loss, which are precisely the failure modes that make single-agent tool use brittle in manufacturing decision-support settings. Critic and knowledge graph ablations further clarify why additional specialized agents are required to make this structure robust and trustworthy under realistic orchestration noise. Under controlled routing degradation, critic-enabled runs increased mean tool-selection F1 from 0.2919 to 0.6697 across models and achieved full recovery on 61.19% of degraded trials, demonstrating that explicit verification and repair is critical for preventing early routing faults from propagating into unusable or unsafe outputs. Similarly, knowledge graph grounding produced consistent improvements in quantitative machining answers, raising mean open-ended score from 0.3462 to 0.4736 and mean multiple-choice accuracy from 0.4733 to 0.5733, while adding a predictable latency overhead that remains negligible relative to machining cycle times. Taken together, these ablations show that the additional agents are not optional performance enhancements but explicit reliability mechanisms. Multi-agent orchestration provides the structure needed for correct tool chaining, the critic provides a recovery layer under missing or degraded dependencies, and the knowledge graph agent supplies evidence-linked numeric grounding and constraint-aware caveats that reduce hallucination risk and improve decision quality. By coupling these decomposed contributors with geometric compensation relationships under fixed tool tilt and with physics-based deflection simulation, MAKA generated actionable toolpath and parameter compensation candidates compatible with NX CAM. The effect of successive compensations was evaluated within a high-fidelity digital twin toolchain, providing a verified pre-deployment baseline for risk-aware human decision-making rather than a claim of physical closed-loop correction. Across the staged compensation sequence, the predicted deviation field progressed from large localized errors on the order of 10−210^-2 in to a predominantly near-nominal state within approximately ±0.001± 0.001 in over most of the surface, demonstrating that coordinated, tool-grounded reasoning can drive the simulated process toward a high-accuracy operating regime while preserving interpretability and traceability. The complete multi-agent reasoning and retrieval loop executes in 4.3 s. Relative to aerospace machining cycle times that are typically minutes to hours for complex rotor blades, this latency is negligible, rendering the computational overhead effectively inconsequential. As a result, MAKA can be invoked between machining stages to assimilate inspection data or process telemetry and inform subsequent decisions without inducing machine idle time, enabling practical inter-process decision support in production settings. Declaration of Competing Interest The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper. Acknowledgments This work was supported under Cooperative Agreement W56HZV-21-2-0001 with the U.S. Army DEVCOM Ground Vehicle Systems Center (GVSC), through the Virtual Prototyping of Autonomy Enabled Ground Systems (VIPR-GS) program; the National Science Foundation (grant no. 2434519); and the Department of Energy (grant no. DE-E0011029). The authors gratefully acknowledge the valuable contributions from the Connecticut Center for Advanced Technology (CCAT) for this research. References [1] M. Abdelaal, S. Lokadjaja, and G. Engert (2025) GLLM: self-corrective g-code generation using large language models with user feedback. arXiv preprint arXiv:2501.17584. Cited by: Table 1, §2. [2] Y. Cao (2025) Multisensor data fusion-driven digital twins in computer numerical control machining: a review.. Machines 13 (10). Cited by: §1. [3] L. Chen, H. Xu, Q. Huang, and P. Wang (2024) An integrated method for compensating and correcting nonlinear error in five-axis machining utilizing cutter contacting point data. Scientific Reports 14 (1), p. 8763. Cited by: §1. [4] X. Chen, Y. Lei, Y. Li, S. Parkinson, X. Li, J. Liu, F. Lu, H. Wang, Z. Wang, B. Yang, et al. (2025) Large models for machine monitoring and fault diagnostics: opportunities, challenges, and future direction. Journal of Dynamics, Monitoring and Diagnostics 4 (2), p. 76–90. Cited by: §1. [5] Y. Chen, J. Wang, Q. Tang, and J. Li (2024) A study on the coarse-to-fine error decomposition and compensation method of free-form surface machining. Applied Sciences 14 (19), p. 9044. Cited by: §1. [6] Z. Chen, H. Chen, M. Imani, and F. Imani (2025) Can multimodal large language models be guided to improve industrial anomaly detection?. In International Design Engineering Technical Conferences and Computers and Information in Engineering Conference, Vol. 89213, p. V02BT02A051. Cited by: §1. [7] Z. Chen, D. Hoang, F. J. Piran, R. Chen, and F. Imani (2025) Federated hyperdimensional computing for hierarchical and distributed quality monitoring in smart manufacturing. Internet of Things 31, p. 101568. Cited by: §1. [8] Z. Chen and F. Imani (2025) A multi-expert framework for enhancing multimodal large language models in industrial anomaly detection. Pattern Recognition, p. 112752. Cited by: §1. [9] C. A. Escobar, M. E. McGovern, and R. Morales-Menendez (2021) Quality 4.0: a review of big data challenges in manufacturing. Journal of Intelligent Manufacturing 32 (8), p. 2319–2334. Cited by: §1. [10] H. Fan, C. Liu, N. E. Janvisloo, S. Bian, J. Y. H. Fuh, W. F. Lu, and B. Li (2025) MaViLa: unlocking new potentials in smart manufacturing through vision language models. Journal of Manufacturing Systems 80, p. 258–271. Cited by: §1. [11] U. H. Garba, T. Wang, J. Dong, Y. Tian, J. Kang, and C. Tian (2025) Enhancing propeller design with freeform contours through nurbs interpolation for 2d fabrication, cad/cam for 3d production, optimized with taguchi method and artificial neural network. Results in Engineering, p. 107069. Cited by: §1. [12] D. Hoang, R. Chen, G. Bollas, and F. Imani (2025) Hyperdimensional computing for explainable information fusion and multi-task adaptation in advanced manufacturing. Information Fusion, p. 103898. Cited by: §1. [13] D. Hoang, D. Gorsich, M. P. Castanier, and F. Imani (2025) Knowledge graph fusion with large language models for accurate, explainable manufacturing process planning. arXiv preprint arXiv:2506.13026. Cited by: §1, Table 1, §2. [14] S. Hossain, M. Z. Abedin, R. K. Saha, M. Touhiduzzaman, and M. J. Hossen (2025) Optimization of cutting temperature and surface roughness in cnc turning of ti-6al-4v alloy using response surface methodology. Heliyon 11 (1). Cited by: Table 3. [15] M. Hossfeld and A. Wortmann (2024) A universal framework for skill-based cyber-physical production systems. Journal of Manufacturing and Materials Processing 8 (5), p. 221. Cited by: Table 1, §2. [16] S. Ingle and D. Raut (2024) Evaluation of tool wears mechanism considering machining parameters and performance parameters for titanium alloy in turning operation on cnc. Advances in Materials and Processing Technologies 10 (3), p. 1380–1400. Cited by: Table 3. [17] J. Jeon, Y. Sim, H. Lee, C. Han, D. Yun, E. Kim, S. L. Nagendra, M. B. Jun, Y. Kim, S. W. Lee, et al. (2025) ChatCNC: conversational machine monitoring via large language model and real-time data retrieval augmented generation. Journal of Manufacturing Systems 79, p. 504–514. Cited by: §1, Table 1, §2, §2. [18] A. Jignasu, K. Marshall, B. Ganapathysubramanian, A. Balu, C. Hegde, and A. Krishnamurthy (2023) Towards foundational ai models for additive manufacturing: language models for g-code debugging, manipulation, and comprehension. arXiv preprint arXiv:2309.02465. Cited by: §2. [19] S. Kernan Freire, C. Wang, M. Foosherian, S. Wellsandt, S. Ruiz-Arenas, and E. Niforatos (2024) Knowledge sharing in manufacturing using llm-powered tools: user study and model benchmarking. Frontiers in Artificial intelligence 7, p. 1293084. Cited by: Table 1, §2. [20] A. Kukreja and S. S. Pande (2023) Optimal toolpath planning strategy prediction using machine learning technique. Engineering Applications of Artificial Intelligence 123, p. 106464. Cited by: §1. [21] E. Li, J. Zhou, C. Yang, J. Zhao, Z. Li, S. Zhang, and M. Wang (2023) Part machining deformation prediction based on spatial-temporal correlation learning of geometry and cutting loads. Journal of Manufacturing Processes 92, p. 397–411. Cited by: §1. [22] S. Li and J. Corney (2025) MechRAG: a multimodal large language model for mechanical engineering. Communications Engineering 4 (1), p. 187. Cited by: §1, Table 1, §2. [23] Y. Li, H. Zhao, H. Jiang, Y. Pan, Z. Liu, Z. Wu, P. Shu, J. Tian, T. Yang, S. Xu, et al. (2024) Large language models for manufacturing. arXiv preprint arXiv:2410.21418. Cited by: Table 1, §2. [24] J. Liao and Z. Huang (2024) Data model-based toolpath generation techniques for cnc milling machines. Frontiers in Mechanical Engineering 10, p. 1358061. Cited by: §1. [25] J. Lim, B. Vogel-Heuser, and I. Kovalenko (2024) Large language model-enabled multi-agent manufacturing systems. In 2024 IEEE 20th International Conference on Automation Science and Engineering (CASE), p. 3940–3946. Cited by: Table 1, §2. [26] T. Mao, S. Yang, and B. Fu (2025) A multi-agent framework for multi-source manufacturing knowledge integration and question answering. In Companion Proceedings of the ACM on Web Conference 2025, p. 1687–1695. Cited by: Table 1, §2. [27] N. G. Markatos and A. Mousavi (2023) Manufacturing quality assessment in the industry 4.0 era: a review. Total Quality Management & Business Excellence 34 (13-14), p. 1655–1681. Cited by: §1. [28] D. K. Mohanta, B. Sahoo, and A. M. Mohanty (2024) Experimental analysis for optimization of process parameters in machining using coated tools. Journal of Engineering and Applied Science 71 (1), p. 38. Cited by: §1. [29] M. Ni, T. Wang, J. Leng, C. Chen, and L. Cheng (2025) A large language model-based manufacturing process planning approach under industry 5.0. International Journal of Production Research, p. 1–20. Cited by: Table 1, §2. [30] C. Qu, S. Dai, X. Wei, H. Cai, S. Wang, D. Yin, J. Xu, and J. Wen (2025) Tool learning with large language models: a survey. Frontiers of Computer Science 19 (8), p. 198343. Cited by: §1. [31] D. V. P. Ramena, K. A. Vikram, R. Chebolu, P. Barmavatu, V. S. Sikarwar, J. Giri, and T. Sathish (2025) Sustainable green cutting fluid for interpreting optimization of process variables while machining on various cnc manufacturing systems—an experimental approach for exploring. The International Journal of Advanced Manufacturing Technology 136 (1), p. 329–342. Cited by: Table 3. [32] R. P. Singh and Y. Chen (2025) Curvature-adoptive cnc machining of freeform optics via dynamic tangential toolpath optimization. Materials 18 (22), p. 5153. Cited by: §1. [33] K. Šket, D. Potočnik, M. Brezocnik, M. Ficko, and S. Klančnik (2025) Large language models for g-code generation in cnc machining: a comparison of chatgpt-3.5 and chatgpt-4o. Advances in Production Engineering & Management 20 (2), p. 224–238. Cited by: Table 1, §2. [34] X. Wang, Q. Bai, S. Gao, L. Zhao, and K. Cheng (2023) A toolpath planning method for optical freeform surface ultra-precision turning based on nurbs surface curvature. Machines 11 (11), p. 1017. Cited by: §1. [35] B. Williams, R. A. Awad, C. Mulkey, G. Ciocarlie, M. Ismail, and K. Saleeby (2025) Securing smart manufacturing: detection of cyber-physical attacks in cnc-based systems. In 2025 IEEE International Symposium on Hardware Oriented Security and Trust (HOST), p. 428–438. Cited by: §1. [36] D. Wu, H. Wang, J. Peng, K. Zhang, J. Yu, Y. Li, M. Wang, and X. Zhang (2019) Analysis of machining deformation for adaptive cnc machining technology of near-net-shaped jet engine blade. The International Journal of Advanced Manufacturing Technology 104 (9), p. 3383–3400. Cited by: Table 3. [37] Y. Xiao, S. Zheng, J. Shi, X. Du, and J. Hong (2023) Knowledge graph-based manufacturing process planning: a state-of-the-art review. Journal of Manufacturing Systems 70, p. 417–435. Cited by: Table 1, §2. [38] W. Xu, C. Huang, S. Gao, and S. Shang (2025) LLM-based agents for tool learning: a survey: w. xu et al.. Data Science and Engineering, p. 1–31. Cited by: §1. [39] H. Yang, H. Wang, Q. Huang, X. Wu, W. Ji, Z. Li, and X. Han (2025) Aero-engine blade error distributions predictions using novel machine learning models. International Journal of Mechanical Sciences, p. 110262. Cited by: Table 1, §2. [40] J. Yao, L. Zhang, and J. Huang (2025) Evaluation of large language model-driven automl in data and model management from human-centered perspective. Frontiers in Artificial Intelligence 8, p. 1590105. Cited by: §1. [41] X. Zhao, L. Zheng, M. Shi, X. Zhang, and Y. Zhang (2024) Unified modelling for continuous–discrete hybrid adaptive machining cps of large thin-walled parts. International Journal of Production Research 62 (9), p. 3099–3119. Cited by: §1.