⚡ electrical engineering

From Intent to Infrastructure: LLM-Driven Agent Compilers for ISAC Networks

This paper introduces the Agent Compiler, a large language model-driven framework that translates high-level engineering intent into executable Integrated Sensing and Communications (ISAC) system configurations via a four-stage process and a verifiable intermediate representation, while maintaining strict time-scale separation between strategic LLM decisions and real-time algorithmic control.

Original authors: Lijie Zheng, Xudong Zhong, Baoquan Ren, Xiangwu Gong, Xinghui Zhu, Ji He

Published 2026-07-21

📖 8 min read🧠 Deep dive

CC BY 4.0

Original authors: Lijie Zheng, Xudong Zhong, Baoquan Ren, Xiangwu Gong, Xinghui Zhu, Ji He

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the air around us is a bustling, invisible highway. For decades, we've used this highway just to send text messages, videos, and calls—this is the world of wireless communication. But scientists are now building a new kind of vehicle for this highway: a car that can talk and look at the same time. This is called Integrated Sensing and Communications (ISAC). Instead of just sending a signal to your phone, the network sends a signal that bounces off objects, like a bat using echolocation, to figure out where cars, people, or drones are. It's like having a superpower where your phone can see the world while it talks to you.

However, building this dual-purpose system is incredibly tricky. It's like trying to write a symphony where the musicians must also act as a stage crew, changing lights and moving props, all while playing perfectly in tune. The "musicians" are the radio waves, the "props" are the antennas, and the "stage" is the spectrum of frequencies they share. If you make the music louder to hear better (sensing), you might drown out the conversation (communication). If you move the stage too fast, the musicians can't keep up. As these networks grow to handle 6G (the next generation of internet), the number of choices becomes so huge that human engineers can't possibly tune every knob manually. They need a smarter way to manage this chaos.

This is where a new idea called the "Agent Compiler" comes in, proposed in a recent paper for IEEE Communications Magazine. Think of this not as a robot that replaces the engineers, but as a super-smart "translator" or "orchestra conductor" powered by a Large Language Model (LLM)—the same kind of AI that can chat with you or write stories. The paper suggests that instead of asking a human to tweak thousands of settings every time a drone flies or a storm hits, we should just tell the AI our goal in plain English. The AI then acts like a compiler (a tool that turns human code into machine instructions), translating our simple wish into a complex, working plan for the entire network.

The paper doesn't claim to have built a perfect, finished product that runs on every phone today. Instead, it proposes a new framework and tests it in a computer simulation. The researchers found that this "Agent Compiler" can take a messy, high-level request—like "find survivors in a disaster zone"—and break it down into a step-by-step recipe for the network. It decides which drones to use, how fast they should scan, and how to share the airwaves, all while keeping the system safe and fast.

Here is how the magic happens, broken down into a story:

The Problem: Too Many Knobs to Turn

Imagine you are the captain of a spaceship. You have a button for "Scan for Asteroids" and a button for "Send Message to Earth." But these buttons are connected to the same engine. If you push the "Scan" button too hard, the engine gets hot and the message gets garbled. If you push the "Message" button too hard, the scanner goes blind.

In the real world, ISAC networks face this exact problem. They have to share the same hardware, the same radio waves, and the same time. The paper points out that old ways of fixing this—like following a strict rulebook or letting a computer learn by trial and error (Deep Reinforcement Learning)—are too rigid or too slow. A rulebook can't handle a surprise storm, and a learning computer might take too long to figure out what to do when the situation changes.

The Solution: The "Agent Compiler"

The authors propose a new system called the Agent Compiler. Think of it as a master chef who doesn't cook the food but writes the perfect recipe for a team of specialized cooks.

The Chef (The LLM): You tell the chef, "I need to find 4 survivors in a 3 km by 3 km area using 6 drones, and I need to send video back to base within 100 milliseconds." The chef (the AI) understands this natural language.
The Recipe Book (The IPG): The chef doesn't just shout orders. It writes a detailed "ISAC Policy Graph" (IPG). This is like a blueprint. It breaks the big job into small tasks: "Drone A scans here," "Drone B sends video," "Drone C waits for data." It also draws lines showing how the data flows between them.
The Specialized Cooks (The Algorithms): The chef doesn't try to do the math for the radar or the video compression itself. It picks the best existing tools (algorithms) for the job and tells them exactly what to do.
The Safety Check: Before the recipe is sent to the kitchen, the chef checks: "Is this possible? Do we have enough power? Will the video be too slow?" If the plan is impossible, the chef fixes the recipe before anyone starts cooking.

The Three-Speed Adaptation

The coolest part of this system is how it handles things going wrong. The paper describes a "Runtime Engine" that watches the network like a hawk. It has three levels of reaction, like a video game character with different power-ups:

Level 1: The Quick Fix (Milliseconds): If a signal gets a tiny bit weak, the system tweaks a knob (like turning up the volume) instantly. This happens so fast that the AI isn't even involved; it's just a reflex.
Level 2: The Partial Rewrite (Seconds): If a drone gets stuck in a cloud of dust and can't see well for a few seconds, the AI steps in. It doesn't rewrite the whole plan; it just rewrites the part of the recipe for that specific drone.
Level 3: The Full Restart (Minutes): If a drone crashes or the mission changes completely (e.g., "Stop looking for survivors, start looking for fire"), the AI throws out the old recipe and writes a brand new one from scratch.

The Test: A Disaster Rescue Simulation

To see if this works, the researchers ran a simulation of a disaster rescue. Imagine an earthquake has hit a city. Six drones are sent in. Four are "scanners" looking for survivors, and two are "relays" carrying video back to a command center.

They set up a scenario where things go wrong:

At 80 seconds: A pile of metal debris creates a "clutter" zone, making it hard for the scanners to see.
At 200 seconds: One drone runs out of battery and crashes, and the command center sends a new, urgent order.

The researchers compared their "Agent Compiler" against five other methods, including a "Fixed" method (that never changes) and a "Direct LLM" method (that asks the AI for advice every single second).

The results were interesting. The "Fixed" method failed immediately when the debris appeared. The "Direct LLM" method figured out the right direction but was too slow to react because it took too long to think. The "Agent Compiler," however, was the star.

When the debris appeared, it quickly adjusted the settings (Level 1) and then rewrote the scanning plan (Level 2) to focus on the clear areas.
When the drone crashed, it completely reorganized the mission (Level 3) to cover the gap with the remaining drones.

In the simulation, the Agent Compiler achieved the highest "utility" (a score combining how well it saw and how well it talked) at 0.524, beating the next best method (Direct LLM) which scored 0.519.

What This Means (and What It Doesn't)

The paper is very clear about what it has and hasn't done. It hasn't built a physical network that you can buy today. It hasn't proven that this will work in every single real-world situation. The results are based on a computer simulation over 300 seconds.

The authors suggest that this approach is a promising way to handle the complexity of future 6G networks. They argue that we need to stop trying to tune every single radio wave manually and start using AI to translate our high-level goals into low-level instructions.

However, they also warn that there are hurdles. The AI might sometimes make a mistake in its recipe (hallucinate a plan that doesn't work). It might take too long to think if the situation changes too fast. And, of course, we need to make sure the AI doesn't get tricked by hackers or give away private information about where people are hiding.

In short, this paper offers a new way to think about the future of wireless networks: not as a collection of machines we have to micromanage, but as a team we can give a simple mission to, trusting a smart "compiler" to figure out the rest. It's a step toward a world where our technology adapts to us, rather than us having to adapt to it.

Technical Summary: From Intent to Infrastructure: LLM-Driven Agent Compilers for ISAC Networks

Problem Statement
As Integrated Sensing and Communications (ISAC) transitions from proof-of-concept to sixth-generation (6G) system-level deployment, the design space has become prohibitively complex for manual tuning or isolated optimization methods. ISAC systems require the joint management of tightly coupled resources (waveforms, spectrum, hardware) across sensing, communication, computation, and control layers. Traditional design paradigms face significant limitations:

Manual/Rule-based systems are rigid and cannot handle dynamic, multi-objective trade-offs.
Monolithic optimizers rely on fixed model assumptions and lack generalization across changing topologies.
Deep Reinforcement Learning (DRL) suffers from high training costs, poor interpretability, and limited transferability to new tasks.
Direct Large Language Model (LLM) optimization offers strong semantic understanding but lacks the millisecond-level latency required for real-time control loops.

Consequently, there is a critical gap in translating high-level engineering intent into executable, end-to-end ISAC system configurations that can adapt to dynamic environments while respecting strict timing and hardware constraints.

Methodology: The Agent Compiler
The paper proposes the Agent Compiler, an LLM-enabled framework that acts as a system architect to translate high-level intent into executable infrastructure configurations. The framework is built on the principle of strict time-scale separation: the LLM handles slow-loop strategic decisions (seconds to minutes), while deterministic algorithms retain control over fast-loop real-time operations (milliseconds).

The architecture operates through four compilation stages and a runtime adaptation loop:

Intent Parsing: The LLM converts natural language or structured inputs (e.g., "Deploy UAVs for detection with 5Hz refresh") into a structured Intent Specification, extracting task objectives, performance constraints, environmental context, and priority ordering.
Task Decomposition and Planning: The system breaks the intent into subtasks across sensing, communication, computation, and control domains. It resolves dependencies (e.g., ensuring localization waits for detection outputs) by querying hardware capability and environment model tools.
Policy Graph Synthesis (IR Generation): Instead of generating direct device commands, the LLM produces an ISAC Policy Graph (IPG). This is a domain-specific intermediate representation (IR) that separates task logic from hardware details. The IPG is a directed attributed graph containing:
- Execution Nodes: Subtasks with algorithm types and parameter ranges.
- Edges: Information, control, and feedback flows.
- Annotations: Constraint checks (latency, power, accuracy) and trigger conditions for recompilation.
- Benefits: The IPG allows for pre-deployment verification, hardware agnosticism (reusability across different node fleets), and incremental recompilation.
Infrastructure Mapping: The IPG is mapped to physical devices via node binding, resource allocation, and interface adaptation. A lightweight constraint checker validates feasibility before dispatching protocol-level commands.
Runtime Engine (Closed-Loop Adaptation): A continuous monitor-evaluate-adapt cycle ensures the system aligns with the original intent. It employs a three-level adaptation strategy:
- Level 1 (Fast): Millisecond-scale parameter tuning (e.g., beam steering, power) using deterministic controllers without LLM involvement.
- Level 2 (Partial): Second-scale partial recompilation of affected subgraphs by the LLM when persistent degradation occurs.
- Level 3 (Full): Minute-scale full workflow recompilation for major topology changes or new mission objectives.

Key Contributions

Conceptual Framework: Introduces the "Agent Compiler" paradigm, defining its role as a translator between high-level intent and low-level ISAC infrastructure, distinct from existing LLM-based local optimization methods.
System Architecture: Presents an end-to-end compilation flow (Intent $\to$ IPG $\to$ Execution) that integrates LLM reasoning with deterministic control loops.
Experimental Validation: Demonstrates the framework in a UAV-assisted disaster rescue scenario, showing how the system generates coherent configurations under dynamic conditions (e.g., clutter emergence, node failure).
Critical Analysis: Identifies open challenges including compilation latency, output reliability, constraint verification, and pipeline security.

Results
The paper evaluates the Agent Compiler against five strategies in a 300-second simulation of a UAV disaster rescue scenario involving dynamic events (clutter onset and UAV loss):

Fixed Baseline: Static resource split.
Rule-based: Predefined if-then rules.
MADDPG: Multi-agent Deep Reinforcement Learning.
Direct LLM: LLM queried at every decision epoch (with 3s latency).
Agent Compiler: The proposed hierarchical approach.

Performance Findings:

The Agent Compiler achieved the highest average joint ISAC utility (0.524), outperforming Direct LLM (0.519), MADDPG (0.507), Fixed (0.498), and Rule-based (0.487).
Adaptation Speed: Unlike the Direct LLM, which suffered from a 3-second inference lag causing delayed responses, the Agent Compiler triggered immediate fast parameter updates (Level 1) and followed up with partial recompilation (Level 2) when degradation persisted.
Robustness: While the Fixed baseline dropped immediately upon clutter onset with no recovery, and MADDPG produced oscillating values due to out-of-distribution states, the Agent Compiler successfully shifted resource allocation (e.g., reducing sensing time to prioritize communication links in heavy clutter) and redistributed coverage after a UAV loss.

Significance and Claims
The paper claims that the Agent Compiler provides a necessary abstraction layer to manage the complexity of 6G ISAC networks, moving beyond isolated optimization to holistic system design. Its primary significance lies in:

Bridging the Gap: It connects high-level semantic intent with physical infrastructure execution without replacing existing optimization algorithms, but rather orchestrating them.
Scalability: By using an intermediate representation (IPG), the system supports hardware-agnostic deployment and incremental updates, addressing the scalability issues of manual design.
Safety and Real-Time Viability: The strict separation of LLM-driven slow loops and algorithm-driven fast loops ensures that the system remains responsive to real-time physical constraints while leveraging the reasoning capabilities of LLMs for strategic planning.

The authors conclude that while challenges regarding latency, verification, and security remain, this intent-to-infrastructure abstraction is a critical step toward realizing the integrated vision of 6G communication, sensing, computation, and control.