PREDICT: Preference Reasoning by Evaluating Decomposed preferences Inferred from Candidate Trajectories

## Abstract

Abstract Accommodating human preferences is essential for creating AI agents that deliver personalized and effective interactions. Recent work has shown the potential for LLMs to infer preferences from user interactions, but they often produce broad and generic preferences, failing to capture the unique and individualized nature of human preferences. This paper introduces PREDICT, a method designed to enhance the precision and adaptability of inferring preferences. PREDICT incorporates three key elements: (1) iterative refinement of inferred preferences, (2) decomposition of preferences into constituent components, and (3) validation of preferences across multiple trajectories. We evaluate PREDICT on two distinct environments: a gridworld setting and a new text-domain environment (PLUME). PREDICT more accurately infers nuanced human preferences improving over existing baselines by 66.2% (gridworld environment) and 41.0% (PLUME).

## 1 Introduction

A fundamental component of effective interaction is understanding the preferences of those with whom we engage. Successfully recognizing and accommodating these preferences leads to more pleasant and efficient experiences (Felfernig et al., ). While such preferences can be verbalized explicitly, they can also be inferred implicitly from past interactions. Ideally, an AI agent should be able to both use explicit feedback and learn from implicit cues. As human directions are commonly expressed in natural language, creating a mapping from implicit cues to natural language could enable a natural-language conditioned agent to seamlessly integrate both implicitly and explicitly defined preferences. This work focuses on this gap by proposing a method to infer natural language preferences from a user’s actions.

Large Language Models (LLMs) possess strong priors about human behavior (Brown et al., ). Previous work has demonstrated that these priors can provide the basis to infer user preferences in domains such as robotic manipulation (Peng et al., ) and collaborative authoring (Gao et al., ).
However, current methods infer preferences without reflection nor refinement, resulting in generic outcomes that limit the models’ adaptability toward the uniqueness and nuance of an individual’s preferences.
We propose PREDICT (Preference Reasoning by Evaluating Decomposed preferences Inferred from Counterfactual Trajectories), which is comprised of three algorithmic contributions to enhance the precision and efficiency of preference inference: (1) iteratively refining inferred preferences until the induced trajectory closely aligns with the user’s example, (2) breaking down (or decomposing) inferred preferences into constituent components, and (3) validating the inferred preferences across multiple user examples.

We systematically demonstrate the benefits of PREDICT’s contributions on two environments: a gridworld environment, where an agent learns to pick up objects based on a user’s preferences over colors and shapes, and PLUME, a text-domain environment we adapt from Gao et al. (), where an agent learns to write text based on a user’s preferences.
PLUME addresses several limitations in the task from Gao et al. (), and is an additional contribution of this paper.
PREDICT demonstrates improvements of 66.2% over behavioral cloning in the gridworld environment, and 41.0% over CIPHER (Gao et al., ) in PLUME. In PLUME, we augment PREDICT with in-context learning and achieve a further 17.9% improvement. The innovations outlined in this paper are a key step toward more personalized and effective interactions between AI agents and humans.

## 2 Related Work

Natural Language Conditioned Agents
Language is the most natural way for humans to communicate and express themselves. As a result, considerable research has focused on natural language-conditioned agents across a variety of domains. BabyAI (Chevalier-Boisvert et al., ) introduces an environment for natural language conditioned gridworld agents. Further advancements, such as gSCAN (Qiu et al., ), investigate how gridworld agents handle compositionality, while Zhong et al. () explore the ability of agents to learn environment dynamics from text. Misra et al. () proposes LingUNet as way to fuse language and vision in a simulated 3D world. Blukis et al. (, ) extend this for continuous drone control. In room-to-room navigation, works such as CLIPNav (Du et al., ) and Embodied CLIP (Khandelwal et al., ) use CLIP embeddings (Radford et al., ) to condition agents on visual-language aligned representations.

In robotic arm manipulation, Lynch & Sermanet () condition trajectories on both goal images and natural language, demonstrating successful task completion with limited language labelling. Jang et al. () builds upon this and use videos as goal contexts. For pick-and-place tasks, Shridhar et al. () uses a CLIP-based two-stream architecture, and Mees et al. (, ) demonstrate long-horizon task completion via hierarchical approaches.

In natural language generation, prompting (Radford et al., ) and in-context learning (Brown et al., ) have proven effective methods for controlling the generation of text, especially in a preference-driven context (Sun et al., , ).

Personalization
Some prior approaches of adapting models to user preferences involve RLHF (Stiennon et al., ) and fine-tuning (Tan et al., ; Zhuang et al., ), which can be compute-intensive and inaccessible to some practitioners without the budget or scale of needed data. With the rise of LLMs with strong instruction-following capabilities, methods like prompting to adapt a user’s profile have become more popular (Shen et al., ; Salemi et al., ), however these approaches often rely on explicit feedback provided from the user (Lin et al., ). PREDICT circumvents these issues by learning from implicit user signals, breaking down preferences into sub-components to generate tailored user-preferences, all without the need of fine-tuning.

Preference-Conditioned Agents
Combined preference inference and conditioning has recently gained traction, with the following two works being most aligned with our approach.

Peng et al. () explores preference learning in quadrupedal mobile manipulation using an object detection module to map image observations to text. An LLM then infers preferences by comparing pairs of trajectories. These preferences are in turn used to improve task alignment with user preferences. Gao et al. () propose the PRELUDE environment, where an LLM learns writing style preferences in a collaborative authoring task. We discuss this work in detail in Section 4.3.

These methods rely on a single inference step, whereas our approach uses iterative refinement for more precise preferences, and validation across several user examples for robustness.

## 3 PREDICT

Figure: Figure 1: The three PREDICT components: iterative refinement, breakdown, and validate.
Refer to caption: x1.png

We now outline PREDICT’s key contributions to preference inference: (1) iteratively refining preferences, (2) breaking down inferred preferences into their constituent components, and (3) validating the inferred preferences against relevant user examples. The prompts for each step and each evaluation task are shown in Section F.1 (Fig. 7 and  8), and the algorithm is provided in Appendix A(^1^11code coming soon!).

Iterative Refinement using Candidate Trajectories
A preference-inferring agent requires a preference-conditioned agent that can act according to the inferred preferences. There has been significant work in the area of natural language conditioned agents (Szot et al., ; Ichter et al., ; Chevalier-Boisvert et al., ; Mees et al., , ; Lynch & Sermanet, ; Sun et al., ) demonstrating the viability of natural language preference-conditioned agents. Motivated by how (Peng et al., ) and Gao et al. () use comparative examples to infer preferences, PREDICT uses the preference-conditioned agent to iteratively create tailored candidate trajectories using the most recently inferred preferences for comparison. By comparing these contrasting trajectories to the user examples, the inferring agent can more clearly pin point differences that indicate missing preferences, in turn enabling the inferring agent to extract more from a single user example.

Specifically, for each task instance, the preference-conditioned agent in PREDICT completes the task with the current set of inferred preferences—if no user examples have been seen before, an empty preference set is used. This provides an initial candidate trajectory. If the candidate trajectory matches the user’s examples then the current inferred preferences are sufficient to explain the user’s behavior and no further learning is required. However, if the trajectory differs, we prompt the LLM to refine the inferred preferences to explain the difference between the candidate trajectory and the user’s example. We then create a new candidate trajectory using the newly refined preferences, and repeat this process until we match the user’s example, or a maximum number of iteration steps is reached. In all experiments, we use a maximum of three refinement steps per user example.

Breaking Down Preferences
The second novel contribution is to break preferences down into their base components. For example, write as if the events could happen with emojis interspersed could be broken down into [write using conditional expressions, use emojis]. This provides several advantages. Preference components provide greater coverage of the preference space with less data, e.g., three components can be combined to create nine profiles. Further, preference components make it easier to refine preference sets by adding, removing, or modifying single components of a preference rather than modifying full preferences. Lastly, preference components remove ambiguity when validating preferences. If we validate a compound preference and only a single component is incorrect, then the entire compound preference including any useful components may be discarded.

Validating Preferences
The third contribution of PREDICT is motivated by the insight that preferences should be observed consistently(^2^22assuming similar contexts and within reasonable time spans), i.e., preferences should be noticeable in several user examples. The most similar work of Gao et al. () retrieves related user examples to create the starting preferences for a new task instance. PREDICT adds an additional stage that uses these examples to validate inferred preferences and filter incorrectly inferred preferences.

We test each preference component of the inferred preference set against each user example by prompting an LLM to determine whether the user’s examples strongly confirm the preference, somewhat confirm the preference, is neutral toward the preference, somewhat contradict the preference, or strongly contradict the preference. Each answer is mapped to a score from -2 (strongly contradicts) to +2 (strongly confirms). We take the mean score across all samples, and if the score is below a threshold, we remove the preference. To avoid discarding correct preferences due to a single spurious LLM output, a preference must be validated against a minimum of two user examples before being filtered out. In all our experiments, we use a validation threshold of 0.25.

Preference Aggregation
Following Gao et al. (), before solving a new task, PREDICT retrieves up to five previous, relevant examples. The preferences inferred for each example are aggregated, and an LLM is prompted to remove redundancy and condense the combined set of preferences. The condensed preference set is then used to complete the task.

## 4 Experimental Set Up

All of our experiments consist of three phases per task. First, the user completes the task using their true preferences. Second, the agent attempts to complete the task using its currently inferred preferences (if any). Finally, the agent compares its attempt at task completion with the user’s example to infer new preferences to use going forward.

All agents are evaluated along two dimensions: preference quality that measures similarity between the true and inferred preference sets, and action quality that evaluates an agent’s task completion against the user’s true preferences. Note that the first task completion will always be conditioned on an empty preference set and that we evaluate the preference set used to solve the task. Thus, the first step is equivalent across all agents, and we omit its results.

The agent learns from 4 – 10 users (depending on the task) with five examples per user, and performance is reported as the mean across all examples, users, and across five seeds (standard deviation is reported over these seeds). The user preferences for the assistive writing tasks
are in Appendix D (Table 4), whereas the PICK UP task has a rule-based user preference construction procedure described in  Section 4.2. For all experiments, we use GPT-4o as the inferring agent except when we compare LLMs of different sizes and quality (shown in Fig. 2) (^3^33Determined by MMLU performance: [llama8b (68.4) and 70b (82)](https://ai.meta.com/blog/meta-llama-3/); [GPT-4o-mini (82) and GPT-4o (88.7)](https://openai.com/index/gpt-4o-mini-advancing-cost-efficient-intelligence/)). For the assistive writing tasks, GPT-4o is used as a synthetic human. The synthetic human prompts can be found in Section F.2.

### 4.1 Research Questions

We pose the following research questions:

RQ1: Does iteratively creating candidate comparison trajectories improve the quality of inferred preferences? To explore this, we consider three variants of PREDICT: (1) PREDICT${}_{\text{1NC}}$ (1NC=1 inference step, no candidate) uses no example comparisons and prompts the LLM a single step to infer the preference given only the user’s example; PREDICT${}_{\text{1SC}}$ (1SC=1 inference step, single candidate) is PREDICT with a single inference step and a single candidate trajectory; and (3) PREDICT${}_{\text{SC}}$ ($\leq$3 inference steps, single candidate) is PREDICT with a single candidate used for all inference steps. Comparing PREDICT${}_{\text{1NC}}$ and PREDICT${}_{\text{SC}}$ measures the effect of comparing candidate examples to the user’s examples when inferring preferences.
The differences between the PREDICT${}_{\text{1SC}}$ and PREDICT${}_{\text{SC}}$ variants quantifies the role of increasing the number of inference steps, while comparing PREDICT${}_{\text{SC}}$ and the full PREDICT algorithm clarifies the effects of explicitly providing the LLM with the outcomes of its predictions.

RQ2: Does breaking down preferences into components improve the performance and consistency of the preference inferring methods? To answer this question we compare the full PREDICT algorithm with a variant that does not breakdown preferences PREDICT${}_{\text{CP}}$ (CP=compound preferences). We hypothesize that PREDICT improves performance and reduces variance between seeds relative to PREDICT${}_{\text{CP}}$.

RQ3: Does filtering preferences by validating them across multiple examples lead to fewer errors? While the preference inferring step can add missing preferences, we hypothesize that validating preferences provides a strong mechanism to remove incorrectly inferred preferences. To test this hypothesis, we evaluate a variant, PREDICT${}_{\text{NV}}$ (NV=no validation), that does not validate preferences. Our hypothesis is that PREDICT’s attempts to complete the tasks will be of a higher quality than attempts using PREDICT${}_{\text{NV}}$.

### 4.2 Environment 1: PICK UP

We develop the PICK UP (Policy Imitation by Comprehending Key User Preferences) task in a gridworld environment populated with various objects of different shapes and colors. Users in the environment navigate to pick up objects with attributes (i.e., shape/color) they like, while avoiding objects with attributes they dislike, before navigating to an end goal location. When an object is collected, a reward of +1 is awarded for each liked attribute and a reward of -1 is awarded for each disliked attribute. For example, an object whose shape and color are both liked would have a reward of +2, while an object whose shape is liked and color disliked has a reward of 0. Note the reward function is used only for evaluation purposes and does not play a role in preference learning.

For PICK UP, we automatically transform trajectories into a structured language description. Fig. 4 (Appendix B) shows a visual and natural language representation of the environment and its trajectories. The objective of a preference inferring agent in this environment is to be able to collect the same objects that the user’s would. To accomplish this, they must first identify the user’s likes and dislikes, and then navigate the world to collect the appropriate objects. We include the presence of neutral objects in the environment, which adds ambiguity to the system as neutral objects are only picked up if they are along the shortest path between desirable objects or the goal, which is not identifiable from the text representation of the user’s example. Thus, from the perspective of an inferring LLM, the environment is only partially observable. This design is intentional; motion is inherently difficult to encode in language, so many tasks will be partially observable to an LLM. Due to the partial observability, we require three validations to discard a preference in PICK UP.

In this environment, each task instance is defined by a user identifier and an environment layout containing seven random objects placed at random locations in a 5x5 grid. The user identifier maps to a unique and private set of preferences. Each user’s preference set contains exactly one liked shape, one liked color, one disliked shape, and one disliked color, however this information is not provided to the inferring agent. These are all specified in the structured format: <likes/dislikes><attribute>. Users are neutral toward all the remaining attributes. The well-defined structure of the preferences in PICK UP allows us to map a preference set to a set of positive reward objects and negative reward objects. We then use this mapping to condition an A* agent that collects all the positive objects while avoiding negative objects.

The preference structure also enables direct comparison of preferences. To this end, we report the Intersection over Union (IoU) between the inferred and true preference sets as the preference quality metric. A downside of the rigid preference structure is that it requires us to decompose preferences, which prevents us from addressing RQ2 in this environment.
For the action quality metric, we measure the cumulative reward, or return, of the agent’s trajectories. Each liked/disliked attribute (shape or color) in the set of collected objects adds +1/-1 to the score respectively. For all experiments, we use 10 distinct users (N = 10).

### 4.3 Environment 2: Assistive Writing

PRELUDE:
Gao et al. () propose PRELUDE (PREference Learning from User’s Direct Edits) as an environment to evaluate preference inferring algorithms. PRELUDE consists of two tasks: summarizing articles and writing emails from notes. Each task has a set of users with each user having a distinct set of preferences. Each user additionally writes their summaries/emails on different topics, with each topic corresponding to a different source of articles/notes (e.g., chat forums, paper abstracts, encyclopedia articles). The summarization and email writing tasks have five and four users respectively.

For each task instance, the agent must write a summary or email using the article / notes and any inferred preferences it has learned up to that point. The user is then asked if the agent’s output is satisfactory based on their true preferences. If the agent’s output is satisfactory, the cost to the agent is zero. If the agent’s output is not satisfactory, the user edits the agent’s output according to their preferences, and a cost based on the extent of the edit is incurred.

PLUME:
The objective of the PRELUDE environments is to evaluate how well a model infers a user’s preferences and the cost of incorrectly inferred preferences. Therefore, it is vital that the measure of inferred preference quality is highly correlated with the cost function. We analyze PRELUDE (see below) and find that the chosen metrics, the editing process, and the sets of preferences used are key limitations of the environment, which contribute to a weak correlation between the quality of the preferences and the quality of the generated writing.

For these reasons, we develop a new environment based on same underlying tasks as PRELUDE, which we call PLUME: Preference Learning from User Memos and Emails. As in Gao et al. (), PLUME uses GPT-4o as a proxy-human to be our user. In the following sections, we provide a detailed description of each limitation and how it is addressed by PLUME.

Metric Correlation
We begin by investigating the magnitude of the correlation between the proposed preference quality metric — preference set accuracy(^4^44a preference is correct if its BERTScore (Zhang* et al., ) with true preference set is greater than the BERTScore with any other preference set.) — and action quality metric — Levenshtein distance (Levenshtein, ) — used in PRELUDE (Gao et al., ). To find this correlation, for a given context, we generate the powerset of the preference set.
We then create a population of agents, each conditioned on one of the subsets from the powerset. These agents and a user complete five instances of the task within their context, on which we measure the preference and action quality. Intuitively, agents conditioned on larger subsets of the true preference set have a higher preference quality score and their generation quality should reflect this. We repeat across every context and both tasks, and calculate the Pearson correlation between every preference quality metric and every action quality metric. The results are shown in Section C.2 Table 3 (for metric correlation by task).

The results, reported in the first column of Section C.2, show a weak correlation ($<0.5$) between the PRELUDE’s preference accuracy and Levenshtein distance. This can be explained by the inherent limitations with the metrics. The accuracy metric relies on the “highest” BERTScore, and therefore cannot differentiate partially correct preferences from perfectly correct preferences. Moreover, the Levenshtein distance can vary substantially between generations, leading to a wide range of possible costs even when the exact same preferences are used for the generation (an illustrative example of this is shown in Section E.1). Gao et al. () allude to this fact as a motivation for their two-stage editing process, and when we compare the results to a version of PRELUDE where the user always generates summaries/emails directly from the article/notes instead of editing the agent’s summary/email (PRELUDE${}_{\text{NoEdit}}$), we see a further drop in correlation. However, we propose addressing this issue using improved metrics, as the editing procedure itself imposes notable limitations, which are discussed below.

To this end, we investigate and compare several new preference and generation-quality metrics. For the preference quality metric, we test using the BERTScore (Zhang* et al., ) directly. For the action quality metric, we additionally test length-normalized Levenshtein distance (ln-L-dist), BERTScore, and an LLM-as-a-Judge (Zheng et al., ) metric inspired from the editing procedure in PRELUDE. The LLM-as-a-Judge evaluation is a per preference-component match (PPCM) that asks an LLM how much a component of a preference is exhibited in a piece of writing on a five point scale from “clearly contradicts” (score of -2) to “clearly exhibits” (score of +2). This is repeated for each component of the true preference set, and we compute the mean score across components. The full prompts used for both of these metrics are shown in Section F.4 (Fig. 12).

The results in Table 3 (Section C.2) show that BERTScore has a stronger correlation than PRELUDE’s accuracy metric with every writing generation metric compared. Looking at action/generation quality metrics, Levenshtein distance consistently has the weakest correlation, while PPCM has the strongest. Notably, the pairing of BERTScore (preference quality) and PPCM (generation quality) provides the highest correlation in every situation and are the primary metrics we report in PLUME.

The Editing Procedure
Asking whether a generation matches the user’s preferences is inherently ambiguous in cases where they only partially meet the user’s preferences.
Even if this ambiguity is resolved, generations that are not selected for editing incur no cost, which removes any incentive to further improve the quality of the learned preferences. This limits the environments ability to differentiate a wide range of methods. Lastly, the editing process unduly influences the user’s writing, as demonstrated in Section E.2.

In place of the editing, PLUME has the agent and user independently solve the task at every step. This removes any ambiguity on whether a generation should be edited and incur a cost, provides a smoother curve along which to evaluate different methods, prevents agents from influencing users, and enables the agent to learn from every user example.

Preference Sets
We observe the following limitations with PRELUDE’s preference sets: (1) certain preference components have little impact on the generated text, due to unclear definitions (e.g., skillful foreshadowing) or similarity to default LLM behavior (e.g., clear); (2) Some preferences are repeated across several contexts (e.g., short, brief, concise appear in four of five summarization contexts); and (3) There is a large variance in preference set complexities (e.g., targeted to young children, storytelling, short sentences, playful language, interactive, positive vs. question answering style).

To address these, PLUME reworks the preference sets with the following criteria: (1) each preference set contains an equal number of components, (2) within each task, preference sets should have a shared structure, (3) as much as possible, preferences should be orthogonal to each other, avoiding overlapping preferences (e.g., write in the style of old-timey radio and use archaic language) or contradictory preferences (e.g., use emojis and use a formal tone). (4) Preferences should not follow an LLMs default biases — i.e., generating an output conditioned on no preference should lead to a low score. A full list of the preferences used in PRELUDE and PLUME is shown in Appendix D (Table 4). We encourage future researchers to use PLUME with different preference sets to adjust difficulty or examine specific concepts.

Knowledge of Contexts
Instead of treating each article/notes topic as a distinct user, PRELUDE introduces the additional challenge of context awareness where a single user has different preferences based on the topic of the article/notes. Therefore, prior to writing a summary or an email the agent must first identify the correct context. However, this is orthogonal to the challenge of inferring preferences from user examples. As this work focuses on how to infer preferences, the version of PLUME used in all experiments assume a distinct known user per topic. We note that PLUME is easily adaptable to use hidden contexts if desired.

### 4.4 Baselines

In addition to the PREDICT baselines outlined Section 4.1, we implement the following models.

In PICK UP, we implement behavioral cloning (BC) (Pomerleau, ) that is trained using a cross-entropy loss on the related user examples seen to date. Due to the low-data regime, we first pre-train the BC agent on a dataset ($1000$ trajectories, $\sim 12,000$ state-action pairs) of distinct user examples whose preference sets differ from those found in the gridworld environment. During evaluation, when the BC agent sees a new user example, it adds the example to its dataset of user specific examples. It then creates a clone of its pre-trained agent and fine-tunes a version of the agent on examples from the same user, early stopping on a single user example reserved for validation.

In PLUME, we implement CIPHER-1 and CIPHER-5 (Gao et al., ), and an in-context learning (ICL) agent using previously observed article/notes and resulting user summary/email as examples.

We then implement three additional baselines across both environments. An agent that solves the task with no preferences (NP), providing a lower-bound of performance. An oracle agent that receives access to the user’s true preference, providing an upper bound of performance, and PREDICT${}_{\text{Base}}$, which is a variation of PREDICT that uses only a single candidate trajectory, a single inference step, compound preferences instead of a set of preference components, and uses no validation. We note that PREDICT${}_{\text{Base}}$ is conceptually equivalent to CIPHER, however it uses the prompts from PREDICT, which differ from those in CIPHER.

## 5 Results and Discussion

We present our main results comparing baselines and various PREDICT ablations in Table 1. Results on PRELUDE can be found in Section C.1. To compare tasks on action quality with metrics on different scales, we use a percentile score, where 0% corresponds to the no-preference (NP) baseline and 100% to the oracle preference baseline. All percentage improvements are reported as the difference in scores on this scale. Overall, PREDICT${}_{\text{Full}}$ outperforms PREDICT${}_{\text{Base}}$ by 9.3%, BC by 66.2%, and CIPHER by 41.0%.

**Table 1: Main Results. PREDICT’s ability to infer the correct preference set and quality of generated behaviors. Results are reported as the mean and standard deviation across five seeds. For all metrics, a higher score is better. Acronym Glossary: IoU (Intersection over Union), BScore (BERTScore), PPCM (per preference-component match), NP (No-Preferences), BC (behavioral cloning), ICL (in-context learning), C1/C5 (CIPHER-1/5), 1NC (1-step No Candidate), 1SC (1-step Single Candidate), SC (Single Candidate), CP (Compound Preferences), NV (No Validation).**
|  | PICK UP | Summarization | Emails |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| Method | IoU | Return | BScore | PPCM | BScore | PPCM |
| No Learning Baselines |  |  |  |  |  |  |
| NP | $0.00_{\pm 0.00}$ | $-0.07_{\pm 0.03}$ | $-0.50_{\pm 0.00}$ | $-1.49_{\pm 0.15}$ | $-0.50_{\pm 0.00}$ | $-1.07_{\pm 0.17}$ |
| Oracle | $1.00_{\pm 0.00}$ | $2.06_{\pm 0.19}$ | $1.00_{\pm 0.00}$ | $1.68_{\pm 0.07}$ | $1.00_{\pm 0.00}$ | $1.84_{\pm 0.04}$ |
| Learning Baselines |  |  |  |  |  |  |
| BC | $0.00_{\pm 0.00}$ | $-0.01_{\pm 0.10}$ | - | - | - | - |
| ICL | - | - | $-0.50_{\pm 0.00}$ | $1.07_{\pm 0.22}$ | $-0.50_{\pm 0.00}$ | $1.11_{\pm 0.17}$ |
| C1 | - | - | $0.12_{\pm 0.01}$ | $-0.58_{\pm 0.12}$ | $0.12_{\pm 0.01}$ | $-0.04_{\pm 0.20}$ |
| C5 | - | - | $0.07_{\pm 0.01}$ | $-0.66_{\pm 0.04}$ | $0.07_{\pm 0.02}$ | $-0.14_{\pm 0.12}$ |
| PREDICT Ablations |  |  |  |  |  |  |
| Base | $0.41_{\pm 0.07}$ | $1.22_{\pm 0.15}$ | $0.18_{\pm 0.02}$ | $0.38_{\pm 0.14}$ | $0.15_{\pm 0.02}$ | $0.90_{\pm 0.16}$ |
| 1NC | $0.42_{\pm 0.04}$ | $1.24_{\pm 0.28}$ | $0.17_{\pm 0.02}$ | $0.25_{\pm 0.09}$ | $0.16_{\pm 0.02}$ | $1.02_{\pm 0.34}$ |
| 1SC | $0.43_{\pm 0.07}$ | $1.18_{\pm 0.20}$ | $\boldsymbol{0.29_{\pm 0.01}}$ | $0.49_{\pm 0.13}$ | $\boldsymbol{0.24_{\pm 0.05}}$ | $0.95_{\pm 0.12}$ |
| SC | $0.45_{\pm 0.02}$ | $1.24_{\pm 0.27}$ | $0.25_{\pm 0.01}$ | $0.68_{\pm 0.17}$ | $0.22_{\pm 0.02}$ | $1.07_{\pm 0.27}$ |
| CP | - | - | $0.15_{\pm 0.02}$ | $0.81_{\pm 0.13}$ | $0.13_{\pm 0.02}$ | $1.09_{\pm 0.28}$ |
| NV | $0.48_{\pm 0.06}$ | $1.25_{\pm 0.17}$ | $0.26_{\pm 0.03}$ | $0.73_{\pm 0.18}$ | $0.20_{\pm 0.01}$ | $0.95_{\pm 0.15}$ |
| Full | $\boldsymbol{0.49_{\pm 0.06}}$ | $\boldsymbol{1.40_{\pm 0.15}}$ | $0.27_{\pm 0.03}$ | $0.78_{\pm 0.06}$ | $0.23_{\pm 0.02}$ | $1.10_{\pm 0.10}$ |
| +ICL | - | - | $0.26_{\pm 0.02}$ | $\boldsymbol{1.32_{\pm 0.20}}$ | $0.20_{\pm 0.02}$ | $\boldsymbol{1.64_{\pm 0.14}}$ |

RQ1. In our first question, we set out to verify whether generating iterative candidate trajectories is beneficial to inferring preferences. Comparing PREDICT to its ablated versions on the action/generation quality metric (PPCM), shows each component of the iterative refinement process improves performance. Comparing PREDICT with no comparison trajectory — PREDICT${}_{\text{1NC}}$ — to PREDICT with a single candidate comparison trajectory — PREDICT${}_{\text{1SC}}$ — we can see providing comparison trajectories is beneficial when inferring preferences (2.3% mean improvement). This result supports the algorithmic decisions in (Gao et al., ; Peng et al., ). Allowing for multiple refinement steps provides a further increase in performance (Table 1: PREDICT${}_{\text{1SC}}$ vs. PREDICT${}_{\text{SC}}$, 4.3% mean improvement). This can be explained by the LLM having more chances to infer correct preferences. Lastly, when comparing PREDICT${}_{\text{SC}}$ to PREDICT${}_{\text{Full}}$ we see another 3.9% improvement. This highlights the benefits of updating candidates after each inference step using the newly inferred preferences. In all, iterative refinement provides a mean improvement of 9.0%.

RQ2. We next examine the effect of splitting compound preferences down into their constituent components by comparing PREDICT to PREDICT${}_{\text{CP}}$ (compound preferences) (Table 1) on PLUME. Action/generation quality (PPCM) does not show a clear trend, with both models achieving similar scores on both tasks. However the full version of PREDICT does achieve a higher preference BERTScore on both tasks; in fact PREDICT${}_{\text{CP}}$ produces one of the lowest BERTScores. More interesting however, is the variance: using compound preferences leads to high PPCM variance, whereas the full version of PREDICT is the most consistent performer (lowest variance). We hypothesize that splitting preferences into components enforces structure and benefits consistency, but it also prevents the LLM from using the more complex, multi-faceted preferences that PREDICT${}_{\text{CP}}$ can utilize. On the other hand, when PREDICT${}_{\text{CP}}$ makes an error, the error is much more difficult to isolate and rectify. This can lead to PREDICT${}_{\text{CP}}$ retaining incorrect preferences or discarding everything. More work is required to investigate and potentially mitigate this trade-off.

RQ3. We investigate the benefit of validating preferences by comparing PREDICT to PREDICT${}_{\text{NV}}$ (no validation). Here, we see a modest but consistent action quality benefit of 7.0%, 1.6%, and 5.2% for the PICK UP, email writing, and summarization tasks respectively when using validation.

Figure: Figure 2: Mean and standard deviation (5 seeds) performance for CIPHER-1, in-context learning (ICL), PREDICT, Oracle, and no preferences (NPC) for different preference-inferring LLMs.
Refer to caption: x2.png

Discussion.
Fig. 2 shows that the performance of PREDICT scales better with the quality of the underlying LLM (e.g., Llama3 70B-instruct vs. GPT-4o), compared to every other methods.
Additionally, as expected, performance increases as more user examples are seen (Fig. 5), with the largest performance gain from the first example.

While BERTScore is a more representative metric than the accuracy used in Gao et al. (), it does not fully capture the impact of the inferred preferences: preferences can be written very differently, but lead to similar outcomes (e.g., use hashtags for emphasis versus write in the style of tweet). For this reason, we focus primarily on action quality in this paper, but encourage future work to investigate alternatives metrics that better capture preference intent.

While PREDICT outperforms all preference-conditioned and no-learning baselines, ICL and PREDICT perform equally well on email writing with ICL outperforming PREDICT on summarization. All summarization tasks have a formatting/structure preference (e.g., write in the style of a tweet), which are difficult to capture using natural language preference descriptions. PREDICT often tries to capture these preferences using multiple relevant, but imperfect preferences (e.g., use hashtags for emphasis, include emojis to create a playful tone, employ attention grabbing phrasing). We further investigate the performance gap by comparing the performance across preference sets (Fig. 3) and find that ICL excels on sets with the strongest structural preferences (e.g., write in the style of a screenplay). In contrast, PREDICT outperforms ICL on the preference sets requiring a more nuanced understanding of tone (e.g., be intensely emotional or
be sharply critical). While ICL generally performs well, preference conditioning has several advantages: (1) preferences are easier to interact with than a dataset of in-context examples, (2) at inference time, it requires 10x fewer tokens, and (3) it can benefit a wider range of tasks, e.g., human-agent collaboration (Liu et al., ), sample efficient imitation/reinforcement learning, or generating personalized preference pairs for RLAIF (Sun et al., ).

As the two methods seem to have complementary benefits, we combine the two methods (PREDICT${}_{\text{Full+ICL}}$), and achieve a performance gain of 17.9% and 13.1% over PREDICT and ICL respectively. PREDICT${}_{\text{Full+ICL}}$ outperforms previous state-of-the-art CIPHER by 58.8%.

Figure: Figure 3: PPCM mean and standard deviation (5 seeds) for PREDICT, CIPHER-1, and in-context learning (ICL) by Email (top) and Summary (bottom) sub-task type. GPT-4o is the LLM.
Refer to caption: x3.png

### 5.1 Limitations and Future Work

While the methods proposed in this work provide a number of significant improvements, their limitations and challenges provide interesting avenues for future work.

First, in this paper we focus on learning with the fewest user examples possible. However another aspect of efficiency is the total number of prompt and generated tokens used, and adding more refinement and preference validation steps increases the number of tokens used. In our experiments, PREDICT${}_{\text{Full}}$ used (5.87x / 6.07x) more (prompt / generated) tokens on average than PREDICT${}_{\text{Base}}$. Given the monetary and environmental cost of LLMs, reducing the number of tokens while retaining performance is an important area for improvement.

Another limitation is the requirement to represent all trajectories in language. While this is possible for the environments used here, it may not be possible in all domains (e.g., any environment requiring an understanding of subtle movement patterns). Future work is needed to investigate the use of multimodal foundations models, such as VLMs, to address this limitation.

Lastly, a full-scale human trial would provide a greater understanding of the benefits and limitations of the proposed method. We look forward to investigating this more closely in future work.

Ethical Concerns The proposed method allows for greater personalization of assistive agents. However inferring a user’s preferences could be seen as an invasion of privacy. With this in mind, these methods should be applied only with explicit consent from human users.

## 6 Conclusion

In this paper, we propose three novel contributions to guide an LLM to better infer preferences from user examples and introduce a new environment for evaluation. First, we iteratively refine preferences by using a preference conditioned agent to test inferred preferences. Second, we break preferences down into their constituent components. Third, we validate preferences against other user examples. We demonstrate on both navigation and writing environments that the proposed method improves performance by as much as $66.2\%$ and $58.8\%$.

## 7 Acknowledgements

We would like to thank Miguel Sarabia, Charlotte Magister, Maartje ter Hoeve, and Walter Talbott for their helpful feedback on the manuscript drafts. We would like additionaly thank Charlotte for her help with the LLM personalization literature review. We would like to thank Martin Klissarov for his discussions during ideation and project framing, and Yizhe Zhang for discussions during prompt tuning. Finally a big thank Lindsay Hislop for help coordinating dataset and model use approvals.

## Appendix A Algorithm

Figure: Algorithm 1 Preference-Conditioned Agent Task Completion

Figure: Algorithm 2 PREDICT: Preference Refinement and Inference

## Appendix B PICK UP Objects Visualization

A rendering of the PICK UP Objects task is provided in Appendix Fig. 4.

Figure: Figure 4: A depiction of a user example and associated language descriptions for the PICK UP task.
Refer to caption: x5.png

## Appendix C Extended Results

Additional results tables and figures discussed in the main body of the paper.

### C.1 PRELUDE Results

Results on PRELUDE (Gao et al., ) for PREDICT and baselines: a No-Learning baseline (NPC), an Oracle preference baseline, in-context learning (ICL), CIPHER-1, and CIPHER-5 Gao et al. () (Table 2). To directly evaluate the ability to infer preferences, we provide all models with ground-truth knowledge of the source of the documents. On the summarization task, PREDICT outperforms all baselines on action/generation quality. On the email writing task, PREDICT outperforms all baselines on the PPCM metric, but slightly underperforms CIPHER-1 on the poorly correlated Levenshtein distance metric (see Section 4.3-Metric Correlation for issues with Levenshtein distance).

Results in this table further support issues with the current preference-quality metrics. In the email writing task, the no-learning baseline (which always uses an empty preference), has a higher accuracy than any learning method, which may be due to the significant overlap between preference sets in the task. Further, in both tasks, the highest preference-quality scores do not lead to the highest action-quality scores. We encourage future work to look into alternative preference-quality metrics.

We lastly note that PRELUDE has substantially smaller range between the no-learning (NPC) and oracle preference baselines relative to PLUME. On PPCM, PRELUDE has a range 2.45 and 0.62 for summarization and email writing respectively, while PLUME has ranges of 3.17 and 2.91 for the two tasks. This further supports PLUME as the primary evaluation environment.

**Table 2: PRELUDE Results. PREDICT’s ability to infer the correct preference set and quality of generated behaviors across the two PRELUDE tasks compared against a no-learning baseline (NPC), a method with access to the true preferences (Oracle), in-context learning (ICL), and CIPHER Gao et al. (). Results are reported as the mean and standard deviation across five seeds. Accuracy and Bscore (BERTScore) Zhang* et al. () are preference-quality metrics, while Levenshtein distance and PPCM (per preference-component match) are action-quality metrics.**
| Summarization |  |  |  |  |
| --- | --- | --- | --- | --- |
| Method | Accuracy | BScore | Levenshtein | PPCM |
| No Learning Baselines |  |  |  |  |
| NPC | $0.20_{\pm 0.00}$ | $-0.43_{\pm 0.00}$ | $111.50_{\pm 4.91}$ | $-0.89_{\pm 0.12}$ |
| Oracle | $1.00_{\pm 0.00}$ | $1.00_{\pm 0.00}$ | $1.35_{\pm 3.02}$ | $1.56_{\pm 0.09}$ |
| Learning Baselines |  |  |  |  |
| ICL | - | - | $113.98_{\pm 7.84}$ | $-0.81_{\pm 0.19}$ |
| C1 | $\boldsymbol{0.79_{\pm 0.07}}$ | $\boldsymbol{0.13_{\pm 0.04}}$ | $49.20_{\pm 9.15}$ | $0.79_{\pm 0.24}$ |
| C5 | $0.66_{\pm 0.19}$ | $0.04_{\pm 0.04}$ | $45.34_{\pm 20.07}$ | $0.59_{\pm 0.45}$ |
| PREDICT | $0.73_{\pm 0.10}$ | $0.10_{\pm 0.03}$ | $\boldsymbol{9.21_{\pm 5.20}}$ | $\boldsymbol{1.03_{\pm 0.26}}$ |
| Emails |  |  |  |  |
| Method | Accuracy | BScore | Levenshtein | PPCM |
| No Learning Baselines |  |  |  |  |
| NPC | $0.25_{\pm 0.00}$ | $-0.40_{\pm 0.00}$ | $30.50_{\pm 10.23}$ | $0.89_{\pm 0.09}$ |
| Oracle | $1.00_{\pm 0.00}$ | $1.00_{\pm 0.00}$ | $1.72_{\pm 1.21}$ | $1.51_{\pm 0.03}$ |
| Learning Baselines |  |  |  |  |
| ICL | - | - | $35.85_{\pm 9.85}$ | $0.87_{\pm 0.05}$ |
| C1 | $\boldsymbol{0.07_{\pm 0.07}}$ | $-0.25_{\pm 0.03}$ | $\boldsymbol{13.61_{\pm 6.88}}$ | $0.94_{\pm 0.06}$ |
| C5 | $\boldsymbol{0.07_{\pm 0.10}}$ | $\boldsymbol{-0.04_{\pm 0.02}}$ | $21.88_{\pm 4.35}$ | $0.93_{\pm 0.12}$ |
| PREDICT | $0.04_{\pm 0.06}$ | $-0.25_{\pm 0.04}$ | $18.93_{\pm 9.10}$ | $\boldsymbol{0.96_{\pm 0.12}}$ |

### C.2 Metric Correlation Results

The metric correlation results for the assistive writing tasks both across the summary versus email writing sub-tasks and by sub-task (Table 3).

**Table 3: Pearson R correlation between preference similarity metrics and generated writing similarity metrics broken down by task (summarization vs. email). For Levenshtein distance (L-dist) and length-normalized Levenshtein distance (ln-L-dist) lower is better, so inverse correlation is expected. All other metrics are higher is better. Best correlation in each environment is bold. Best overall correlation is underlined. See Section 4.3 for a full description of each metric.**
|  | PRELUDE | PRELUDENoEdit | PLUME |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| Metric | Acc. | B.Score | Acc. | B.Score | Acc. | B.Score |
| Emails |  |  |  |  |  |  |
| L-dist | 0.05 | -0.25 | -0.06 | -0.28 | -0.07 | -0.14 |
| ln-L-dist | 0.05 | -0.24 | -0.01 | -0.28 | -0.05 | -0.21 |
| PPCM | 0.29 | 0.34 | 0.21 | 0.30 | 0.42 | 0.77 |
| Summarization |  |  |  |  |  |  |
| L-dist | -0.40 | -0.54 | -0.03 | -0.17 | -0.10 | -0.12 |
| ln-L-dist | -0.50 | -0.60 | -0.18 | -0.37 | -0.16 | -0.37 |
| PPCM | 0.51 | 0.70 | 0.51 | 0.71 | 0.47 | 0.76 |
| Across Tasks |  |  |  |  |  |  |
| L-dist | -0.35 | -0.44 | -0.03 | -0.17 | -0.07 | -0.12 |
| ln-L-dist | -0.43 | -0.48 | -0.11 | -0.22 | -0.15 | -0.30 |
| PPCM | 0.46 | 0.58 | 0.44 | 0.56 | 0.45 | 0.76 |

### C.3 Preference Inference and Conditioning Performance by Number of User Samples

In Fig. 5 we show the impact of the number of samples for a given user according to the measures for inferred-preference and action/generation quality metrics.

Figure: Figure 5: Performance for PREDICT, behavior cloning (BC), CIPHER-1, and in-context learning (ICL) given different numbers of user samples to learn from. Mean and standard deviation (5 seeds) for preference similarity (IoU in PICK UP and BScore in PLUME) and preference-conditioned generation quality (Avg. Return for PICK UP and PPCM for PLUME). GPT-4o is the LLM used.
Refer to caption: x6.png

## Appendix D PRELUDE vs. PLUME Preference Sets

The preference sets used for each document source and environment (PRELUDE vs. PLUME) are given in Appendix Table 4.

**Table 4: The user preferences for each assistive writing task (summarization vs. email writing), document source, and version (PRELUDE vs. PLUME).**
| Document Source | Task Version | User Preferences |
| --- | --- | --- |
| Summarization |  |  |
| News Articles | PRELUDE | interactive, playful language, positive, short sentences, storytelling, style targeted to young children |
| PLUME | adopt a step-by-step structure, include a simile, use ampersands (&) instead of “and”s, write in the style of a children’s book |  |
| Chat Forum Posts | PRELUDE | brief, immersive, invoke personal reflection, second person narrative, show emotions |
| PLUME | adopt a header and sub-header structure, include rhetorical questions, use ALLCAPS to emphasize words, write in the style of a tweet |  |
| Encylopedia Pages | PRELUDE | brief, bullet points, parallel structure |
| PLUME | adopt a rhyming structure, include modern slang, use semicolons (;) when possible, write in the style of a screenplay |  |
| Paper Abstract | PRELUDE | inquisitive, simple English, skillful foreshadowing, tweet style, with emojis |
| PLUME | adopt a question-answering style structure, include personifications, use archaic language, write in the style of a podcast |  |
| Movie Review | PRELUDE | question answering style |
| PLUME | adopt a stream-of-consciousness structure, include onomatopoeias, use imagery, write in the style of old timey radio |  |
| Email Writing |  |  |
| Personal Problem | PRELUDE | conversational, informal, no closing |
| PLUME | be intensely emotional, include alliterations, use a formal tone, write in a second person narrative |  |
| Paper Review | PRELUDE | call to action, casual tone, clear, positive |
| PLUME | be sharply critical, include several short and punchy sentences, use parenthetical asides, write using assertive expressions |  |
| Paper Tweet | PRELUDE | engaging, personalized, professional tone, thankful closing |
| PLUME | be blatantly sarcastic, include hyperboles, use an informal tone, write in a third person perspective |  |
| Paper Summary | PRELUDE | professional greeting and closing, respectful, straight to the points, structured |
| PLUME | be highly inquisitive, include several long and flowing sentences, use emojis, write using conditional expressions |  |

## Appendix E Illustrative Examples of Issues with PRELUDE

### E.1 Levenshtein Distance and Multiple Generations

We present here an inherent issue with Levenshtein distance. For all three generations, we prompt gpt-4o to summarize the encyclopedia article on hotdogs. The first two generations (A. and B.) use identical prompts, in which we ask it to use the preference: “use a haiku”. In the third generation, we ask it to use the preference “use a single short sentence”. We then calculate the Levenshtein distance between each pair, reported in Table 5. Notably, the Levenshtein distance and length normalized Levenshtein distance, in which a lower score represents higher similarity, would both indicate that generation A and C are more similar to generation A and B, even though generation A and B share the same exact same prompt while generation C uses a entirely different preference. BERTScore does a better job of identifying the most similar texts, however the PPCM scores, which compares writing directly to the true preferences, clearly labels both Generation A. and Generation B. as “strongly exhibiting” the preference “use a haiku", and Generation C. as “strongly contradicting” the preference.

Generation A.

> A sausage in bun, Toppings vary near and far, Hot dog, rich in roots.

Generation B.

> Grilled or steamed sausage, In a bun with cheese or spice, Street food’s warm embrace.

Generation C.

> A hot dog is a sausage in a bun with various toppings such as mustard, ketchup, and relish

**Table 5: Levenshtein distance between each pair of generations.**
| Pairing | Levenshtein Dist. | Norm. Levenshtein Dist. | BERTScore | PPCM per generation |
| --- | --- | --- | --- | --- |
| A-B | 17 | 0.85 | 0.27 | (2, 2) |
| A-C | 16 | 0.76 | 0.20 | (2, -2) |
| B-C | 17 | 0.81 | 0.10 | (2, -2) |

### E.2 Editing Influences the User

In this next example, we demonstrate how the editing procedure can influence the output of the user. We again ask an LLM to summarize the encyclopedia article on hot dog. Let’s assume, an inferring agent has incorrectly inferred the preference "question answering style". Using this preference, the preference-conditioned agent writes:

> What is a hot dog? A hot dog is a dish made of a sausage (typically a wiener or frankfurter) served in a partially sliced bun. It can refer to the sausage itself, which is grilled, steamed, or boiled. How is a hot dog typically prepared? Hot dog preparation varies, but common condiments include mustard, ketchup, relish, and onions. Some toppings can also include cheese sauce, sauerkraut, chili, bacon, or jalapeños. Where did hot dogs originate? The sausages used in hot dogs were culturally imported from Germany, and the dish became popular in the U.S. as a working-class street food. Over time, hot dogs became closely associated with American culture, particularly baseball. Where are hot dogs most popular? While they are especially associated with New York City, hot dogs became widespread across the United States throughout the 20th century, becoming an integral part of American cuisine.

We ask the user if the above is satisfactory for it’s true preference of: “style targeted to young children". It does not, so we then ask the user to edit the above for it true preference “style targeted to young children", and the user writes:

> What is a hot dog? A hot dog is a yummy snack made of a sausage (like a wiener or frankfurter) inside a soft bun. Sometimes people call the sausage itself a hot dog, and it can be cooked by grilling, steaming, or boiling. How is a hot dog usually made? Hot dogs can be made in different ways, but they often have yummy toppings like mustard, ketchup, relish, and onions. Some people like to add even more fun stuff like cheese, sauerkraut, chili, bacon, or spicy jalapeños. Where did hot dogs come from? The sausages in hot dogs came from Germany, and a long time ago, they became super popular in the U.S. as a quick and tasty street food for busy people. Now, hot dogs are a big part of American culture, especially at baseball games! Where are hot dogs the most popular? Even though hot dogs are popular all over, they are especially loved in New York. Over the years, hot dogs have become a favorite food all across the United States!

While the above summary does correctly follow the true preference, it is still formatted in a question answering style, which is not part of the user’s preferences. I.e., the preference-inferring agent’s error has directly impacted the user’s writing. This is another reason why PLUME removes the editing procedure.

For reference, if the user is directly asked to summmarize the encyclopedia article on hot dogs using it’s true preference of “style targeted to young children", it outputs:

> A hot dog is a yummy food that’s made with a sausage, like a wiener or frankfurter, inside a soft bun. You can cook the sausage in different ways, like grilling or boiling. People love to put tasty toppings on their hot dogs, such as ketchup, mustard, cheese, and even onions! Hot dogs came from Germany, but they became super popular in the US, especially at baseball games. Now, you can find hot dogs all over the country, and in some places, like Chicago, people have special ways of making them!

## Appendix F Prompts

### F.1 Preference Inference and Preference-Conditioned Agent Prompts

The prompts used by PREDICT for candidate trajectory generation and task completion in the PLUME environment are in Appendix Fig. 6. The prompts used by PREDICT to infer the user preferences from user examples are provided in Appendix Fig. 8 for the PICK UP environment and in Appendix Fig. 7 for the PLUME environment.

Figure: Figure 6: LLM prompts for the preference-conditioned agent and for task completion on the PLUME’s summarization and e-mail writing tasks. The system prompt is prepended to the user prompt following the LLM’s chat template. “{…$|$…}” means that of the two options is selected based on the task and “<...>” indicates that the text is formatted from a variable. inferred_preference_i refers to one of the inferred user preferences.

Figure: Figure 7: LLM prompts for preference inference on PLUME’s summarization and e-mail writing tasks. The system prompt is prepended to each user prompt following the LLM’s chat template. “{…$|$…}” means that of the two options is selected based on the task and “<...>” indicates that the text is formatted from a variable. user_output refers to how the user completes the task, assistant_output how the assistant completes the task, and inferred_preference_i to one of the inferred user preferences. Continued on next page.

Figure: Figure 7: LLM prompts for preference inference on the PLUME’s summarization and e-mail writing tasks. The system prompt is prepended to each user prompt following the LLM’s chat template. “{…$|$…}” means that of the two options is selected based on the task and “<...>” indicates that the text is formatted from a variable. user_output refers to how the user completes the task, assistant_output how the assistant completes the task, and inferred_preference_i to one of the inferred user preferences.

Figure: Figure 8: LLM prompts for each step of preference inference on the PICK UP task. The system prompt is prepended to each user prompt following the LLM’s chat template. “<...>” indicates that the text is formatted from a variable. user_output refers to how the user completes the task, assistant_output how the assistant completes the task, and inferred_preference_i to one of the inferred user preferences. Continued on next page.

Figure: Figure 8: LLM prompts for each step of preference inference on the PICK UP task. The system prompt is prepended to each user prompt following the LLM’s chat template. “<...>” indicates that the text is formatted from a variable. user_output refers to how the user completes the task, assistant_output how the assistant completes the task, and inferred_preference_i to one of the inferred user preferences.

### F.2 Synthetic Human Prompts

The prompts used to have GPT-4o play the role of our synthetic human for PREDICT are given in Appendix Fig. 9. The “human” is instructed to complete the task in the same way as the preference-conditioned agent when completing the writing tasks (see Appendix Fig. 6).

Figure: Figure 9: LLM prompts for the synthetic human on the PLUME’s summarization and e-mail writing tasks. The system prompt is prepended to the user prompt following the LLM’s chat template. “{…$|$…}” means that of the two options is selected based on the task and “<...>” indicates that the text is formatted from a variable. inferred_preference_i refers to one of the inferred user preferences.

### F.3 Preference-Conditioned Agent Baseline Prompts

The prompts used in the no-preference baseline are in Appendix Fig. 10 and for the in-context learning baseline are in Appendix Fig. 11. For the in-context learning baseline, the number of examples $l$ matches the number of examples used when coalescing prevoiusly inferred prompts (see Appendix Fig. 7).

Figure: Figure 10: LLM prompts for the no preference baseline in the PLUME environment. The system prompt is prepended to the user prompt following the LLM’s chat template. “<...>” indicates that the text is formatted from a variable. task_content refers to the content of either the article to be summarized or the notes to include in the email, depending on the sub-task.

Figure: Figure 11: LLM prompts for the in-context learning baseline in the PLUME environment. The system prompt is prepended to the user prompt following the LLM’s chat template. “<...>” indicates that the text is formatted from a variable, and completion_$l$ refers to an example completion provided for in-context learning. task_content refers to the content of either the article to be summarized or the notes to include in the email, depending on the sub-task.

### F.4 LLM-as-a-Judge Prompts

The prompts used by the LLM-as-a-Judge are shown in Fig. 12.

Figure: Figure 12: LLM-as-a-Judge prompts for the per preference-component match metric (PPCM) used in the PLUME environment. The system prompt is prepended to the user prompt following the LLM’s chat template. “<...>” indicates that the text is formatted from a variable. agent_completion refers to the agent’s article summary or email, depending on the sub-task. true_preference_i refers to one of the $k$ true preferences that the user has.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: What setting would you propose in which such learned preferences are actionable?

How do you obtain sufficient user trajectories in practice?
soundness: 2
strengths: The proposed idea is quite interesting. The idea of examining counterfactual trajectories seems novel and is intuitive. Additionally, it appears the proposed PLUME environment addresses valid limitations of prior work. The presented main experimental section also includes several important ablations to consider, and the main results indicate strong improvements over the presented baselines.
summary: The paper introduces a method called PREDICT which is designed to infer individual user preferences from user interaction trajectories. The proposed approach is evaluated in two settings: a toy gridworld environment designed by the authors in which an agent must pick up objects on a 5x5 grid while maximizing a reward with user preferences unbeknownst to the agent, and PLUME, an assistive writing preference environment developed by the authors by modifying the recently proposed PRELUDE environment.

Update: The discussion has been helpful in improving the clarity and positioning of the work. I have increased the presentation score and overall rating.
weaknesses: *The writing is somewhat confusing.* For instance, Figure 2 is pretty underspecified and hard to parse, and many of the important details are not available in the main text (e.g., in L122-139 it is hard to concretely understand what the algorithm is doing; preference aggregation in L165-169 is unclear).

*The overall interaction setting seems unrealistic.* The PICKUP environment is rather toy-ish, and it is difficult to say whether such types of preference identification (determining what colors a user prefers) is actually reflective of real-world personalization settings (e.g., linguistic style, interaction length). While PLUME appears to address some of these concerns, it is actually not clear to me whether the cost function is representative of user preference. The number of users seems quite small (only five for summarization and four for email writing).

*The baseline comparisons are rather limited.* In Figure 3, PREDICT may outperform CIPHER-1, but it underperforms ICL for all LLMs evaluated. While it seems that PREDICT + ICL outperforms ICL alone in Table 1, this raises questions about comparing PREDICT with more sophisticated prompt-based baselines which may involve examining trajectories and requiring similar levels of complexity as PREDICT + ICL (for instance, Monte-Carlo Tree Search). Relatedly, Behavior Cloning is the only baseline for the gridworld environment whereas it may be more expected to compare against standard RL-based baselines in such environments. While the authors also claim that PREDICT is not limited by the issues of fine-tuning, it is not clear to me that it is necessarily advantageous compared to tuning.

---

confidence: 3
contribution: 2
initial_rating: 3
presentation: 2
questions: 1. Ln 142 "base components": are they all hand crafted for each task?
2. Ln 156, 173, 260: who are the 'users'? Human? LLM proxy?
3. Ln 233: it is unclear what the relevance/importance it is for the environment to be partially observable
soundness: 2
strengths: - The paper studies an important and challenging problem: how to infer and accommodate user's implicit preferences
- The paper proposed a method to infer user's preference by comparing user VS LLM assistant's action trajectories, decompose into several components, and validate the preferences across users
- The paper conducted experiments in two environments
- The paper conducted thorough experiments with ablation studies and compared against several baselines
summary: The paper proposed a method for personalized LLM assistant that infers implicit user preference. The PREDICT pipeline includes an initial LLM assistant which conducts the same task as the user, a preference-inferring agent which summarizes the difference between the user and the assistant's trajectory, as well as a validation step to generalize the inferred preferences on multiple users. 

The paper conducted experiments in two environment settings, a grid world navigation, and PLUME, a text summarization and email editing environment. The paper proposed two evaluation dimensions, preference quality and action quality, to measure the inferred preference correctness and the overall task completion rate. Both evaluation dimensions are further translated in domain-specific measures.

The paper compared the proposed method against several baselines and conducted ablation studies, and demonstrated improved performance.
weaknesses: The paper could largely benefit from a major round of revision:
- It would be helpful to illustrate detailed examples for each of the benchmark environment in the main paper
- Figure 2 is very abstract. It would be helpful to add more details, such as examples of the constituent components, examples of the contrast between user and agent's predictions, examples of validation set, etc.
- It would be helpful to formally define each of the evaluation metrics
- Table 1: how significant are there results as most of the differences fall within the std margin. How would Table 1 support the main claim (Ln 22) that 'PREDICT more accurately infers nuanced human preferences', especially when the Ln 420 concluded that 'PPCM does not show a clear trend' when comparing PREDICT to PREDICT_{CP}
- The paper heavily references Gao et al. 2024 for experiment setups, methods, etc without specifying the necessary details within the paper

---

confidence: 2
contribution: 3
initial_rating: 6
presentation: 3
questions: See weakness part.
soundness: 3
strengths: 1. Good Solution: introduce a thoughtful combination of iterative refinement, preference decomposition, and validation, effectively addressing the generic nature of existing preference inference methods.

2. A new reliable benchmark: LUME environment is a valuable contribution, offering a more reliable benchmark compared to previous setups like PRELUDE.

3. Significant Performance Gains: The method achieves impressive improvements over established baselines, notably outperforming behavioral cloning by 66.2% in PICK UP and CIPHER by 41.0% in PLUME, highlighting the practical efficacy of the proposed components.
summary: This paper presents PREDICT (Preference Reasoning by Evaluating Decomposed Preferences Inferred from Candidate Trajectories), a novel method aimed at enhancing the inference of human preferences in AI agents. Addressing the limitations of existing Large Language Models (LLMs) that often generate broad and generic preferences, PREDICT introduces three key innovations: iterative refinement of inferred preferences, decomposition of preferences into constituent components, and validation of preferences across multiple user trajectories. The approach is rigorously evaluated in two distinct environments—a gridworld setting (PICK UP) and a newly introduced text-domain environment (PLUME)—demonstrating substantial improvements over baseline methods by 66.2% in PICK UP and 41.0% in PLUME. Additionally, augmenting PREDICT with in-context learning yields a further 17.9% enhancement, underscoring its effectiveness in capturing nuanced human preferences.
weaknesses: 1. Need investigate how varying iterative refinement steps impacts the performance and efficiency of the method, potentially overlooking optimal configurations.
2. Lack of Real User Case: experiments are primarily based on synthetic users, consider adding some real case analyses to verify the practicality and generalizability of the method.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: 1. One concern I had with the preference validation approach is that preferences might only apply in rare circumstances. It seems that the validation stage would then return almost all neutrals, which would result in filtering out, even if the preference was very clear. Is this reasoning accurate and is there a way to address this issue (e.g., by doing some more targeted sampling)?
2. Honestly, I am not sure why performance on the PICK UP task increases, given the simplicity of preferences in that environment. One potential concern would be that if initial inferred preferences are over objects (e.g., “prefers yellow triangles”), then the breaking down of preferences could provide an implicit bias toward the “compositional” preference structure of the task. Can you provide a bit more intuition on whether this is a valid concern, and why you think performance on the PICK UP task improves?
3. Would it be possible to provide some examples of inferred preferences before and after applying your method somewhere in the paper?
soundness: 3
strengths: 1. The proposed method is relatively simple but appears to provide clear gains on the preference inference task 
2. The paper provides two new tasks, one toy gridworld (PICK UP) and one modification of an existing assistive writing task (PLUME). These tasks, especially PLUME, seem like good starting points for future modeling work
summary: This paper proposes a prompting-based method for inferring and refining user preferences from action trajectories. The proposed method takes an initial set of inferred preferences, asks a language model to refine them (e.g., by collapsing duplicates, breaking down complex preferences into individual preferences) and then validates the preferences by asking a language model whether sampled user examples confirm or contradict the inferred preference. The paper tests the proposed approach in two domains, (1) a gridworld object collection domain and (2) a writing/editing benchmark, finding clear gains, especially in the latter domain.
weaknesses: 1. The proposed method and benchmark could be a bit more clearly described. In particular, I found the interleaving of contributions and the actual method description in Section 3 to be a bit confusing, and it’s a bit difficult to understand how the iterative refinement step works without looking at the corresponding prompts in the Appendix — perhaps a more detailed Figure 2 could help here? I also think the description of PREDICT is a bit hard to follow for someone not familiar with PLUME (and again, I think figures would help!)
2. Not really a weakness (i.e., does not affect my score): the paper only focuses on inferred preferences, rather than stated preferences. It would be great to see how this approach works in a setting with both stated and inferred preferences

Meta-review: This paper introduces PREDICT, a method that enhances the precision and adaptability of inferring human preferences in AI interactions by refining preferences iteratively, decomposing them into components, and validating them across multiple trajectories. Evaluated in both a gridworld and a new text-domain environment, PREDICT demonstrates significant improvements over existing baselines. Despite its contributions, according to the reviewers' feedback and discussions, this paper still has to be improved on the following aspects: unrealistic interaction settings, limited baseline comparisons, lack of detailed examples and formal definitions, insufficient investigation of iterative refinement steps, reliance on synthetic users without real case analyses, and the presentation of the methodologies.

Decision: Reject