- Home
- Skills
- Workflow Automation
- Python 3D Printing Automation Architect
More screenshots
Works with the AI Agents you already use
Python 3D Printing Automation Architect
Do not automate uncertainty blindly.
$9.99
Python 3D Printing Automation Architect
Example session with this skill installed
PROJECT
Name
NovaPrint Farm Automation
Objective
Automate model intake, slicing, queue scheduling, printer assignment, monitoring, material tracking, and production logging.
Environment
Small commercial print farm
Printer Count
8
Primary Process
FDM / FFF
PRINTERS
Printer P1
Firmware
Klipper
Integration
Moonraker
Build Volume
250 × 250 × 250 mm
Nozzle
0.4 mm
Materials
PLA
PETG
Enclosure
No
Printer P2
Firmware
Klipper
Integration
Moonraker
Build Volume
250 × 250 × 250 mm
Nozzle
0.4 mm
Materials
PLA
PETG
ABS
ASA
Enclosure
Yes
Printer P3
Firmware
Klipper
Integration
Moonraker
Build Volume
300 × 300 × 300 mm
Nozzle
0.6 mm
Materials
PLA
PETG
Enclosure
No
Printers P4–P8:
Similar mixed configurations.
SLICER
Primary
PrusaSlicer
Automation
Command-line slicing
Production Slicer Version
Must be pinned and logged.
Profiles
Printer Profiles
Material Profiles
Print Profiles
Required Profile States
DRAFT
TESTING
APPROVED
DEPRECATED
Only APPROVED profiles may be used for customer jobs.
MODEL INPUT
Formats
STL
3MF
Source
/incoming/
Each file belongs to a production job.
Need
File stability detection
Hashing
Duplicate detection
Geometry validation
Bounding-box validation
Build-volume check
Do not automatically scale models when units are ambiguous.
MODEL REPAIR
Allowed
Yes
Rule
Never overwrite the original.
Create
*_repaired.stl
QUEUE
Need persistent queue
Yes
Database
PostgreSQL
Priority Levels
HIGH
NORMAL
LOW
Need Due Dates
Yes
Need Printer Capability Matching
Yes
Need Multi-Worker Safe Scheduling
Yes
MATERIAL MANAGEMENT
Need
Spool Inventory
Remaining Weight
Material
Color
Printer Assignment
Material Reservation
Rule
Do not start a job if estimated filament plus 10% reserve exceeds available spool material.
COST ESTIMATION
Need
Material Cost
Estimated Print Time
Machine Time Cost
Electricity
Optional
AUTOMATION LEVEL
Automatically
Detect New Model
Preflight
Slice
Validate G-code
Estimate Material
Select Eligible Printer
Place Job in Queue
Operator Approval Required
First print of every new model revision
After approval
Automatic physical submission allowed.
G-CODE RULES
Validate
Printer Profile
Build Bounds
Maximum Z
Nozzle Temperature
Bed Temperature
Nozzle Diameter
Required Machine Macros
Estimated Material
Estimated Time
If G-code contains unknown critical macros:
BLOCK
PRINTER STATE
Normalized States
OFFLINE
IDLE
PREPARING
PRINTING
PAUSED
COMPLETE
ERROR
MAINTENANCE
UNKNOWN
Rule
UNKNOWN must never be treated as IDLE.
SUBMISSION RELIABILITY
Critical requirement
If Moonraker receives a print-start command but the Python service loses the response:
Do not automatically retry.
Mark
SUBMISSION_UNKNOWN
Then query the printer and reconcile the active job.
MONITORING
Track
Printer State
File
Progress
Elapsed Time
Remaining Time
Nozzle Temperature
Bed Temperature
Webcams
Yes
Camera Behavior
Snapshot at Start
Snapshot Every 10 Minutes
Snapshot on Failure
Snapshot on Completion
VISION
Future feature
Spaghetti detection
Initial policy
MEDIUM confidence
Alert only
HIGH confidence
Alert operator and request review
Do not cancel automatically.
MAINTENANCE
Track
Print Hours
Nozzle Hours
Print Count
Lubrication
Belt Inspection
States
OK
DUE_SOON
DUE
BLOCKED
BLOCKED printers cannot receive jobs.
NOTIFICATIONS
Need
Print Started
Print Complete
Print Failed
Printer Offline
Material Low
Maintenance Due
Queue Blocked
AUDIT
For every job record
Job ID
Part ID
Revision
Source Hash
G-code Hash
Slicer Version
Printer Profile
Material Profile
Print Profile
Printer
Spool
Start Time
Finish Time
Status
Operator
QA Result
SAFETY
Need
Global Scheduler Pause
Per-Printer Disable
No Automatic Cancellation on Communication Loss
No Bypass of Firmware Safety Controls
Physical emergency stop remains independent.
TESTING
Need tests for
Malformed Model
File Still Uploading
Out-of-Bounds Model
Unknown Units
Wrong Nozzle
Wrong Material
High Temperature
Slicer Failure
Slicer Timeout
Printer Offline
Unknown Printer State
Duplicate Job
Submission Timeout
Worker Restart
Spool Shortage
Maintenance Block
G-code Out of Bounds
REQUEST
Design the complete production-grade Python architecture.
Include
Project Structure
Domain Models
Database
Preflight
Slicer Wrapper
Profile Versioning
G-code Validator
Printer Adapter
Moonraker Boundary
Printer Matcher
Queue
Scheduler
Concurrency Control
Material Reservation
Cost Estimator
Monitoring
Camera Workflow
Failure Handling
Retry Policy
Reconciliation
Maintenance
Notifications
Audit Logs
Tests
Deployment Strategy
Safety Controls
Do not invent current Moonraker endpoint details.
Clearly identify any API behavior that requires verification against the installed Moonraker version.
- Read your context and instructions
- Compiled the python 3d printing
=== PYTHON 3D PRINTING AUTOMATION ARCHITECTURE ===
Project
NovaPrint Farm Automation
Environment
8-Printer Commercial FDM Farm
Primary Runtime
Python
Database
PostgreSQL
Slicer
PrusaSlicer
Printer Integration
Klipper / Moonraker
Physical Automation
Operator-approved automatic submission
=== 1. RECOMMENDED SYSTEM ARCHITECTURE ===
incoming/
|
v
File Intake Worker
|
v
Model Preflight
|
v
Model Registry
|
v
Slicer Worker
|
v
G-code Validator
|
v
Cost + Material Estimator
|
v
Printer Capability Matcher
|
v
Operator Approval Gate
|
v
Persistent Job Queue
|
v
Scheduler
|
v
Moonraker Printer Adapter
|
v
Physical Printer
|
v
Monitoring + Reconciliation
|
v
QA + Audit Archive
=== 2. CORE DOMAIN MODELS ===
PrintJob
Fields
job_id
part_id
revision
source_model_id
material
color
quantity
priority
due_date
status
assigned_printer_id
slice_id
approval_id
created_at
updated_at
ModelArtifact
Fields
model_id
job_id
source_path
source_hash
validated_path
validated_hash
file_type
bounds_x
bounds_y
bounds_z
volume
validation_status
SliceArtifact
Fields
slice_id
job_id
gcode_path
gcode_hash
slicer
slicer_version
printer_profile_version
material_profile_version
print_profile_version
estimated_time
estimated_filament_g
validation_status
Printer
Fields
printer_id
name
firmware
adapter_type
build_x
build_y
build_z
nozzle
enclosed
status
maintenance_state
last_seen
Spool
Fields
spool_id
material
color
remaining_weight_g
reserved_weight_g
printer_id
status
Approval
Fields
approval_id
job_id
gcode_hash
approved_by
approved_at
status
=== 3. MODEL INTAKE ===
Monitor
/incoming/
Do not process the file immediately when it first appears.
Required state
FILE_DISCOVERED
→ FILE_STABLE
→ HASHED
→ PREFLIGHT
File Stability Rule
A file is eligible only after size and modification timestamp remain stable for the configured interval.
Alternative
Uploader writes
filename.stl.partial
then atomically renames to:
filename.stl
Failure
File remains unstable.
Result
P3D-027 FILE_INCOMPLETE
=== 4. MODEL IDENTITY ===
Calculate
source_hash
Use it for
Duplicate Detection
Traceability
Slice Cache
Revision Audit
Duplicate key should not rely on filename alone.
=== 5. STL UNIT POLICY ===
STL units are not assumed automatically.
If geometry dimensions are outside expected production ranges:
Result
P3D-003 UNIT_AMBIGUITY
Action
REQUIRES OPERATOR REVIEW
Do not automatically multiply or divide dimensions.
=== 6. MODEL PREFLIGHT ===
Validate
Readable Geometry
Non-Empty Mesh
Finite Coordinates
Bounding Box
Mesh Defects
Disconnected Shells
Degenerate Faces
Build-Volume Feasibility
If repair is required
Create
*_repaired.stl
Preserve original.
=== 7. SLICER PROFILE ARCHITECTURE ===
Production profiles use immutable version IDs.
Example
Printer
klipper_250_04_v8
Material
pla_generic_v6
Print
quality_020_v11
Lifecycle
DRAFT
→ TESTING
→ APPROVED
→ DEPRECATED
Production Rule
Only APPROVED profiles may generate customer production G-code.
=== 8. SLICER INVOCATION ===
Execute PrusaSlicer as an isolated external process.
Requirements
Structured Argument List
No Unsafe Shell Concatenation
Timeout
Exit-Code Validation
Standard Output Capture
Error Capture
Output-File Verification
Slicer CLI flags
REQUIRES VERIFICATION AGAINST INSTALLED PRUSASLICER VERSION
=== 9. SLICER TIMEOUT ===
Configured
max_slice_time
If exceeded
Terminate slicer process safely.
Result
P3D-009 SLICER_TIMEOUT
=== 10. SLICE CACHE ===
Cache key
Source Hash
+
Slicer Version
+
Printer Profile Version
+
Material Profile Version
+
Print Profile Version
+
Override Hash
Reuse only when every component matches.
=== 11. G-CODE VALIDATION ===
Before queue eligibility verify
G-code exists.
G-code is non-empty.
Expected slicer metadata exists.
Expected printer profile matches.
Maximum X fits.
Maximum Y fits.
Maximum Z fits.
Nozzle diameter matches.
Nozzle temperature is permitted.
Bed temperature is permitted.
Required macros are recognized.
Estimated material exists.
Estimated time exists.
Unknown critical macro
BLOCK
Reason
GCODE_UNKNOWN_CRITICAL_MACRO
=== 12. TEMPERATURE POLICY ===
For every printer store
max_nozzle_temp
max_bed_temp
For every material profile store
approved_nozzle_range
approved_bed_range
Requested temperature must satisfy both
Machine Limit
Material Profile Policy
Never bypass Klipper or printer firmware thermal safeguards.
=== 13. PRINTER CAPABILITY MATCHING ===
Job Requirements
Material
Nozzle
Build Volume
Enclosure
Validated Profile
P1:
PLA / PETG
0.4 mm
Open
ABS job
INELIGIBLE
P2:
PLA / PETG / ABS / ASA
0.4 mm
Enclosed
ABS job
ELIGIBLE
P3:
PLA / PETG
0.6 mm
0.4 mm profile:
INELIGIBLE
=== 14. PRINTER STATE MODEL ===
OFFLINE
IDLE
PREPARING
PRINTING
PAUSED
COMPLETE
ERROR
MAINTENANCE
UNKNOWN
Hard Rule
UNKNOWN != IDLE
UNKNOWN printers are removed from scheduling eligibility.
=== 15. MATERIAL RESERVATION ===
Example
Estimated Filament
200 g
Safety Margin
10%
Reservation Required
220 g
Spool Remaining
205 g
Result
P3D-017 MATERIAL_UNAVAILABLE
Do not schedule the physical job.
=== 16. RESERVATION TRANSACTION ===
When a job is assigned
Lock spool record.
Verify availability.
Reserve material.
Commit reservation.
Then reserve printer.
This prevents concurrent workers from oversubscribing the same spool.
=== 17. SCHEDULER ===
Candidate Filter
Printer IDLE
+
Maintenance Not BLOCKED
+
Correct Nozzle
+
Correct Material
+
Build Volume Fits
+
Approved Profile Exists
+
Material Reservation Available
Ranking
Priority
→ Due Date
→ Earliest Finish
→ Material Changeover Cost
→ Maintenance Balance
Compatibility always overrides utilization.
=== 18. CONCURRENCY CONTROL ===
Multiple scheduler workers must not assign the same printer.
Use PostgreSQL transactional locking or equivalent coordination.
Printer assignment must be atomic.
=== 19. JOB RESERVATION ===
Create
reservation_id
job_id
printer_id
expires_at
status
If reservation expires before submission
Reconcile first.
Then either
Renew
or
Release
=== 20. OPERATOR APPROVAL ===
Required
First physical print of every model revision.
Approval binds to
job_id
gcode_hash
profile versions
If G-code changes
APPROVAL INVALIDATED
=== 21. MOONRAKER ADAPTER ===
Normalized operations
health_check
get_state
upload_file
start_print
pause_print
cancel_print
get_job
get_temperatures
get_progress
list_files
get_capabilities
Current exact Moonraker API endpoints and payload semantics:
REQUIRES VERIFICATION AGAINST INSTALLED VERSION
=== 22. PHYSICAL SUBMISSION ===
Before start
Printer
IDLE
Maintenance
Allowed
Material
Confirmed
Reservation
Active
Approval
Valid
G-code
Validated
Kill Switch
Inactive
Then
SUBMITTING
=== 23. SUBMISSION TIMEOUT ===
Scenario
Start request transmitted.
Printer starts.
Python loses response.
Do NOT
Call start again.
Set
SUBMISSION_UNKNOWN
Then
Query Printer State
Query Current Job
Compare Active Filename
Compare Job Metadata
Reconcile
If active job matches
Adopt
PRINTING
If printer state cannot be determined
Keep
SUBMISSION_UNKNOWN
Block new work.
=== 24. MONITORING ===
Monitor
State
Progress
Elapsed Time
Remaining Time
Current File
Nozzle Temperature
Bed Temperature
Last Seen
Camera
Start Snapshot
10-Minute Snapshot
Failure Snapshot
Completion Snapshot
=== 25. COMPUTER-VISION POLICY ===
MEDIUM Confidence Failure
ALERT ONLY
HIGH Confidence Failure
ALERT OPERATOR
REQUEST REVIEW
Automatic Cancel
DISABLED
This keeps probabilistic vision separate from deterministic machine control.
=== 26. NETWORK LOSS ===
If printer connection disappears during PRINTING:
Do not mark job failed automatically.
Set
PRINTER_STATE_UNKNOWN
Continue recovery attempts with bounded retry.
On reconnect
Query active job.
Reconcile.
Resume monitoring.
=== 27. WORKER RESTART RECOVERY ===
On application startup
READY_FOR_PHYSICAL_PRINT = FALSE
Load
SUBMITTING
SUBMISSION_UNKNOWN
PRINTING
PAUSED
For each
Query associated printer.
Match active job.
Restore state.
Only after all critical reconciliation succeeds:
READY_FOR_PHYSICAL_PRINT = TRUE
=== 28. DATABASE ===
PostgreSQL recommended because
Multiple Printers
Multiple Workers
Concurrent Scheduling
Material Reservations
Durable Queue
Core tables
jobs
models
slices
printers
printer_capabilities
materials
spools
reservations
approvals
maintenance
job_events
notifications
=== 29. AUDIT EVENT STREAM ===
Append-only events
JOB_CREATED
MODEL_VALIDATED
SLICE_STARTED
SLICE_COMPLETED
GCODE_VALIDATED
JOB_APPROVED
JOB_QUEUED
PRINTER_ASSIGNED
SUBMISSION_STARTED
PRINT_STARTED
PRINT_PAUSED
PRINT_RESUMED
PRINT_COMPLETED
PRINT_FAILED
QA_PASSED
QA_FAILED
JOB_CANCELLED
=== 30. CORRELATION ID ===
One correlation ID follows
Model
→ Slice
→ Approval
→ Queue
→ Printer
→ QA
=== 31. MAINTENANCE ===
Track
Print Hours
Nozzle Hours
Print Count
Lubrication
Belt Inspection
States
OK
DUE_SOON
DUE
BLOCKED
BLOCKED
Remove printer from scheduler candidate set.
=== 32. GLOBAL SOFTWARE CONTROLS ===
Global Scheduler Pause
Per-Printer Disable
Queue Pause
Behavior
Block New Starts
Keep Monitoring
Preserve Active Print State
Do Not Automatically Cancel Running Prints
Physical Emergency Stop
Independent of automation.
=== 33. NOTIFICATIONS ===
Events
Print Started
Print Complete
Print Failed
Printer Offline
Material Low
Maintenance Due
Queue Blocked
Submission Unknown
Severity
INFO
WARNING
HIGH
CRITICAL
Use deduplication and cooldown to prevent notification storms.
=== 34. ERROR TAXONOMY ===
P3D-001 MODEL_UNREADABLE
P3D-002 MODEL_EMPTY
P3D-003 UNIT_AMBIGUITY
P3D-004 MODEL_OUT_OF_BOUNDS
P3D-005 MESH_INVALID
P3D-006 PROFILE_MISSING
P3D-007 PROFILE_NOT_APPROVED
P3D-008 SLICER_NOT_FOUND
P3D-009 SLICER_TIMEOUT
P3D-010 SLICER_ERROR
P3D-011 GCODE_INVALID
P3D-012 GCODE_OUT_OF_BOUNDS
P3D-013 TEMPERATURE_POLICY
P3D-014 PRINTER_INCOMPATIBLE
P3D-015 PRINTER_OFFLINE
P3D-016 PRINTER_STATE_UNKNOWN
P3D-017 MATERIAL_UNAVAILABLE
P3D-018 NOZZLE_MISMATCH
P3D-019 MAINTENANCE_BLOCK
P3D-020 APPROVAL_REQUIRED
P3D-021 SUBMISSION_UNKNOWN
P3D-022 PRINT_FAILED
P3D-023 PRINTER_API_ERROR
P3D-024 STORAGE_LOW
P3D-025 DUPLICATE_JOB
P3D-026 CONFIG_INVALID
P3D-027 FILE_INCOMPLETE
P3D-028 CAMERA_UNAVAILABLE
P3D-029 QUEUE_CONFLICT
P3D-030 INTERNAL_ERROR
=== 35. TEST PLAN ===
UNIT
Geometry Bounds
Profile Matching
Nozzle Matching
Material Reservation
State Transitions
Cost Calculation
Path Validation
INTEGRATION
PostgreSQL
PrusaSlicer
Moonraker Adapter
Printer State
File Upload
Queue
FAILURE INJECTION
Slicer Timeout
Printer Offline
API Timeout
Database Restart
Worker Restart
Spool Shortage
Lost Submission Response
=== 36. DUPLICATE JOB TEST ===
Submit identical
job_id
model_hash
configuration
twice.
Expected
One logical production job.
Second request
DUPLICATE
No second physical start.
=== 37. UNKNOWN SUBMISSION TEST ===
Simulate
Printer starts job.
Python loses response.
Expected
P3D-021 SUBMISSION_UNKNOWN
Reconciliation finds active print.
Final
PRINTING
No duplicate start.
=== 38. WRONG-NOZZLE TEST ===
Profile
0.4 mm
Printer
0.6 mm
Expected
P3D-018 NOZZLE_MISMATCH
=== 39. HIGH-TEMPERATURE TEST ===
G-code
300°C
Printer approved maximum
285°C
Expected
P3D-013 TEMPERATURE_POLICY
=== 40. MAINTENANCE TEST ===
Printer
BLOCKED
Expected
Never assigned.
=== 41. MATERIAL TEST ===
Required
220 g
Available
205 g
Expected
P3D-017 MATERIAL_UNAVAILABLE
=== 42. WORKER-RESTART TEST ===
Restart during active print.
Expected
No restart of physical job.
Printer state reconciled.
Monitoring restored.
=== 43. DEPLOYMENT PHASES ===
Phase 1:
Read-Only Printer Monitoring
Phase 2:
Automated Model Validation + Slicing
Phase 3:
Automated Queue Recommendations
Phase 4:
Operator-Approved Physical Submission
Phase 5:
Controlled Automatic Submission
=== 44. FINAL ARCHITECTURE RECOMMENDATION ===
Use
Python
+
PostgreSQL
+
Versioned Profiles
+
Safe Slicer Worker
+
G-code Validation
+
Printer Capability Registry
+
Transactional Scheduler
+
Material Reservations
+
Moonraker Adapter
+
Reconciliation
+
Monitoring
+
Audit Events
Highest-priority reliability controls
- UNKNOWN printer state is never treated as IDLE.
- G-code must be validated against the selected machine.
- Production profiles must be versioned and approved.
- Material must be reserved before assignment.
- Printer assignment must be transactional.
- Physical approval must bind to the G-code hash.
- Ambiguous print-start timeouts require reconciliation.
- Worker restart requires physical-state reconciliation.
- Maintenance blocks must be enforced.
- Firmware safety controls must never be bypassed.
FINAL STATUS
ARCHITECTURE READY FOR STAGED IMPLEMENTATION
VERSION-SPECIFIC ITEMS REQUIRING VERIFICATION:
PrusaSlicer CLI Flags
Moonraker Endpoints
Moonraker Authentication
Moonraker Job-State Fields
Printer-Specific Klipper Macros
Installed Firmware Capabilities
Connects securely to your tools. The creator never sees your data.
About this skill
Python 3D Printing Automation Architect is a premium engineering agent for designing, auditing, and implementing robust Python-based automation around additive-manufacturing and 3D-printing workflows.
It is designed for
Print-Farm Operators Makers Engineering Teams Prototyping Laboratories Small-Batch Manufacturers Etsy Sellers Service Bureaus Education Labs Hardware Startups Product-Development Teams Automation Consultants Advanced Hobbyists Internal Manufacturing Teams
The agent can automate the complete lifecycle from a digital model to a controlled production job.
Its canonical workflow is
Model Intake
- Validation
- Metadata Extraction
- Repair / Preflight
- Slicer Selection
- Profile Resolution
- Slicing
- G-code Validation
- Cost / Time Estimation
- Printer Selection
- Queue Assignment
- Operator Approval
- Printer Submission
- Print Monitoring
- Failure Handling
- Completion Verification
- Audit Logging
- QA
- Post-Processing
The agent treats 3D printing as a production system rather than simply:
"Send this file to the printer."
It distinguishes
Source Model Validated Model Repaired Model Slicer Version Printer Profile Material Profile Print Profile Generated G-code Selected Printer Selected Material Estimated Resources Job Authorization Printer Availability Submission State Physical Print State Completion State QA State
This separation is important because the same source model can produce materially different output depending on:
Printer Nozzle Material Slicer Profile Orientation Support Strategy Temperature Layer Height Firmware Machine Macros
The agent can work with
Stl
3MF
Obj
Amf
G-code
Json
Yaml
Csv
SQLite Images Printer Profiles Slicer Configuration Files Production Logs
It can design Python workflows for
Automated File Intake Folder Watching Batch Processing Model Hashing Duplicate Detection Mesh Validation Bounding-Box Analysis Build-Volume Validation Geometry Repair Model Metadata Extraction Automated Slicing G-code Preflight Printer Assignment Queue Scheduling Material Inventory Spool Reservation Cost Calculation Time Estimation Printer API Integration Webcam Monitoring Notifications Failure Recovery Maintenance Tracking Production Traceability
A core principle is
Automate repetitive work.
Do not automate uncertainty blindly.
Before slicing, the agent can validate
File Readability Non-Empty Geometry Bounding Box Build-Volume Fit Mesh Manifoldness Inverted Normals Disconnected Shells Degenerate Faces Zero-Area Faces Non-Finite Coordinates Extreme Scale Duplicate Geometry Polygon Count Unit Ambiguity
STL files are handled carefully because STL does not reliably encode units.
If dimensions appear implausible, the agent should not silently assume:
Millimeters Inches 25.4× Conversion
Instead, it should report
Unit ambiguity
and require a defined workflow rule or operator confirmation.
Build-volume compatibility is a hard preflight check.
Example
Model
230 × 210 × 260 mm
Printer
220 × 220 × 250 mm
Result
Model out of bounds
The job should not be assigned to that printer unless the model is intentionally reoriented, scaled, or otherwise modified under an authorized process.
The agent can inspect or automate model repair.
Possible workflow
Original
part.stl
Repaired
part_repaired.stl
The original source should not be overwritten automatically.
Python-side geometry tooling can include approved libraries such as:
trimesh numpy Mesh-Processing Libraries External Mesh Utilities
The agent can design slicer automation around
PrusaSlicer CuraEngine SuperSlicer-Compatible Workflows OrcaSlicer-Related CLI Workflows Where Supported Other Command-Line Slicers
Exact command-line flags must be verified against the installed slicer version before production deployment.
The slicing architecture separates
Model Printer Profile Material Profile Print Profile Slicer Version
This makes jobs reproducible.
Example profile architecture
Printer Profile
voron_24_04mm_v3
Material Profile
pla_generic_v5
Print Profile
quality_020_v7
Profiles should be
Versioned Traceable Approved Immutable for Production Use
The agent can maintain profile lifecycle states
Draft
Testing
Approved
Deprecated
Only APPROVED profiles should normally be used for production jobs.
The agent can generate a complete profile-promotion workflow:
Profile Change
- Calibration Print
- QA
- Approval
- Production Promotion
Every production job should record
Slicer Name Slicer Version Printer Profile Version Material Profile Version Print Profile Version
This protects against silent configuration drift.
The agent can design safe slicer invocation in Python.
External processes should be called using structured argument arrays rather than unsafe string concatenation.
The architecture can use subprocess execution with
Exit-Code Validation Timeout Captured Output Captured Errors Output-File Verification
Slicer failures can be normalized as
Input_invalid
Profile_missing
Slicer_not_found
Slicer_timeout
Slicer_error
Output_missing
Gcode_invalid
Unsupported_configuration
The agent can design slice caching.
A cache key may include
Source Model Hash Slicer Version Printer Profile Version Material Profile Version Print Profile Version Override Hash
This means identical validated configurations do not need to be sliced repeatedly.
However, cached G-code should only be reused if
Model Identity Matches Profile Versions Match Slicer Version Matches Machine Compatibility Matches Authorization Remains Valid
The agent performs G-code preflight before physical submission.
Checks can include
File Exists File Is Non-Empty Expected Printer Expected Slicer Metadata Build Bounds Maximum X Maximum Y Maximum Z Nozzle Temperature Bed Temperature Layer Height Filament Usage Estimated Print Time Tool Count Extruder Usage Start Sequence End Sequence Unexpected Commands Machine-Specific Macros
The agent treats G-code as machine-specific.
G-code produced for one printer should not automatically be assumed compatible with another.
Differences can include
Build Volume Firmware Printer Macros Coordinate System Toolhead Geometry Nozzle Diameter Temperature Limits Acceleration Limits Bed Mesh Extruder Count Start / End Procedures
Temperature validation is treated as a machine-safety gate.
If requested nozzle or bed temperature exceeds the approved machine limits:
Block
The automation must never bypass
Firmware Thermal Runaway Protection Manufacturer Temperature Limits Hardware Safety Controls
The agent can maintain a printer capability model.
Each printer record may contain
Printer ID Model Firmware API Type Build X Build Y Build Z Extruder Count Nozzle Diameter Approved Materials Maximum Nozzle Temperature Maximum Bed Temperature Enclosure Heated Chamber Camera Maintenance State Connection State
Printer states can be normalized as
Offline
Idle
Preparing
Printing
Paused
Complete
Error
Maintenance
Unknown
A critical rule is
Unknown is not idle
If the automation cannot establish printer state, it should not submit another job.
The agent can build intelligent printer matching.
A print job may require
Minimum Build Volume Specific Material Specific Nozzle Enclosure Heated Chamber Printer Quality Level Firmware Capability Validated Profile
Only compatible printers should become scheduling candidates.
Example
Job
Material
Abs
Required Nozzle
0.4 mm
Enclosure
Required
Printer A
Open frame
Result
Not eligible
Printer B
Enclosed 0.4 mm nozzle Validated ABS profile
Result
Eligible
The agent can design print-farm schedulers.
Scheduling inputs may include
Priority Due Date Estimated Duration Printer Availability Material Color Nozzle Maintenance Status Current Queue Machine Eligibility Operator Constraints
Possible scheduling objectives include
Earliest Due Date Shortest Completion Time Printer Utilization Material Grouping Color Grouping Reduced Changeovers Maintenance Balancing
The agent never optimizes utilization at the expense of machine compatibility.
Queue states can include
Created
Preflight
Ready_to_slice
Slicing
Slice_failed
Ready_for_approval
Approved
Queued
Submitting
Submitted
Printing
Paused
Complete
Failed
Cancelled
Requires_review
A production job can follow
Created
- PREFLIGHT
- SLICING
- READY_FOR_APPROVAL
- APPROVED
- QUEUED
- SUBMITTING
- PRINTING
- COMPLETE
- QA
Alternative paths include
Preflight
- REQUIRES_REVIEW
Slicing
- SLICE_FAILED
Submitting
- UNKNOWN_SUBMISSION
- RECONCILIATION
Printing
- FAILED
The agent handles duplicate-print protection.
A dangerous scenario is
Python sends a print-start request.
The printer receives it.
The network response is lost.
The middleware sees a timeout.
A weak implementation may immediately send another print-start command.
This can create duplicate work or state confusion.
The correct architecture is
Mark
Submission_unknown
Then
Query Printer Check Active Job Check Active File Check Printer State Reconcile
Only after the system establishes the real machine state should any resubmission be considered.
This principle is similar to idempotent order processing in distributed systems.
The skill supports OctoPrint architecture.
Possible normalized operations include
Health Check Connection State File Upload File Selection Print Start Pause Cancel Job Status Temperatures Progress
Current OctoPrint endpoints, authentication, and payload formats should be verified against official documentation before production use.
The skill supports Klipper / Moonraker architecture.
Possible operations include
Printer State G-code File Management Print Start Pause Cancel Temperature Monitoring Macros Job Metadata Webcam Integration
Current Moonraker behavior should be verified against the installed version.
The agent can define a generic printer-adapter interface.
Possible methods
health_check get_state upload_file start_print pause_print cancel_print get_job get_temperatures get_progress list_files delete_file get_capabilities
Each adapter should declare capabilities such as
Supports Upload Supports Start Supports Pause Supports Cancel Supports Progress Supports Temperature Supports Camera Supports Event Stream Supports Macros Supports File Delete
Unknown capabilities should not be assumed.
The agent keeps
Code Configuration Secrets
separate.
Printer API tokens should not be stored in
Source Code G-code Model Files Logs Public Configuration
Configuration can be stored in
Yaml
Json
Toml
Database Records
Sensitive credentials should use a suitable secrets mechanism.
The agent validates configuration during startup.
The automation should fail fast when critical configuration is invalid.
Examples
Missing Printer URL Unknown Machine ID Invalid Build Volume Missing Profile Unknown Material Rule Missing Printer Adapter
The skill supports
Dry run
and
Simulation
Dry Run can
Validate Model Resolve Printer Generate Slicer Command Slice Audit G-code Calculate Cost Calculate Material Stop Before Physical Submission
Simulation can use fake printer adapters to test
Scheduling Queue State Retries Restart Recovery Failure Handling Notifications
Physical printing should be treated as an explicit operational mode.
Possible requirements before physical submission
Printer Registered Printer Healthy Correct Profile Material Confirmed G-code Validated Approval Present Monitoring Healthy Machine Safety Controls Available
The agent can design operator-approval gates.
Approval can be required for
New Model New Material New Profile New Printer Profile Long Print High-Temperature Print Overnight Print Large Batch Safety-Sensitive Part
Approval records may include
Approval ID Job ID Operator Timestamp Profile Versions G-code Hash
Approval should bind to the exact G-code.
If the G-code changes
Approval should expire.
Material automation is a major capability.
A material profile can contain
Material Brand Color Density Nozzle Temperature Range Bed Temperature Range Enclosure Requirement Drying Requirement Cost per Kilogram Spool ID
The agent can estimate filament mass from length and density where sufficient data exists.
Material cost can be calculated from
Filament Mass Spool Cost
Machine cost can optionally use
Estimated Print Hours Configured Machine-Hour Rate
Energy estimation can use
Average Power Duration Electricity Rate
These values should be labeled as estimates.
The agent can manage spool inventory.
A spool record may contain
Spool ID Material Brand Color Initial Weight Remaining Weight Reserved Weight Printer Assignment
Before queueing a job
Reserve Expected Filament + Configured Safety Margin
If remaining filament is insufficient
Material_unavailable
The agent can release reservations after
Cancellation Failed Slice Reassignment
After successful printing, estimated usage can be replaced with actual usage when available.
The agent can detect nozzle mismatch.
Example
G-code Profile
0.4 mm
Printer
0.6 mm
Result
Nozzle_mismatch
unless the profile explicitly supports that machine configuration.
The agent can automate maintenance tracking.
Possible counters
Print Hours Print Count Filament Throughput Nozzle Hours Belt Inspection Lubrication Filter Replacement Enclosure Inspection
Maintenance states
OK
Due_soon
Due
Blocked
If maintenance is BLOCKED
Do Not Schedule New Production Jobs
The skill supports health monitoring.
Possible checks
Printer Online Firmware Responsive No Active Fault Temperatures Plausible Storage Available Queue Service Healthy Maintenance Allowed
Temperature sensor values should be sanity checked.
An implausible sensor value may indicate a disconnected or failed sensor.
In that condition
Block new print
Require review
The agent can monitor
Print Progress Elapsed Time Remaining Estimate Nozzle Temperature Bed Temperature Printer State Current File Layer Pause State Errors Camera Snapshots
Event-driven updates can be used where supported.
Periodic reconciliation is still recommended because event streams can disconnect.
The agent can integrate webcams for
Start Snapshot Periodic Snapshot Failure Snapshot Completion Image Time-Lapse
Camera-based failure detection can detect patterns such as
Spaghetti Part Detachment Severe Warping Empty Build Plate Possible Nozzle Problems
Computer-vision results are probabilistic.
A medium-confidence visual anomaly should not automatically cancel a physical print unless operator policy explicitly authorizes that action.
Possible failure policies include
Alert only
Pause
Cancel
Require operator review
The exact response should be configured.
The automation should never imply that a webcam replaces
Smoke Detection Fire Prevention Electrical Safety Physical Supervision Requirements
Physical emergency-stop controls must remain independent from software automation.
Network failures are handled carefully.
If communication is lost during an active print
Do Not Assume the Printer Stopped
Many printers can continue independently.
After reconnect
Query Printer Recover Active State Restore Monitoring Reconcile Job
The same principle applies to application restarts.
On Python worker restart
Disable New Submissions
- Load Incomplete Jobs
- Query Printer State
- Match Active Print
- Reconcile
- Restore Monitoring
- Re-Enable Scheduler
Critical queue state should not exist only in process memory.
For small installations, the agent can recommend
SQLite
For larger farms
PostgreSQL or another transactional database
Typical tables include
jobs models slices printers printer_capabilities materials spools job_events approvals maintenance notifications
The agent can use append-only event logging.
Possible lifecycle events
Job_created
Model_validated
Slice_started
Slice_completed
Gcode_validated
Job_approved
Job_queued
Printer_assigned
Submission_started
Print_started
Print_paused
Print_resumed
Print_completed
Print_failed
Job_cancelled
A production audit record can include
Event ID Job ID Printer ID Part ID Revision Model Hash G-code Hash Slicer Slicer Version Profile Versions Material Spool ID Action Status Timestamp Operator Reason Software Version
Structured logs are preferred.
Sensitive API credentials must be redacted.
The agent can maintain one correlation ID across
Model Intake Slicing Queue Printer Assignment Physical Print QA
Notifications can be integrated with authorized systems such as:
Email Slack Discord Telegram Push Notifications Desktop Notifications
Useful notification events include
Job Ready for Approval Print Started Print Completed Print Failed Printer Offline Low Spool Maintenance Due Queue Blocked
Notification systems should use
Severity Debounce Grouping Cooldown
to avoid excessive alerts.
Retry architecture distinguishes safer operations from physical control operations.
Safer retries may include
Status Query Metadata Query Database Query Camera Snapshot
Potentially unsafe retries include
Start Print Cancel Print Execute Macro Change Heater State Delete File
These require explicit state and reconciliation.
Retries must be bounded.
Possible configuration
Maximum Attempts Timeout Backoff Jitter Retryable Errors
The skill can design circuit breakers.
When a printer API repeatedly fails
Open circuit
Block new jobs
Keep queue
Notify operator
Circuit states
Closed
Open
Half_open
The agent can prevent multi-worker scheduling conflicts.
Possible controls include
Database Transactions Row Locks Advisory Locks Leader Process Job Reservations
A reservation record can contain
Reservation ID Job ID Printer ID Expiration Status
If the reservation expires before submission
Release or Reconcile
The agent supports priority scheduling.
Possible priorities
Critical
High
Normal
Low
The scheduler should avoid starvation.
It can also use due-date-aware scheduling.
Batch printing can track
Plate Part IDs Quantity Expected Output Count
If one plate fails, both
Batch-Level Impact
and
Part-Level Impact
should be recorded.
Automatic part nesting can be supported, but spacing, cooling, adhesion, collision, and toolhead clearance matter.
Sequential printing should never be enabled automatically unless machine-clearance constraints have been validated.
The skill understands that orientation affects mechanical properties.
For functional parts, orientation can change
Layer Adhesion Tensile Strength Bending Resistance Impact Resistance Surface Quality Support Requirements
The agent should not optimize orientation only for fastest printing.
Dimensional-compensation settings can also be versioned.
Examples
Shrink Compensation Elephant-Foot Compensation Hole Compensation XY Compensation
The agent can automate calibration workflows.
Possible tests
Calibration Cube Temperature Tower Flow Test Pressure Advance Resonance Test
Automatic acceptance criteria should come from user-defined QA policy.
Calibration results can be stored by
Printer Material Nozzle Test Type Result Approved Setting Date
The agent separates
Print complete
from
Qa pass
A printer reporting completion means the machine finished the job.
It does not guarantee
Dimensional Accuracy Surface Quality Mechanical Integrity Correct Material Correct Quantity
QA states can include
Pass
Fail
Rework
Review
Post-processing workflows can be added for
Support Removal Washing Curing Sanding Annealing Painting Assembly Inspection Packing
The agent can adapt architecture for
Fdm / fff
Sla / msla
Resin Industrial Additive Systems
Resin workflows require additional consideration for
Ppe
Ventilation Exposure Wash Cure Waste Handling
The agent should not apply FDM assumptions blindly to resin systems.
Industrial or proprietary printers may expose vendor-specific APIs or workflow constraints.
The preferred integration order is
Official API Official SDK Supported File Workflow Operator-Assisted Process
The agent should not reverse-engineer protected private interfaces without authorization.
A simple local workflow can use folder watching
incoming/
- Python detects file
- waits for file completion
- validates
- slices
- moves result to ready/
The agent must detect incomplete file writes.
Possible techniques
Stable File Size Atomic Rename .partial Suffix
A half-written STL should not be processed.
Possible folder lifecycle
incoming/ validated/ sliced/ ready/ printing/ complete/ failed/ archive/
The agent can use atomic filesystem moves for state transitions where appropriate.
Naming conventions can include
Job ID Part ID Revision Material Profile
Sensitive customer information should not be unnecessarily embedded in filenames.
Path traversal must be prevented.
Untrusted filenames should not escape the configured workspace.
The agent can implement storage guards.
Before slicing
Check Local Disk Space
Before uploading
Check Printer Storage
Old printer files should only be removed using an explicit retention policy.
The agent can expose system health.
Possible health indicators
service_alive database_ok slicer_ok printer_adapters scheduler_ok
It distinguishes
Service alive
from
Ready for physical print
A worker can be running while printer state is unsafe.
Print-farm operational metrics can include
Jobs Created Jobs Completed Jobs Failed Slice Failures G-code Rejections Printer Offline Events Printer Errors Queue Depth Average Wait Time Printer Utilization Filament Used Maintenance Due
Printer reliability metrics can include
Success Rate Failure Rate Average Job Duration Utilization Maintenance Frequency Mean Time Between Failures
Failure attribution can classify
Model
Slicing
Material
Printer
Adhesion
Operator
Network
Api
Unknown
The agent does not automatically assume "printer failure" whenever a job fails.
For multi-customer farms, architecture can isolate
Customers Jobs Files Permissions Billing Audit Trails
The skill includes security controls such as
Authentication Authorization Least Privilege API Token Protection Network Segmentation Safe File Handling Path Validation Log Redaction
Printer controllers should generally not be directly exposed to the public internet without appropriate protection.
Possible secure architectures include
Private Network
Vpn
Authenticated Reverse Proxy Controlled Gateway
The agent can design
Web Dashboards REST Services CLI Tools Background Workers Schedulers Monitoring Services
Possible CLI commands
jobs list jobs submit jobs approve jobs cancel printers status printers reconcile spools list maintenance due
Python concurrency can use
asyncio Thread Pools Process Pools Task Queues
depending on workload.
Network I/O is a good fit for asynchronous processing.
Slicer processes and heavy geometry work should not block an asynchronous event loop.
The agent can create domain-specific exception categories such as:
ModelValidationError SlicerError GCodeValidationError PrinterUnavailableError SubmissionUnknownError MaterialUnavailableError ApprovalRequiredError
It also supports a detailed error taxonomy
P3d-001 model_unreadable
P3d-002 model_empty
P3d-003 unit_ambiguity
P3d-004 model_out_of_bounds
P3d-005 mesh_invalid
P3d-006 profile_missing
P3d-007 profile_not_approved
P3d-008 slicer_not_found
P3d-009 slicer_timeout
P3d-010 slicer_error
P3d-011 gcode_invalid
P3d-012 gcode_out_of_bounds
P3d-013 temperature_policy
P3d-014 printer_incompatible
P3d-015 printer_offline
P3d-016 printer_state_unknown
P3d-017 material_unavailable
P3d-018 nozzle_mismatch
P3d-019 maintenance_block
P3d-020 approval_required
P3d-021 submission_unknown
P3d-022 print_failed
P3d-023 printer_api_error
P3d-024 storage_low
P3d-025 duplicate_job
P3d-026 config_invalid
P3d-027 file_incomplete
P3d-028 camera_unavailable
P3d-029 queue_conflict
P3d-030 internal_error
Testing can include
Unit Tests Integration Tests Simulation Failure Injection Physical Validation
Important failure scenarios include
Printer Offline API Timeout Slicer Timeout Malformed Model Full Disk Failed Upload Lost Start Response Worker Restart Spool Shortage Maintenance Block Wrong Nozzle Wrong Material Out-of-Bounds G-code Excess Temperature Unknown Printer State
A strong duplicate-start test should verify
Same Job ID Same Model Same Configuration
does not produce multiple physical job starts.
A restart test should verify that an active physical print is discovered and monitored rather than restarted.
The agent can design a global submission kill switch, per-printer stop, and scheduler pause.
The software kill switch should generally
Block New Print Starts Keep Monitoring Active Allow Status Queries Preserve Current Job State
Active prints should not automatically be cancelled unless the operator's policy explicitly requires it.
Physical emergency-stop mechanisms remain independent.
The skill can build complete production traceability.
For each printed part
Part ID Revision Printer Material Spool G-code Hash Profile Versions Start Time Finish Time Operator QA Result
can be recorded.
Reprints should also be controlled.
Recommended workflow
Failure
- Review
- Root Cause
- Reprint Authorization
Automatic reprint loops must be bounded.
Long or overnight prints may require additional operator-defined controls such as:
Approved Printer Material Sufficiency Maintenance Health Monitoring Camera Remote Notifications Physical Safety Procedures
The skill supports gradual rollout.
Recommended migration for an existing manual print farm
Phase 1
Read-Only Monitoring
Phase 2
Automated Slicing
Phase 3
Automated Queue Recommendations
Phase 4
Operator-Approved Submission
Phase 5
Controlled Automatic Submission
Recommended production progression
Simulation
- Dry Run
- Single Printer
- Operator Approval
- Limited Farm
- Full Farm
This staged deployment reduces automation risk while preserving traceability and operator control.
3D-printing hardware, slicers, firmware, and APIs vary substantially between ecosystems.
A workflow validated for one printer may not be safe or correct for another.
G-code is often machine-specific.
Differences can include:
Build Volume
Firmware
Nozzle Diameter
Extruder Configuration
Machine Macros
Temperature Limits
Acceleration
Coordinate Systems
Bed Mesh
Toolhead Geometry
STL files can contain unit ambiguity.
Automatic scale correction may therefore be unsafe without additional context.
Mesh-validation libraries do not always identify every manufacturability problem.
A technically valid mesh can still print poorly because of:
Orientation
Supports
Bridging
Overhangs
Adhesion
Cooling
Material Behavior
Mechanical Design
Slicer estimates are approximate.
Actual:
Print Time
Material Usage
Energy
Cost
may differ from calculated estimates.
Printer APIs can fail while the physical printer continues operating.
A network timeout must therefore not automatically be interpreted as job failure.
Camera-based failure detection can produce:
False Positives
False Negatives
and should be treated as probabilistic.
Print completion does not prove:
Dimensional Accuracy
Mechanical Strength
Surface Quality
Correct Material
Correct Quantity
QA remains a separate production stage.
Material inventory can become inaccurate when:
Spools Are Manually Moved
Material Is Used Outside the Automation
Actual Extrusion Differs from Estimates
Spool Weight Is Incorrect
Periodic reconciliation may be required.
Slicer CLI behavior and API interfaces can change across versions.
Version-specific implementation should therefore be verified before deployment.
Automatic orientation and nesting can change:
Mechanical Strength
Surface Quality
Support Requirements
Collision Risk
and should not be optimized solely for print speed.
Physical 3D printing involves:
Hot Surfaces
Electrical Systems
Moving Machinery
Potential Fumes
Fire Risk
Mechanical Collisions
Software automation cannot eliminate these risks.
Firmware protections, manufacturer limits, physical emergency controls, and appropriate operating procedures remain necessary.
Resin printing introduces additional chemical-handling and post-processing requirements.
Industrial additive-manufacturing systems may use proprietary workflows that cannot be treated like consumer FDM printers.
The skill improves automation architecture, repeatability, traceability, and failure handling.
It does not guarantee successful prints, physical safety, dimensional accuracy, or production yield.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 2 months ago
Permissions
File Scopes
Use Read Files to inspect authorized STL/3MF/OBJ models, G-code, Python source code, printer configurations, slicer profiles, material profiles, queue data, OctoPrint or Moonraker integration code, printer logs, maintenance history, material inventory, QA results, and existing automation architecture. Use Write Files only when the user requests creation or updating of derived artifacts such as: Python Automation Scripts Printer Adapters Queue Workers Scheduler Modules Slicer Wrappers Model Preflight Tools G-code Validators Material Inventory Systems Spool Tracking Tools Maintenance Trackers Configuration Files REST Services CLI Utilities Monitoring Components Audit Reports Test Suites Architecture Documentation Use Browser when current authoritative public documentation is needed and authorized. For version-specific implementation, prioritize: Official OctoPrint Documentation Official Moonraker Documentation Official Klipper Documentation Official Slicer Documentation Official Printer Vendor Documentation Do not invent: Current API Endpoints Current Authentication Flows Current Slicer CLI Flags Current Printer Capabilities Current Firmware Macros Current Rate Limits Current Vendor-Specific File Formats when those details are version-dependent. Always distinguish: VERIFIED PRINTER CAPABILITY Confirmed by configuration, documentation, or supplied data. USER-SUPPLIED MACHINE CONFIGURATION Provided by the user. DERIVED MODEL METADATA Calculated from model geometry. DERIVED G-CODE METADATA Calculated from G-code. CONFIGURED POLICY A user-defined safety or workflow rule. ASSUMPTION An explicitly disclosed assumption. UNKNOWN A value that cannot currently be established. REQUIRES PRINTER VERIFICATION A machine-specific capability that must be confirmed. Critical operational rules: UNKNOWN printer state is not IDLE. A timeout does not prove that a physical print did not start. Do not blindly retry print-start commands after an ambiguous response. Reconcile the physical printer first. Do not send unvalidated G-code to a printer. Do not assume STL units. Do not silently rescale ambiguous models. Do not send G-code to a printer with incompatible: Build Volume Nozzle Material Firmware Temperature Limits Profile Do not bypass: Firmware Thermal Protection Hardware Limits Manufacturer Safety Controls Keep: Code Configuration Secrets separate. Do not put printer API tokens in: Source Code G-code Model Files Public Configuration Logs Production profiles should be versioned. Profile changes should create a new revision rather than silently mutating historical configuration. Physical job approvals should bind to the exact G-code hash whenever possible. If G-code changes after approval, require re-approval. A printer reporting COMPLETE does not mean the part passed QA. Separate: PRINT COMPLETE from: QA PASS Camera-based failure detection is probabilistic. Do not automatically cancel physical jobs from low-confidence computer-vision alerts unless an explicit operator policy authorizes that behavior. A webcam is a monitoring aid. It is not a replacement for physical machine, electrical, thermal, or fire-safety controls. On worker restart or printer reconnect: Reconcile Before Scheduling New Physical Work. Never keep critical production queue state only in volatile process memory. Use bounded retries. Never use infinite retry loops for physical-control operations. This skill is intended for legitimate additive-manufacturing workflows and should not be used to automate illegal weapon manufacturing.