HuggingFace Launches MachinaCheck: A Multi-Agent System That Lets AI Directly Judge Whether a Part Can Be Manufactured

HuggingFace has just released an interesting new project called MachinaCheck—a manufacturability analysis (DFM, Design for Manufacturability) solution for CNC machining built on a multi-agent architecture. This isn’t just another chatbot demo—it’s a case of embedding large language models directly into industrial workflows: upload a CAD file, and the system automatically tells you whether the part can be machined, where the problems lie, and how to fix them.

The project was created by HuggingFace and AMD during a developer hackathon and runs on AMD’s MI300X accelerators. The focus isn’t on how new the model is, but rather on its architectural design—specialized agents that each handle a specific technical task and collaboratively produce a comprehensive manufacturability assessment report.

Why Manufacturability Analysis Is So Challenging

In traditional manufacturing, there’s a persistent headache: parts designed by engineers often turn out to be unmanufacturable when they reach the workshop. Tool access issues, overly tight tolerances, improper fillet radii, walls that are too thin—these problems don’t show up in CAD software and have to be caught by experienced process engineers.

Existing DFM tools are mostly rule-based expert systems filled with hardcoded if–else logic. The problems include:

• High maintenance cost of rule libraries: each material, machine, and process requires its own configuration
• Lacking contextual understanding: they only check local features and can’t grasp overall design intent
• Unintelligent feedback: they only say “invalid,” without suggesting “how to fix it”

Large language models could, in theory, overcome these issues—they can understand textual process knowledge, learn implicit patterns from large datasets, and produce human-readable analytical reports. But a single model would struggle to do it all: interpret 3D geometry, understand materials mechanics, and know machining capabilities.

MachinaCheck’s idea is to split tasks so that different specialized agents handle distinct responsibilities.

How the Multi-Agent Architecture Is Designed

MachinaCheck uses four specialized intelligent agents, each with clearly defined roles:

1. Geometry Analyzer

Responsible for parsing CAD files and extracting key geometric features:

• Detects holes, slots, bosses, chamfers, etc.
• Measures dimensions such as wall thickness, depth, and diameter
• Identifies high-risk features like sharp corners, thin walls, and deep cavities

This agent leverages geometry libraries such as Open3D and Trimesh to convert 3D models (STEP, STL) into structured data. It doesn’t decide machinability directly—it “translates” geometric information into a format understandable by subsequent agents.

2. Machining Expert

The core decision-maker responsible for assessing manufacturability:

• Determines whether each feature can be processed using standard cutting tools
• Identifies areas requiring special processes (e.g., EDM)
• Evaluates machining difficulty and cost

Its knowledge base includes typical CNC machine capabilities, tool specifications, and material properties. For example, it might analyze a 2 mm diameter, 50 mm deep blind hole, recognize that the length-to-diameter ratio is too high, and recommend a gun drill or reduced depth.

3. Design Advisor

When manufacturability issues are detected, this agent provides modification suggestions:

• Proposes design alternatives that conform to DFM principles
• Explains how modifications reduce machining difficulty
• Evaluates functional impact of each change

For example, if the design has a 90° internal corner, the milling tool would leave a fillet. The Design Advisor would recommend accepting an R0.5 radius (matching cutter radius), redesigning as a chamfer, or using EDM (tripling cost).

4. Report Generator

Integrates the outputs from the previous three agents into a human-readable report:

• Summarizes key issues in natural language
• Generates annotated 3D visualizations highlighting problem areas
• Provides prioritized improvement recommendations

The report isn’t just text concatenation—it’s context-aware. For instance, when both insufficient wall thickness and deep cavity issues exist, it explains their relationship—thickening the wall improves rigidity and reduces vibration during deep-cavity machining.

Technical Implementation Details

Model Selection

MachinaCheck doesn’t train models from scratch but fine-tunes open-source large models:

• Base model: Llama 3.1 70B, open-sourced on HuggingFace
• Fine-tuning data: Around 5,000 real CNC machining cases, including design files, process reviews, and final machining outcomes
• Fine-tuning method: LoRA for parameter-efficient tuning, training only 0.5% of parameters

All agents share the same base model but load different LoRA adapters: Geometry Analyzer for spatial reasoning, Machining Expert for process knowledge, and Design Advisor for creative suggestion generation.

Agent Collaboration Mechanism

The four agents work not in simple sequential calls but through an AutoGPT-like reflection loop:

1. Geometry Analyzer performs initial analysis
2. Machining Expert evaluates manufacturability
3. If issues are found, Design Advisor generates modification proposals
4. Geometry Analyzer reevaluates the revised design
5. Machining Expert verifies if the problems are resolved
6. The loop continues until a viable solution or iteration limit is reached
7. Report Generator produces the final report

The loop runs for up to 3 rounds. In testing, 70% of cases produce a clear conclusion in one round, 25% need two rounds, and 5% max out at three rounds (usually due to fundamentally flawed designs).

Why AMD MI300X Was Chosen

The MI300X is AMD’s data center GPU, positioned against NVIDIA’s H100. It was chosen for several reasons:

• Large memory: 192 GB of HBM3, enabling concurrent LoRA-adapted 70B models
• Inference performance: 1.3 PFLOPS FP16, with end-to-end latency of ~15 s per part
• Cost: AMD provided free compute at the hackathon, and even commercially, MI300X offers better cost-performance than H100

Inference acceleration uses vLLM with continuous batching and PagedAttention. Agents share a KV cache, avoiding redundant computation.

Real-World Performance

The team tested 200 real parts, comparing results to manual process reviews:

• Accuracy: correctly identified 87% of issues
• Recall: detected 92% of actual problems (8% missed)
• False positives: 15% (judged machinable features as unmachinable)

False positives mainly occurred in borderline cases—features theoretically machinable but requiring nonstandard tools or fixtures. The system leans toward conservative judgments, acceptable in industrial settings (better to double-check than scrap a part).

The 8% missed issues included:

• Clamping interferences (part geometry prevents proper fixturing)
• Tool reachability (geometry feasible but tool holder collisions occur)
• Material-specific problems (certain alloys chip at specific cutting parameters)

Solving these requires deeper process simulation beyond current model capabilities.

A Practical Example

An aerospace part originally had an L-shaped slot, depth 40 mm, width 3 mm, fillet R0.2 at the bottom.

Geometry Analyzer detected:

• Slot depth-to-width ratio 13.3:1
• Bottom fillet radius 0.2 mm
• Material: 7075 Aluminum

Machining Expert determined:

• Standard end mill max length-to-diameter ratio 5:1—not manufacturable
• Bottom radius R0.2 requires a Ø0.4 mm ball end mill, which vibrates severely at 40 mm depth
• Suggests EDM cutting—cost ×8, lead time +5 days

Design Advisor proposed three options:

1. Split the slot into two sections machined from opposite sides with a 2 mm connecting rib (requires functional verification)
2. Increase slot width to 5 mm and use a Ø4 mm long-reach cutter (space must be evaluated)
3. Keep original design and accept EDM cost/time

The designer chose option 1, added the rib, and confirmed functionality remained unaffected. Manually, this would take 2–3 rounds of back-and-forth between designer and process engineer; the system offered the complete analysis in 20 seconds.

Architecture Generalization

MachinaCheck’s multi-agent design can extend to other manufacturing processes requiring expert judgment:

• Injection mold design: checking draft angles, wall thickness uniformity, gate placement
• Sheet metal unfolding: evaluating bend radii, clearance holes, weld accessibility
• PCB layout: validating trace spacing, via density, thermal design
• Welding process: assessing joint reachability, deformation risk, recommended welding sequence

The key is structuring domain knowledge into parallelizable subtasks handled by specialized agents. This approach is more practical and easier to optimize incrementally than training a single omnipotent model.

Recently, two Chinese ministries issued directives promoting intelligent agent applications in 20 industries including steel, petrochemical, automotive, and medical equipment. MachinaCheck’s architecture fits industrial requirements perfectly: complex tasks, cross-domain expertise, low tolerance for error, and explainability.

Open Source or Closed Source?

MachinaCheck’s code and model weights are open-sourced on HuggingFace under the MIT license. However, real deployment requires:

• Domain data: The existing 5000 cases are only a start—dataset size needs to expand by 10× to cover more materials, processes, and machines
• Process knowledge base: structured databases for machine parameters, tool specs, and material properties
• CAD integration: currently standalone; ideally embedded in mainstream CAD tools like SolidWorks or Fusion 360

Open sourcing lowers entry barriers, but real adoption demands industry investment. Two possible directions:

1. CAD vendor integration: major vendors (Autodesk, Dassault, Siemens) might embed similar capabilities in products
2. Vertical SaaS: startups use open-source models for specialized sectors (e.g., aerospace, medical devices)

Either way, multi-agent architectures fit industrial software better than monolithic ones. Industrial software’s essence is not “intelligence” but “reliability”—each decision must have justification, each suggestion traceable, each error locatable. Multi-agent systems naturally support modular debugging and incremental optimization—exactly what industry needs.

Performance and Cost

On AMD MI300X, processing a medium-complexity part (≈ 500 geometric features) end-to-end:

• Geometry analysis: 3 s
• Manufacturability evaluation: 8 s
• Design suggestions generation: 4 s
• Report generation: 2 s
• Total: ≈ 17 s

Using CPU inference (96-core AMD EPYC) takes 4–5 min for the same task. GPU acceleration yields 15× speedup—crucial for interactive use: designers can tolerate 20 s feedback, but not 5 min delays.

In terms of cost, with cloud MI300X pricing (~ $3/hour), processing one part costs under $0.02. Manual process review costs about $25 per part (engineer hourly rate $50, 30 min per review). The AI solution is 1000× cheaper—not to replace humans but to perform initial screening: 90% routine parts pass automatically; 10% complex cases then get human review.

Limitations

MachinaCheck remains a proof of concept and is not yet production-ready:

1. Supports only 3-axis milling—no 5-axis, turning, or grinding processes
2. Limited material coverage—mostly aluminum and common steels; lacks data for Ti and Ni alloys or composites
3. No cost/time estimation—only tells whether feasible, not how expensive
4. No toolpath planning—focuses on manufacturability, not actual G-code generation

All of these can be incrementally addressed. The deeper issue is that large-model “hallucinations” are intolerable in industrial settings—if the system says a part is machinable and it ends up scrapped, who’s liable? Validation and accountability frameworks are required beyond pure technology.

Insights for Developers

MachinaCheck’s value lies not merely in solving CNC manufacturability, but in demonstrating how multi-agent architectures can work for vertical domains. Key takeaways:

• Task decomposition matters: don’t expect one model to do everything; split into sub-tasks with focused agents
• Structure domain knowledge: large models aren’t magic—they need high-quality data and well-organized knowledge bases
• Explainability is mandatory: industrial users won’t trust black-box reasoning; every judgment must be traceable
• Human–AI collaboration, not replacement: AI handles screening and suggestions; humans make final decisions

For anyone developing vertical AI applications, MachinaCheck’s framework is worth studying. HuggingFace has open-sourced the code; you can build on it directly. AMD’s MI300X, though less ubiquitous than NVIDIA’s GPUs, offers notable cost advantages—its large memory is especially suited for multi-agent workloads.

Domestic industrial software teams should explore this direction. The moat around traditional CAD/CAM software is weakening; AI-native industrial software may present a new opportunity. The key is to identify a narrow, deep niche, implement a working multi-agent system, then scale horizontally.

---

References

• MachinaCheck: Building a Multi-Agent CNC Manufacturability System on AMD MI300X - HuggingFace Blog – Official technical blog detailing system architecture, model choices, and implementation specifics