Towards an Intention Abstraction Layer for Autonomous Industrial Systems¶

🕒 Published (v1): 2026-07-16 04:31 UTC · Source: Arxiv · link

Why this paper was selected

Intention abstraction layer for multi-subsystem coordination; directly relevant to agent harness design

Ask a follow-up

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

TL;DR¶

The paper proposes the Intention Abstraction Layer (IAL), a middleware that treats autonomous agents' goals as persistent, machine-interpretable runtime objects rather than discarding them after translation to control logic. An LLM anchored to an OWL ontology parses natural-language goals into structured intentions, and a deterministic consistency monitor flags conflicts before execution. A proof-of-concept demonstrates pre-execution detection of a production/energy conflict in a two-agent industrial scenario.

Problem¶

In multi-agent industrial environments (schedulers, energy managers, AGV fleets), high-level human intentions are translated into low-level setpoints and then discarded. This causes three recurring failure patterns: lost intent (purpose unqueryable at runtime), silent conflict (two agents specify incompatible objectives independently, contradiction surfaces only at execution failure), and stale intent (an obsolete objective keeps executing after its context changes). Existing coordination mechanisms—Contract Net, FIPA-ACL, rule engines—do not represent intentions as managed runtime objects and cannot detect open-world conflicts pre-execution.

Method¶

The IAL sits as a domain-agnostic middleware between goal-specification and execution layers, never intervening in real-time control. It comprises four modules:

Intent Parser — An LLM (Claude Opus 4.8) maps natural-language or semi-structured input to formal intention tuples \(\langle G, A, R, C \rangle\) (Goal, Abstract Solution, Requirement, Context), where each element is constrained to an OWL ontology vocabulary, producing grounded structures rather than free text.
Consistency Monitor — On each register(goal, source) call, compares the new intention against all active intentions in the store using ontology-based semantic similarity and constraint intersection; raises typed, severity-annotated conflicts for overlapping resources/time windows with incompatible constraints.
Transparency & Resolution API — Renders detected conflicts back into operator-facing natural language and proposes candidate resolutions (e.g., defer a batch, relax a ramp); advisory only—does not enforce.
Intention Store — A persistent OWL repository (via owlready2) with lifecycle management (register, update, supersede, retire) to address stale intent.

All conflict logic is deterministic Python; the LLM is confined to the parsing step. The implementation supports active mode (agents call the API) and passive mode (IAL infers intentions from observed setpoints).

Key Contributions¶

IAL architecture: domain-agnostic middleware that lifts intention modeling from design time to runtime, managing intentions as first-class, persistent, explainable objects across agent boundaries.
LLM-grounded intention parsing: demonstrates that an OWL-constrained LLM can bridge natural-language goal specification and machine-interpretable intention structures without pre-specified conflict rules.
Pre-execution conflict detection: consistency monitor that flags goal conflicts at registration time rather than post-failure.
Open-source proof-of-concept validating the three core modules on a simulated two-agent production/energy scenario.
Formal lifecycle management for intentions (addressing stale intent via explicit retire/supersede operations).

Results¶

Scenario: Production Scheduler registers "run high-temperature batch 14:00–16:00 at ~92% peak load"; Energy Manager registers "keep total load below 80% peak during 13:00–17:00."
Without IAL: conflict is latent; the 80% cap is breached during execution at 14:00–16:00.
With IAL: the Consistency Monitor raises a high-severity conflict on shared resource peak_load at registration time, quantifying exceedance as 12 percentage points (92% − 80%); the Transparency module proposes deferring the batch to 17:00 or reducing demand; the resolved schedule keeps load compliant throughout the constrained window.
No quantitative benchmarks (accuracy, latency, scalability) are reported; this is an explicit work-in-progress paper with a single illustrative scenario.

Limitations¶

Single proof-of-concept scenario with a simulated (not real PLC/OPC-UA) execution layer; no statistical evaluation of parser accuracy or conflict detection recall.
LLM non-determinism and latency: the paper mitigates this by recording parsed outputs and confining the model to the advisory layer, but determinism is not fully solved.
No real concurrency control, agent identity management, or trust mechanisms implemented.
Only the forward path (goal → intention → conflict check) is implemented; the backward path (inferring intention from observed execution to detect declared-vs-enacted divergence) is sketched but deferred.
Cloud LLM dependency conflicts with on-premise industrial deployment requirements; a local/rule-based alternative is planned but not yet built.
No operator confirmation step for conflict-free registrations (identified as a trust gap).
Scalability to many concurrent agents and large ontologies is unaddressed.

Relevance to Agentic AI / LLM Agents¶

This paper directly addresses a core unsolved problem in multi-agent systems: how to coordinate autonomous agents whose goals may silently conflict, without a shared runtime representation of intent. The approach of using an LLM as a structured parser grounded in a formal ontology—rather than as a free-form reasoner—is a concrete architectural pattern for making LLM outputs safe and deterministic enough for industrial coordination. The IAL's design principle of keeping non-deterministic components (the LLM) strictly out of safety-critical execution paths is a transferable lesson for any agentic system deployed in high-stakes environments. The work also operationalizes the BDI (Belief-Desire-Intention) agent model at the infrastructure level, bridging classical multi-agent systems theory with modern LLM-based automation.