🤖 AI

Dynamic Adaptation of the LLM Context for Generating Routines with Coupled Semantics

This paper introduces a sample-efficient, dynamic context adaptation framework that combines a validation agent's execution trace analysis, a knowledge graph for semantic constraints, and simulated annealing to outperform existing LLM-based code generation methods in solving problems where correctness relies on runtime-dependent coupling between components.

Original authors: Gnaneswar Villuri, Hashmath Shaik, Alex Doboli

Published 2026-09-07✓ Author reviewed ⓘ

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Gnaneswar Villuri, Hashmath Shaik, Alex Doboli

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 by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the modern landscape of software creation, artificial intelligence has become a powerful partner, capable of drafting code with a speed and fluency that once seemed impossible. These systems, known as large language models, are trained on vast libraries of human writing and code, allowing them to predict the next word or line of a program based on patterns they have seen before. For simple tasks, this approach works beautifully; the AI can assemble standard functions or create basic structures almost instantly. However, a significant gap remains when the software being built requires different parts to work together in a specific, dynamic way. If the success of one piece of code depends on how another piece behaves while the program is actually running, rather than just how it is described on paper, these AI models often stumble. They tend to treat each part as an isolated island, missing the invisible threads that tie the system together. This limitation is particularly frustrating for complex engineering challenges where the whole is greater than the sum of its parts, and where getting the details right requires understanding the consequences of actions in real time.

Researchers at Stony Brook University have developed a new method to help artificial intelligence navigate this tricky terrain. Their approach, described in a recent study, focuses on a problem they call "static binding." This occurs when an AI model links concepts together based solely on their written descriptions, assuming that the meaning of one routine is fixed and independent of others. In reality, many software problems require "coupled semantics," where the meaning of a component is defined by its runtime behavior and its relationship to other components. To solve this, the team created a system that does not rely on a single, static attempt at writing code. Instead, they built a loop where a computer program acts as a validator, running the code generated by the AI and watching exactly what happens. This validator does not just say "it failed" or "it worked." Instead, it produces a structured report, pointing out specific errors, wasted steps, or missed opportunities in the execution. This detailed feedback is then fed back to the AI, which uses it to propose several new versions of the code for the next round.

The system is designed to be efficient, avoiding the need for thousands of random attempts to find a solution. It uses a technique called simulated annealing to choose which new code version to keep. Imagine a hiker trying to find the highest peak in a foggy mountain range; a greedy approach would only move upward, potentially getting stuck on a small hill. The simulated annealing method allows the system to occasionally accept a step that goes slightly downhill, giving it the chance to explore other areas and find a much higher peak later. This prevents the AI from getting stuck in a mediocre solution too early. Furthermore, the system builds a knowledge graph from the problem description, a structured map that helps the AI understand how different parts of the problem are supposed to connect. This map acts as a guide, ensuring that the AI keeps the big picture in mind while it refines the details.

The researchers tested this method on eight different problems, ranging from a maze navigation task for a robot to complex resource allocation scenarios for disaster management. In the maze example, the robot had to collect keys before it could pick up items, a rule that required the navigation logic to be tightly linked with the item collection logic. In the disaster management scenario, the system had to balance the needs of surgical teams with the repair of a power grid, where decisions in one area directly affected the other. The results showed that the new method was remarkably fast at learning. In the early stages of testing, with only a few hundred attempts, the system outperformed other leading methods on seven out of the eight problems. It found high-quality solutions much faster than systems that relied on large populations of random variations or those that simply tried to improve a single line of code based on vague feedback.

The study found that the most critical ingredient for this success was the structured feedback from the validation agent. When the researchers removed this specific type of detailed, execution-based feedback, the system's performance dropped significantly, falling back to near-random levels of success. This confirmed that the ability to see exactly how the code behaved and to receive a clear, actionable diagnosis of what went wrong was the primary driver of improvement. The method was particularly effective on the problem that most directly involved coupled semantics: the cross-coupled optimization task. Here, the system achieved the best score of all methods tested, suggesting that when the correctness of a solution depends entirely on how different parts interact during execution, this dynamic, feedback-driven approach is superior.

While the system excelled in the early stages of problem-solving, the researchers observed a turning point. After about six hundred to eight hundred attempts, other methods that rely on maintaining a large population of different solutions began to catch up and eventually surpass the new system on some tasks. This indicates that while the feedback-driven approach is incredibly efficient at finding good solutions quickly, population-based methods have an advantage in exploring the search space over a very long period. The researchers conclude that their method offers a powerful tool for situations where quick, directed improvement is needed, especially when the problem involves complex dependencies that cannot be solved by looking at the text alone. By grounding the AI in the reality of how code actually runs, rather than just how it is written, the system bridges the gap between static description and dynamic behavior, offering a more reliable path to generating complex software routines.

Technical Summary: Dynamic Adaptation of the LLM Context for Generating Routines with Coupled Semantics

1. Problem Definition: Static Binding and Coupled Semantics

The paper identifies a fundamental limitation in Large Language Model (LLM)-based code generation: the inability to resolve static binding. While LLMs excel at scaffolding code based on textual descriptions, they fail when the correctness of one routine depends on the runtime behavior of another. In these scenarios, the semantic meaning of a component is not defined by its static description but by its execution patterns relative to other components.

The authors formalize this as a taxonomy of meaning dependencies among software components:

Independent: Component meaning is fully defined by its description (e.g., independent scanner routines).
Sender-Receiver (Unidirectional): The meaning of a data sender depends on the receiver (e.g., a maze generator's actions depend on the robot's navigation capabilities).
Receiver-Sender (Unidirectional): The meaning of a receiver depends on the sender.
Cross-Correlated (Bidirectional): The meanings of two components depend on each other (e.g., coupled optimization algorithms where energy distribution depends on crew dispatch, and vice versa).

Standard LLM approaches, including zero-shot prompting and iterative refinement methods like Reﬂexion, treat these dependencies as static. They link concepts at generation time without interpreting runtime semantics, leading to failures in problems requiring joint execution behavior, such as cross-coupled optimization or complex maze navigation.

2. Methodology: Dynamic Context Adaptation

To address static binding, the paper proposes a Dynamic Context Adaptation framework. This system replaces static linking with a validation-generation loop that grounds code synthesis in execution feedback. The architecture consists of three core components:

Knowledge Graph (KG) Intermediate Layer:
Before generation, the system extracts a KG from the problem description using a two-step LLM prompt. This graph clusters text into requirements and constraints, extracting typed nodes and edges (e.g., implements, constrains, depends_on). This structured representation ( $M_{text} \to M_{KG} \to M_{code}$ ) explicitly encodes semantic constraints and coupling relationships, which are injected into the generation agent's prompt.
Validation-Generation Agent Loop:
- Validation Agent: Instead of relying on free-form verbal reflection, this agent executes the current code candidate and analyzes quantitative outcomes and qualitative execution traces. It produces structured diagnostic feedback (e.g., identifying specific token violations, unproductive loops, or coupling violations) rather than general suggestions.
- Generation Agent: Receives the incumbent code, the KG-derived constraints, and the structured feedback. It proposes $k$ new candidates per iteration, guided by actionable suggestions derived from the execution traces.
Simulated Annealing (SA) Selection:
To prevent the system from greedily committing to local improvements (a common failure mode in single-trajectory methods), the system employs Simulated Annealing to select the next incumbent.
- A candidate with a better score is always accepted.
- A worse candidate is accepted with probability $P = \exp((s_2 - s_1)/T)$ .
- The temperature $T$ cools geometrically ( $T \leftarrow T \times \alpha$ ), allowing for broad exploration early in the process (when feedback signal is weak) and near-greedy exploitation later (when structured feedback provides strong directional guidance).

3. Key Contributions

Formal Taxonomy: A precise characterization of LLM static-binding limitations through four cases of meaning dependencies among software components.
Novel Architecture: A two-agent system integrating a Knowledge Graph for semantic grounding and a validation-generation loop with structured execution feedback.
Sample Efficiency: Empirical evidence demonstrating that structured execution feedback drives rapid, directed improvement in low-budget regimes (300–600 evaluations), outperforming population-based search methods that require more evaluations to accumulate diversity.

4. Experimental Results

The method was evaluated on eight problems, including two primary motivating cases (Maze Navigation and Cross-Coupled Optimization) and six standard benchmarks (Circle Packing, Function Minimization, TSP, etc.). The system used the Qwen/Qwen2.5-72B-Instruct model.

Performance vs. Baselines:
- Low Budget (300 & 600 evaluations): The proposed method outperformed OpenEvolve (a population-based evolutionary method) and Reﬂexion on 7 out of 8 problems at both 300 and 600 evaluations ( $p < 0.01$ ).
- High Budget (1000 evaluations): OpenEvolve surpassed the proposed method on 7 of 8 problems. However, the proposed method achieved the best score on the Cross-Coupled Optimization problem (0.694 vs. 0.681 for OpenEvolve, $p = 0.019$ ), validating the hypothesis that structured feedback is most beneficial when runtime coupling is explicit.
- Convergence Dynamics: The results show a "crossover" point between 600–800 evaluations. Below this threshold, the gradient-like feedback of the proposed method allows for faster convergence than the diversity accumulation required by population-based methods. Above this threshold, population-based methods find novel structural variations that the single-incumbent approach misses.
Ablation Study:
- Structured Feedback: The primary driver of performance. Removing it caused a significant drop in scores (e.g., -28% on Maze Navigation), reducing the system to near-random generation.
- Simulated Annealing: Critical for high-variance discrete problems (e.g., -16% drop on Maze Navigation when replaced with greedy selection), preventing premature convergence.
- Knowledge Graph: Provided consistent but moderate gains, particularly when constraint structures were underspecified in plain text.

5. Significance and Claims

The paper claims that structured execution feedback acts as a "gradient approximation" for discrete code generation. By extracting diagnostic information from execution traces, the system provides directional guidance that eliminates entire classes of failure, compressing the search space more effectively than undirected mutations in the early stages of optimization.

The authors position their work not as a replacement for population-based search, but as a complementary approach. The system is most effective in the sample-efficient regime (under 600–800 evaluations) and for problems with coupled semantics where runtime behavior defines correctness. The crossover with population-based methods reflects a trade-off between feedback-driven early convergence and population-based asymptotic exploration, rather than a failure of the feedback mechanism itself.

The paper concludes that for problems where correctness depends on the joint execution behavior of components, grounding LLM context in dynamic execution traces is superior to static linking or unstructured reflection.