Eluna: An Agentic LLM System for Automating Warehouse Operations with Reasoning and Task Execution

🕒 Published (v1): 2026-07-09 21:51 UTC · Source: Arxiv · link

Why this paper was selected

SOP-enforcing agentic system for procedural task execution; harness compliance enforcement pattern

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

Eluna is a production-deployed, graph-guided multi-agent framework that encodes warehouse Standard Operating Procedures (SOPs) as directed acyclic graphs and executes them via hierarchical sub-agent delegation with progressive context disclosure. To meet production latency constraints, it uses asymmetric episodic distillation: a large teacher's trajectories are corrected by episodic learning, and a smaller student is fine-tuned on those corrected trajectories with episodic memory stripped at inference. A fine-tuned 32B student matches or exceeds its 355B teacher and all larger off-the-shelf baselines.

Problem

LLM agents (ReAct, Reflexion) use loosely structured prompts that cannot enforce deterministic procedural compliance with multi-step SOPs. Presenting a full SOP in context causes performance degradation ("context overload") regardless of model scale, because agents conflate branches, omit nodes, or attend to irrelevant subtrees. Existing multi-agent frameworks (AutoGen, MetaGPT) decompose tasks but do not structurally bind agents to graph-encoded decision logic. Prompting alone is insufficient for reliable operational SOP execution; domain-specific training is required but prior distillation pipelines (FireAct, AgentTuning) operate on free-form tasks rather than graph-structured procedural logic.

Method

SOP Graph Representation. Each SOP is formalized as \(G = (V, E)\) where \(V\) contains five typed nodes—observations, root causes, calculations, constraints, and actions—each with a parameterized evaluation specification producing a boolean, classification, or numeric value. Edges encode directed dependencies: single-parent edges activate children on boolean outcomes; multi-parent edges require all parents to hold simultaneously.

Progressive Disclosure. A retrieval tool runs BFS from the triggered entry node and returns only the reachable subgraph (types, relationships, brief descriptions). Full per-node procedural specifications are fetched individually only when the main agent begins evaluating that node, bounding working context to one node at a time.

Hierarchical Multi-Agent Execution. A main agent holds the retrieved subgraph and delegates individual node evaluations to parallel sub-agents, each initialized with a fresh isolated context containing only that node's specification, role instructions, and tools. Sub-agents use a persistent IPython interpreter (CodeAct paradigm) and access live operational data via MCP. Only structured conclusions propagate back; sub-agents cannot spawn further sub-agents. Action nodes remain with the main agent for constraint sequencing.

Skill Packaging. Each workflow is bundled into a self-contained skill comprising: (1) the SOP DAG, (2) MCP-registered use-case tools, (3) node detail specifications, (4) CodeAct functions, and (5) execution instructions. A skill-loading tool registers the skill's namespace, injects CodeAct modules, and appends instructions at runtime, keeping the execution engine use-case-agnostic.

Asymmetric Episodic Distillation. A strong teacher (GLM-4.7, 355B) generates initial trajectories within the full framework. Episodic learning iteratively corrects the teacher's errors by accumulating atomic facts into an episodic memory and feeding reflective feedback across attempts (no weight updates). Rejection sampling with an LLM judge filters corrected trajectories for correctness. A smaller student (Qwen3-32B or GLM-4.5-Air) is then fine-tuned via LoRA on turn-level decomposed JSONL samples derived from these corrected trajectories, with episodic memory stripped—forcing the student to internalize corrections in weights and eliminating inference-time memory dependence.

Key Contributions

• Graph-guided, skill-packaged agent framework: SOPs as DAGs with two-level progressive disclosure, enabling procedural compliance at scale without context overload.
• Hierarchical multi-agent architecture with isolated parallel sub-agent delegation; context growth in the main agent is \(O(\text{nodes evaluated})\), not \(O(\text{trajectory length})\).
• Asymmetric episodic distillation pipeline: episodic learning improves teacher trajectory quality; student is fine-tuned on episodic-memory-stripped trajectories so runtime dependence is eliminated.
• Production deployment on Amazon Bedrock AgentCore across two real warehouse applications processing thousands of events.

Results

Operational reasoning benchmark (13 tasks, 1,400 samples vs. GLM-4.5-Air baseline): - Eluna-G: +6.5% average; Eluna-Q: +6.0% average - OTS Qwen3-32B: −38.0% average (shows gap closed by domain-specific training) - OTS Qwen3-235B: −10.0% average (larger model still underperforms fine-tuned 32B) - Largest gains on Causal Chain Analysis (+23.7%), Query Understanding (+12.5%), Metric Trend Detection (+14.3%)

Robotic conveyance application (1,500 real scenarios, end-to-end SOP on 63-node graph): - Observation binary correctness: +49% vs. baseline - Root-cause binary correctness: +73.9% - Root-cause exact match: +84.4%; Action exact match: +165.3% - 32B fine-tuned models match 355B teacher on all metrics - End-to-end latency reduced by 54.3–54.8% vs. teacher; 300% speedup vs. manual operators in production

Ticket processing application (410 real tickets, 46-node SOP, Eluna-G-XL 355B fine-tune): - Overall estimated correctness: 94.4% - Consolidation decision precision: 96.7%, recall: 99.2%, F1: 98.0% - 84.1% of tickets processed autonomously; 2.2% require manual handling

Ablation (episodic learning): - EL in teacher only (Eluna design): +16.2% on Task 5, +28.6% on Task 10 vs. no-EL - Student trained with EL but EL removed at inference: −52.7%/−40.0% (catastrophic degradation, confirming asymmetric design necessity)

Limitations

• Validated only on two operational domains (robotic conveyance and ticket processing); generalization to substantially different environments is untested.
• Episodic distillation pipeline requires a capable large teacher model and compute budget for multiple trajectory generation rounds.
• Both episodic learning and SFT depend on ground-truth labels, which are expensive and time-consuming to obtain; the ticket processing task required expert annotation of sampled traces rather than deterministic labels.
• Residual errors trace to SOP-specification gaps and upstream data quality—neither addressable by agent improvements alone.

Relevance to Harnesses / Meta-Harnesses

Eluna is directly a meta-harness instantiation: its skill-packaging system is a runtime harness that remains use-case-agnostic and loads domain-specific execution bundles on demand, matching the architectural pattern of harnesses that separate orchestration logic from payload. The progressive-disclosure mechanism and two-level agent hierarchy constitute the harness's core context-management strategy—a reusable scaffold that governs what information flows where and when. The asymmetric episodic distillation pipeline is itself a meta-level training harness: it coordinates teacher trajectory generation, episodic correction loops, rejection sampling, and student SFT as a structured pipeline that can be applied to any new SOP workflow bundled as a skill. For researchers tracking harnesses, the paper provides concrete evidence that a production harness must co-design inference-time orchestration with training-time trajectory correction to meet real deployment constraints.