Technical Summary: Eluna – An Agentic LLM System for Automating Warehouse Operations

Problem Statement

Modern warehouse operations rely on Standard Operating Procedures (SOPs) that encode complex, multi-system decision logic. These workflows, such as robotic conveyance diagnosis and inventory ticket processing, require strict adherence to procedural constraints, quantitative thresholds, and multi-step reasoning across dozens of systems. Current execution is often manual, slow, and error-prone, leading to throughput degradation.

While Large Language Models (LLMs) demonstrate strong reasoning capabilities, existing agentic frameworks (e.g., ReAct, Reflexion) struggle with SOP compliance. They rely on loosely structured prompts that lack mechanisms to enforce deterministic procedural constraints, causing capable models to deviate from prescribed decision paths. A primary bottleneck is context overload: when full SOP specifications are presented to the model, performance degrades as complex workflows overwhelm the model's ability to select relevant actions. This performance plateau persists regardless of model scale, and prompting alone is insufficient without domain-specific training.

Methodology: The Eluna Framework

Eluna is a production-deployed, graph-guided, multi-agent system designed to ensure reliable SOP execution. It addresses context overload and use-case generality through three core architectural components:

1. Graph-Guided SOP Representation & Progressive Disclosure

SOPs are encoded as Directed Acyclic Graphs (DAGs) containing five node types: observations, root causes, calculations, constraints, and actions.

• Progressive Disclosure: Instead of presenting the full graph, the system discloses the graph in two levels:
  1. A retrieval tool runs a Breadth-First Search (BFS) from the triggered node to return only the reachable subgraph (structure and brief descriptions).
  2. Full procedural specifications (evaluation logic, tool calls, thresholds) for a specific node are fetched only when the agent begins evaluating that node.
• This approach bounds the working context to one node at a time, preventing the agent from inflating branches or exploring irrelevant subtrees.

2. Hierarchical Multi-Agent Architecture

Eluna employs a two-level hierarchy to manage complexity and parallelism:

• Main Agent (Orchestrator): Holds the retrieved subgraph, selects the next nodes to evaluate based on edge dependencies, and issues delegation calls. It retains graph-level state for sequencing and constraint checking.
• Parallel Sub-Agents: Independent sub-agents are delegated to evaluate specific nodes in parallel. Each sub-agent operates in an isolated context containing only its assigned node's specification, role instructions, and tools.
• Tool Ecosystem: Sub-agents utilize a persistent code interpreter (CodeAct paradigm) for data manipulation and the Model Context Protocol (MCP) for real-time data access. Only structured conclusions are returned to the main agent, preventing context bloat.

3. Skill Packaging

To avoid tool-space conflicts and context overload from loading all use cases simultaneously, each workflow is packaged as a self-contained Skill. A skill includes the decision graph, specific tools, node specifications, CodeAct functions, and execution instructions. Skills are loaded on demand at runtime, allowing the same agent engine to serve diverse operational use cases.

4. Training Strategy: Asymmetric Episodic Distillation

Recognizing that prompting alone is insufficient, Eluna utilizes a trajectory-centric training pipeline:

• Teacher Trajectory Improvement: A strong teacher model generates trajectories within the framework. Episodic Learning iteratively corrects the teacher's errors using memory and reflection without updating the model weights.
• Asymmetric Distillation: A smaller, low-latency student model is fine-tuned on the corrected trajectories. Crucially, the episodic memory is stripped during student training and inference. The student must internalize the corrections into its weights rather than relying on memory at runtime. This eliminates inference-time memory dependence and overhead.
• Data Processing: Trajectories are decomposed turn-by-turn, and rejection sampling with an LLM judge filters for correctness before fine-tuning.

Key Contributions

The paper outlines three primary contributions:

1. A Graph-Guided Skill-Based Framework: Encodes SOPs as DAGs with progressive disclosure and uses hierarchical multi-agent execution with parallel sub-agent delegation to achieve scalable, procedurally compliant reasoning.
2. Asymmetric Episodic Distillation Pipeline: A training method where episodic learning improves teacher trajectories, and a student model is fine-tuned on these corrected, memory-stripped trajectories, internalizing procedural logic without runtime memory overhead.
3. Real-World Performance: Demonstrates that a fine-tuned 32B model outperforms larger off-the-shelf (OTS) baselines and matches a much larger teacher model on operational benchmarks and production applications.

Experimental Results

Operational Reasoning Benchmark

Evaluated on a 13-task benchmark covering capabilities like causal chain analysis, metric trend detection, and cross-system knowledge synthesis:

• Eluna-G (fine-tuned GLM-4.5-Air) and Eluna-Q (fine-tuned Qwen3-32B) improved average performance by +6.5% and +6.0% respectively over the GLM-4.5-Air baseline.
• OTS Qwen3-32B performed 38.0% worse than the baseline, highlighting the necessity of domain-specific training.
• Eluna-Q, despite being a different and smaller architecture than the teacher (GLM-4.7), matched the teacher's performance, demonstrating effective transfer of operational reasoning across model families.

Production Applications

1. Robotic Conveyance (Latency-Critical):

   • The system processed ~8,000 triggers in production.
   • Fine-tuned models improved observation binary correctness by >49% and root-cause correctness by >73% over the baseline.
   • Exact match rates improved by +165% for actions.
   • Median execution latency was reduced by ~54% compared to the large teacher model, meeting real-time diagnostic SLAs.
   • SME reviews indicated near-perfect SOP adherence, with errors attributed to SOP specification gaps rather than agent reasoning.

2. Ticket Processing (Complex Reasoning):

   • Applied to a 46-node inventory consolidation SOP.
   • A fine-tuned 355B model (Eluna-G-XL) achieved 94.4% estimated correctness against expert annotations.
   • The system automated the digital triage for tickets that previously required ~6 minutes of manual processing, with a median generation time of 187 seconds.

Ablation Studies

Experiments confirmed that asymmetric distillation is critical. Applying episodic learning (EL) only to the teacher yielded significant gains (+16.2% to +28.6%). However, training the student with EL but removing it at inference caused catastrophic performance drops (−52.7%), proving that episodic knowledge must be internalized into weights rather than exposed as a brittle runtime dependency.

Significance and Claims

The paper claims that Eluna demonstrates two generalizable lessons for deploying agentic systems in production:

1. Distillation Beats Scale for Compliance: Within a graph-guided framework, a fine-tuned 32B model can match a significantly larger teacher and surpass all tested off-the-shelf models. Performance plateaus for OTS models regardless of size, whereas training on structured trajectories yields superior results.
2. Latency Constraints Drive Architecture: The requirement for low-latency inference under production SLAs necessitated the asymmetric distillation design. Relying on episodic memory at inference proved to be a brittle dependency rather than a pure accuracy gain.

The authors note that residual errors in the system stem from gaps in SOP specifications and upstream data quality, identifying the SOP authoring and data-integrity pipeline as the next bottleneck for reliable operational automation. The system is currently deployed in two operational domains, with transfer to substantially different environments remaining to be empirically validated.