A Language for Describing Agentic LLM Contexts

Technical Summary: A Language for Describing Agentic LLM Contexts

Problem Statement
Large language models (LLMs) are increasingly deployed as core reasoning components within complex, multi-component agentic systems. These systems rely on sophisticated input contexts that evolve dynamically over time, comprising instructions, observations, interaction history, and tool outputs. The structure of this context—specifically which messages are included, how history is accumulated, and under what conditions content appears—is a critical design artifact that directly shapes agent behavior.

Despite its centrality, there is currently no standard method for describing context construction. Practitioners rely on informal prose, ad hoc diagrams, or direct code inspection. This lack of a shared descriptive framework creates several issues:

1. Ambiguity: Textual descriptions often fail to precisely capture how a prompt evolves across interaction steps or how two structurally similar strategies differ.
2. Reproducibility: Even when code and prompt templates are shared, the logic governing context assembly is rarely explicit in research papers, complicating reproduction.
3. Comparability: It is difficult to rigorously communicate or compare context evolution strategies across different systems or within research teams.
4. Performance Sensitivity: Small structural variations (e.g., including or excluding reasoning traces from history) can lead to measurable differences in agent performance, yet these nuances are often obscured in standard documentation.

Methodology: The Agentic Context Description Language (ACDL)
To address these challenges, the authors introduce the Agentic Context Description Language (ACDL), a domain-specific language (DSL) designed to precisely describe the structure and dynamics of LLM input contexts independently of any specific implementation.

ACDL operates on the following principles:

• Abstraction: It abstracts away concrete wording (the domain of prompt engineering) to focus on the macro-logic of information selection and structuring (context engineering). It uses symbolic labels to denote the role, type, and source of information (e.g., distinguishing system instructions from tool outputs).
• Temporal Modeling: The language models agentic systems as discrete-time state machines. It uses time-indexed variables (e.g., @T) to track how elements accumulate across interaction steps. It supports nested time steps (sub-steps) to describe complex loops, such as a multi-turn chat where each turn contains an internal ReAct loop.
• Control Flow: ACDL includes constructs for conditional logic (If, Else, Switch) and iteration (ForEach) to describe how context is assembled, transformed, and how history is unpacked into the prompt.
• Information Sources: It categorizes information sources into constants, system state (sys), environment state (env), previous LLM responses (resp), and pure functions. This allows the language to describe dynamic content without specifying the underlying state management code.
• Multi-Agent Support: The language can parameterize contexts by agent ID, allowing for the description of systems with isolated states or shared memory/clocks.

The language is designed to be both human-readable and machine-parseable. It supports visual rendering, allowing specifications to be rendered as diagrams (similar to flowcharts or sequence diagrams) that make structural differences immediately apparent.

Key Contributions

1. Formal Language Specification: The paper defines ACDL, a formal syntax for specifying context composition, evolution, and control flow.
2. Tooling Ecosystem: The authors provide a parser, an interactive web-based visualizer, a VS Code extension with live rendering, and a Claude Code skill to operationalize ACDL.
3. Reverse-Engineering and Documentation: The authors demonstrate the language's utility by documenting several existing systems:
   • ReAct Variants: Showing how minor structural changes in ReAct loops (e.g., placement of reasoning traces) are explicitly captured.
   • OpenCode and OpenClaw: Reverse-engineering the main loop prompts of these popular open-source coding and personal assistant agents to highlight differences in their context compaction and tool-calling strategies.
   • Gemini Pokémon Agent: Documenting the context structure of the Gemini 2.5 agent playing Pokémon Blue, as described in a technical report, providing a clearer, less ambiguous representation than the original text.
4. Empirical Validation: The authors conducted a small experiment on a ReAct agent where they removed reasoning traces from the history (a change easily specified in ACDL). They observed that this variant hurt performance on reasoning tasks while slightly improving performance on code tasks, illustrating the tangible impact of structural context choices.

Results and Demonstrations
The paper does not claim to solve the problem of optimizing context, but rather to solve the problem of describing it. The results presented are qualitative and demonstrative:

• Clarity: ACDL renders structural differences (e.g., the location of instructions, the interleaving of tool responses) explicit and comparable at a glance, whereas textual descriptions require lengthy prose.
• Precision: The language successfully captures complex scenarios, such as nested loops in multi-step agents and the specific history compression strategies used in state-of-the-art systems.
• Adoption Potential: The authors note that the tools allow for both human-to-human communication (via whiteboard diagrams or PDFs) and human-to-AI communication, observing that coding agents (like Claude Code) can read ACDL specifications to generate corresponding agentic loops.

Significance and Claims
The paper positions ACDL as a necessary standard for the "science and engineering of agentic systems." Its significance lies in:

• Rigorous Communication: Enabling unambiguous communication of context design choices within teams and across the research community.
• Faithful Comparison: Allowing researchers to compare context construction strategies across different systems without the noise of implementation details.
• Elevating Context Engineering: Moving context construction from an "after-thought" or informal practice to a "rigorous object of study" by providing a formal vocabulary and visualization method.

The authors are modest in their claims, acknowledging that ACDL is a descriptive language, not a programming language for building agents. They also note current limitations, such as the difficulty of describing systems with mutable state during context construction (requiring a conversion to an immutable model first) and the lack of a clean mechanism for multi-agent systems with separate clocks sharing mutable state. They view ACDL as a candidate standard intended to facilitate clearer documentation, comparison, and analysis in the rapidly evolving field of agentic LLMs.