PaperlayerView exact revision on arXiv

Source-linked AI summary

Intent Engine: Natural-Language Intent Translation for Intent-Driven Orchestration in the Compute Continuum

Koushikur Islam, Rodrigo N. Calheiros

arXiv:2608.20388v1cs.CLcs.DC

TL;DR

Users must translate contextual placement intents into structured SLOs, but existing approaches provide limited support for infrastructure-dependent requirements. Intent Engine constructs validated, infrastructure-grounded SLO artifacts, improving correctness and hallucination reduction across evaluated models and baselines.

  • Problem

    Existing placement frameworks require explicit SLOs, while current natural-language approaches inadequately support ambiguous, context-dependent, and infrastructure-state-dependent intents.

  • Method

    Intent Engine extracts constraints, grounds implicit requirements in infrastructure state, and validates schema compatibility before emitting SLO artifacts for downstream orchestration.

  • Results

    Intent Engine improves constraint correctness, structural accuracy, hallucination reduction, implicit-value grounding, and invalid-intent rejection versus prompting baselines and a rule-based parser.

  • Takeaways & Limitations

    Reliable intent-to-SLO construction requires infrastructure-aware grounding and schema-constrained validation, particularly for implicit, multi-constraint, and invalid intents.

  • Takeaways & Limitations

    The evaluation excludes autoscaling, fault recovery, migration, cost optimization, closed-loop assurance, and business-level or multi-service workflow constraints.

Abstract

from arXiv · show

Microservice placement in the compute continuum is driven by low-level Service-level Objectives (SLOs), but requiring users to specify metric-level constraints creates an adoption barrier and increases misconfiguration risk. Although large language models (LLMs) can interpret natural-language intents, direct generation of orchestration-consumable SLO artifacts remains unreliable due to unsupported constraints, incorrect grounded values, and schema violations. These errors can propagate to downstream placement logic and produce infeasible or incorrect placements. This paper presents Intent Engine, a natural-language intent translation architecture that constructs validated SLO artifacts for compute-continuum service placement. Intent Engine acts as an intent acquisition and SLO construction layer for existing intent-driven orchestration and placement frameworks; it does not perform placement or runtime QoS optimization. The architecture combines schema-constrained extraction, retrieval-grounded value construction from monitored infrastructure state, and validation against supported constraints before emitting the final SLO artifact. We evaluate Intent Engine using a 716-record intent-to-SLO dataset derived from an edge-cloud testbed, including valid and invalid intents. Across GPT-4.1 mini, Claude Sonnet 4.5, and DeepSeek V4-Flash, Intent Engine outperforms prompting baselines and a non-LLM rule-based parser. With GPT-4.1 mini, it achieves 0.941 total F1 Score and reduces aggregate hallucination by 85.1%, while lowering downstream placement failure from 30.8% to 2.1%.

1. Introduction

Intent Engine addresses the gap between natural-language placement intents and the validated SLO specifications required by compute-continuum orchestration. It constructs platform-agnostic SLO artifacts through extraction, infrastructure-aware grounding, and schema validation, without performing placement or runtime QoS optimization.

  • Motivation: The compute continuum combines endpoint, edge, and cloud resources to reduce latency while supporting scalable microservice placement across heterogeneous infrastructures.Placement must satisfy requirements including low latency, high availability, storage efficiency, and QoS.
  • Problem: Low-level SLO requirements impose an expertise barrier, while structured-input orchestration frameworks leave natural-language intents vulnerable to ambiguity and misconfiguration.LLM translations add risks because hallucinated or contextually incorrect specifications can cause invalid configurations and system failures.
  • Approach: Intent Engine converts natural-language service-placement intents into validated, platform-agnostic SLO artifacts consumable by existing intent-driven orchestration and placement frameworks.The architecture treats translation as control-plane specification construction rather than unconstrained generation.
  • Architecture: Its multi-stage pipeline separates semantic extraction, intermediate SLO representation, infrastructure-aware grounding, and schema validation.Grounding resolves implicit requirements such as highest or lowest resource values from monitored compute-continuum state.
  • Evaluation and scope: The study releases a 716-record testbed dataset covering valid, ambiguous, conflicting, malformed, and unsupported intents, and evaluates translation correctness, grounding, hallucination, rejection, overhead, and downstream impact.Placement, deployment, and runtime QoS optimization remain outside the paper’s scope.

2. Related Work

Related work shows that intent-driven orchestration reduces operational overhead but still exposes users to low-level SLO specification and struggles with dynamic compute-continuum placement. Existing natural-language interfaces lower the expertise barrier, yet generally lack reliable, schema-bounded, infrastructure-grounded construction of placement-ready SLO artifacts.

  • Intent-driven orchestration: Intent-driven orchestration lets users express high-level policies while orchestration logic determines how to achieve them through SLOs.This paradigm aims to decouple application management and reduce administrative and operational overhead.
  • Placement challenges: Distributed edge–cloud placement remains difficult because fluctuating states, resource trade-offs, and cost constraints must satisfy service intents.Traditional Kubernetes-based orchestration lacks native intent-centric abstractions and often requires manual intervention and specialized expertise.
  • Low-level specification: Traditional intent acquisition requires users to specify lower-level SLOs directly, creating an expertise barrier for resource allocation.Kubernetes and KubeEdge extensions similarly depend on detailed low-level configuration and operator involvement.
  • Natural-language interfaces: Natural-language intent interfaces reduce expertise requirements, but related systems target network configurations, RL objectives, workflow DAGs, or NSDs rather than placement-specific SLOs.These approaches include LUMI, RL-environment translation, Action Engine, IBN policy translation, and NSD-generation systems.
  • Research gap: A gap remains in reliably transforming natural-language placement intents into orchestration-consumable SLO artifacts before downstream placement logic uses them.Addressing this gap requires schema-bounded construction, infrastructure-aware grounding, and rejection of unsupported, ambiguous, or conflicting requests.

3. System Architecture

Intent Engine is a control-plane layer that translates natural-language placement intents into validated, infrastructure-grounded SLO artifacts for existing orchestration and placement frameworks. Its pipeline separates constraint extraction, contextual grounding, and validation, while leaving placement and runtime assurance to downstream systems.

  • Architecture overview: Intent Engine integrates with existing intent-driven orchestration and placement frameworks without replacing placement algorithms or runtime assurance mechanisms.It emits orchestration-consumable control-plane SLO artifacts for downstream frameworks.
  • Architecture overview: The pipeline extracts semantic constraints into an intermediate SLO representation, retrieves infrastructure evidence for implicit requirements, and validates the final specification.This sequence is designed to ensure compatibility with existing orchestration and placement engines.
  • Core components: The architecture comprises Natural Language Intent Decomposition and Retrieval-Augmented SLO Specification Generation, forming an artifact boundary that emits only schema-valid, infrastructure-grounded specifications.The first component prepares the intermediate representation; the second grounds implicit requirements and produces the validated SLO specification.
  • Natural Language Intent Decomposition: The SLO Parser extracts explicit metrics, operators, and values under the supported schema, while validation rejects unsupported or inconsistent intermediate clauses.The Intermediate SLO Specification Builder then normalizes fields, verifies schema conformity, and marks value-less constraints for grounding.
  • Retrieval-Augmented SLO Specification Generation: The grounding component resolves context-dependent requirements by querying retrieved compute-continuum state while preserving the predefined SLO schema.Context comes from top-k vector-database retrieval with snapshot-based fallback when evidence is insufficient or unavailable.

4. Implementation and Experimental Setup

Intent Engine was implemented and evaluated as an intent-to-SLO construction layer on a physical edge–cloud testbed. The implementation combines LLM-based parsing, schema-compliant normalization, monitored-context retrieval, deterministic aggregation, and validated SLO generation.

  • Implementation Architecture: The system combines a heterogeneous edge–cloud testbed with an Intent Engine pipeline for intent decomposition, retrieval-augmented grounding, and SLO specification generation.The testbed supplies monitored system context for grounding implicit constraints and deriving labeled SLO targets.
  • Testbed: The physical testbed collects resource-state traces under deployment-like conditions and continuously supplies context for grounding and ground-truth label construction.It spans geographically distributed edge and cloud resources with heterogeneous capacities and resource variability.
  • SLO Parser: GPT-4.1-mini parses unstructured service-placement intents at temperature 0.0, exposing structured outputs through a lightweight Python Flask API.The API accepts JSON requests containing a service identifier and intent text, then forwards structured JSON to later stages.
  • Intermediate Specification: The post-processing module enforces the intermediate SLO schema by normalizing fields, filling missing values with null, validating constraints, and canonicalizing metrics, units, and operators.It also marks constraints with grounding_required before serializing the intermediate specification as JSON.
  • Retrieval-Augmented Grounding: The grounding stage retrieves monitored context, generates final SLO specifications, and validates structural and schema completeness before downstream use.Context retrieval uses deterministic chunks, returns the top-k relevant chunks with k = 8, and can fall back to the most recent Amazon S3 snapshot.

5. Evaluation

Intent Engine is evaluated as an intent-acquisition and SLO-construction layer using a 716-record compute-continuum dataset. It improves translation accuracy, reduces hallucinations and downstream placement failures, and reliably rejects invalid intents.

  • Dataset: 716 intent records include 521 valid intent-to-SLO pairs and 195 invalid cases spanning ambiguous, conflicting, malformed, and unsupported intents.Valid records evaluate translation correctness, while invalid records assess robustness and failure handling.
  • Hallucination reduction: 85.1% aggregate hallucination reduction is obtained relative to Zero-shot, with unsupported or spurious constraints reduced by 97.2% and structural errors by 95.8%.Value issues decline by 60.7%, and remaining hallucinations are mostly value-related.
  • Translation accuracy: 0.941 total F1 Score is achieved by GPT-4.1 mini with Intent Engine, versus 0.758 with the Few-shot CoT prompting baseline.Intent Engine also improves total F1 from 0.794 to 0.870 for Claude Sonnet 4.5 and from 0.779 to 0.903 for DeepSeek V4-Flash.
  • Failure handling: 98.5% of invalid records are correctly rejected, including 93.9% rejection of conflicting intents and only 3 false accepts out of 195 invalid intents.Few-shot variants often over-generate SLOs for conflicting intents, indicating that examples do not reliably enforce safe rejection.
  • Efficiency: 2.35 s median and 4.30 s P95 latency make GPT-4.1 mini the lowest-latency LLM-backed option, while retrieved context stabilizes near 2,000 tokens after 25 nodes.DeepSeek V4-Flash reaches a 17.43 s P95, and full snapshot prompting grows to 501,726 tokens at 1000 nodes.
  • Downstream impact: 2.1% placement failure is achieved with Intent Engine versus 30.8% for the best prompting baseline, mainly by reducing no-match cases to 0.8%.Incomplete or inconsistent SLOs generally produce no matching node rather than an invalid returned placement.

6. Limitations

Intent Engine is limited to validated, snapshot-grounded natural-language-to-SLO construction and does not provide autonomous orchestration, runtime guarantees, or broader continuum optimization. Its evaluation and LLM-based generation remain constrained by testbed scale, supported intent scope, stale context, residual errors, and the absence of a domain-specific dataset.

  • System role and assurance: Intent Engine constructs and validates SLO artifacts, while downstream IDO frameworks handle placement, execution, enforcement, re-grounding, and runtime assurance.System-critical decisions should be inspected before execution because stale context, malformed intents, or incorrectly accepted constraints may cause service issues.
  • Scope of supported objectives: Autoscaling, fault recovery, migration, cost optimization, closed-loop assurance, and non-infrastructure goals remain outside the current evaluation.Supported intents mainly cover placement, compute capacity, utilization, storage, and network constraints; business goals, privacy, energy, carbon-awareness, dependencies, and workflows are excluded.
  • Grounding freshness: Snapshot-grounded values reflect monitored infrastructure conditions at one time and may become stale in highly dynamic environments.The generated SLO is a snapshot-grounded specification rather than an always-current runtime guarantee, with re-grounding left to downstream IDO assurance.
  • Evaluation generalizability: Evaluation uses a six-node edge–cloud testbed and TeaStore records, limiting assessment of node-scale behavior and retrieval-augmented context selection in larger continuum systems.TeaStore serves only as a reference microservice application, while the pipeline remains application-agnostic; no richer public grounded intent-to-SLO dataset is currently available.
  • Residual generation errors: LLM-based semantic extraction and grounded SLO generation can still produce value-level errors despite schema constraints and validation.Intent Engine reduces unsafe outputs but does not eliminate all errors, and the absence of a contextual dataset prevents feasible domain-specific LLM training or fine-tuning.

7. Conclusion and Future Work

Intent Engine constructs validated, orchestration-consumable SLO artifacts from natural-language placement intents while preserving the boundary between intent interpretation and downstream orchestration. Future work will extend the architecture toward closed-loop assurance of runtime intent satisfaction within a full IDO framework.

  • Contribution: Intent Engine transforms unstructured placement intents into validated, orchestration-consumable SLO artifacts for downstream IDO and placement frameworks.It serves as an intent acquisition layer for compute-continuum service placement.
  • Contribution: The architecture combines schema-bounded extraction, retrieval-grounded value construction, and schema validation before downstream orchestration decisions.This separation supports construction of control-plane artifacts rather than free-form text outputs.
  • Results: Evaluation on a real edge–cloud testbed dataset shows improvements in constraint correctness, structural accuracy, hallucination reduction, implicit-value grounding, and invalid-intent rejection over prompt-only LLM baselines and a non-LLM parser.The architecture is intended to integrate natural-language intent acquisition with existing IDO frameworks while leaving placement optimization, deployment actuation, and runtime QoS assurance to consuming systems.
  • Future Work: Future work will address intent drift and closed-loop intent assurance after constructed SLOs are consumed by orchestration systems.Planned extensions include re-grounding, feasibility checking, conflict detection and resolution, and intent negotiation after initial service placement.

CRediT authorship contribution statement

Koushikur Islam contributed across the paper’s conceptual, investigative, methodological, data, software, visualization, and original-draft work. Rodrigo N. Calheiros contributed to conceptualization, methodology, and review and editing.

  • Koushikur Islam handled conceptualization, investigation, methodology, data curation, software, visualization, and the original draft.
  • Rodrigo N. Calheiros contributed to conceptualization, methodology, and writing—review and editing.
  • Both authors contributed to conceptualization and methodology.

Declaration of Generative AI and AI-assisted technologies in the writing process

The authors used OpenAI’s ChatGPT for grammar checking and language refinement, while retaining responsibility for reviewing, editing, and ensuring the final manuscript’s accuracy and integrity.

  • Declaration of Generative AI and AI-assisted technologies in the writing process: The authors used OpenAI’s ChatGPT for grammar checking and language refinement, then reviewed and edited all content themselves.They take full responsibility for the accuracy and integrity of the final manuscript.

A. Prompt templates · B. Dataset samples · B.1. Dataset sample

The zero-shot and zero-shot CoT prompt template is provided in Figure 8.

  • A.2. Zero-Shot and Zero-Shot CoT prompt: The prompt template is shown in Figure 8.
Loading 2608.20388v1…