The Intention Abstraction Layer (IAL) is proposed, a domainagnostic middleware that represents intentions as first-class, persistent, and explainable runtime objects and shifts behavioral assurance for cooperating autonomous systems from post-hoc failure analysis to pre-execution, intention-level checking.
Abstract
Modern industrial environments increasingly run many autonomous subsystems at once - schedulers, energy managers, vehicle fleets - each pursuing its own goals while sharing the same physical resources. Because high-level human intentions are translated into low-level control logic and then discarded, no running component can tell whether it is still doing what was actually intended, and goal conflicts surface only after they have caused a missed target or a shutdown. We propose the Intention Abstraction Layer (IAL), a domainagnostic middleware that represents intentions as first-class, persistent, and explainable runtime objects: a large language model grounded in a formal OWL ontology parses naturallanguage goals into structured intentions, a consistency monitor detects conflicts at registration time, before execution, and a transparency module explains them in natural language. We report a first proof of concept in which two autonomous agents register conflicting production and energy intentions, and the IAL flags and explains the conflict before it reaches the execution layer. The result is a mechanism that shifts behavioral assurance for cooperating autonomous systems from post-hoc failure analysis to pre-execution, intention-level checking.
This work presents PhyAgentOS, a runtime foundation delivering scheduling, verification, memory, benchmarking, and safety as system-level services, and distinguishes execution termination from semantic task completion via evidence-grounded verdicts of success, failure, or replan.
Yang Liu, Weixing Chen, Xinshuai Song et al.· 2 citations
The integration of large language models (LLMs) into KUKA industrial robots offers a promising pathway toward intuitive natural language control and a higher level of intelligence. However, existing methods face two primary challenges: their reliance on predefined motion primitives and the syntactic fragility imposed by the strict constraints of proprietary KUKA Robot Language (KRL). To address these challenges, we propose MIKI (multi-agent integrated KUKA interface), a decoupled dual-agent framework that bridges high-level reasoning and low-level syntactic verification for industrial robot programming. The controller agent incorporates a chain-of-thought (CoT) reasoning mechanism to systematically decompose abstract human instructions into logical intermediate steps. By leveraging a visual toolchain, it translates these reasoned plans into a sequence of executable actions, each embedded with precise world coordinates. Subsequently, the code generation agent employs a syntax-guided iterative refinement process, underpinned by an ANTLR4 parser, to transform these actions into verified and executable KRL code. Experimental results demonstrate that this closed-loop approach substantially improves the syntactic success rate of code generation from 0.61 to 0.89. Furthermore, the framework achieves an average success rate of 0.6 across five desktop manipulation tasks of varying complexity using a physical KUKA robotic arm, validating its effectiveness in bridging high-level cognitive reasoning with deterministic industrial execution.
Zhendao Chen, Haibo Chao, Yanhao He et al.· Robotica (Cambridge. Print)· 0 citations
Large language models (LLMs) can plan behavior for embodied agents from natural language, but treating the LLM as a request/response oracle on the critical path is fundamentally at odds with real-time control and concurrent goals. We argue for an operating-system-style runtime for embodied agents, and instantiate this idea in an early prototype, TypeGo. TypeGo structures LLM-based planning as asynchronous loops at multiple timescales that overlap with execution, and manages the agent's physical body like an OS manages hardware: the Skill Kernel arbitrates typed physical subsystems among concurrent per-task processes, a scheduler preempts them and resumes or replaces each by source, and speculative skill streaming hides LLM latency behind ongoing motion, while a fast first-action path yields visible feedback within a second. Users program behavior through natural language prescriptions that TypeGo dispatches to the LLM-based planners or compiles into low-latency interrupt handlers. Our prototype of Kalos, a Unitree Go2 quadruped, provides preliminary evidence for the design: in our current task suite, it cuts per-step delay by 50% over step-by-step planning and time-to-first-action by 73% over monolithic planning, while admitting concurrent tasks at low scheduling overhead.
It is shown that LLM-driven agents can violate this condition and introduced a canonical deployment wrapper that guarantees it for arbitrary base agents while preserving already-equivariant behaviour, and it is proved that computing canonical representations required by this construction is graph-isomorphism-hard.
Large language model (LLM) agents increasingly automate multi-step engineering and informatics workflows, yet they rarely ask how much effort a task actually requires. They often follow a maximum-context-first strategy--re-reading files and dependencies they have already seen--turning a one-line edit into a small code-base audit. We argue the missing capability is task-aware execution-scope estimation: judging a task's difficulty, the information it truly needs, and the shortest reliable path before committing budget. We formalize minimum-sufficient execution and the Agent Cognitive Redundancy Ratio (ACRR), and propose E3 (Estimate, Execute, Expand): the agent estimates an initial operating point, executes a minimum viable path, and expands scope only when verification fails. On MSE-Bench--a deterministic benchmark of 121 edits in a capability-controlled simulator--E3 matches the strongest baseline's 100% success while cutting cost by 85%, tokens by 91%, and inspected files by 92%, and further beats a strong adaptive retrieval baseline by 16%; the gains survive held-out instruction wording and essentially every cost weighting. A companion real-model harness (LLM-Case) corroborates the effect on a live gpt-4o agent editing a real open-source library, with every candidate patch graded by actually running the project's real pytest suite against a measured oracle: the over-reading is milder but real, and E3 is the leanest and fastest policy at comparable task success--its one shortfall a provider rate-limit, not a wrong edit. We frame this as a controlled probe of execution redundancy, not a measurement of any deployed agent, and position task-aware execution as a step toward engineering-grounded AI (EGAI)--agents whose effort is anchored in the engineering reality of the task. We release the framework and benchmark.
This work introduces the concept of an agentic transaction and proposes an ACID-compliant agent system framework that reinterprets the classical ACID properties for agent execution through four semantic guarantees: Semantic Atomicity, Semantic Consistency, Semantic Isolation, and Semantic Durability.