💻 computer science

PackingGPT: 3D Packing Agent for Real Furniture in Last-Mile Delivery

This paper introduces PackingGPT, a framework and real-world benchmark dataset for the 3D packing of heterogeneous furniture into personal vehicles, demonstrating that enforcing Center-of-Mass constraints during sequential placement significantly reduces stability failure rates compared to traditional methods.

Original authors: Yi You, Hui Li

Published 2026-08-04

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yi You, Hui Li

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to fit a giant, awkwardly shaped puzzle into a backpack that is already half-full of lunchboxes, a water bottle, and a pair of sneakers. This is the daily struggle of "3D bin packing," a classic problem in logistics where computers try to figure out how to stack boxes perfectly to save space. Usually, these computer programs act like Tetris masters, focusing only on geometry: "Does this box fit in the hole?" But in the real world, physics adds a tricky new rule: gravity. If you stack a tall, thin box on top of a tiny, wobbly one, it might tip over and crash, even if it fits perfectly in the empty space. This is especially true for furniture, where flat-pack boxes are often long, narrow, and heavy, and your car trunk is rarely an empty, perfect rectangle.

The question researchers are asking is: How can we teach a computer to pack a car not just efficiently, but safely? It needs to understand that a heavy box shouldn't be placed on a flimsy one, and that the center of gravity of the whole pile needs to stay balanced so nothing topples over while driving. This isn't just about saving a few inches of space; it's about making sure that when you drive home with your new bookshelf, it doesn't slide across the trunk and break your rear window.

This paper introduces a new way to solve this messy problem called PackingGPT, a smart system designed to help people pack flat-pack furniture (like the kind you buy from big furniture stores) into their personal cars, even when the trunk is already cluttered with groceries or sports gear. The researchers realized that old computer methods, which just try to stuff as many boxes as possible in, often fail because they ignore the "tipping" problem. In their tests, when they tried to pack a sedan trunk using standard rules, about 10% to 40% of the boxes would have been unstable and likely to fall over.

To fix this, the team created a new "brain" for packing called Lego-Language Packing (LLP). Instead of using a rigid set of math rules, they treated the packing process like building with Lego bricks. They taught a large language model (a type of AI that usually writes stories or answers questions) to "speak" the language of packing. They gave the AI a dataset of real furniture boxes and car trunks, but with a special twist: the AI was only allowed to learn from packing sequences where every single box was physically stable. It's like teaching a child to build a tower by only letting them stack blocks that don't wobble, so they naturally learn the feeling of balance.

The results were quite promising in their computer simulations. When the new AI model tried to pack a car trunk, the rate of unstable, tipping boxes dropped dramatically to just 0.67% for larger SUVs and 3.3% for smaller sedans. This is a huge improvement over the old methods. The AI learned to place heavy items low and wide, and to avoid putting tall, thin boxes on top of small, narrow supports. Interestingly, the model was so good at learning the "feeling" of balance that it could handle new furniture items and different car trunks it had never seen before without needing to be retrained.

However, the paper also points out a small catch. While the AI was much better at keeping things stable, it sometimes packed slightly fewer boxes than the old, purely geometric methods. This is because the AI, like a human, sometimes gets "confused" about exactly where a box fits in a crowded space and might skip a spot to be safe. The researchers suggest that in the future, they could combine the AI's sense of balance with the old math methods to get the best of both worlds: maximum space and zero tipping.

In short, this paper doesn't just say "stack the boxes." It teaches a computer to think like a careful human mover, understanding that a box isn't just a shape, but a physical object that needs a solid foundation. By turning packing into a language game and training the AI on real-world stability, they've taken a big step toward making sure your next furniture delivery arrives in one piece, without a single box toppling over in the back of your car.

Technical Summary: PackingGPT: 3D Packing Agent for Real Furniture in Last-Mile Delivery

Problem Definition
This paper addresses the Heterogeneous Furniture-in-Vehicle Packing (HFVP) problem, a specific variant of the 3D bin packing challenge. Unlike standard logistics scenarios involving uniform containers, HFVP involves loading flat-pack furniture boxes (heterogeneous in dimensions and weight) into personal vehicle trunks that are often partially occupied by pre-existing clutter (e.g., groceries, strollers). The core difficulty lies not only in maximizing volume utilization but in ensuring per-box physical stability during transit.

The authors highlight that while traditional heuristic algorithms focus on geometric constraints to maximize space, they often ignore the Center-of-Mass (CoM) constraints required for physical balance. In real-world scenarios, flat-pack boxes are frequently thin and tall, making them prone to tipping if placed on narrow supports or in irregular gaps left by existing clutter. The problem is defined as finding a sequential placement policy $\pi$ that maps a set of boxes to a vehicle cargo space $C$ such that every box satisfies non-overlap, containment, and a strict per-box support stability constraint.

Methodology
The paper proposes a two-pronged approach: the creation of a real-world benchmark dataset and a novel deep learning framework called Lego-Language Packing (LLP).

Dataset Construction:
- The authors curated a dataset from real IKEA flat-pack packaging data, covering 202 products across 86 families (300 total boxes).
- The data includes precise dimensions (length, width, depth) and weights, derived from official product specifications.
- Two vehicle configurations were modeled: a large SUV (Chevrolet Suburban, 220×140×90 cm) and a sedan (Toyota Camry, 110×95×45 cm).
- Crucially, the dataset generation process simulates "cluttered" trunks by pre-loading random items to create irregular remaining spaces.
Stability Constraints (CoM):
- The paper defines a rigorous stability check for every placement step. A box is considered stable only if:
  - It has at least one support point (or 1-2 points for very short boxes <5cm).
  - Its Center-of-Mass (projected to the geometric center) lies within the convex hull of its support points.
  - It maintains an anti-tipping margin, where the distance from the CoM to the nearest edge of the support hull is at least 15% of the box's height ( $d_{min} \ge 0.15 \cdot h_i$ ).
The Lego-Language Packing (LLP) Framework:
- Concept: Inspired by Lego assembly, the framework treats packing as a sequential process where heterogeneous "bricks" are placed step-by-step into irregular "creations" (remaining cargo space).
- Architecture: The system utilizes a fine-tuned Transformer-based Large Language Model (LLaMA-3.2-1B-Instruct).
- Tokenization: The problem is reframed as an autoregressive text generation task. The input includes natural language prompts describing the vehicle, the box inventory, and the grid resolution. The output is a sequence of tokens representing the placement of each box: $(ID, x, y, z, \theta)$ , where $\theta$ represents one of six axis-aligned orientations.
- Training Data Generation: To train the model, the authors generated synthetic packing sequences using a "reverse disassembly" logic. Starting from a fully packed state, boxes are removed one by one to reveal the underlying structure. Conversely, for training, boxes are placed bottom-up into the irregular gaps. A CoM-gated filter ensures that every step in the training sequence satisfies the physical stability constraints defined above. This allows the model to learn the "necessity of center-of-mass awareness" directly from the data.

Key Results
The authors evaluated the LLP model against five baseline heuristic strategies (Large-First, Heavy-First, Small-First, Longest-First, and Random-Best) on the generated datasets.

Baseline Performance: When tested without CoM constraints, the baselines achieved high placement counts but failed stability checks significantly. In sedan simulations, 10–40% of placed boxes failed the stability check on average.
LLP Performance:
- SUV-500: The LLP model achieved a CoM failure rate of 0.67%, compared to failure rates ranging from 18.9% to 34.2% for the baselines.
- Sedan-500: The failure rate dropped to 3.3%, a significant improvement over the best baseline (Small-First) at 11.3%.
Generalization: The model demonstrated strong generalization capabilities. It successfully handled unseen products and entirely different customer cargo configurations (different clutter patterns) without additional fine-tuning.
Sample Efficiency: An ablation study showed the model is highly sample-efficient; training on as few as 100 scenarios (500 samples) was sufficient to reduce the failure rate below 2%.

Significance and Claims
The paper claims three primary contributions:

Benchmark Dataset: The release of the first dataset of real flat-pack packaging dimensions paired with vehicle cargo configurations, enabling reproducible research on HFVP with realistic item geometries rather than synthetic generators.
LLP Framework: A novel approach that reframes 3D spatial packing as a language modeling task. This allows the model to learn complex physical constraints (like CoM stability) implicitly through autoregressive training on CoM-gated sequences.
Practical Application: The model supports pre-trip packing feasibility checks. It can predict whether a specific customer order will fit and remain stable in a specific vehicle, directly supporting last-mile delivery route planning and customer self-pickup scenarios.

The authors note that while the current model simplifies constraints (e.g., assuming axis-aligned placements and ignoring crush-sensitivity), the token-based paradigm is designed to be extensible. Future iterations could incorporate more complex real-world constraints (e.g., unloading order, axle weight limits) simply by adding structured tokens to the input, potentially allowing the model to learn multi-constraint strategies by imitating human packers.

More like this