Paper deep dive
Kinematics-Grounded Agentic AI for Robotic Additive Manufacturing Process Planning
Jingzhan Ge, Ruimin Chen, Azadeh Haghighi, Jiong Tang, Farhad Imani
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 9/18/2026, 4:01:23 AM
Summary
The paper introduces A-RAM, an agentic robotic additive manufacturing framework that integrates Large Language Models (LLMs) with deterministic kinematic tools to optimize process planning. It addresses the coupling between slicer decisions (infill, orientation) and robot execution (inverse kinematics, joint jerk) by generating traceable, execution-ready plans. The system uses an LLM Triage Agent to interpret user intent and a Planning Agent to orchestrate domain tools for quantitative evaluation of candidate plans, demonstrating significant improvements in motion quality and efficiency on a six-axis robotic arm.
Entities (8)
Relation Signals (7)
A-RAM → uses → LLM
confidence 95% · The LLM interprets manufacturing objectives and constraints... in the A-RAM framework.
A-RAM → comprises → Triage Agent
confidence 92% · An LLM-based Triage Agent interprets the manufacturing objective... in A-RAM.
A-RAM → comprises → Planning Agent
confidence 92% · A deterministic Planning Agent then instantiates the interpreted request... in A-RAM.
A-RAM → optimizes → Joint-6 jerk
confidence 90% · selected plans achieve up to 53.5% lower maximum Joint-6 jerk... than the least favorable valid candidates.
A-RAM → validatedon → Six-axis robotic-arm
confidence 90% · The framework is evaluated on a six-axis robotic-arm AM cell...
A-RAM → evaluates → Inverse Kinematics
confidence 88% · domain tools compute quantitative evidence for... inverse kinematics... in A-RAM.
Jingzhan Ge → affiliatedwith → University of Connecticut
confidence 85% · Jingzhan Ge... Address: School of Mechanical, Aerospace, and Manufacturing Engineering, University of Connecticut...
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Robotic additive manufacturing (AM) extends material-extrusion printing beyond gantry kinematics but makes process planning robot-dependent. A slicer-generated plan that appears favorable in part coordinates can become infeasible or robotically unfavorable on a manipulator because slicer-process decisions and part orientation determine the generated path, while part orientation and workspace placement affect its kinematic realization. Existing AM tools, large language model (LLM)-based decision-support methods, and digital-shadow systems do not provide integrated pre-execution evaluation of these coupled decisions. This paper presents agentic robotic additive manufacturing (A-RAM), an agent-specialist-tool framework that converts user intent and a part file into traceable, execution-ready plans. The LLM interprets manufacturing objectives and constraints, identifies prescribed and searchable planning variables, and encodes this reasoning in a schema-constrained request; a deterministic Planning Agent instantiates the corresponding search workflow, while domain tools compute quantitative evidence for slicing, placement, inverse kinematics, trajectory timing, Joint-6 jerk, and extrusion. The framework is evaluated on a six-axis robotic-arm AM cell through three case studies covering expert-specified planning, goal-only planning, objective-dependent infill screening, and geometry-dependent orientation-placement selection. Across the evaluated candidate sets, selected plans achieve up to 53.5% lower maximum Joint-6 jerk and 48.3% lower mean absolute Joint-6 jerk than the least favorable valid candidates, while objective-specific infill screening yields motion-plan completion times up to 40.1% shorter and extrusion paths up to 12.7% shorter than the corresponding least favorable screened patterns.
Tags
Links
- Source: https://arxiv.org/abs/2609.19347v1
- Canonical: https://arxiv.org/abs/2609.19347v1
Trouble viewing inline? Open PDF directly →
Full Text
101,361 characters extracted from source content.
Expand or collapse full text
Kinematics-Grounded Agentic AI for Robotic Additive Manufacturing Process Planning Jingzhan Ge Ruimin Chen Azadeh Haghighi Jiong Tang Farhad Imani farhad.imani@uconn.edu Address: School of Mechanical, Aerospace, and Manufacturing Engineering, University of Connecticut, Storrs, Connecticut, USA Address: Department of Mechanical and Industrial Engineering, University of Illinois Chicago, Chicago, IL 60608, USA Abstract Robotic additive manufacturing (AM) extends material-extrusion printing beyond gantry kinematics but makes process planning robot-dependent. A slicer-generated plan that appears favorable in part coordinates can become infeasible or robotically unfavorable on a manipulator because slicer-process decisions and part orientation determine the generated path, while part orientation and workspace placement affect its kinematic realization. Existing AM tools, large language model (LLM)-based decision-support methods, and digital-shadow systems do not provide integrated pre-execution evaluation of these coupled decisions. This paper presents agentic robotic additive manufacturing (A-RAM), an agent–specialist–tool framework that converts user intent and a part file into traceable, execution-ready plans. The LLM interprets manufacturing objectives and constraints, identifies prescribed and searchable planning variables, and encodes this reasoning in a schema-constrained request; a deterministic Planning Agent instantiates the corresponding search workflow, while domain tools compute quantitative evidence for slicing, placement, inverse kinematics, trajectory timing, Joint-6 jerk, and extrusion. The framework is evaluated on a six-axis robotic-arm AM cell through three case studies covering expert-specified planning, goal-only planning, objective-dependent infill screening, and geometry-dependent orientation–placement selection. Across the evaluated candidate sets, selected plans achieve up to 53.5% lower maximum Joint-6 jerk and 48.3% lower mean absolute Joint-6 jerk than the least favorable valid candidates, while objective-specific infill screening yields motion-plan completion times up to 40.1% shorter and extrusion paths up to 12.7% shorter than the corresponding least favorable screened patterns. keywords Kinematics-Grounded Agentic AI ,Robotic Additive Manufacturing ,Robot-Aware Process Planning ,Joint-Space Motion Planning †corresponding: Corresponding author 1 Introduction Robotic additive manufacturing (AM) extends fabrication beyond the geometric and kinematic constraints of conventional gantry-based systems by exploiting the configurational flexibility of manipulators. The additional degrees of freedom enable large-format fabrication, multi-axis deposition, dynamically reoriented printing, and task-specific configuration of the robot workspace and build platform [6, 16, 3]. This flexibility, however, fundamentally changes the process-planning problem. In gantry-based printing, the machine realization of a deposition path is largely prescribed by the Cartesian toolpath. In robotic AM, the same deposition path can be executed through multiple joint-space realizations determined by part placement, robot configuration, inverse-kinematics (IK) branch selection, transition-motion generation, and trajectory timing [38]. Consequently, a geometrically valid toolpath does not uniquely determine a feasible or favorable robot motion. The resulting joint-space behavior also feeds directly into the deposition process because configuration-dependent tool-center-point (TCP) velocity, acceleration, and motion continuity influence synchronized material extrusion [2]. Slicer-level decisions, including infill pattern, infill density, infill orientation, and part orientation, therefore do more than modify the deposited geometry. They regenerate waypoint sequences, transition motions, robot configurations, and joint-space motion responses, while build-plate placement changes the IK feasibility and motion quality of otherwise equivalent deposition paths. Existing studies provide evidence for individual elements of this coupling, but slicer-level process decisions and robot-execution decisions have largely been studied in isolation. Slicer studies demonstrate that infill pattern, density, and angle affect filament consumption, printing time, mechanical response, and strength–time tradeoffs [42, 28, 14, 8, 25]. These investigations establish that slicer parameters generate materially different deposition and travel paths. Robot-aware studies, in parallel, show that relocating a fixed G-code trajectory changes the available IK solutions and positional deviation [18, 5], that workpiece placement constrains feasible TCP speed [41], and that minimum-time trajectory planning must explicitly account for jerk and motion continuity [21, 27]. However, these studies hold either the slicer-generated path or the robot-execution configuration fixed. They therefore do not provide a unified candidate-level evaluation of how slicer-process decisions change the generated path, extrusion length, and planned completion time, while part orientation and workspace placement change IK feasibility and joint-space motion for the resulting path. This coupling cannot be reduced to a universal planning heuristic because the preferred solution depends jointly on the manufacturing objective, part geometry, generated path, and robot configuration. Material efficiency is associated with extrusion path length, production speed with trajectory completion time, and motion quality with joint-space behavior; however, these quantities are not interchangeable. A shorter deposited path does not necessarily produce a shorter planned completion time because the timed Cartesian trajectory also includes non-deposition transitions and junction-dependent acceleration and deceleration. Likewise, low Cartesian path variation does not guarantee smooth joint motion because the nonlinear IK mapping can amplify small TCP changes into large joint-space accelerations or jerk. Placement optima are also obtained for a particular part and trajectory [18, 5, 17]; therefore, a placement that is favorable for one geometry, orientation, or infill pattern cannot be assumed to remain favorable for another. Each candidate must be evaluated from the G-code it generates, through the IK and time-parameterized trajectory that realize it, to the execution metrics produced in robot joint space. These characteristics motivate an agentic orchestration layer for robotic AM process planning, while execution-critical evaluation remains quantitative and tool-based. Candidate feasibility and ranking are therefore grounded in explicit models of deposition geometry, robot kinematics, IK feasibility, time-parameterized joint motion, joint-space jerk, and synchronized extrusion. Existing AM-oriented LLM systems support knowledge access, process-parameter reasoning, defect-related prediction, runtime monitoring, and manufacturing workflow coordination [9, 33, 34, 22, 20]. However, these systems generally do not generate robot-specific feasibility, trajectory, and joint-motion evidence for comparing candidate deposition plans before execution, while digital-shadow and digital-twin systems primarily provide execution-side observability after key process-planning decisions have already been made [36]. We propose agentic robotic additive manufacturing (A-RAM), an agent–specialist–tool planning framework that converts a natural-language manufacturing objective and a part STL into a traceable, execution-ready robotic AM plan. An LLM-based Triage Agent interprets the manufacturing objective and user constraints, determines which planning variables are prescribed and which require exploration, and encodes this planning intent in a schema-constrained request associated with the supplied part. A deterministic Planning Agent then instantiates the interpreted request as the required search and evaluation workflow, determining how the identified variables are enumerated or conditionally expanded under the available planning rules. Domain specialists coordinate candidate-placement generation, slicer-parameter assignment, G-code generation, batch IK evaluation, robot motion planning, time-parameterized trajectory analysis, joint-jerk computation, extrusion-path evaluation, and execution monitoring. This separation assigns the LLM responsibility for manufacturing-intent interpretation and planning-variable reasoning while keeping execution-critical numerical evidence grounded in deterministic domain tools. For every candidate, A-RAM preserves the G-code, candidate placement and orientation, feasible or infeasible IK outcomes, planned joint trajectory, trajectory completion time, extrusion length, joint-jerk metrics, and final selection as structured artifacts. The resulting evidence chain makes the decision auditable from the original natural-language objective to the robot motion and extrusion commands delivered to the manufacturing cell. It also permits rejected candidates to be inspected rather than silently discarded, exposing whether rejection results from reachability, IK discontinuity, unfavorable joint motion, excessive execution time, or objective-specific tradeoffs. We instantiate and validate A-RAM on a six-axis robotic-arm AM cell. Tool orientation is held fixed during planar deposition, thereby isolating the coupling among path-generating slicer variables, part orientation, workspace placement, IK, trajectory timing, and joint-space motion. This controlled setting supports full-factorial evaluation of candidate plans together with low-cost physical execution, while retaining the central planning challenges that distinguish robotic AM from conventional gantry-based printing. The main contributions are threefold. 1. We introduce a kinematics-grounded agent–specialist–tool architecture for robotic AM in which an LLM interprets manufacturing objectives and constraints, reasons over which planning variables are prescribed or require exploration, and encodes this intent in a schema-constrained request; a deterministic Planning Agent instantiates the resulting request as a query-conditioned workflow, and domain tools compute and constrain execution-critical geometric, kinematic, trajectory, joint-motion, and extrusion quantities. 2. We formulate robotic AM planning as a coupled candidate-level evaluation of slicer variables, part orientation, and workspace placement, using kinematics-grounded robot-side evidence that includes IK feasibility, time-parameterized execution, extrusion path length, and joint-space jerk rather than slicer-only estimates or unverified model predictions. 3. We instantiate and validate A-RAM through three case studies on a six-axis robotic-arm AM testbed, demonstrating query-dependent search scoping, objective-dependent tradeoffs, placement-dependent joint-space behavior, and geometry-dependent changes in the selected manufacturing plan. The remainder of this paper is organized as follows. Section 2 introduces the related work. Section 3 presents the proposed methodology, kinematics-grounded toolchain, and agent workflow. Section 4 reports the experimental design, quantitative results, and robotic-cell demonstrations. Finally, Section 5 summarizes the findings, identifies the current limitations, and discusses future work. 2 Related Work This section reviews four bodies of work underlying robotic AM planning, including agentic tool coordination, slicer variables that generate candidate paths, robot-side execution planning for fixed paths, and monitored execution. 2.1 Agentic and LLM-based manufacturing decision support Agent formulations established that language models can interleave reasoning with external actions and observations, positioning the model as a coordinator of tools rather than only a generator of text [43]. In AM, one line of work stores domain knowledge in the model or retrieval system. AMGPT combines a pretrained Llama2 model with a curated AM corpus and live literature retrieval for contextual question answering [9]. AdditiveLLM predicts defect-related outcomes and performs better with structured parameter inputs than with natural-language prompts [33], while AdditiveLLM2 extends adaptation to multimodal inputs with task-dependent accuracy [34]. FDM-Bench further shows that G-code anomaly detection and user-query performance vary substantially across model and task type [15]. Closer to execution, LLM-3D Print uses a pretrained vision-language model for print monitoring and corrective reasoning during a running print [22]. These systems support AM knowledge access, prediction, and runtime assistance, but they do not close the planning loop from executable AM decisions, such as infill pattern and density, part orientation, and workspace placement, to robot-specific feasibility verification, joint-trajectory evaluation, and synchronized extrusion commands. A second line constrains the LLM to workflow decomposition and tool coordination. In fiber-composite manufacturing, an LLM agent performs process-chain setup, time estimation, resource allocation, and cycle-time planning [20]. Design-to-fabrication demonstrations translate natural-language concepts into meshes and printer-ready G-code [29]. Configuration-selection studies pair a setting generator with an evaluator that computes the objective score for F parameters [39]. Agentic alloy evaluation uses tool calls to compute thermophysical property diagrams and lack-of-fusion process maps for alloys such as S316L and IN718 [32]. These works validate tool-grounded orchestration, but their tools operate at the knowledge, process-chain, configuration, design-to-G-code, or materials-property level. They do not verify candidate plans in the workspace of the executing robot. For execution-critical robotic AM planning, the LLM must therefore remain a coordinator, while domain tools produce the numerical evidence used for selection. 2.2 Slicer variables as path-generating decisions Material-extrusion process planning is multi-objective as path strategies affect accuracy, surface quality, build time, material use, and structural or functional properties [23]. At the toolpath level, infill angle adjustment, non-deposition travel reduction, and smoothing of sharp connections affect build time, deposition error, and fabrication quality [24]. The generated path also depends on geometric representation and layer strategy. Direct CAD slicing improves contour accuracy relative to STL-based slicing [19], while planar and nonplanar layers differ in support demand, surface quality, build time, dimensional accuracy, and mechanical properties [31]. Within a fixed layer strategy, infill pattern, density, and angle affect filament length, print time, mechanical response, energy consumption, and path length [42, 28, 14]. Pattern selection also shifts the strength–time tradeoff [8], and continuously varied infill can improve tensile performance while reducing print time on unmodified hardware [25]. These studies establish that slicer settings are not passive profile entries. They generate different extrusion paths, travel motions, waypoint sequences, and process-performance tradeoffs. However, the reported evaluations are performed in part coordinates. In robotic AM, the same slicer decision must also be evaluated after it is mapped into robot joint space. A fixed G-code file is therefore insufficient when infill pattern, density, angle, or part orientation remain open decisions; candidate G-code must be regenerated before robot-side scoring. 2.3 Robot-side planning for fixed deposition paths Robotic material extrusion showed that deposition is not governed by slicer-generated Cartesian commands alone: serial-robot dynamics and pose-dependent TCP-speed variation require coordinated control of robot motion and extrusion [2]. Nonplanar and conformal robotic AM further couple path generation with reachability, nozzle-orientation planning, collision avoidance, joint-limit enforcement, and continuity constraints [40, 45]. Existing robot-aware methods mainly improve execution after a path has already been generated. One group smooths or optimizes the robot motion along a fixed path. Time-jerk optimal and jerk-continuous trajectory formulations explicitly account for joint-trajectory smoothness during time optimization [21, 27]. In robotic AM, tool-orientation or tool-axis redundancy can create multiple robot realizations of the same deposition path [40]. Dai et al. select among alternative IK solutions under discrete-time constraints for jerk-optimized redundant-robot trajectories [13]. Zhang et al. integrate singularity and collision handling and show that discontinuous joint motion near singular regions can produce over- and under-extrusion in deposition [44]. Chen et al. co-optimize tool orientation, kinematic redundancy, and waypoint timing for robot-assisted manufacturing [12], while surrogate-guided formulations reduce search cost by predicting joint jerk for nozzle-orientation selection [37]. These methods improve how a robot executes a given path; they do not choose the slicer variables that generate the path. A second group changes execution by relocating the part. For a prescribed G-code trajectory, workspace location changes IK solutions, energy consumption, and maximum positional deviation [18]. Placement selection improves deposition accuracy in robot-based AM cells [5], map-based methods precompute workspace energy-quality distributions for multi-robot placement [17], and multi-robot WAAM studies optimize the placement of several manipulators around a common build [7]. Related work in robot machining shows the same dependency: workpiece placement bounds feasible TCP-speed capability along a trajectory and determines whether the robot can execute the path efficiently within joint limits [41]. These studies show that workspace placement strongly affects robot execution, but they rank placements for a trajectory produced under fixed slicing settings. The joint space of slicer variables, part orientation, and workspace placement remains largely unsearched. 2.4 Monitored execution and digital shadows Digital manufacturing systems differ by data flow; a digital model has no automatic data exchange, a digital shadow receives one-way physical-to-digital updates, and a digital twin requires bidirectional coupling [26]. AM digital-twin frameworks organize execution around data acquisition, model development, calibration, validation, and real-time monitoring [4, 11]. Implemented systems demonstrate this monitoring role. A WAAM digital shadow fuses sensor streams to detect bead-level and geometry-related defects during deposition [30], and a robotic wire-based laser metal deposition cell integrates robot state, process data, and sensor feedback for in-situ quality monitoring [1]. Recent architecture-level work also connects LLMs with digital twins under Industry 5.0 [10]. These systems improve observability after a process plan exists. They do not produce the pre-execution evidence used to choose among candidate slicer, placement, and robot-motion plans. For the planning problem considered here, monitored execution is therefore a traceability layer where live robot and extrusion states are compared against a selected plan whose feasibility and motion quality have already been verified. Taken together, existing AM LLM systems support knowledge access, prediction, recommendation, monitoring, or process-chain orchestration; slicer studies evaluate path-generating variables in part coordinates; robot-aware planners improve fixed paths or fixed-G-code placements; and digital shadows observe execution after planning. What remains missing is a tool-grounded planning loop that generates candidate deposition jobs and verifies them before execution across slicer variables, part orientation, workspace placement, IK feasibility, trajectory timing, extrusion length, and joint-space motion quality. Such a planning loop requires a clear separation among language-level planning reasoning, deterministic workflow instantiation, and execution-critical computation. 3 Methodology A-RAM is formulated as a query-conditioned, tool-grounded planning framework for robotic additive manufacturing. An LLM-based Triage Agent interprets the natural-language manufacturing objective and constraints and identifies the planning variables that are prescribed or require exploration; a deterministic Planning Agent instantiates this structured intent as a constrained search and evaluation workflow; and deterministic manufacturing and robot-execution tools evaluate the resulting candidate deposition plans. The framework returns an execution-ready plan whose numerical evidence is traceable from slicing to monitored execution. Figure 1: Overview of A-RAM from natural-language manufacturing intent to tool-grounded candidate evaluation and monitored execution. Candidate artifacts are retained throughout the workflow to provide traceability from user intent to G-code, robot motion, and extrusion commands. 3.1 Problem formulation Let u denote the user request, ℳM the input part mesh, and ℛR the calibrated robotic AM cell. The planning decision is a candidate deposition job x=(p,θ,)x=(p,θ,c), where p∈p denotes a slicer-process candidate, including the infill pattern and slicer settings, θ∈Θθ∈ denotes the in-plane part orientation, and ∈ℝ2c ^2 denotes the build-plate placement center. After geometric screening, the nominal product space is restricted by the part geometry and build-plate limits, giving (ℳ)=(p,θ,)|p∈,θ∈Θ(ℳ),∈(ℳ,θ).X(M)= \(p,θ,c)\, |\,p ,\;θ∈ (M),\;c (M,θ) \. (1) The user request does not necessarily activate the full candidate space. The LLM-interpreted planning request identifies which variables are prescribed by the user and which remain open for exploration, and the Planning Agent deterministically instantiates these decisions as a query-specific search scope σ(u)⊆(ℳ)σ(u) (M). Expert-constrained queries therefore evaluate only the variables left open by the user, whereas goal-only queries expand the search over slicer variables, part orientation, workspace placement, or their combinations. A screening evaluation can use a G-code or numerical evaluation profile that differs from the final print profile. Let η∈ℋη denote this profile and let ηF _F denote the final, user-specified print profile. The profile records only evaluation choices, for example, a zero-infill screening override or a trajectory sampling interval, and is not an additional user decision variable. An evaluated job is therefore the tagged tuple z=(x,η)z=(x,η). Each evaluated job is processed through the deterministic chain (x,η)→g(x,η)→(x,η)→(t,x,η)→(x,η).(x,η)\; \;G\;\;g(x;η)\; \;T\;\; τ(x;η)\; \;K\;\;q(t;x,η)\; \;A\;\;m(x;η). (2) Here, G generates the transformed STL and G-code, T converts the G-code into a time-parameterized Cartesian trajectory, K solves the sequential inverse-kinematics problem and produces the joint trajectory, and A extracts the candidate evidence vector (x,η)=[χbed(x,η),χslice(x,η),χik(x,η),χjoint(x,η),tf(x,η),ℓe(x,η),j6max(x,η),j¯6(x,η)]⊤.m(x;η)= [ _bed(x;η),\, _slice(x;η),\, _ik(x;η),\, _joint(x;η),\,t_f(x;η),\, _e(x;η),\,j_6 (x;η),\, j_6(x;η) ] . (3) The binary variables χbed _bed, χslice _slice, χik _ik, and χjoint _joint indicate build-plate fit, slicer success, inverse-kinematics feasibility, and joint-continuity feasibility, respectively. The scalar tft_f is the trajectory end time, ℓe _e is the extrusion path length, and j6maxj_6 and j¯6 j_6 are the maximum and mean absolute Joint-6 jerk values, respectively. For a fixed evaluation profile η, the feasible candidate set is f(u,η)=x∈σ(u)|χbed(x,η)χslice(x,η)χik(x,η)χjoint(x,η)=1.X_f(u;η)= \x∈σ(u)\, |\, _bed(x;η) _slice(x;η) _ik(x;η) _joint(x;η)=1 \. (4) When the profile argument is omitted, f(u)X_f(u) denotes f(u,ηF)X_f(u; _F). Let ω(u)ω(u) denote the interpreted objective. In a two-stage workflow, ηpat _pat denotes the profile used for infill-pattern screening and ηplc _plc denotes the profile used for orientation–placement evaluation; for a single-profile workflow, ηpat=ηplc=η _pat= _plc=η. Each objective is ranked by the ordered priority vector u(x,ηpat,ηplc)=[tf(p,θa,a,ηpat),j6max(x,ηplc),j¯6(x,ηplc)]⊤,time-minimization request,[ℓe(p,θa,a,ηpat),j6max(x,ηplc),j¯6(x,ηplc)]⊤,material-saving request,[j6max(x,ηplc),j¯6(x,ηplc)]⊤,motion-quality request,x=(p,θ,).r_u (x; _pat, _plc )= cases [t_f(p, _a,c_a; _pat),\,j_6 (x; _plc),\, j_6(x; _plc) ] ,&time-minimization request,\\[2.84526pt] [ _e(p, _a,c_a; _pat),\,j_6 (x; _plc),\, j_6(x; _plc) ] ,&material-saving request,\\[2.84526pt] [j_6 (x; _plc),\, j_6(x; _plc) ] ,&motion-quality request, cases x=(p,θ,c). (5) For a time- or material-oriented request, the first entry of ur_u screens the slicer-process candidates at the common anchor pose (θa,a)( _a,c_a): p^∈argminp:(p,θa,a)∈f(u,ηpat)tf(p,θa,a;ηpat),time-minimization request,argminp:(p,θa,a)∈f(u,ηpat)ℓe(p,θa,a;ηpat),material-saving request. p∈ cases *arg\,min_p:\,(p, _a,c_a) _f(u; _pat)t_f(p, _a,c_a; _pat),&time-minimization request,\\[8.53581pt] *arg\,min_p:\,(p, _a,c_a) _f(u; _pat) _e(p, _a,c_a; _pat),&material-saving request. cases (6) The comparison set for the subsequent jerk-based ranking is ℬu(ηplc)=(p^,θ,)∈f(u;ηplc),time- or material-oriented request,f(u,ηplc),motion-quality request.B_u( _plc)= cases \( p,θ,c) _f(u; _plc) \,&time- or material-oriented request,\\[8.53581pt] X_f(u; _plc),&motion-quality request. cases (7) The remaining entries of ur_u, namely j6maxj_6 and then j¯6 j_6, rank candidates within ℬuB_u by a tolerance-aware lexicographic rule. For any nonempty comparison set ℬB, candidates whose maximum Joint-6 jerk lies within 1%1\% of the minimum form the near-tie set ϵ(ℬ,η)=x∈ℬ|j6max(x,η)≤(1+ϵ)minx′∈ℬj6max(x′,η),ϵ=0.01.N_ε(B;η)= \x \; |\;j_6 (x;η)≤(1+ε) _x j_6 (x ;η) \, ε=0.01. (8) The selected candidate minimizes mean absolute Joint-6 jerk within this near-tie set: Selϵ(ℬ;η)=argminx∈ϵ(ℬ,η)j¯6(x,η),x⋆(ηplc)∈Selϵ(ℬu(ηplc);ηplc).Sel_ε(B;η)= *arg\,min_x _ε(B;η) j_6(x;η), x ( _plc) _ε (B_u( _plc); _plc ). (9) Equations (5)–(9) define the ranking rule used in the reported tasks. For time- and material-oriented requests, the leading non-jerk criterion selects the infill pattern at the anchor pose, and the Joint-6 jerk criteria select the orientation–placement candidate within ℬuB_u. For a motion-quality request, the entire feasible set is ranked directly by the Joint-6 jerk criteria. For a workflow evaluated entirely with the final print profile, ηpat=ηplc=ηF _pat= _plc= _F and the reported winner is x⋆=x⋆(ηF)x =x ( _F). In a profile-tagged two-stage workflow, the stage-two winner is subsequently re-evaluated under ηF _F for execution feasibility and final evidence; this verification does not establish that the reduced-profile ranking is preserved under ηF _F. 3.2 Agent protocol and workflow scoping The agent–specialist–tool architecture is shown in Fig. 2. The LLM-based Triage Agent interprets the free-form manufacturing request u, reasons over its objective and constraints, identifies the planning variables that are prescribed or require exploration, and encodes this planning intent as the structured request ρ(u)=(ω,,fix,search,μ),ρ(u)= (ω,\, κ,\,V_fix,\,V_search,\,μ ), (10) where ω is the manufacturing objective interpreted from the user request, κ contains the interpreted user constraints together with validated process limits, fixV_fix contains planning variables identified as prescribed by the user, searchV_search contains variables identified as requiring exploration, and μ specifies the requested downstream execution mode, such as simulation, physical printing, or both. The LLM therefore reasons over the manufacturing intent and the planning degrees of freedom, but it does not estimate the execution-critical numerical quantities used for candidate feasibility or ranking. The resulting request is schema-validated before it reaches the Planning Agent. Invalid objectives, missing required fields, unsupported slicer settings, infeasible numeric ranges, or ambiguous execution modes trigger a repair prompt using the validation error as feedback. If the request remains invalid after a bounded number of repair attempts, the system returns the unresolved fields for human clarification instead of fabricating execution parameters. In the reported implementation, the Triage Agent is run with deterministic decoding, and numerical values used by downstream tools are either user-provided, system-defaulted, or tool-computed. The Planning Agent deterministically instantiates the validated request ρ(u)ρ(u) by mapping its objective, constraints, and fixed/search variables to a query-dependent search scope σ(u)σ(u), the corresponding evaluation profile when applicable, and the specialist–tool workflow. Thus, different user queries activate different search and evaluation workflows rather than passing through a single fixed candidate sweep. When the query leaves the slicer-process variables, orientation, and placement open, the Planning Agent activates a full search, σfull(u)=(p,θ,)|p∈u,θ∈Θu,∈u(θ),|σfull(u)|=|u|∑θ∈Θu|u(θ)| _full(u)= \(p,θ,c)\, |\,p _u,\;θ∈ _u,\;c _u(θ) \, | _full(u) |=|P_u| _θ∈ _u|C_u(θ)| (11) Only in the special case |u(θ)|=C|C_u(θ)|=C for every θ∈Θuθ∈ _u does this reduce to |u||Θu|C|P_u|\,| _u|\,C. For the default experimental grid with 16 infill-pattern candidates, five feasible orientations, and three placement centers at every orientation, Eq. (11) gives 16(5×3)=24016(5× 3)=240 evaluated candidate jobs. For time- or material-oriented requests, the Planning Agent can instead activate a two-stage workflow that screens infill patterns before evaluating orientation and placement. Pattern candidates are therefore first compared at a common anchor pose (θa,a)( _a,c_a), with θa=0∘ _a=0 and a=2c_a=c_2 in the reported experiments, and the selected pattern p p is then passed to the orientation–placement search. This allows extrusion path length or motion-plan completion time to be evaluated once per pattern during the pattern-screening stage, while robot-specific feasibility and Joint-6 motion quality are subsequently evaluated over the orientation–placement candidates. The two workflow stages are represented as sets of profile-tagged evaluations, pat(u) _pat(u) =(p,θa,a,ηpat)|p∈u, = \(p, _a,c_a, _pat)\, |\,p _u \, (12) plc(u) _plc(u) =(p^,θ,,ηplc)|θ∈Θu,∈u(θ), = \( p,θ,c, _plc)\, |\,θ∈ _u,\;c _u(θ) \, (13) screen(u) _screen(u) =pat(u)∪plc(u). =Z_pat(u) _plc(u). (14) Assuming θa∈Θu _a∈ _u, a∈u(θa)c_a _u( _a), and p^∈u p _u, the general set cardinality is |screen(u)|=|u|+∑θ∈Θu|u(θ)|−ηpat=ηplc, |Z_screen(u) |=|P_u|+ _θ∈ _u|C_u(θ)|-1\! \ _pat= _plc \, (15) where the indicator subtracts the single duplicated anchor evaluation only when both stages use the same evaluation profile. In the reported reduced-profile workflow, pattern screening uses the target-density profile ηpat _pat and placement screening uses the zero-infill profile ηplc _plc, so ηpat≠ηplc _pat≠ _plc and the two anchor evaluations are formally distinct. With 16 patterns, five orientations, and three placements per orientation, the evaluation count is therefore 16+5×3=3116+5× 3=31. When the user already fixes the slicer-process candidate, the Planning Agent instead activates a fixed-process orientation–placement workflow, σplace(u)=(p0,θ,)|θ∈Θu,∈u(θ),|σplace(u)|=∑θ∈Θu|u(θ)|. _place(u)= \(p_0,θ,c)\, |\,θ∈ _u,\;c _u(θ) \, | _place(u)|= _θ∈ _u|C_u(θ)|. (16) Under the default grid, this gives |σplace|=5×3=15| _place|=5× 3=15. The full, two-stage, and fixed-process orientation–placement formulations therefore represent alternative query-conditioned search scopes selected by the Planning Agent according to the objective and the variables fixed or left open by the user. Figure 2: A-RAM agent–specialist–tool architecture for robotic AM. The LLM-based Triage Agent interprets the manufacturing objective and constraints, identifies the planning variables that require exploration, and produces a schema-constrained planning request. The Planning Agent deterministically instantiates this request as the search and evaluation workflow, specialists coordinate tools for candidate generation and verification, and the Execution Agent dispatches the selected plan to simulation or monitored physical printing. Figure 3: Representative query-conditioned sweep scopes. The Planning Agent changes σ(u)σ(u) according to query specificity, ranging from a full slicer–orientation–placement search to profile-tagged two-stage screening or expert-constrained placement evaluation. 3.3 Candidate generation Candidate generation begins with geometric screening of ℳM. The CAD analysis stage extracts mesh bounds, dimensions, watertightness, volume, surface area, and the projected footprint. For each θ∈Θuθ∈ _u, the oriented footprint is checked against the usable build-plate region with a prescribed safety margin. Feasible orientations define admissible placement-center intervals, from which the placement stage samples deterministic centers along the larger available workspace direction. This produces the orientation-dependent placement set u(θ)C_u(θ) without treating elementary bounding-box arithmetic as part of the formal method. For each evaluated job (x,η)(x,η), with x=(p,θ,)x=(p,θ,c), the slicer stage applies the orientation and placement to the mesh, applies the process settings associated with p, applies only the explicit overrides recorded in η, and exports G-code g(x,η)g(x;η). The active slicer variables include infill pattern, infill density, infill angle, and solid-layer settings when they are included in searchV_search or specified in fixV_fix. The generated G-code is parsed into deposition and travel segments, feature labels, segment-level extrusion targets, and path statistics. These artifacts provide process-side evidence, such as ℓe(x,η) _e(x;η), and the Cartesian segment sequence used by the robot-side trajectory planner. When reduced evaluation G-code is used, η makes the distinction between the evaluation job and the final print job explicit. For example, ηplc _plc can set infill density to zero during placement screening to isolate shell motion, while ηF _F retains the final user-specified infill settings. After the reduced-profile screen selects θ⋆θ and ⋆c , the candidate (p^,θ⋆,⋆)( p,θ ,c ) is re-sliced using ηF _F. The final-profile G-code is then passed through robot-motion verification and extrusion generation; reduced-profile evidence is never presented as if it were computed from the final G-code. 3.4 Robot-side trajectory verification The parsed G-code for evaluated job (x,η)(x,η) is represented as an ordered segment sequence i(λ,x,η)i=1ns\r_i(λ;x,η)\_i=1^n_s, where λ∈[0,1]λ∈[0,1] parameterizes each Cartesian segment. The trajectory planner assigns boundary speeds at segment junctions, generates a constant-acceleration time parameterization, samples target TCP poses, and solves inverse kinematics sequentially. This module is used as a deterministic evaluation model for comparing candidates under identical timing assumptions; it is not claimed as a new globally optimal time-parameterization algorithm. Let segment i connect junction i−1i-1 to junction i, with length ℓi _i, junction speeds vi−1v_i-1 and viv_i, acceleration bound amaxa_ , deceleration bound dmaxd_ , and TCP speed bound vmaxv_ . The feasible peak speed for the segment is vi⋆=min[vmax,(2amaxdmaxℓi+dmaxvi−12+amaxvi2amax+dmax)1/2].v_i = [v_ , ( 2a_ d_ _i+d_ v_i-1^2+a_ v_i^2a_ +d_ )^1/2 ]. (17) The segment traversal time follows from the acceleration, cruise, and deceleration phases: ti=vi⋆−vi−1amax+vi⋆−vidmax+[ℓi−(vi⋆)2−vi−122amax−(vi⋆)2−vi22dmax]+vi⋆,tf(x,η)=∑i=1nsti.t_i= v_i -v_i-1a_ + v_i -v_id_ + [ _i- (v_i )^2-v_i-1^22a_ - (v_i )^2-v_i^22d_ ]_+v_i , t_f(x;η)= _i=1^n_st_i. (18) Here, [⋅]+=max(0,⋅)[·]_+= (0,·), and zero-length segments are removed before time parameterization. Equation (18) covers both triangular and trapezoidal profiles through the nonnegative cruise-distance term. To avoid stop–go motion at short G-code segments, junction speeds are refined by lookahead. Let iu_i be the unit direction of segment i, and let αi=cos−1(i⊤i+1) _i= ^-1(u_i u_i+1) be the turning angle at interior junction i. The initial junction-speed cap is vi(0)=vmaxγ(αi)v_i^(0)=v_ γ( _i), with γ(0)=1γ(0)=1 and γ(π)=0γ(π)=0; the implementation uses γ(αi)=max(0,cosαi)γ( _i)= (0, _i). With boundary speeds v0=vns=0v_0=v_n_s=0, forward and backward feasibility passes enforce vi v_i ←min(vi,vi−12+2amaxℓi), ← (v_i,\, v_i-1^2+2a_ _i ), i=1,…,ns, i=1,…,n_s, (19) vi−1 v_i-1 ←min(vi−1,vi2+2dmaxℓi), ← (v_i-1,\, v_i^2+2d_ _i ), i=ns,…,1. i=n_s,…,1. After time parameterization, inverse kinematics is solved at each sampled target pose. Write the target pose as k0=(k,k)∈SE(3)^0T_k=(R_k,p_k)∈ SE(3) and the forward-kinematic pose as FK()=((),())FK(q)=(R(q),p(q)). The translational and rotational error coordinates are p(,k)=()−k,R(,k)=Log(k⊤())∨,e_p(q,k)=p(q)-p_k, _R(q,k)=Log\! (R_k R(q) ) , (20) and the weighted pose-error metric is dSE(3)(FK(),k0)=‖T[p(,k)R(,k)]‖2,T=diag(wp3,wR3).d_SE(3)\! (FK(q),^0T_k )= \|W_T bmatrixe_p(q,k)\\ e_R(q,k) bmatrix \|_2, _T=diag\! (w_pI_3,w_RI_3 ). (21) Let kS_k be the ordered seed list supplied to the IK plugin, and let IKplug(k0;)IK_plug(^0T_k;s) denote the finite set of solutions returned from seed s. The enumerated, deduplicated solution set is kenum(x,η)=Uniqueεdup(⋃∈kIKplug(k0(x,η);)),Q_k^enum(x;η)=Unique_ _dup ( _s _kIK_plug\! (^0T_k(x;η);s ) ), (22) where periodic coordinates are compared using the same wrapping convention used by the continuation stage. The accepted IK-feasible set is the subset of enumerated solutions that satisfies the external pose-error and joint-limit checks: kik(x;η)=∈kenum(x;η)|dSE(3)(FK(),k0(x;η))≤εT,min≤max.Q_k^ik(x;η)= \q _k^enum(x;η)\, |\,d_SE(3)\! (FK(q),^0T_k(x;η) )≤ _T,\;q \. (23) The IK routine is invoked from an ordered seed list kS_k. A fixed initial seed is used at the first trajectory sample, and the previously accepted configuration k−1q_k-1 is the leading seed at every subsequent sample. The pose-error tolerance εT _T, translational and rotational weights wpw_p and wRw_R, seed-generation order, and duplicate-solution threshold εdup _dup are held fixed for every candidate in a comparison set. The continuity-admissible subset is kc(x;η)=∈kik(x;η)||wrap2π(qj−qk−1,j)|≤δqjmax,j=1,…,5.Q_k^c(x;η)= \q _k^ik(x;η)\, |\, |wrap_2π\! (q_j-q_k-1,j ) |≤δ q_j ,\;j=1,…,5 \. (24) If kik(x,η)=∅Q_k^ik(x;η)= , then χik(x,η)=0 _ik(x;η)=0; if kc(x,η)=∅Q_k^c(x;η)= , then χjoint(x,η)=0 _joint(x;η)=0. Otherwise, the accepted configuration is selected by nearest-neighbor continuation: k(x,η)=argmin∈kc(x,η)‖q(~−k−1(x,η))‖2,q=diag(d1,…,d6).q_k(x;η)= q _k^c(x;η)arg\,min\; \|D_q ( q-q_k-1(x;η) ) \|_2, _q=diag(d_1,…,d_6). (25) The positive diagonal entries d1,…,d6d_1,…,d_6 define the fixed joint-space normalization used for nearest-neighbor continuation. The vector ~ q is obtained after periodic wrist unwrapping. Specifically, Joint 6 is replaced by q~6=q6+2πargminn∈ℤ|q6+2πn−qk−1,6|. q_6=q_6+2π n arg\,min |q_6+2π n-q_k-1,6 |. (26) The sequential inverse-kinematics stage returns, for each printing and transition segment, the accepted joint configurations k(x,η)q_k(x;η) on that segment’s planner time stamps. The per-segment configurations are concatenated into a single time-ordered joint trajectory tk,k(x,η)k=1nx\t_k,q_k(x;η)\_k=1^n_x, whose time stamps are generally nonuniform. This concatenated trajectory is then fitted, joint by joint, with a B-spline and resampled onto a candidate-specific time grid trc(x,η)r=0Nx,η\t_r^c(x;η)\_r=0^N_x,η with common nominal spacing Δtc=0.005s t_c=0.005\,s, q^i(t;x,η)=∑ℓ=1nbβi,ℓ(x;η)Bℓ,dB(t),i=1,…,6,dB=3, q_i(t;x,η)= _ =1^n_b _i, (x;η)B_ ,d_B(t), i=1,…,6, d_B=3, (27) where nbn_b denotes the number of spline basis functions. Thus, the batch-ranking and final-verification stages use the same nominal resampling interval even though their original IK waypoint intervals differ. The resulting time vectors remain candidate-dependent because trajectory completion times differ across candidates. The same spline construction procedure and endpoint treatment are used throughout, with cubic degree dB=3d_B=3. The stored trajectory that enters every downstream statistic is the spline evaluated on the corresponding candidate-specific resampling grid. This resampled joint trajectory is the object passed to A. The continuity gate rejects candidates with excessive wrapped joint changes in joints 1–5, while the unwrapped wrist coordinate records the orientation accommodation that remains visible in q6(t,x,η)q_6(t;x,η). This is why Joint 6 jerk is used as a sensitive metric for placement-dependent wrist motion rather than hidden inside the feasibility filter. Candidate rejection is based on deterministic candidate-level checks at irreversible stages: build-plate fit, slicer success, IK existence, joint limits, and joint-continuity limits; execution-parameter ranges are validated earlier at the request-schema stage. Here, feasibility refers to the stated sampled kinematic checks, and the timing model estimates motion-plan duration; these checks do not constitute a complete verification of robot dynamics or collision clearance. 3.5 Motion-quality metric Maximum absolute Joint-6 jerk is used as the primary ranking criterion. Placement changes the IK mapping of the same prescribed TCP trajectory, so the placement-dependent motion-quality difference is evaluated in joint space. Over the current workspace, q5q_5 is nearly stationary and q1q_1–q4q_4 exhibit substantially different jerk magnitudes, so a full-joint metric would require additional normalization or weighting to avoid domination by large-magnitude joints. Joint 6 is used as a consistent local wrist-motion indicator; its jerk does not directly measure whole-arm motion quality or deposited-part quality. The maximum value is used to capture the worst local motion transient, which may be diluted by trajectory-averaged measures. The motion-quality metric is computed from a single jerk definition used for all candidate rankings and reported tables. Let tr,q6(tr,x,η)r=0Nx,η\t_r,q_6(t_r;x,η)\_r=0^N_x,η denote the unwrapped Joint 6 coordinate of candidate x on its candidate-specific resampling grid, where trt_r denotes the corresponding recorded time stamp from Eq. (27). All candidates use the same nominal resampling interval of 0.005s0.005\,s, although their trajectory durations and therefore their numbers of samples may differ. The sampled time vectors are nominally uniform but may contain floating-point representation differences, so all derivatives are taken with respect to the recorded time vector rather than a nominal step size. Joint 6 jerk is obtained by applying a second-order-accurate central first-difference operator D three times to the sampled position. At an interior node, with hr−=tr−tr−1h_r^-=t_r-t_r-1 and hr+=tr+1−trh_r^+=t_r+1-t_r, (y)r=(hr−)2yr+1+[(hr+)2−(hr−)2]yr−(hr+)2yr−1hr−hr+(hr−+hr+),(Dy)_r= (h_r^-)^2y_r+1+ [(h_r^+)^2-(h_r^-)^2 ]y_r-(h_r^+)^2y_r-1h_r^-h_r^+(h_r^-+h_r^+), (28) with second-order one-sided formulas at the endpoints, and j6(tr,x,η)=(3q6)r,j_6(t_r;x,η)= (D^3q_6 )_r, (29) i.e. the third successive numerical derivative q˙6=q6 q_6=Dq_6, q¨6=q˙6 q_6=D q_6, j6=q¨6j_6=D q_6. The same differencing convention is applied to every candidate in a comparison set. The reported maximum and mean absolute jerk are j6max(x,η) j_6 (x;η) =max0≤r≤Nx,η|j6(tr,x,η)|, = _0≤ r≤ N_x,η|j_6(t_r;x,η)|, (30) j¯6(x,η) j_6(x;η) =1Nx,η+1∑r=0Nx,η|j6(tr,x,η)|. = 1N_x,η+1 _r=0^N_x,η|j_6(t_r;x,η)|. (31) Because every candidate is differenced using the same nominal 0.005s0.005\,s resampling interval, there is no coarse/fine distinction in the jerk computation itself: the batch and final stages differ only in the waypoint interval used to generate the trajectory, not in the nominal interval used for jerk evaluation. For a motion-quality request, ℬu(η)=f(u,η)B_u(η)=X_f(u;η) in Eq. (7); the selected candidate is therefore obtained only by the one-percent maximum-jerk near-tie rule in Eq. (8), followed by minimization of mean absolute jerk in Eq. (9). This is the sole motion-quality ranking rule. 3.6 Extrusion synchronization The slicer provides segment-level extrusion targets, whereas the robot executes a timestep-level trajectory after velocity-profile generation and IK selection. The Extrusion Specialist therefore regenerates extrusion commands on the final robot-motion grid. Let ese_s be the extrusion amount assigned by the G-code to deposition segment s, and let ℐs(x)I_s(x) be the set of robot-trajectory timesteps assigned to that segment. For timestep k∈ℐs(x)k _s(x), with TCP travel increment dk(x)d_k(x), the synchronized extrusion command is ek(x)=dk(x)∑r∈ℐs(x)dr(x)es,k∈ℐs(x).e_k(x)= d_k(x) _r _s(x)d_r(x)\,e_s, k _s(x). (32) Thus, ∑k∈ℐs(x)ek(x)=es _k _s(x)e_k(x)=e_s by construction, while travel moves receive ek(x)=0e_k(x)=0 even when TCP speed is nonzero. Optional feature-level scaling is represented as ek(x)←αℓek(x)e_k(x)← _ e_k(x) for samples belonging to feature class ℓ , such as infill, perimeter, or solid layers. The final execution file stores the time vector, joint trajectory, TCP increments, deposition flag, feature label, cumulative extrusion target, and synchronized extrusion increments. Figure 4: Motion-synchronized extrusion regeneration. Travel moves may have nonzero TCP speed with zero extrusion, whereas deposition segments redistribute the G-code extrusion target over the final robot-motion timesteps in proportion to local TCP travel distance. 3.7 Execution monitoring and traceability The Execution Agent dispatches the selected plan either to the simulation branch or to physical printing. Both branches consume the same selected motion–extrusion trajectory. In simulation, the trajectory is executed through the ROS 2 mock-hardware branch for kinematic preview. In physical printing, the joint trajectory is sent to the UR3 controller and the synchronized extrusion targets are sent to the extrusion controller. The digital-shadow branch samples live TCP pose, Joint 6 state, extrusion command state, deposition flag, feature label, layer index, and matched trajectory index, and aligns these states with the selected plan. The role of this layer is traceability: planning tools select the candidate before execution, and the digital shadow records whether the simulated or physical execution follows the selected trajectory and extrusion command stream. Forward kinematics is used as a diagnostic reconstruction layer. With the standard flange-to-tool convention, the TCP transform is tcp,k0=6,k0tcp6,tcp,k=6,k+6,ktcp6,^0T_tcp,k=^0T_6,k^6T_tcp, _tcp,k=r_6,k+R_6,k\,^6r_tcp, (33) where tcp6^6r_tcp is defined from the Joint-6 flange frame to the nozzle TCP. This convention fixes the sign of the tool-offset term and keeps the forward-kinematic reconstruction consistent with the flange-to-tool transform. The monitored extrusion state in the current implementation is command-side rather than encoder-measured filament displacement. Consequently, layer-wise deposition visualization is interpreted as a nominal command-side proxy, not as measured bead geometry. For two consecutive samples with nonzero TCP travel, the displayed bead-width proxy is computed from volume conservation as wb,kcmd=ekAfhΔsk,Af=πdf24,w^cmd_b,k= e_kA_fh\, s_k, A_f= π d_f^24, (34) where eke_k is the commanded filament-feed increment, AfA_f is the filament cross-sectional area, dfd_f is the filament diameter, h is the layer height, and Δsk s_k is the TCP travel between samples. This signal supports visualization and post-run comparison against the selected plan, but it is not used as a closed-loop bead-width measurement. 3.8 Implementation on the robotic-arm F cell The implemented system uses a six-axis UR3 robotic arm equipped with a fused-filament extrusion end effector. PrusaSlicer CLI generates candidate G-code, ROS 2 and MoveIt support execution and visualization, and RTDE provides live robot-state access during physical printing. Batch candidate ranking uses Δtbatch=0.01s t_batch=0.01\,s for efficient screening, and the selected job is regenerated at Δtfinal=0.005s t_final=0.005\,s; both are resampled using the same nominal 0.005s0.005\,s interval before jerk evaluation, as defined in Eq. (27). The default build region is 160m×160m160\,m× 160\,m with a 2m2\,m safety margin, and the default orientation set is Θ=0∘,30∘,45∘,60∘,90∘ =\0 ,30 ,45 ,60 ,90 \. The numerical values of vmaxv_ , amaxa_ , dmaxd_ , δqjmaxδ q_j , layer height, and extrusion width are fixed by the experimental configuration and reported with the case-study settings. The IK acceptance settings, seed-ordering rule, joint-space scaling, spline construction procedure, and nominal jerk-evaluation interval are held fixed across all candidates evaluated within the same comparison. The LLM used in the reported implementation is Qwen3-8B without task-specific fine-tuning. Because execution-critical numerical evaluation remains tool-based, the language model can be replaced or upgraded without changing the formal planning problem or quantitative verification pipeline. 4 Experimental Design and Results This section evaluates A-RAM through three case studies comprising nine query-conditioned planning tasks. Across all experiments, the layer height is fixed at 1m1\,m, the extrusion width is fixed at 2.5m2.5\,m, the maximum TCP speed is set to vmax=25ms−1v_ =25\,m\,s^-1, and the acceleration and deceleration limits are set to amax=dmax=25ms−2a_ =d_ =25\,m\,s^-2. The maximum allowable joint change between consecutive IK samples is set to δqjmax=0.35radδ q_j =0.35\,rad for joints j=1,…,5j=1,…,5. Joint-6 jerk is computed from the unwrapped wrist trajectory defined in Section 3.5; j6maxj_6 and j¯6 j_6 denote the maximum and mean absolute Joint-6 jerk, respectively, and are reported in rads−3rad\,s^-3. Case Study I uses a Dogbone Type IV specimen to compare an expert-specified query with a goal-only query that asks to minimize Joint-6 jerk. Case Study I uses a five-layer Husky Head to compare material-saving and time-minimization objectives under 90% and 100% infill densities. Case Study I compares three geometries under the same perimeter-focused motion-quality query to test whether an orientation–placement rule transfers across parts. Table 1 summarizes the nine planning tasks and their search scopes. Table 1: Summary of the query-conditioned planning tasks evaluated in this section. Case Part Objective Candidate scope Execution mode I-a Dogbone Type IV Expert-specified plan 1×1×31× 1× 3 Planning output & digital shadow I-b Dogbone Type IV Minimize j6maxj_6 16×5×316× 5× 3 Planning output I-a Husky Head, 5-layer Save filament, 90% infill 16+5×316+5× 3 Planning output & digital shadow I-b Husky Head, 5-layer Fastest, 90% infill 16+5×316+5× 3 Planning output & digital shadow I-c Husky Head, 5-layer Save filament, 100% infill 16+5×316+5× 3 Planning output & digital shadow I-d Husky Head, 5-layer Fastest, 100% infill 16+5×316+5× 3 Planning output & digital shadow I-a Gator Head, 4-layer Minimize j6maxj_6 1×5×31× 5× 3 Planning output & physical print I-b Husky Head, 4-layer Minimize j6maxj_6 1×5×31× 5× 3 Planning output & physical print I-c Husky Head, 5-layer Minimize j6maxj_6 1×5×31× 5× 3 Planning output 4.1 Case Study I: Dogbone Type IV Expert-specified query. This task evaluates an expert-specified request in which the user prescribes the main process parameters: gyroid infill, 50% infill density, 25% infill overlap, a 45∘45 infill angle, a 45∘45 part orientation, one top solid layer, one bottom solid layer, and physical printing after planning. Because the infill pattern and part orientation are fixed, A-RAM does not perform a global pattern–orientation sweep. The Planning Agent treats the request as an expert-constrained workflow and evaluates only the three candidate placements available at the prescribed 45∘45 orientation. The selected plan preserves all user-defined slicing settings and chooses placement C3. A final single-candidate rerun with Δtfinal=0.005s t_final=0.005\,s then generates the execution-ready motion and extrusion plans. Agentic execution trace for the expert-specified Dogbone query User query: Gyroid infill, 50% density, 25% overlap, 45∘45 fill angle, 45∘45 part orientation, one top layer, one bottom layer, and print the part after planning. Interpreted objective: custom. Selected workflow: fixed_pattern_then_placement. Search space: 1 infill pattern × 1 orientation × 3 placements = 3 candidates. Valid candidates: 3 motion-planning cases satisfy the current IK and continuity constraints. Selected plan: gyroid infill, 50% density, 45∘45 part orientation, placement C3. Final rerun: single-candidate rerun with Δtfinal=0.005s t_final=0.005\,s. Execution decision: execution-ready motion and extrusion plans generated. With the part orientation prescribed as 45∘45 , the Placement Tool restricts candidate generation to three placement centers, C1–C3, as shown in Fig. 7 (a, 45∘45 ). The rotated footprint satisfies the build-region constraint, so all three placements are passed to slicing and robot-side evaluation. The Slicer Tool converts each placement into G-code using the prescribed gyroid infill, 50% density, 25% overlap, 45∘45 infill angle, one top solid layer, and one bottom solid layer. Figure 5 shows representative layers extracted from the generated G-code. These G-code paths are the direct inputs to robot-side motion planning and jerk evaluation. Figure 5: Representative slicer-generated layer patterns for the expert-specified Dogbone query. The orange paths denote perimeters, the red paths denote gyroid infill, and the purple paths denote top or bottom solid layers generated with the prescribed 45∘45 fill angle. Table 2 reports the placement ranking. Because the infill pattern, slicer settings, and part orientation are fixed, the changes in Joint-6 jerk are caused by workspace placement. Placement C3 minimizes j6maxj_6 among the three feasible candidates, reducing it from 606.7101rads−3606.7101\,rad\,s^-3 for C1 to 543.6724rads−3543.6724\,rad\,s^-3, a 10.4% reduction. The same placement reduces j¯6 j_6 from 4.4117rads−34.4117\,rad\,s^-3 to 3.6033rads−33.6033\,rad\,s^-3, an 18.3% reduction. Table 2: Joint-6 jerk ranking for the expert-specified Dogbone query. Rank Orientation Placement Infill pattern j6maxj_6 (rads−3)(rad\,s^-3) j¯6 j_6 (rads−3)(rad\,s^-3) 1 45∘45 C3 gyroid 543.6724 3.6033 2 45∘45 C2 gyroid 576.1122 3.9878 3 45∘45 C1 gyroid 606.7101 4.4117 The spatial and joint-motion comparisons in Fig. 6 further contextualize the ranking. As shown in Fig. 6 (a), the best and worst candidates use the same G-code pattern and part orientation, so their local deposition geometries are identical. However, the toolpaths are located at different positions within the robot workspace, leading to different induced joint trajectories. The resulting Joint-6 position, velocity, acceleration, and jerk responses are shown in Fig. 6 (b)–(e), with the best placement exhibiting lower Joint-6 jerk than the worst placement. Figure 6: Comparison of the best and worst placements for the expert-specified Dogbone query. The best candidate is gyroid, 45∘45 , C3, while the worst candidate is gyroid, 45∘45 , C1. (a) End-effector XY toolpaths, including the robot origin and the reference arc with a radius of 0.10.1 m. (b)–(e) Joint-6 position, velocity, acceleration, and jerk profiles, respectively. After C3 is selected, the Motion Planning Specialist performs the final rerun and the Extrusion Specialist regenerates the synchronized extrusion plan. Goal-only query. The second Dogbone task evaluates a goal-only request in which the user specifies only the objective of minimizing Joint-6 jerk. The LLM-based Triage Agent interprets the request as min_j6_jerk. Since no infill pattern, part orientation, or placement is fixed by the user, the Planning Agent selects the full cross sweep. The resulting search evaluates 16 infill patterns, five orientations, and three placements, giving 240 candidate combinations. Under the current robotic-arm constraints, 239 candidates are valid and one candidate has no feasible IK solution. The selected plan uses stars infill, a 30∘30 part orientation, and placement C3. Agentic execution trace for the goal-only Dogbone query User query: I want to minimize Joint-6 jerk. Interpreted objective: min_j6_jerk. Selected workflow: full_cross_sweep. Search space: 16 infill patterns × 5 orientations × 3 placements = 240 candidates. Valid candidates: 239 motion-planning cases satisfy the current constraints. Invalid candidates: 1 candidate has no feasible IK solution. Selected plan: stars infill, 30∘30 part orientation, placement C3. Final rerun: single-candidate rerun with Δtfinal=0.005s t_final=0.005\,s. Planning output: execution-ready motion and extrusion plans generated. Because the user leaves orientation and placement open, the Placement Tool enumerates candidates across the tested orientations, as shown in Fig. 7 (a). The Slicer Tool then generates G-code for the 16 infill patterns considered in the sweep. Figure 7: Combined candidate-generation figure. Orientation-dependent placement candidates for (a) Dogbone Type IV, (b) Husky Head, and (c) Gator Head. Each column corresponds to one tested part orientation, and the colored overlays denote the three generated placement centers, C1–C3, within the build region. The dashed red rectangle indicates the allowable placement region used during candidate generation. Table 3 reports representative candidates from the Joint-6 jerk ranking of the 239 valid plans. The selected plan, stars, 30∘30 , C3, reduces j6maxj_6 from 760.800rads−3760.800\,rad\,s^-3 for the least favorable valid candidate to 353.593rads−3353.593\,rad\,s^-3, corresponding to a 53.5% reduction. It also reduces j¯6 j_6 from 5.524rads−35.524\,rad\,s^-3 to 2.854rads−32.854\,rad\,s^-3, corresponding to a 48.3% reduction. The candidates are ranked using the tolerance-aware lexicographic rule defined in Eqs. (8)–(9). For the global ranking in Table 3, the candidate set is the full set of 239 feasible plans. Under this global ranking, no additional candidate falls within 1% of the minimum j6maxj_6 in this evaluation. Table 3: Representative lexicographic Joint-6 jerk ranking for the goal-only Dogbone query. Rank Orientation Placement Infill pattern j6maxj_6 (rads−3)(rad\,s^-3) j¯6 j_6 (rads−3)(rad\,s^-3) 1 30∘30 C3 stars 353.593 2.854 2 30∘30 C3 rectilinear 360.214 2.882 3 30∘30 C3 lightning 361.884 2.632 4 30∘30 C3 line 366.272 3.111 5 30∘30 C3 archimedeanchords 375.162 3.032 235 0∘0 C1 cubic 751.279 4.193 236 0∘0 C1 grid 752.137 3.806 237 0∘0 C1 triangles 752.470 4.079 238 0∘0 C1 archimedeanchords 759.194 4.645 239 0∘0 C1 honeycomb 760.800 5.524 The full search landscape is summarized in Fig. 8, which includes all 239 feasible orientation–placement candidates across the 16 infill patterns. Each row shows the candidate distribution for one pattern, with marker color denoting orientation and marker shape denoting placement. The horizontal line spans the within-pattern range, the vertical tick marks the median, and the hollow marker identifies the minimum maximum absolute Joint-6 jerk within that pattern. The minimum over the evaluated feasible set is obtained for stars at 30∘30 /C3, with j6max=353.6rads−3j_6 =353.6\,rad\,s^-3. Notably, the raw maximum-jerk minimum for every infill pattern occurs at 30∘30 /C3, indicating a consistent orientation–placement preference under this metric for the present search. Figure 8: Ranked candidate landscape for the goal-only Dogbone search. Each row shows all feasible orientation–placement candidates for one infill pattern. Horizontal lines span the within-pattern range, vertical ticks mark the medians, color denotes orientation, and marker shape denotes placement. Hollow markers identify within-pattern minima, and the gold star marks the selected candidate over the evaluated feasible set. One candidate, Hilbert curve at 90∘90 /C2, was infeasible and is omitted. After the selected candidate is identified, the Motion Planning Specialist performs the final single-candidate rerun with Δtfinal=0.005s t_final=0.005\,s. This task stops at the planning stage. The result demonstrates that a goal-only motion-quality request activates a broader candidate space than an expert-specified request and identifies the lowest-jerk feasible plan within the evaluated pattern–orientation–placement grid. 4.2 Case Study I: Husky Head This case study uses a five-layer Husky Head model to evaluate four related user queries formed by two objectives, material saving and time minimization, under two prescribed final infill densities, 90% and 100%. These percentages denote nominal slicer settings; material-saving comparisons use extrusion-path length without imposing equal achieved volume fraction or mechanical performance across patterns. A representative query is: ”Print the Husky Head with 90% infill while minimizing material consumption and prioritize the robot-motion quality of the perimeter and top/bottom solid-infill trajectories.” The other three queries follow the same structure with the objective and infill density changed accordingly. The prescribed 90% or 100% infill density is retained for the final print, whereas orientation–placement selection focuses on perimeter and top/bottom solid-infill motion. These regions define the external boundary and visible solid surfaces of the part, while internal infill is enclosed within the part and primarily supports subsequent layers. At high infill densities, internal infill can constitute a large fraction of the total trajectory and could therefore dominate the placement metric, biasing selection away from the perimeter and solid-surface trajectories targeted by the query. Internal infill is consequently excluded only during orientation–placement selection and restored for the final print. The resulting orientation–placement pair is selected among the evaluated candidates using the query-defined reduced-profile motion-quality criterion. The four compressed execution records are summarized in Table 4. The same staged workflow is used in all four cases, but the pattern-screening criterion changes with the objective. The material-saving objective selects the shortest extrusion path from the G-code summary, whereas the time-minimization objective selects the shortest motion-plan end time at the common anchor pose. Table 4: Agentic execution trace summary for the four Husky Head queries. Task Density Interpreted objective Pattern-screen criterion Placement-evaluation setting Selected final plan 1 90% save_filament shortest extrusion path infill-¿0%, with solid layers lightning, 90∘90 , C3 2 90% fastest shortest motion-plan time infill-¿0%, with solid layers supportcubic, 90∘90 , C3 3 100% save_filament shortest extrusion path infill-¿0%, with solid layers octagramspiral, 90∘90 , C3 4 100% fastest shortest motion-plan time infill-¿0%, with solid layers rectilinear, 90∘90 , C3 Because the user does not prescribe a fixed placement or orientation, the Placement Tool first generates the feasible orientation–placement candidates shown in Fig. 7 (b). This orientation–placement set is shared by the four Husky tasks. At 90% infill density, the Slicer Tool generates valid G-code for all 16 default infill patterns. Figure 9 shows representative slicer-generated layers. The quantitative pattern-screening results are summarized in Fig. 10. For the time-minimization objective, panel (a) ranks the realizable patterns by motion-plan end time. Supportcubic is selected at 1131.7031s1131.7031\,s using the full-precision outputs, practically tied with adaptivecubic at 1131.7032s1131.7032\,s. Compared with hilbertcurve at 1753.49s1753.49\,s, the selected pattern reduces motion-plan end time by 35.5%. For the material-saving objective, panel (c) ranks the patterns by total extrusion path. Lightning is selected because it gives the shortest extrusion path, 11049.11m11049.11\,m. Compared with 3dhoneycomb, the largest extrusion-path case at 12652.44m12652.44\,m, this corresponds to a 12.7% reduction. Figure 9: Slicer-generated G-code visualization under the 90% infill-density setting. The orange paths denote perimeters, the purple and light-red paths denote bottom and top solid regions, respectively, and the dark-red paths denote infill. In the first row, from left to right, the infill patterns are octagramspiral, archimedeanchords, hilbertcurve, supportcubic, adaptivecubic, cubic, gyroid, 3dhoneycomb, honeycomb, and concentric. In the second row, the first five panels, from left to right, show line, stars, triangles, grid, and rectilinear. The final five panels show layers 1–5 of the full Husky Head with the lightning infill pattern. Figure 10: Quantitative infill-pattern screening for the Husky Head queries under 90% and 100% infill densities. Panels (a) and (b) rank realizable patterns by motion-plan end time for the time-minimization objective at 90% and 100% infill, respectively. Panels (c) and (d) rank realizable patterns by total extrusion path for the material-saving objective at 90% and 100% infill, respectively. Gold stars denote the selected patterns. In panel (a), the outlined marker denotes a rounded-value tie between adaptivecubic and supportcubic; supportcubic is selected using the full-precision tool outputs. At 100% infill, only realizable patterns are shown. At 100% infill density, the feasible pattern set becomes smaller under the current slicer configuration. Only rectilinear, concentric, hilbertcurve, archimedeanchords, and octagramspiral generate valid G-code for this density and solid-fill configuration; the remaining default patterns fail slicer validation or are not realizable under this configuration and are removed before robot-side evaluation. For the time-minimization objective, Fig. 10 (b) shows that rectilinear gives the shortest motion-plan end time, 1137.91s1137.91\,s, a 40.1% reduction relative to hilbertcurve at 1900.25s1900.25\,s. For the material-saving objective, Fig. 10 (d) shows that octagramspiral gives the shortest total extrusion path, 11993.30m11993.30\,m, a 5.1% reduction relative to concentric at 12632.71m12632.71\,m. After infill-pattern screening, orientation–placement selection is performed using perimeter-and-solid-infill evaluation G-code, generated by the Placement Specialist at each orientation–placement candidate with the infill density overwritten to 0%. Setting the density to zero empties only the internal sparse-infill layers, chiefly the second layer, which becomes empty, while the other layers remain essentially unchanged, because their material is deposited as top/bottom solid-infill motion associated with the shell rather than as ordinary infill. The comparison therefore reflects the perimeter and solid-infill motion instead of the objective-dependent internal infill. The selected orientation–placement pair is used only after the final infill-containing G-code has been re-sliced and re-verified. Table 5 reports representative candidates from the lexicographic Joint-6 jerk ranking over the 15 no-infill orientation–placement cases. The selected orientation–placement pair is 90∘90 /C3. Compared with the least favorable shown candidate, 45∘45 /C1, the selected pair reduces j6maxj_6 from 798.290rads−3798.290\,rad\,s^-3 to 563.067rads−3563.067\,rad\,s^-3, a 29.5% reduction, and reduces j¯6 j_6 from 7.443rads−37.443\,rad\,s^-3 to 6.112rads−36.112\,rad\,s^-3, a 17.9% reduction. Table 5: Representative Joint-6 jerk ranking for Husky Head orientation–placement selection under the perimeter-and-solid-infill evaluation setting. Rank Orientation Placement j6maxj_6 (rads−3)(rad\,s^-3) j¯6 j_6 (rads−3)(rad\,s^-3) 1 90∘90 C3 563.067 6.112 2 60∘60 C3 602.324 6.185 3 0∘0 C3 640.401 5.848 4 90∘90 C2 653.045 6.679 5 45∘45 C3 669.861 6.191 11 60∘60 C2 705.141 6.786 12 60∘60 C1 711.719 7.574 13 0∘0 C1 714.007 5.805 14 90∘90 C1 732.653 7.329 15 45∘45 C1 798.290 7.443 The corresponding orientation–placement interaction is shown in Fig. 11 (a). Lower values indicate more favorable Joint-6 motion quality under the reported ranking rule. Figure 12 compares the best and least favorable orientation–placement candidates. As shown in Fig. 12 (a), changing the part orientation and placement alters the end-effector path within the robot workspace, even though both candidates are evaluated using the same perimeter-and-solid-infill evaluation geometry. These spatial differences produce distinct Joint-6 motion responses, as shown in Fig. 12 (b)–(e), with the best candidate exhibiting lower jerk than the least favorable candidate. Figure 11: Orientation–placement interaction for maximum absolute Joint-6 jerk in (a) the five-layer Husky Head with infill set to 0% while retaining the top and bottom solid layers; (b) the four-layer Gator Head under the perimeter-only profile; (c) the four-layer Husky Head under the perimeter-only profile; and (d) the five-layer Husky Head under the perimeter-only profile. The horizontal axis denotes part orientation, and the three connected profiles correspond to placements C1–C3. Gold stars mark the reported selected candidates, while gaps denote infeasible configurations. Connecting lines are used only to guide comparison across the tested discrete orientations and do not imply interpolation. Figure 12: Comparison of the best and least favorable orientation–placement candidates in the Husky Head perimeter-and-solid-infill evaluation. The best candidate is 90∘90 /C3, while the least favorable candidate is 45∘45 /C1. (a) End-effector XY toolpaths. (b)–(e) Joint-6 position, velocity, acceleration, and jerk profiles, respectively. After orientation–placement selection, each final pattern–orientation–placement configuration is regenerated with the target infill density and re-verified by the Motion Planning Specialist using Δtfinal=0.005s t_final=0.005\,s. The resulting plans are then printed with the digital-shadow pipeline activated. Figure 13 shows the printed second-layer infill for the four selected configurations, Fig. 14 and Fig. 15 provide the digital-shadow view of the printing process, including layer-wise command-side deposition visualization and synchronized monitoring of TCP motion, Joint-6 motion, and extrusion states. The corresponding physical prints are shown in Fig. 16 (a)–(d). Together, the results show that A-RAM applies objective-dependent pattern screening while retaining a shared robot-aware orientation–placement check and synchronized execution monitoring across the four density–objective combinations. Figure 13: Printed second-layer infill for the selected Husky Head configurations: (a) fastest, 90% infill, supportcubic; (b) save filament, 90% infill, lightning; (c) fastest, 100% infill, rectilinear; and (d) save filament, 100% infill, octagramspiral. Figure 14: Layer-wise deposition visualization from the digital-shadow pipeline. Screenshots are taken at the end of the second-layer infill for (a) fastest, 90% infill, supportcubic; (b) save filament, 90% infill, lightning; (c) fastest, 100% infill, rectilinear; and (d) save filament, 100% infill, octagramspiral. Figure 15: Execution-state monitoring from the digital-shadow pipeline during printing. The left column shows the commanded TCP position in x, y, and z, together with the corresponding Joint-6 position. The right column shows Joint-6 velocity and acceleration, as well as extrusion position and extrusion velocity. These synchronized signals provide a time-resolved view of robot motion and material-deposition states during execution. Figure 16: Physical prints of representative selected final plans: (a) Husky Head, fastest plan at 90% infill using supportcubic; (b) Husky Head, material-saving plan at 90% infill using lightning; (c) Husky Head, fastest plan at 100% infill using rectilinear; (d) Husky Head, material-saving plan at 100% infill using octagramspiral; (e) four-layer Gator Head; and (f) four-layer Husky Head. 4.3 Case Study I: Geometry-Dependent Orientation–Placement Selection This case study compares three parts: a four-layer Gator Head, a four-layer Husky Head, and a five-layer Husky Head. To isolate geometry-dependent orientation–placement effects, the infill pattern is fixed to rectilinear for all three parts, while part orientation and workspace placement remain open search variables. The same controlled query is used for all three parts: “Use rectilinear infill at 100% density and select the orientation and placement that prioritize perimeter motion quality only.” This query represents a perimeter-prioritized placement scenario motivated by the structural importance of the perimeter. According to PrusaSlicer, part strength is governed primarily by the number of perimeters rather than by infill, while internal infill mainly supports subsequent layers [35], and top and bottom solid infill primarily determines the external surface finish. Accordingly, unlike Case Study I, where both perimeter and top/bottom solid-infill trajectories are retained because the query also prioritizes visible solid-surface motion, the present query excludes both internal infill and top/bottom solid infill from the placement criterion. The evaluation G-code therefore contains only perimeter trajectories. The prescribed 100% infill density remains a final manufacturing requirement and is restored after orientation–placement selection; it does not define the motion-quality scope used to rank candidates. This contrast with Case Study I illustrates the query-conditioned evaluation behavior of the framework: the placement-evaluation trajectory is generated according to the motion-quality regions specified in the user request rather than from a fixed evaluation profile. Under this controlled setting, any change in the selected orientation–placement pair among the three parts is caused by part geometry and layer-stack differences rather than by changes in objective, infill pattern, or search workflow. Table 6: Agentic execution trace summary for the geometry-dependent orientation–placement tasks. Part Search scope Placement-evaluation setting Selected plan Gator Head, 4-layer 1×5×3=151× 5× 3=15 infill-¿0%, without solid layer rectilinear, 0∘0 , C3 Husky Head, 4-layer 1×5×3=151× 5× 3=15 infill-¿0%, without solid layer rectilinear, 0∘0 , C1 Husky Head, 5-layer 1×5×3=151× 5× 3=15 infill-¿0%, without solid layer rectilinear, 90∘90 , C3 The Placement Tool generates the same five-orientation by three-placement candidate structure for each part under the build-plate constraints. Figure 7 (c) shows the candidate-placement result for the four-layer Gator Head. The five-layer Husky Head placement result was already presented in Fig. 7 (b); the four-layer Husky Head is not shown separately because its XY placement layout is visually the same as the five-layer version. For placement evaluation, the Placement Specialist regenerates G-code for each candidate with infill density overwritten to 0% and the top and bottom solid layers removed, so that the motion comparison reflects the perimeter-focused query. Table 7 summarizes the selected and least favorable candidates for the three parts under the perimeter-only placement-evaluation setting. For the four-layer Husky Head, 90∘90 /C3 has a slightly lower raw j6maxj_6 than 0∘0 /C1 (585.846585.846 versus 586.949rads−3586.949\,rad\,s^-3); however, both candidates fall within the 1% near-tie range, and the tolerance-aware lexicographic rule selects 0∘0 /C1 because it has the lower j¯6 j_6 (10.86510.865 versus 11.009rads−311.009\,rad\,s^-3). Relative to the least favorable candidate in each evaluated set, the selected candidate reduces j6maxj_6 by 31.1%, 22.6%, and 30.6% for the four-layer Gator Head, four-layer Husky Head, and five-layer Husky Head, respectively. The corresponding j¯6 j_6 values decrease by 5.6% and 9.0% for the four-layer Gator Head and four-layer Husky Head, respectively, whereas the five-layer Husky Head exhibits a 4.2% increase in j¯6 j_6. Table 7: Selected and least favorable orientation–placement candidates for the geometry-dependent orientation–placement study under the perimeter-only evaluation setting. Part Case Orientation Placement j6maxj_6 (rads−3)(rad\,s^-3) j¯6 j_6 (rads−3)(rad\,s^-3) Gator Head Selected 0∘0 C3 553.46 8.82 Gator Head Least favorable 90∘90 C3 803.38 9.34 Husky Head, 4-layer Selected 0∘0 C1 586.95 10.87 Husky Head, 4-layer Least favorable 30∘30 C1 757.91 11.93 Husky Head, 5-layer Selected 90∘90 C3 588.20 11.19 Husky Head, 5-layer Least favorable 0∘0 C1 847.39 10.74 The orientation–placement interactions in Fig. 11 (b)–(d) show that the preferred orientation–placement pair differs across geometries even under the same objective, workflow, pattern setting, and perimeter-only evaluation scope. The four-layer Gator Head selects 0∘0 /C3, the four-layer Husky Head selects 0∘0 /C1, and the five-layer Husky Head selects 90∘90 /C3. The distinct interaction profiles indicate that the effect of placement varies with orientation and geometry, and that the preferred pair under the stated ranking rule differs across the evaluated geometries. Figure 17 compares the end-effector XY trajectories of the selected and least favorable candidates for the three parts. The trajectories occupy different locations and exhibit different path geometries relative to the robot base, leading to distinct robot-side motion behavior. The difference between the four-layer and five-layer Husky Head is especially important: under the prescribed tolerance-aware ranking rule, a small layer-stack change shifts the selected orientation–placement pair from 0∘0 /C1 to 90∘90 /C3. Figure 17: End-effector XY toolpaths of the selected and least favorable orientation–placement candidates for (a) four-layer Gator Head, (b) four-layer Husky Head, and (c) five-layer Husky Head under the perimeter-only evaluation setting. Blue trajectories denote the selected candidates and orange trajectories denote the least favorable candidates. After orientation–placement selection, the Slicer Tool regenerates the selected plans using the query-specified 100% infill density, and the Motion Planning Specialist performs the final single-candidate rerun with Δtfinal=0.005s t_final=0.005\,s. Physical realizations of the four-layer Gator Head and the four-layer Husky Head are shown in Fig. 16 (e)–(f). These results confirm that the preferred orientation–placement pair is geometry-dependent: the four-layer Gator and Husky Heads select different pairs because their geometries differ, while the four-layer and five-layer Husky Heads differ despite identical in-plane geometry, showing that even a small layer-stack change can reshape the Joint-6 jerk landscape and shift the selected orientation–placement pair. 5 Conclusion This paper introduced agentic robotic additive manufacturing (A-RAM) for robotic-arm fused filament fabrication. A-RAM formulates robotic AM planning as a coupled decision problem involving slicer variables, part orientation, workspace placement, inverse kinematics, trajectory timing, motion quality, and extrusion. It converts a natural-language request and part STL into a structured planning workflow in which the LLM interprets the manufacturing objective and constraints, reasons over which planning variables are prescribed or require exploration, and formulates the structured planning intent; a deterministic Planning Agent instantiates that intent as the corresponding search and evaluation workflow, and domain tools compute the execution-critical evidence used for candidate selection and monitored execution. The experimental results show that the selected slicer profile and orientation–placement pair vary with the specified objective and evaluated geometry. A-RAM changes its search scope according to the user objective and query specificity, while the selected plan also varies with part geometry. In the expert-specified Dogbone case, placement-only evaluation reduced the maximum and mean absolute Joint-6 jerk by 10.4% and 18.3%, respectively. In the goal-only Dogbone case, the 240-candidate search reduced these metrics by 53.5% and 48.3%, respectively, relative to the least favorable valid candidate. In the Husky Head study, objective-specific infill-pattern screening reduced motion-plan completion time by up to 40.1% and extrusion path length by up to 12.7%. The geometry-dependent placement study further showed that different parts, including layer-stack variants of similar geometries, select different orientation–placement pairs under the same objective and evaluation setting. These findings show that robotic AM process planning must be query-specific, part-specific, and robot-aware, and that slicer-side quantities alone are insufficient for selecting a robotic manufacturing plan. By combining LLM-based manufacturing-intent and planning-variable reasoning with schema-constrained orchestration and deterministic tool-based verification, A-RAM provides a reproducible and auditable planning loop. Future work will extend the framework toward richer robot-dynamics metrics, closed-loop extrusion sensing, multi-objective optimization, and broader robotic AM processes. References [1] A. J. Alvares, E. Rodriguez, and B. Figueroa (2025) Digital-twin-enabled process monitoring for a robotic additive manufacturing cell using wire-based laser metal deposition. Processes 13 (8), p. 2335. Cited by: §2.4. [2] R. Badarinath and V. Prabhu (2021) Integration and evaluation of robotic fused filament fabrication system. Additive Manufacturing 41, p. 101951. Cited by: §1, §2.3. [3] E. S. Barjuei, A. Capitanelli, R. Bertolucci, E. Courteille, F. Mastrogiovanni, and M. Maratea (2024) Digital workflow for printability checking and prefabrication in robotic construction 3d printing based on artificial intelligence planning. Engineering Applications of Artificial Intelligence 133, p. 108254. Cited by: §1. [4] S. Ben Amor, N. Elloumi, A. Eltaief, B. Louhichi, N. H. Alrasheedi, and A. Seibi (2024) Digital twin implementation in additive manufacturing: a comprehensive review. Processes 12 (6), p. 1062. Cited by: §2.4. [5] P. M. Bhatt, A. Kulkarni, R. K. Malhan, and S. K. Gupta (2021) Optimizing part placement for improving accuracy of robot-based additive manufacturing. In 2021 IEEE International Conference on Robotics and Automation (ICRA), p. 859–865. Cited by: §1, §1, §2.3. [6] P. M. Bhatt, R. K. Malhan, A. V. Shembekar, Y. J. Yoon, and S. K. Gupta (2020) Expanding capabilities of additive manufacturing through use of robotics technologies: a survey. Additive manufacturing 31, p. 100933. Cited by: §1. [7] P. M. Bhatt, A. Nycz, and S. K. Gupta (2022) Optimizing multi-robot placements for wire arc additive manufacturing. In 2022 International Conference on Robotics and Automation (ICRA), p. 7942–7948. Cited by: §2.3. [8] M. T. Birosz, D. Ledenyák, and M. Andó (2022) Effect of fdm infill patterns on mechanical properties. Polymer Testing 113, p. 107654. Cited by: §1, §2.2. [9] A. Chandrasekhar, J. Chan, F. Ogoke, O. Ajenifujah, and A. Barati Farimani (2024) AMGPT: a large language model for contextual querying in additive manufacturing. Additive Manufacturing Letters 11, p. 100232. External Links: ISSN 2772-3690, Document Cited by: §1, §2.1. [10] C. Chen, K. Zhao, J. Leng, C. Liu, J. Fan, and P. Zheng (2025) Integrating large language model and digital twins in the context of industry 5.0: framework, challenges and opportunities. Robotics and Computer-Integrated Manufacturing 94, p. 102982. External Links: Document Cited by: §2.4. [11] L. Chen, X. Yao, K. Liu, C. Tan, and S. K. Moon (2023) Multisensor fusion-based digital twin in additive manufacturing for in-situ quality monitoring and defect correction. Proceedings of the design society 3, p. 2755–2764. Cited by: §2.4. [12] Y. Chen, T. Zhang, Y. Huang, T. Liu, and C. C. Wang (2025) Co-optimization of tool orientations, kinematic redundancy, and waypoint timing for robot-assisted manufacturing. IEEE Transactions on Automation Science and Engineering. Cited by: §2.3. [13] C. Dai, S. Lefebvre, K. Yu, J. M. P. Geraedts, and C. C. L. Wang (2020) Planning jerk-optimized trajectory with discrete time constraints for redundant robots. IEEE Transactions on Automation Science and Engineering 17 (4), p. 1711–1724. External Links: Document Cited by: §2.3. [14] L. De Bernardez, G. Campana, M. Mele, J. Sanguineti, C. Sandre, and S. M. Mur (2023) Effects of infill patterns on part performances and energy consumption in acrylonitrile butadiene styrene fused filament fabrication via industrial-grade machine. Progress in Additive Manufacturing 8 (2), p. 117–129. Cited by: §1, §2.2. [15] A. Eslaminia, A. Jackson, B. Tian, A. Stern, H. Gordon, R. Malhotra, K. Nahrstedt, and C. Shao (2025) FDM-bench: a domain-specific benchmark for evaluating large language models in additive manufacturing. Manufacturing Letters 44, p. 1415–1424. External Links: Document Cited by: §2.1. [16] N. R. Fry, R. C. Richardson, and J. H. Boyle (2020) Robotic additive manufacturing system for dynamic build orientations. Rapid prototyping journal 26 (4), p. 659–667. Cited by: §1. [17] S. Ghungrad and A. Haghighi (2024) Three-dimensional spatial energy-quality map construction for optimal robot placement in multi-robot additive manufacturing. Robotics and Computer-Integrated Manufacturing 88, p. 102735. Cited by: §1, §2.3. [18] S. Ghungrad, A. Mohammed, and A. Haghighi (2023) Energy-efficient and quality-aware part placement in robotic additive manufacturing. Journal of Manufacturing Systems 68, p. 644–650. External Links: ISSN 0278-6125, Document Cited by: §1, §1, §2.3. [19] X. Han, Z. Zhan, X. Song, and L. Cui (2022) An additive manufacturing direct slicing algorithm based on a step model. Electronics 11 (10), p. 1582. Cited by: §2.2. [20] M. Holland and K. Chaudhari (2024) Large language model based agent for process planning of fiber composite structures. Manufacturing Letters 40, p. 100–103. External Links: ISSN 2213-8463, Document Cited by: §1, §2.1. [21] J. Huang, P. Hu, K. Wu, and M. Zeng (2018) Optimal time-jerk trajectory planning for industrial robots. Mechanism and Machine Theory 121, p. 530–544. Cited by: §1, §2.3. [22] Y. Jadhav, P. Pak, and A. Barati Farimani (2025) LLM-3d print: large language models to monitor and control 3d printing. Additive Manufacturing 114, p. 105027. External Links: ISSN 2214-8604, Document Cited by: §1, §2.1. [23] J. Jiang and Y. Ma (2020) Path planning strategies to optimize accuracy, quality, build time and material use in additive manufacturing: a review. Micromachines 11 (7), p. 633. Cited by: §2.2. [24] Y. Jin, Y. He, J. Fu, W. Gan, and Z. Lin (2014) Optimization of tool-path generation for material extrusion-based additive manufacturing technology. Additive manufacturing 1, p. 32–47. Cited by: §2.2. [25] S. Kim, A. Andreu, I. Kim, J. Kim, J. Lee, and Y. Yoon (2022) Continuously varied infill pattern (convip): improvement of mechanical properties and printing speed of fused filament fabrication (f) 3d printing. Journal of Materials Research and Technology 18, p. 1055–1069. Cited by: §1, §2.2. [26] W. Kritzinger, M. Karner, G. Traar, J. Henjes, and W. Sihn (2018) Digital twin in manufacturing: a categorical literature review and classification. Ifac-PapersOnline 51 (11), p. 1016–1022. Cited by: §2.4. [27] H. Liu, X. Lai, and W. Wu (2013) Time-optimal and jerk-continuous trajectory planning for robot manipulators with kinematic constraints. Robotics and Computer-Integrated Manufacturing 29 (2), p. 309–317. Cited by: §1, §2.3. [28] C. Lubombo and M. A. Huneault (2018) Effect of infill patterns on the mechanical performance of lightweight 3d-printed cellular pla parts. Materials Today Communications 17, p. 214–228. Cited by: §1, §2.2. [29] L. Makatura, M. Foshey, B. Wang, F. HähnLein, P. Ma, B. Deng, M. Tjandrasuwita, A. Spielberg, C. E. Owens, P. Y. Chen, A. Zhao, A. Zhu, W. J. Norton, E. Gu, J. Jacob, Y. Li, A. Schulz, and W. Matusik (2023) How can large language models help humans in design and manufacturing?. arXiv preprint arXiv:2307.14377. External Links: Document Cited by: §2.1. [30] H. Mu, F. He, L. Yuan, P. Commins, D. Ding, and Z. Pan (2024) A digital shadow approach for enhancing process monitoring in wire arc additive manufacturing using sensor fusion. Journal of Industrial Information Integration 40, p. 100609. Cited by: §2.4. [31] P. Nayyeri, K. Zareinia, and H. Bougherara (2022) Planar and nonplanar slicing algorithms for fused deposition modeling technology: a critical review. The International Journal of Advanced Manufacturing Technology 119 (5), p. 2785–2810. Cited by: §2.2. [32] P. Pak, A. Chandrasekhar, and A. Barati Farimani (2026) Agentic additive manufacturing alloy evaluation. Additive Manufacturing Letters 17, p. 100355. External Links: Document Cited by: §2.1. [33] P. Pak and A. B. Farimani (2025) AdditiveLLM: large language models predict defects in metals additive manufacturing. Additive Manufacturing Letters 14, p. 100292. Cited by: §1, §2.1. [34] P. Pak and A. B. Farimani (2026) AdditiveLLM2: a multi-modal large language model for additive manufacturing. arXiv preprint arXiv:2603.22017. Cited by: §1, §2.1. [35] Prusa Research Layers and perimeters. Note: Prusa Knowledge BaseAccessed: August 29, 2026 External Links: Link Cited by: §4.3. [36] S. M. Rachmawati, M. A. P. Putra, J. M. Lee, and D. S. Kim (2023) Digital twin-enabled 3d printer fault detection for smart additive manufacturing. Engineering Applications of Artificial Intelligence 124, p. 106430. Cited by: §1. [37] S. Rescsanski, S. Ghungrad, A. Haghighi, J. Tang, and F. Imani (2026) Constrained motion planning for reduced jerk in robotic additive manufacturing systems. Robotics and Computer-Integrated Manufacturing 101, p. 103311. Cited by: §2.3. [38] S. Rescsanski, R. Hebert, A. Haghighi, J. Tang, and F. Imani (2025) Towards intelligent cooperative robotics in additive manufacturing: past, present, and future. Robotics and Computer-Integrated Manufacturing 93, p. 102925. Cited by: §1. [39] E. U. Samani and C. G. Atkeson (2026) Programming manufacturing robots with imperfect ai: llms as tuning experts for fdm print configuration selection. arXiv preprint arXiv:2603.22118. Cited by: §2.1. [40] A. V. Shembekar, Y. J. Yoon, A. Kanyuck, and S. K. Gupta (2019) Generating robot trajectories for conformal three-dimensional printing using nonplanar layers. Journal of Computing and Information Science in Engineering 19 (3), p. 031011. Cited by: §2.3, §2.3. [41] S. Stradovnik and A. Hace (2024) Workpiece placement optimization for robot machining based on the evaluation of feasible kinematic directional capabilities. Applied Sciences 14 (4), p. 1531. Cited by: §1, §2.3. [42] J. Suteja (2021) Effect of infill pattern, infill density, and infill angle on the printing time and filament length of 3d printing. Jurnal Rekayasa Mesin 12 (1), p. 145–152. Cited by: §1, §2.2. [43] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao (2022) React: synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629. Cited by: §2.1. [44] T. Zhang, X. Chen, G. Fang, Y. Tian, and C. C. L. Wang (2021) Singularity-aware motion planning for multi-axis additive manufacturing. IEEE Robotics and Automation Letters 6 (4), p. 6172–6179. External Links: Document Cited by: §2.3. [45] G. Zhao, G. Ma, J. Feng, and W. Xiao (2018) Nonplanar slicing and path generation methods for robotic additive manufacturing. The International Journal of Advanced Manufacturing Technology 96 (9), p. 3149–3159. Cited by: §2.3.