SHERPA: A Model-Driven Framework for Large Language Model Execution

TL;DR

SHERPA introduces a model-driven framework using hierarchical state machines to explicitly incorporate domain-specific best practices, significantly enhancing large language models' performance on complex tasks across various applications.

Contribution

The paper presents SHERPA, a novel framework that controls LLM behavior through state machines, improving performance on complex tasks by integrating domain-specific knowledge.

Findings

State machines improve LLM output quality.

SHERPA enhances performance on code generation, class naming, and question answering.

Framework is effective across various LLMs.

Abstract

Recently, large language models (LLMs) have achieved widespread application across various fields. Despite their impressive capabilities, LLMs suffer from a lack of structured reasoning ability, particularly for complex tasks requiring domain-specific best practices, which are often unavailable in the training data. Although multi-step prompting methods incorporating human best practices, such as chain-of-thought and tree-of-thought, have gained popularity, they lack a general mechanism to control LLM behavior. In this paper, we propose SHERPA, a model-driven framework to improve the LLM performance on complex tasks by explicitly incorporating domain-specific best practices into hierarchical state machines. By structuring the LLM execution processes using state machines, SHERPA enables more fine-grained control over their behavior via rules or decisions driven by machine learning-based approaches, including LLMs. We show that SHERPA is applicable to a wide variety of tasks-specifically, code generation, class name generation, and question answering-replicating previously proposed approaches while further improving the performance. We demonstrate the effectiveness of SHERPA for the aforementioned tasks using various LLMs. Our systematic evaluation compares different state machine configurations against baseline approaches without state machines. Results show that integrating well-designed state machines significantly improves the quality of LLM outputs, and is particularly beneficial for complex tasks with well-established human best practices but lacking data used for training LLMs.

Figures

Tables

Table 1. TABLE I: Performance comparison between direct and SM-based methods.

	HumanEval		Modeling						Clevr
	Direct	SHERPA	Direct			SHERPA			Direct	SHERPA
	Pass@1	Pass@1	P	R	$F_1$	P	R	$F_1$	ACC	ACC
GPT-4o Mini	85.37	88.82	88.89	63.20	73.36	85.22	70.77	76.77	86.00	86.67
GPT-4o	91.26	90.24	92.98	55.24	68.90	92.82	58.65	71.16	90.67	88.33
Qwen2.5 7B	83.13	85.37	81.15	47.52	57.38	89.75	62.06	71.57	70.00	75.33
Qwen2.5 72B	84.76	90.65	90.41	56.78	68.98	89.35	73.71	80.07	86.67	86.67
Task-Specific LLM	89.84	91.26	88.76	64.07	73.85	88.51	67.68	75.80	83.00	84.67

Full text

I Introduction

Context. Models capturing structural system behavior are fundamental elements of model-driven engineering (MDE). Behavioral models such as hierarchical state machines [1], activity diagrams [2], and sequence diagrams [2] provide well-defined structures to represent system behavior at various levels of abstraction. Within the context of MDE, these models facilitate the mapping of requirements to system design by leveraging human best practices and domain knowledge. Subsequently, these models enable the generation of lower-level artifacts. They also support the verification of system behavior, which is essential for safety-critical applications.

Large language models (LLMs) produce stochastic sequences of predictions based on input prompts [3]. With the emergence of advanced LLMs such as GPT-4o [4] and Qwen-2.5 [5], they have become powerful tools for automating complex tasks across diverse domains using natural language. LLMs have shown remarkable capabilities in various applications, including code generation [6], question answering [7], and planning [8, 9]. In MDE, recent efforts have also shown promising results in fully automating the generation of diverse types of models directly from natural language descriptions [10].

Problem description. However, the stochastic nature of LLMs raises significant concerns around the potential hallucination in the generated outputs [11]. Moreover, specific human best practice is rarely reflected in training data, which limits LLMs’ performance in complex and domain-specific tasks. Approaches like retrieval augmented generation (RAG) provide a way to add up-to-date task context [12, 13, 14, 15], but they do not offer an approach to solve tasks involving complex workflows. Despite recent advancements in multi-step reasoning approaches such as Chain-of-Thought [16], Tree-of-Thought [17], and ReAct [18], LLMs still face challenges in maintaining long-term consistency and performing effective multi-step planning for complex tasks.

Recently, integrating structured workflows into the execution of LLM-based applications has been recognized as a promising solution to address these limitations. Multiple frameworks [19, 20] have been proposed to integrate LLMs with behavioral models to enhance task performance. However, the model used in these approaches still remains simple and is often coupled with implementation. More expressive behavior models, such as hierarchical state machines, which provide flexible and powerful mechanisms to decompose tasks into simpler sub-tasks, have not yet been fully leveraged. Moreover, best practices can often be modeled in multiple ways, which may significantly influence the performance of LLM systems, making it important for the framework to enable rapid experimentation.

Objectives. This paper investigates the impact of model-driven processes on LLM task execution using behavioral models to represent human best practices. We explore the potential of these models to enhance the performance of LLMs for complex tasks, by proposing SHERPA: a framework for Stateful Hierarchical Execution and Reasoning for Process Automation. SHERPA leverages hierarchical state machines to explicitly incorporate best practices into the task execution process. LLMs can be used within actions performed during state transitions. Additionally, SHERPA supports flexible task execution by enabling state transitions driven by logic and stochastic predictions, while explicitly preserving execution histories and intermediate results for subsequent executions.

Contribution. This paper makes the following contributions:

• •

We propose SHERPA, a model-driven framework that integrates human best practices as hierarchical state machines with LLMs to enhance task performance.

• •

We propose a hybrid policy for state transition that combines rule-based and LLM-driven approaches while proposing a belief structure to store the execution history and intermediate results.

• •

We show the applicability of SHERPA to a variety of tasks, including code generation, class name generation, and question answering. We demonstrate how SHERPA can be used to replicate existing approaches while improving their performance by enhancing the state machine design.

• •

We evaluate the effectiveness of SHERPA on these three tasks using two LLM families: GPT-4o [4] and Qwen-2.5 [5] as well as task-specific LLMs such as Qwen-2.5-Coder [21] and Llama3.1-70B [22].

Added value. Compared to existing approaches combining LLMs with structured workflows, SHERPA is a more general, model-driven framework for tackling complex tasks with LLMs. It showcases how current LLMs can benefit from MDE approaches by enabling task decomposition with modular representation. SHERPA decouples the state machine design from the action implementation, allowing changing state machine designs without updating the implementation.

II Background

LLMs. Large language models (LLMs) have gained significant attention for many tasks based on natural language [7, 6, 10]. LLMs use deep neural networks, typically with transformer architecture [23], to estimate a probability distribution of text sequences. Current state-of-the-art generative LLMs are primarily based on the decoder-only architecture, which is derived from the original transformer architecture. In general, an LLM llm can be seen as a mapping between sequences of input and output tokens: $\texttt{llm:}s_{in}\rightarrow s_{out}$. More specifically, given a sequence of tokens (called prompt) $s_{in}=\{s_{1},s_{2},...,s_{k-1}\}$, LLMs estimate the conditional probability of the next token $P(s_{k}|s_{1},...,s_{k-1})$. Then LLMs continue to generate the next tokens auto-regressively until a special stop token is generated or a maximum length is reached to output the final sequence $s_{out}$. These LLMs are typically first pre-trained on a large corpus of text data using unsupervised learning, followed by fine-tuning to follow input instructions [24, 25].

LLM frameworks. Recent studies indicate that augmenting LLMs with external tools can enhance performance across various tasks [26]. Such integration aims to separate task planning and decomposition with LLMs from task solving with other tools  [18] to address specific problems more effectively.

However, the performance of LLMs may be limited in tasks requiring domain-specific knowledge not already available in their training data. For instance, within the context of software modeling, LLMs struggle to generate domain models that adhere to established best practices and modeling patterns [27]. To overcome this limitation, recent LLM frameworks support the construction of structured workflows to guide the behavior of LLMs [28, 19]. In these frameworks, workflows are represented as graphs, with nodes corresponding to different tasks which can be potentially executed by an LLM, and edges denoting task progression. LLMs can also assist in making branching decisions at nodes within these workflows.

Furthermore, LLMs can be equipped with external memory to store and retrieve contextual information as needed [28, 29]. This capability addresses their limitations in handling tasks across multiple steps. Such memory implementations often utilize key-value stores [29], enabling the retrieval of relevant information at various task stages.

In this paper, we aim to combine these aspects for LLMs by leveraging a state-machine-driven approach. Each instance of SHERPA incorporates a hierarchical state machine to structure workflows, where actions within transitions may use external tools. During state machine execution, a belief is maintained as memory to retain and access pertinent information.

State machines. A state machine (SM) [30] is a model used to describe the behavior of a system that can be in a finite number of states. SMs provide a visual representation to help with the development and maintenance of a system. Moreover, they can be used to enable automated code generation [31, 32] and facilitate verification of system behaviors [33].

Formally, an SM is a tuple $(\mathcal{S},\mathcal{T},\mathcal{A},\mathcal{G},entry,exit,\delta,s_{0},\mathcal{F})$ where $\mathcal{S}$ is a set of states, $\mathcal{T}$ is a set of event triggers for transitions, $\mathcal{A}$ is the set of actions that can be performed during transitions or in states, $\mathcal{G}$ is the set of guard conditions for transitions, $entry:\mathcal{S}\to\mathcal{A}$ and $exit:\mathcal{S}\to\mathcal{A}$ map states to entry and exit actions, respectively. $\delta:\mathcal{S}\times\mathcal{T}\times\mathcal{G}\to\mathcal{A}\times\mathcal{S}$ is the state transition function, $s_{0}\in\mathcal{S}$ is the initial state, and $F\subseteq\mathcal{S}$ is the set of final states.

A hierarchical SM is an extension of SMs [1] by organizing states hierarchically. When a state is activated, all its parent states are also considered active, and transitions defined for a parent state apply to its child states as well. This hierarchy improves modularity and abstraction, reducing redundancy in defining transitions between related states. Formally, a hierarchical SM adds a hierarchical function $h:\mathcal{S}\to\mathcal{S}$ that maps states to their parent states. The state transition function $\delta$ is extended to include the parent state in the transition tuple.

There exist many definitions of the textual languages for SMs, such as PlantUML [34] and Umple [35]. While SHERPA uses JSON to define the SM, it can be easily adapted to other concrete syntax by using a parser.

III Combining State Machines with LLMs

This section introduces how SHERPA integrates SMs with LLM execution. We first provide an overview of the SHERPA framework, followed by a detailed description of the architecture with an example in question answering.

III-A Overview

Figure 1 provides an overview of the architecture. We define each instance of SHERPA as an agent that is capable of executing a specific task. Each agent is associated with a state machine. A user, either a human or another agent, interacts with the agent by sending an event to its SM. These events can include messages, such as a question, which are recorded as task context in the agent’s belief. Then the SM performs state transitions based on the received event and may execute predefined actions associated with that transition. Following the transition, the SM updates the agent’s belief with the result of the action and the agent’s new state. The belief contains the trajectory store keeping track of the taken transitions in the SM, and an execution log containing (1) executed actions including their outputs and (2) a key-value store containing information relevant to the subsequent states as action inputs.

This updated belief, along with available transitions in the current state, is then provided to the policy, which uses an LLM or a predefined rule to determine the optimal next step. The selected event is subsequently sent back to the SM to initiate further transitions. This cycle continues until the SM either reaches an end state (terminating the process) or all transitions require external input (e.g., waiting for further user input). Next, we provide a detailed introduction to each component.

III-B Architecture

State machine

The SM in SHERPA systematically controls the LLM behavior by defining explicit states and transitions inspired by human best practices for the targeted task. Note that the state machine is a type of data in SHERPA, which supports dynamically altering the structure of the state machine without changing other components for an agent. Figure 2 shows the metamodel of the SM used in SHERPA.

The core components of the SM are its states. Although standard UML SMs include various types of states, such as parallel regions and history states, hierarchical states are particularly useful for decomposing complex tasks into simpler, manageable sub-tasks. Such decomposition aligns closely with the primary purpose of integrating human best practices into LLMs. Therefore, SHERPA employs two types of states: atomic simple states and hierarchical composite states. A composite state contains multiple sub-states. Each state includes a name and a textual description, which provide meaningful representations of the current state. These attributes are essential for the policy to evaluate and select potential transitions, especially when an LLM is used within the policy. Additionally, states may have optional tags denoting special behaviors. Currently, the supported tags include start and end, indicating the initial and final states, respectively.

The SM also incorporates a set of transitions defining its operational flow. Each transition explicitly connects a source state to a target state and specifies an event that triggers this transition. The triggering event may originate from a user message or be internally generated by the agent’s policy. Transitions may also include optional guard conditions to provide finer-grained control over state transitions. Such guard conditions are represented using the condition class in the form of either a simple logical expression evaluated against the agent’s belief or the name of an action with more sophisticated logic, such as invoking another LLM.

The behavior of the agent during state transitions is defined by actions. Typically, actions perform sub-tasks such as calling an LLM, retrieving relevant data from a database, or calling external tools for various types of specialized computation. Each action is characterized by a name and a set of parameters, which are defined by their names, types, and descriptions, including their expected data type and guidance for how they should be provided. Each parameter in an action can be one of the following two types, depending on how it should be provided: (1) external parameters are provided externally when the action is invoked, such as user input or provided by the policy through an LLM; (2) internal parameters are provided internally through the agent’s belief during the execution of the action. Actions can be integrated into the SM in multiple ways: they may be attached directly to transitions, triggering execution upon transition activation, or associated with states, executing when entering or exiting a particular state.

Policy

A policy in SHERPA determines the next transition for an agent by considering its current state and belief. The term policy is adapted from reinforcement learning literature, given its analogous role in decision-making [36]. Formally, let $s\in\mathcal{S}$ be the current state, $\mathcal{T}_{s}$ be the set of available transitions at state $s$, $\mathcal{E}$ be the set of possible events that can trigger transitions, and $B$ be the agent’s belief. A policy is defined as a mapping $\pi(s,\mathcal{T}_{s},B)\to e$, where $e\in\mathcal{E}$ is the selected event along with any data required by the transitions.

Policies can be implemented using various approaches, including rule-based systems, a supervised machine learning model, reinforcement learning, or LLMs. In the current version of SHERPA, to demonstrate the concept, we introduce two primary policy types that can be combined flexibly to guide an agent’s behavior. Notably, SHERPA can be easily extended to incorporate additional policies provided that they conform to the predefined policy interface.

Rule-based policy. A rule-based policy uses predefined mapping rules to determine the next transition based on the agent’s current state and belief. These rules typically reference the current state and specific values stored within the belief of an agent. For example, a rule may specify that whenever a generated domain model includes an abstract class without subclasses, the policy should select a transition leading back to a state responsible for regenerating the domain model.

LLM-based policy. Inspired by the ReAct framework [18], the LLM-based policy utilizes an LLM to determine the next state transition. Figure 3 illustrates an example prompt used for selecting the next transition within the context of question answering. Upon policy initialization, a task description defining the overall task, along with an output instruction specifying the expected output, is provided. During execution, when the LLM-based policy is invoked, the relevant execution history, including the trajectory and previous actions, is extracted from the belief. To prevent exceeding the maximum token limit of LLMs, SHERPA uses a sliding-window mechanism to extract the most recent execution history that uses up to a fixed amount of tokens. Additionally, the SM provides the current state, including its description and available transitions. If any actions are associated with these transitions, or with exiting the current state or entering the subsequent state, the LLM is also prompted to generate the necessary external input parameters for these actions. Based on this information, the LLM is then prompted to select the most appropriate next transition.

Beyond these two policy types, SHERPA incorporates a fast-forward mechanism for efficiency. In situations where only one transition is available, due to either the SM’s structure or the evaluation of guard conditions, the fast-forward mechanism automatically selects this transition, skipping potentially computationally intensive policy evaluations.

Belief

The belief of an agent in SHERPA is a structured data store to maintain information relevant to the current task. Compared to typical memory in LLM-based agents [29], which usually consists solely of a key-value store, the belief structure in SHERPA additionally includes a trajectory store and an execution log. The trajectory store maintains a sequence of state transitions that the agent has traversed, thereby providing essential context for decision-making. In parallel, the execution log records the history of actions performed by the agent, enabling tracking and retrospective analysis of behavior. The execution log also contains a key-value store preserving task-specific information that can be dynamically saved during action execution. Information in the belief is accessible during both transition selection by the policy and action execution.

III-C Example

Figure 4 illustrates the integration of a routing SM (see Figure 5 (3.a)) for question answering from a scene graph. Specifically, the LLM is prompted with the question: ”How many metal objects would there be if you didn’t include spheres?”. Note that the image is first converted into a textual scene graph, and the LLM’s task is to answer the given question based on this graph. Initial experiments indicate that LLMs frequently produce incorrect answers to counting questions. We hypothesize that this arises because the LLM simultaneously performs multiple complex subtasks: (1) interpreting the question, (2) extracting relevant objects from the scene graph, and (3) counting these extracted objects.

To address this challenge, we propose employing an SM to explicitly decompose the question-answering process into distinct subtasks based on the type of question. Specifically, relevant contextual information, such as the scene graph and question, is initially stored in the belief. Then, the LLM is prompted to determine the question type (classifyQuestion action within the QuestionClassification state). If identified as a counting question, the LLM is subsequently prompted to extract relevant objects from the scene graph (extractObjects action upon entering the ObjectExtraction state). After extraction, the number of objects is counted deterministically (countObjects action upon exiting the ObjectExtraction state). Throughout this procedure, SHERPA maintains a trajectory store to track state transitions, and an execution log that records the sequence of executed actions along with their corresponding inputs and outputs. Finally, the output of SHERPA is defined as the result of the final executed action.

IV Use Cases

To demonstrate and assess the effectiveness of SHERPA, we examine three distinct tasks that can be automated using LLMs: code generation, class name generation, and question-answering. We specifically select these tasks due to their differences in data availability and human best practices. Code generation is widely recognized as a popular task for evaluating the capabilities of LLMs, supported by numerous available datasets [37]. Additionally, established human best practices, such as test-driven development, are already popular in software engineering, providing effective frameworks for addressing this task. In contrast, class name generation represents a typical modeling task. Although this task has well-established human best practices, it currently has significantly fewer available datasets. Finally, question-answering is a well-known task for LLM evaluation with many datasets [38]; however, unlike the previous two tasks, it lacks clearly defined human best practices for systematically solving this task generally.

IV-A Code generation

Task description. The code generation task involves generating code based on natural language descriptions. LLMs recently have emerged as promising tools for this task due to their strong code generation ability [37].

State machines. To systematically address the code generation problem using SHERPA, we implement two SMs (see Figure 5 (1)) based on how humans use tests to write code.

In the test-driven SM, we first ask the LLM to generate test cases based on the function description, after which the LLM is prompted to generate the solution function. A function is returned if it passes all the tests. If not, the process returns to the Test Case Generated state to retry. If no function passes all the tests after a certain budget is reached, the one that passes the most tests is returned.

The agent coder SM is based on the AgentCoder approach [39], with a single LLM performing both roles: programmer and test designer. The process begins with the LLM generating the function. Once the function is produced, the LLM then generates test cases. If the function does not pass all tests, the process retries from the Start state, generating a new candidate function and tests. If no function passes all the tests, the one that passes the most tests is returned.

The agent coder SM shows the applicability of SHERPA by replicating a previous approach. The test-driven SM can be seen as a refinement of the agent coder SM, where the repeated generation of test cases is avoided.

IV-B Class name generation

Task description. Domain model generation is an important MDE task where LLMs are increasingly popular [10]. This task involves generating a domain model based on a problem description. However, the evaluation of generated domain models is typically labor-intensive. Thus, we focus on generating class names in domain models to simplify this process.

State machines. To systematically address this generation problem using SHERPA, we implement two SMs, one of which is shown in Figure 5 (2). The main flow in the SM is motivated by the multi-step iterative generation approach (MIG) [40], which includes the following components for class names:

(1) Classes and attributes generation. In this composite state, the LLM is asked to generate all potential classes, including regular classes, abstract classes, and enumerations. The process begins by extracting relevant nouns from the problem description, which serve as candidate class names, attribute names, or enumeration literals. Subsequently, the approach categorizes these candidates into regular, abstract, and enumeration classes in a cascading manner. The final step involves assigning attributes to each class based on previous noun analysis and previously identified class types.

(2) Pattern generation. Patterns are an integral part of domain modeling. In this composite state, the approach performs player-role pattern identification and makes transitions based on the result using an LLM. If no designated pattern is detected, the SM transitions to the feedback generation state. Otherwise, it proceeds to generate the identified pattern and integrate the pattern into the model to align with modeling practice.

(3) Generate feedback. This composite state enhances the partial domain model through LLM self-reflection. The approach first generates feedback about the model, then iteratively improves the partial domain model based on this feedback. Even though the focus is on class name generation, attributes and patterns are identified as they also help to identify classes.

The above processes are largely linear as there is no mechanism for the generation process to retry if some major mistakes are detected. To address this issue, we further introduce the inspect model composite state, providing transitions to return to the identify classes and attributes state or identify pattern state. The LLM is asked to examine the classes and determine if the process needs to go back to a previous state.

IV-C Question answering

Task description. Question answering is a classic natural language processing task. Due to LLMs’ impressive natural language understanding capabilities, they are increasingly used for this task [38]. In this paper, we specifically focus on scene graph-based question answering, where the input context is provided as a scene graph. We categorize the questions into three types: (1) judging questions, which require determining whether a statement is true or false; (2) counting questions, which ask how many objects within the scene graph satisfy a particular condition; and (3) querying questions, which request specific attributes of objects within the scene graph. Due to the lack of established human best practices, we propose three SM approaches inspired by popular LLM-based methods [41, 18] (two of which are shown in Figure 5 (3)).

State machines. The routing SM follows the approach demonstrated in the example in Figure 4, representing a typical question-answering strategy using LLMs [41]. The core idea is to first classify the question type and then address it using methods tailored specifically for each type. For counting questions, the LLM is prompted to extract objects matching the question criteria, after which counting is performed deterministically. In contrast, for judging and querying questions, the LLM directly generates the answers.

We implement the widely adopted ReAct approach [18] for leveraging LLM reasoning with SHERPA as ReAct SM (not shown in the figure for conciseness). Here, the primary role of the LLM is to perform planning by sequentially calling predefined operations on the scene graph to gather relevant information. Thus, the SM consists of one state with self-transitions for these operations. The available operations are defined as follows: (1) filter, to extract objects from the scene graph based on attribute values; (2) relation, to identify objects having specific relations to another object; (3) checking, to determine objects sharing a particular attribute with another object; and (4) query, to retrieve an attribute of a given object. Finally, there is another transition to the end state.

However, we hypothesize that providing too many action choices might overwhelm the LLM. Therefore, we propose the planning SM, a more structured version of the ReAct SM. This approach provides a predefined action sequence as heuristic based on observations from sampled questions. Specifically, the LLM first filters the scene graph based on attributes, then retrieves objects either related to those filtered objects or by checking objects sharing the same attributes. At any step, the LLM can query attributes of any object in the scene graph.

V Evaluation

Given a use case, there are multiple ways to implement best practices into an SM to guide the behavior of LLMs. Furthermore, while SHERPA can be used to implement existing LLM approaches, it is not trivial to determine the best design for a given use case. In this section, we evaluate popular approaches and their enhanced version implemented with SHERPA using the defined use cases. In particular, we target to address the following research questions:

• •

RQ1 How does integrating state machines in SHERPA impact the performance of LLMs with different sizes compared with directly using LLMs?

• •

RQ2 How does the state machine design and configuration affect the performance and cost of SHERPA?

V-A Evaluation setup

LLMs

We evaluate SHERPA using four popular LLMs for all use cases as discussed in Section IV. Additionally, we choose one dedicated LLM for each use case that was designed to solve the task targeted by that specific use case.

Common LLMs. We evaluate our approach using two of the most recent LLMs from OpenAI: GPT-4o Mini [42] and GPT-4o [4]. These models demonstrate improved capability and performance on complex tasks compared to their predecessors, while reducing inference costs. Nevertheless, their closed-source nature raises concerns regarding data privacy, security, and reproducibility. Thus, we also perform experiments with two state-of-the-art open-source models: Qwen2.5 7B [5], one of the most powerful LLMs deployable on consumer-grade GPUs, and Qwen2.5 72B, one of the most capable configurations within the Qwen LLM family [5]. Both LLMs exhibit better performance over similarly scaled open-source alternatives across a wide range of evaluation tasks.

Task-specific LLMs. We also select specialized LLMs tailored specifically to each use case. For the code generation task, we choose Qwen2.5 Coder (32B) [21], an open-source LLM designed for code generation, achieving top performance across multiple coding benchmarks. For the class name generation and question answering tasks, primarily challenging natural language-related capabilities, we evaluate Llama3.1 70B [22], another popular and powerful open-source LLM comparable to Qwen2.5 72b but outside the GPT and Qwen families.

Benchmarks

We evaluate the effectiveness of different approaches with the following benchmarks.

Code generation. To evaluate how SHERPA enhances the code generation process, we use the HumanEval benchmark [43]. The benchmark includes 164 programming problems and is widely adopted in LLM research to assess model performance in code generation [6]. In this benchmark, the LLM is provided with a natural language description and the header of a Python function and is tasked with generating the function body.

Class name generation. For class name generation, we use the automated domain modeling dataset proposed by Chen et al. [27] (Modeling). This dataset contains eight domain models with a total of 135 classes, spanning diverse domains and varying complexity levels. We specifically use classes from these domain models for evaluation.

Question answering. For the scene-based question answering task, we use human-curated questions from the Clevr dataset [44, 45]. Compared to template-generated questions, these human-curated questions offer greater linguistic diversity and complexity. We manually verify each question and exclude any questions that require visual context beyond the scene graph (e.g., object reflections). In total, we randomly sample 100 questions from the dataset, including 33 judgment-based, 33 counting-based, and 34 querying-based questions.

Metrics

We select metrics to evaluate the quality of results specifically for each use case.

Code generation. Each generated function is evaluated using the test suite from the HumanEval benchmark [43]. We use the Pass@1 metric, measuring the proportion of problems solved by passing the test suite within $1$ attempt.

Class name generation. Evaluating class names can be challenging due to variations in synonyms and naming conventions. Relying solely on exact matches typically significantly underestimates the true generation quality. To overcome this limitation, we adopt an embedding-based evaluation method [46], which has been shown to correlate well with human judgments. This approach measures the cosine similarity between generated and reference labels to create overall scores (precision (P), recall (R), and $F_{1}$-score ($F_{1}$)) for the set of generated classes.

Question answering. For Clevr, we measure answer accuracy (ACC). As the answers belong to a finite set of categories (e.g., numbers, attribute values, etc.), we use exact match accuracy between the generated and ground truth answers.

Furthermore, the iterative nature of the SMs can potentially lead to increased cost for LLM invocations, especially when using an LLM API or when the LLM is deployed on a cloud service. To evaluate this aspect, we also measure the average number of LLM calls required for each use case.

Implementation details

We set the number of maximum state transitions to 10 for each use case. To overcome the variability of the LLM’s output, we choose a 0.01 generation temperature and measure the average performance over 3 runs. The repository for the evaluation is available online [47].

V-B RQ1: Comparison with direct methods

Rationale and setup

When considering building domain-specific SMs to control LLM behavior for a particular task, it is crucial to understand the situations under which such an approach can be beneficial. This research question addresses this aspect by comparing the performance of SMs powered by SHERPA against the Direct approach, which relies solely on prompting techniques. We investigate two sub-questions:

• •

RQ1.1: How do SMs in SHERPA influence the quality of outputs from LLMs compared to Direct?

• •

RQ1.2: How does the impact of SMs vary across different LLM sizes within the same LLM family?

For each use case, we select appropriate prompting techniques for the Direct method. Specifically, for the code generation task, we choose zero-shot prompting using a widely adopted prompt that has demonstrated effectiveness across various GPT models [48]. For the class name generation task, we utilize one-shot prompting, providing a single illustrative example from a domain not included in the testing set, demonstrating the nature of the task and the expected format of the output. Lastly, for the question answering task, we adopt chain-of-thought prompting [16], as answering questions based on scene graphs typically requires step-by-step reasoning.

For the SM in SHERPA, we use the first SM illustrated in Figure 5 for each use case (specifically, the test-driven, inspection, and routing SMs). Note that different SM designs can significantly influence the quality of the final output (see RQ2). For RQ1, our goal is to understand the general impact of using an SM. Therefore, we selected SMs representing straightforward designs that can be easily constructed and implemented by software engineers.

Impact of SM integration

Table I presents the performance comparison between SHERPA and Direct across all use cases and LLMs. For each use case-LLM pair, we underline the better-performing method and highlight the best overall performance for each use case in bold. In general, empowering LLMs with SMs in SHERPA improves performance compared to the Direct approach in 12 out of 15 cases, while being comparable in the remaining three. SHERPA also achieves the highest performance in two out of three use cases, slightly underperforming GPT-4o in the Clevr dataset.

Analyzing the impact for each task individually, SHERPA outperforms Direct in code generation for four out of five LLMs, showing an average improvement of 3.25 percentage points (i.e., SHERPA - Direct = 3.25). The overall improvement in LLMs other than GPT-4o is primarily due to the explicit test-generation step included in the SM, which validates generated code against these tests.

For class name generation, integrating the SM notably improves recall but occasionally leads to decreases in precision. The iterative refinement in the SM results in more class names being discovered, but also occasionally introduces irrelevant class names. Nonetheless, SHERPA consistently achieves higher overall $F_{1}$ for all LLMs, with an average improvement of 6.58 percentage points. This substantial gain can be attributed to the SM’s alignment with existing human best practices.

In the question-answering task, SHERPA achieves higher accuracy in three out of five LLMs, with an average improvement of 2.56 percentage points. Interestingly, it does not bring benefit with the two largest LLMs, likely because these models already effectively manage CLEVR’s question-answering tasks for different question types. Smaller LLMs, however, clearly benefit from the routing logic provided by the SM, which helps them address different aspects of each question type.

RQ1.1. Integrating SMs within SHERPA generally enhances LLM performance compared to the Direct method, improving the performance in 12 out of 15 cases. The most significant benefit occurs in the class name generation task, with an average improvement of 6.58 percentage points, which can be attributed to the fact that there exists an established best practice for this task.

Impact of LLM size

Examining the impact of LLM size on performance, we find that integrating SMs provides more consistent benefits for smaller LLMs. Within both the Qwen and GPT families, SHERPA consistently outperforms Direct for smaller LLMs, while it improves performance in only three out of six cases for larger variants. We hypothesize that larger LLMs possess sufficient capabilities to handle the tasks effectively without integrating SMs. Indeed, larger LLMs consistently outperform their smaller counterparts across all tasks, except in one of the class name generation cases, where GPT-4o Mini unexpectedly outperforms GPT-4o. We suspect that the benefits observed in smaller LLMs may also occur in larger LLMs when applied to more complex tasks.

During early experiments, we iteratively developed the SM with smaller LLMs to reduce inference costs. As a result, the final SM design may favor smaller LLMs and limit effectiveness with larger variants, suggesting that SMs should be tailored to the target LLM to maximize their benefits.

RQ1.2. The impact of SMs on LLM performance is more pronounced in smaller models. Specifically, SHERPA consistently outperforms Direct for smaller LLMs, while it may damage the performance for larger LLMs. This observation indicates that the SM design should be tailored to the specific LLM to maximize effectiveness.

V-C RQ2: Impact of SM design

Rationale and setup

RQ1 demonstrated that integrating SMs with SHERPA generally improves the performance. However, the SM itself may also influence the effectiveness. Moreover, the multi-step nature of SMs increases the number of LLM calls and thus impacts the overall cost of LLM executions. In SHERPA, SM design is decoupled from action implementation, enabling updating the SM without modifying the underlying implementation to reach cost targets. In this RQ, we analyze how different SMs affect both performance and cost. Specifically, we address the following sub-questions:

• •

RQ2.1: How do different SM configurations in SHERPA influence the quality of LLM-generated outputs?

• •

RQ2.2: How do different SM configurations in SHERPA impact the number of LLM invocations?

We use SMs for the use cases described in Section IV to answer these questions. For the code generation task, we compare the test-driven SM, which attempts to reduce LLM calls by avoiding repeatedly generating new test cases when a generated function fails, to the agent coder SM. In the class name generation task, we compare the inspection SM, which introduces an additional inspect model composite state, to the MIG approach. In the question answering task, we examine the routing SM and ReAct SM. We also evaluate the planning SM that further enforces a predefined operation sequence commonly used in this task to avoid wasting LLM invocations.

Impact on performance

Figure 6 presents the performance of various SM configurations across different use cases. Overall, all SM-based approaches generally outperform Direct, although the specific performance varies. For the code generation task, the test-driven SM achieves comparable performance to the agent coder SM, even surpassing it with Qwen2.5-7B and Qwen2.5 72B, indicating that repeatedly generating test cases may be unnecessary for the code generation scenario, particularly with Qwen models.

In the class name generation task, introducing the additional inspection state in the Inspection SM enhances performance over the MIG SM for both Qwen and Llama LLMs; however, it slightly degrades the performance for GPT-4o variants. Nevertheless, the combination of the Inspection SM with Qwen2.5-72B yields the highest overall performance.

For the question answering task, we examine two distinct SM modeling strategies. While the routing SM outperforms the Direct approach in three out of five cases, separating planning and information extraction in the ReAct SM results in further performance gains in four out of five LLMs. Additionally, enforcing a predefined sequence of operations in the planning SM enhances performance specifically for the two strongest LLMs tested in this task: GPT-4o and Qwen2.5 72B. We hypothesize that less capable LLMs might lack sufficient usage of predefined operation order (by consistently firing the continue transitions), making the planning SM less helpful.

RQ2.1. The SMs notably impact SHERPA performance, varying depending on the specific LLM size and LLM architecture. For tasks with well-defined best practices (e.g., code generation, class name generation), the impact seems to vary for different LLM families, while for tasks with less defined best practices (e.g., question answering), the impact seems to depend more on LLM size.

Impact on cost

The orange lines in Figure 6 indicate the cost in terms of the average number of LLM calls required by each SM design. Across all tested LLMs and tasks, a clear trend emerges: SMs designed explicitly to minimize LLM calls indeed result in a reduced number of invocations. Specifically, the test-driven SM achieves approximately 50% fewer LLM calls on average compared to the agent coder SM. Similarly, the pre-defined action orders in the planning SM also reduce the number of LLM calls compared to the ReAct SM, with a particularly significant reduction observed for Llama3.1 70B. Conversely, the additional inspect model state in the Inspection SM increases the number of LLM calls relative to the MIG SM, since this state explicitly prompts the LLM to inspect outputs and potentially revert to previous states.

RQ2.2. The configuration of SMs can influence the number of LLM calls in SHERPA. Generally, configurations explicitly designed to reduce LLM calls achieve notable reductions in cost.

V-D Discussion

Applicability. In RQ1, we demonstrate that integrating SMs into SHERPA consistently enhances LLM performance across three tasks, with the most pronounced improvements for code generation and class name generation. These tasks notably have clear human best practices, which effectively guide the LLM by systematically decomposing the tasks. In contrast, the question-answering task is more general and lacks well-defined best practices, resulting in relatively modest performance gains. We suspect that integrating SMs using SHERPA is more effective for tasks with established best practices, especially for use cases lacking enough training data (e.g., class name generation).

Impact of state machine configuration. In RQ2, we observe that the SM design significantly influences LLM performance, although this influence varies according to the LLM family and size. Due to this experimental nature, the separation of SM design from action implementation in SHERPA is especially valuable, enabling rapid experiments and optimization of different SM designs without altering underlying implementations.

Furthermore, SMs designed to optimize the number of LLM calls consistently achieve reductions across all tested tasks, indicating more predictable costs when using SHERPA. Importantly, these optimized SMs maintain performance comparable to unoptimized SMs, showing that cost savings do not come at the expense of effectiveness. This balance is particularly beneficial when using strong LLMs from an API, where computational costs can be substantial. We believe the explicit structure of SMs enables engineers to more accurately predict and manage LLM execution costs, potentially integrating them effectively with traditional model-checking techniques on SMs [33].

V-E Threats to validity

Internal validity. LLM outputs may be non-deterministic depending on the configuration and hardware. To mitigate this issue, we use a low sampling temperature (0.01) for all experiments and average results across three independent runs. Additionally, the performance of LLMs can vary based on prompting techniques. To minimize this variation, we consistently followed established techniques, such as chain-of-thought prompting [16] and few-shot prompting [3] for different approaches compared in the experiments.

External validity. The impact of SMs could vary across different domains and tasks. In this paper, we evaluate SMs on three distinct use cases. However, the observed impacts may differ for other domains. We leave the exploration of SMs’ impacts on other tasks and domains as future work.

Construct validity. The evaluation metrics adopted in this paper may raise a threat. For the Pass@1 metric, passing all tests does not necessarily guarantee the correctness of the generated functions. Full correctness evaluation may require complex analysis of generated code. Nevertheless, this metric is widely recognized and used in existing research [49]. For the class name generation and question-answering tasks, we likewise selected the most commonly used metrics [27, 44].

VI Related Work

MDE for LLMs. Applying MDE principles to enhance LLM applications is an emerging research area. Clarisó et al. [50] introduce Impromptu, a domain-specific language (DSL) designed for defining prompts. Several frameworks [51, 52] also use DSL to define conversational agents with LLMs. For testing LLMs, Morales et al. [53] present LangBite, a model-driven approach for specifying ethical requirements and automating the testing of ethical biases in LLMs.

SHERPA also uses a model-driven approach to optimize the use of LLMs. While methods like Impromptu primarily focus on the specific prompt, SHERPA works at a higher level of abstraction that constrains the flow of LLM-based applications.

LLMs for MDE. The use of LLMs for automating MDE tasks has emerged as a prominent research area [10]. Notably, these models have been effectively used for model completion or recommendation [54], model query generation [49, 55], domain model generation [56, 27], among others [10].

Most approaches using LLMs for automating MDE tasks resemble the direct approach, typically involving a single prompt or a linear sequence of prompts. For example, Chen et al. [27] evaluate various LLMs for domain model generation using few-shot prompting. Similarly, Abukhalaf et al. [49] use different prompting strategies to generate OCL queries.

The use of LLMs in these approaches are more similar to the Direct baselines used in this paper (for which SM integration shows benefit in the majority of the cases), we believe that, with well-designed SMs tailored for each scenario, SHERPA could be used to further enhance these MDE tasks.

Structured workflow for LLMs. Many approaches [57, 18, 12, 28] have been proposed to improve the performance of LLMs by using a structured workflow. The Reflexion framework [57] enhances LLM agents through self-feedback. In the ReAct framework [18], LLMs generate reasoning traces and task-specific actions. The retrieval-augmented generation (RAG) using various tools has also been explored through various approaches [12, 13, 14, 15]. To better manage external tools and enhance modularity, researchers have explored multi-agent systems [58, 59, 60, 61]. Specifically, Wu et al. [58] introduce AutoGen, which uses multiple customizable and interactive LLM agents to collaboratively accomplish tasks.

SHERPA can also be seen as a way to integrate structured workflows with LLMs. Unlike previous methods, where workflows are either fixed to specific use cases or tightly coupled with the implementation, SHERPA proposes a general approach to define workflows and can be used to implement existing approaches such as RAG and ReACT.

State machines in LLMs. Relatively few research efforts have focused on integrating LLMs with state machine-like workflows [19, 20]. Wu et al. [19] propose StateFlow, a novel LLM-based task-solving framework that models complex task-solving processes as state machines, where transitions between states are governed by heuristic rules or LLM-driven decisions, with actions performed within each state. Another notable effort is the State Machine of Thoughts [20], which uses a state machine to track experiences from previous reasoning trajectories. Langchain [28] and similar frameworks [62, 63, 64, 58] build agentic applications with LLMs using SM–like workflows or pipelines. However, these frameworks typically treat the workflow as pre-compiled and static, making it difficult to modify the workflow dynamically at runtime.

Compared to existing approaches, SHERPA introduces several improvements: (1) it uses a hierarchical SM to support more modular structure definition; (2) it decouples SM design from action implementation, enabling better modularity; (3) it supports various policies for navigating the SM, including both LLM and rule-based approaches; and (4) it treats SMs as data, allowing them to be dynamically updated.

VII Conclusion

In this paper, we propose SHERPA, a model-driven framework designed to enhance the performance of LLMs on complex tasks using domain-specific best practices with hierarchical SMs. By structuring execution through SMs, SHERPA provides more flexible and fine-grained control over the behavior of LLM-based applications. We demonstrate the applicability and effectiveness of SHERPA across diverse tasks. The results show that, although LLM performance is generally improved by SMs, it is highly influenced by the SM design. While the SM designs impact task performance differently depending on the LLM, specially designed SMs reduce the execution cost while maintaining a similar performance. Such result makes the separation of SM definition and action implementation in SHERPA particularly useful to support rapid experiments.

In future work, we plan to integrate different textual languages for SMs to simplify the design process. We also intend to explore applications of SHERPA in different domains beyond the three use cases. Additionally, investigating how SHERPA can be combined with complementary techniques, such as reinforcement learning-based policies, may further improve its performance and broaden its applicability.