Les Agents comme des interpreteurs Scheme : Specification dynamique par la communication

We proposed in previous papers an extension and an implementation of the STROBE model, which regards the Agents as Scheme interpreters. These Agents are able to interpret messages in a dedicated environment including an interpreter that learns from the current conversation therefore representing evolving meta-level Agent’s knowledge. When the Agent’s interpreter is a nondeterministic one, the dialogues may consist of subsequent refinements of specifications in the form of constraint sets. The paper presents a worked out example of dynamic service generation - such as necessary on Grids - by exploiting STROBE Agents equipped with a nondeterministic interpreter. It shows how enabling dynamic specification of a problem. Then it illustrates how these principles could be effective for other applications. Details of the implementation are not provided here, but are available.

💡 Research Summary

The paper extends the STROBE agent model by treating each agent as a Scheme interpreter that can evaluate incoming messages in its own dedicated environment. This interpreter is not static; it can be modified at the meta‑level during a conversation, allowing the agent’s knowledge to evolve dynamically. The authors further equip the interpreter with nondeterministic capabilities (using Scheme’s amb and require constructs) so that a single dialogue can progressively refine a problem specification expressed as a set of constraints.

The core idea is that an agent receives a request, translates it into a Scheme expression, and evaluates it in its private interpreter. Because the interpreter itself can be altered, the agent can add new definitions, functions, or evaluation rules on the fly. When the interpreter is nondeterministic, it can generate multiple candidate solutions for a given specification. As the user adds constraints through natural‑language dialogue, the agent injects corresponding require statements, which prune the solution space until a satisfactory implementation emerges.

To illustrate the approach, the authors present a detailed scenario typical of grid computing: a user asks for a data‑analysis service. The agent replies with a generic Scheme template. The user then specifies that the input must be a CSV file, the output a JSON document, and that the computation should be parallelized. After each constraint, the agent re‑runs the nondeterministic interpreter, which explores all possible ways to satisfy the accumulated constraints and finally produces a concrete Scheme program (or a script that can be submitted to a grid resource manager). This program can be directly deployed, achieving “dynamic service generation” without any pre‑written service description.

Key technical contributions include:

1. Meta‑level interpreter design – a dual‑layer architecture where the lower layer evaluates user code and the upper layer can modify the lower layer’s environment during interaction.
2. Constraint‑driven refinement via nondeterminism – leveraging amb to enumerate alternatives and require to filter them, effectively turning a dialogue into an incremental constraint‑satisfaction process.
3. Automatic provisioning on grids – the generated Scheme code can be mapped to grid job descriptors, enabling on‑the‑fly deployment of services that exactly match the user’s evolving requirements.
4. Knowledge sharing among agents – agents can serialize their meta‑level knowledge (new definitions, heuristics, constraint patterns) and exchange it, allowing rapid adaptation to new domains without rebuilding the interpreter from scratch.

The authors discuss implementation concerns such as the combinatorial explosion of nondeterministic search, which they mitigate by inserting constraints early, limiting search depth, and applying heuristics. They also address the need for secure serialization of interpreter state when agents communicate across a network, recommending signing and encryption. Although the paper does not provide source code, it outlines how the existing STROBE framework can be extended with a Scheme interpreter and nondeterministic operators.

In conclusion, treating agents as mutable Scheme interpreters enables a form of “conversational programming” where users, even without programming expertise, can iteratively define and refine complex services through natural dialogue. This dramatically reduces time‑to‑market for grid‑based services, supports fine‑grained resource allocation, and opens the door to more adaptive, user‑centric service‑oriented architectures. Future work is suggested in scaling the nondeterministic search, formalizing multi‑agent collaboration protocols, and conducting large‑scale experiments on real grid and cloud platforms.