More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Python 3D Printing Automation Architect

    1

    Do not automate uncertainty blindly.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Python 3D Printing Automation Architect

    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

    1. UNKNOWN printer state is never treated as IDLE.
    2. G-code must be validated against the selected machine.
    3. Production profiles must be versioned and approved.
    4. Material must be reserved before assignment.
    5. Printer assignment must be transactional.
    6. Physical approval must bind to the G-code hash.
    7. Ambiguous print-start timeouts require reconciliation.
    8. Worker restart requires physical-state reconciliation.
    9. Maintenance blocks must be enforced.
    10. 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.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Workflow Automation.

    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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    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

    Read Files
    Browser
    Write Files

    File Scopes

    **/*.py
    **/*.pyi
    **/*.toml
    **/*.ini
    **/*.cfg
    **/*.conf
    **/*.json
    **/*.jsonl
    **/*.yaml
    **/*.yml
    **/*.xml
    **/*.csv
    **/*.tsv
    **/*.md
    **/*.txt
    **/*.log
    **/*.db
    **/*.sqlite
    **/*.sqlite3
    **/*.stl
    **/*.3mf
    **/*.obj
    **/*.amf
    **/*.gcode
    **/*.gc
    **/*.gco
    **/*.svg
    **/*.png
    **/*.jpg
    **/*.jpeg
    **/*.webp
    **/3d-printing/**
    **/printing/**
    **/print/**
    **/printers/**
    **/printer/**
    **/print-farm/**
    **/printer-farm/**
    **/farm/**
    **/additive-manufacturing/**
    **/manufacturing/**
    **/models/**
    **/meshes/**
    **/geometry/**
    **/stl/**
    **/3mf/**
    **/gcode/**
    **/g-code/**
    **/slicer/**
    **/slicing/**
    **/prusaslicer/**
    **/cura/**
    **/curaengine/**
    **/superslicer/**
    **/orcaslicer/**
    **/octoprint/**
    **/klipper/**
    **/moonraker/**
    **/firmware/**
    **/printer-api/**
    **/adapters/**
    **/profiles/**
    **/printer-profiles/**
    **/material-profiles/**
    **/print-profiles/**
    **/calibration/**
    **/queue/**
    **/queues/**
    **/scheduler/**
    **/scheduling/**
    **/jobs/**
    **/job-queue/**
    **/materials/**
    **/filament/**
    **/spools/**
    **/inventory/**
    **/cost/**
    **/estimates/**
    **/monitoring/**
    **/camera/**
    **/webcam/**
    **/timelapse/**
    **/notifications/**
    **/maintenance/**
    **/qa/**
    **/quality/**
    **/post-processing/**
    **/audit/**
    **/logs/**
    **/events/**
    **/storage/**
    **/database/**
    **/config/**
    **/configuration/**
    **/secrets/**
    **/simulation/**
    **/dry-run/**
    **/tests/**
    **/integration-tests/**
    **/failure-injection/**
    **/deployment/**
    **/docs/**
    **/output/**

    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.

    Listed2 months ago
    Updated1 month ago

    What's inside

    Frequently Asked Questions

    It acts as a specialist systems-engineering consultant that designs, audits, and generates Python code for end-to-end additive manufacturing pipelines, including mesh validation, automated slicing, printer queue management, and G-code safety auditing.

    The agent is built to integrate with modern 3D printing ecosystems, including OctoPrint, Klipper/Moonraker, and CLI-based slicers like PrusaSlicer and CuraEngine, ensuring it can control single printers or high-volume print farms.

    Safety is a core design principle; the agent enforces strict gates for build-volume compatibility, nozzle/bed temperature limits, nozzle diameter matching, and maintenance state verification before any physical job is submitted.

    Yes, it can design sophisticated scheduling logic that manages material inventory (spool tracking), printer capability matching, and priority-based queueing to maximize utilization without risking print failures.

    You receive a premium engineering agent capable of generating production-ready Python workflows, configuration schemas, and database architectures for tracking print jobs, audit logs, and material traceability.

    The agent implements 'idempotent' submission logic and a reconciliation workflow that queries the printer's actual state after a network drop to prevent accidental duplicate prints or state confusion.

    New in Workflow Automation