Meta Rational Pragmatics article
MRP Research AI-Assisted Research Home
MRP Article 08 Natural language as executable medium

Executable Natural Language

From language to governed execution.

Author: Sînică Alboaie Series: Meta Rational Pragmatics Focus: Executable pragmatics
Permalink & citation

Why Executable Natural Language Matters

The ambition to treat natural language as something closer to a programming language is not new. What has changed is the execution model. Earlier systems typically demanded a controlled language with a deterministic mapping into logic or code. Current systems increasingly rely on language models as interpreters that execute partially structured textual specifications through iterative prompting, retrieval, tool invocation, and local replanning [FUCHS-SCHWITTER-1996] [FUCHS-ET-AL-2008] [XU-2024].

This shift matters because it relocates operational meaning. In older systems, meaning had to be fixed before execution. In contemporary agent systems, part of meaning is decided during execution by the interaction among text, context, memory, tools, and control policy. That is exactly why executable natural language is central for Meta-Rational Pragmatics: the hard problem is no longer only semantic representation, but governance of interpretation under runtime conditions.

Two Main Families of Execution

A useful distinction separates formal-semantics-first systems from runtime-pragmatics-first systems. In the first family, text becomes executable because it is translated into a stable formal target. Attempto Controlled English is the clearest example. ACE keeps a readable English-like surface but constrains the language tightly enough to support unambiguous mapping into discourse representation structures and logic-like forms [FUCHS-SCHWITTER-1996] [FUCHS-ET-AL-2008].

Gherkin shows a weaker but industrially successful model. Its steps are operational only because they are attached to external code. That is still valuable, but it is not a full semantics of natural language; it is a disciplined bridge between scenario text and host-language implementations [CUCUMBER-2025].

The second family leaves more underdetermined until runtime. Here a language model or agentic runtime decides how to interpret a textual step in context, which tools to invoke, what information to retrieve, and what branch to follow. The gain is flexibility. The cost is that guarantees become harder to state and audit.

Runtime-Centered Systems

LMQL occupies an important middle position. It does not translate English into logic in the ACE sense, but it does provide a programming model for language-model interaction with variables, constraints, and control flow, and it can compile some of those constraints into token-level restrictions [BEURER-KELLNER-2022].

CoRE makes the runtime turn even more explicit. It proposes a structured natural-language program whose steps are executed by an LLM-centered runtime with memory, tool use, and explicit branch control. This is one of the clearest examples of executable pragmatics: the text is not enough on its own; execution depends on the surrounding interpretive machine [XU-2024].

ReAct shows the same tendency in a looser form. Intermediate text becomes part of control rather than mere explanation, because reasoning traces and actions are interleaved in an iterative loop [YAO-2023]. PAL moves in the opposite direction by asking the language model to synthesize code and then delegating actual execution to a deterministic interpreter, which remains one of the strongest compromises when one wants flexible understanding but stricter execution [GAO-2022].

Toolformer, DSPy, and AutoGen extend this landscape further. Toolformer internalizes part of the decision about when and how tools should be used [SCHICK-2023]. DSPy treats LM pipelines as declarative programs open to compilation and optimization [DSPY-2023]. AutoGen turns multi-agent conversation patterns into programmable orchestration structures [WU-2023].

Constraints, Schemas, and Hardening Layers

Constraint-oriented systems matter because free-form runtime interpretation is not enough in serious deployments. Guided generation methods restrict output so that only strings compatible with a grammar, schema, or automaton remain admissible. They do not solve the full semantic problem, but they provide a hardening layer between flexible model behavior and reproducible executable artefacts [WILLARD-LOUF-2023] [BEURER-KELLNER-2022].

Once the field is viewed this way, three architectural patterns become visible: translation-based execution, interpreter-based execution, and constraint-shaped execution. None of them is sufficient on its own. The likely future is hybrid: a light controlled language for authoring, an explicit intermediate representation for replay and validation, an agentic runtime for local micro-planning, and boundary constraints that keep execution within declared contracts [XU-2024].

The Role for Meta-Rational and Executable Pragmatics

For Meta-Rational Pragmatics, the decisive lesson is not that natural language has suddenly become a perfectly formal language. The lesson is that execution increasingly depends on a governed runtime that must decide what reading is active, what evidence is admissible, when ambiguity may be tolerated, and when a softer interpretation must be escalated into a stricter regime.

That is why executable natural language belongs directly inside executable pragmatics. It forces us to model not only statements and outputs, but the policies by which statements become operational. In this sense, the central challenge is no longer just “how to prompt a model,” but how to expose, constrain, and audit the transition from text to controlled action.

References

  • [BEURER-KELLNER-2022] Beurer-Kellner, L., et al. (2022). Prompting Is Programming: A Query Language for Large Language Models.
  • [CUCUMBER-2025] Cucumber. (2025). Gherkin Language Reference.
  • [DSPY-2023] Khattab, O., et al. (2023). DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines.
  • [FUCHS-SCHWITTER-1996] Fuchs, N. E., & Schwitter, R. (1996). Attempto Controlled English (ACE).
  • [FUCHS-ET-AL-2008] Fuchs, N. E., Kaljurand, K., & Kuhn, T. (2008). Attempto Controlled English for Knowledge Representation.
  • [GAO-2022] Gao, L., et al. (2022). PAL: Program-aided Language Models.
  • [SCHICK-2023] Schick, T., et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools.
  • [WILLARD-LOUF-2023] Willard, B., & Louf, R. (2023). Efficient Guided Generation for Large Language Models.
  • [WU-2023] Wu, Q., et al. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation.
  • [XU-2024] Xu, S., et al. (2024). AIOS Compiler: LLM as Interpreter for Natural Language Programming.
  • [YAO-2023] Yao, S., et al. (2023). ReAct: Synergizing Reasoning and Acting in Language Models.