UserLM-2.0

UserLM-2.0 is an 8-billion-parameter user simulator for user-AI conversations. Unlike typical language models trained to play the assistant, UserLM-2.0 generates the user side of a conversation. It is conditioned on a task intent that describes the user's high-level objective.

UserLM-2.0 can:

1. Generate an initial user utterance from a task intent.
2. Generate follow-up user utterances from the conversation so far.
3. Emit `` when it determines that the user's objective has been satisfied and the conversation should end.

The model is intended to support research on realistic user simulation and the development and evaluation of more robust assistant models.

Paper: The accompanying UserLM-2.0 paper is forthcoming. An arXiv link will be added when it becomes available.

Model details

• Developed by: Omer Gul (Microsoft Research intern, Spring 2026), Philippe Laban (Microsoft Research), Tanya Goyal (Microsoft Research), and Jennifer Neville (Microsoft Research)
• Model type: Generative causal language model, 8B parameters
• Language: English
• License: MIT
• Backbone: meta-llama/Llama-3.1-8B-Instruct
• Repository: microsoft/UserLM-2.0

How to use

UserLM-2.0 generates user turns. Put the task intent in the system message, generate a user turn, append the assistant's reply, and call the model again. The bundled chat template automatically opens the correct user-role generation header.

The following example uses Hugging Face Transformers directly:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "microsoft/UserLM-2.0"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    dtype=torch.bfloat16,
    device_map="auto",
).eval()

task_intent = (
    "You want help planning a quick vegetarian dinner for four people. "
    "You have 45 minutes, one guest has a peanut allergy, and you need a "
    "shopping list and cooking instructions. You prefer pasta, but only "
    "mention that preference if the assistant asks. Your goal is not "
    "satisfied until you receive a menu, shopping list, and cooking steps."
)
messages = [{"role": "system", "content": task_intent}]

def generate_user_turn(messages: list[dict[str, str]]) -> str:
    inputs = tokenizer.apply_chat_template(
        messages,
        tokenize=True,
        add_generation_prompt=True,
        return_tensors="pt",
        return_dict=True,
    ).to(model.get_input_embeddings().weight.device)

    with torch.inference_mode():
        outputs = model.generate(
            **inputs,
            max_new_tokens=128,
            do_sample=True,
            temperature=1.0,
            top_p=0.8,
            eos_token_id=tokenizer.eos_token_id,
            pad_token_id=tokenizer.pad_token_id,
        )

    generated_ids = outputs[0, inputs["input_ids"].shape[1]:]
    return tokenizer.decode(generated_ids, skip_special_tokens=True).strip()

# First user turn
user_turn = generate_user_turn(messages)
messages.append({"role": "user", "content": user_turn})
print("User:", user_turn)

# Supply an assistant response, then generate the next user turn.
messages.append(
    {
        "role": "assistant",
        "content": "I can help with that. Would you prefer pasta, tacos, or a rice bowl?",
    }
)
user_turn = generate_user_turn(messages)

if "" not in user_turn:
    messages.append({"role": "user", "content": user_turn})
    print("User:", user_turn)
else:
    print("The simulated user ended the conversation.")

Example output

The following user turns were produced by UserLM-2.0 with temperature=1.0 and top_p=0.8. Assistant turns were supplied by the simulation harness.

UserLM-2.0: hi. i need help with a dinner. i have 45 minutes. i need to make a dinner for 4 people. 1 of the people has a peanut allergy. i need a menu, shopping list, and step by step cooking instructions. if you need any more information from me, let me know.

Assistant: I can help with that. Would you prefer pasta, tacos, or a rice bowl?

UserLM-2.0: pasta.

Assistant: Let's make chickpea tomato pasta with a green salad. For four people, buy 12 oz pasta, two cans of chickpeas, one 28 oz can of crushed tomatoes, garlic, one onion, olive oil, Italian herbs, one lemon, mixed greens, one cucumber, and Parmesan or a vegetarian alternative. The menu is peanut-free, but check package labels for cross-contamination. Would you like the step-by-step cooking order?

UserLM-2.0: yes please.

Assistant: Boil the pasta while you prepare a chickpea tomato sauce. Toss the greens and cucumber with lemon and olive oil, combine the pasta and sauce, and serve with the salad and optional cheese. This should take about 35 minutes.

UserLM-2.0: ``

Treat `` as a control signal: stop the rollout rather than showing it as dialogue in an end-user interface. Generated text is stochastic, so outputs will vary across runs.

Uses

Direct intended uses

UserLM-2.0 is released for researchers evaluating assistant language models. It can simulate multi-turn conversations to help estimate how an assistant may perform with real users. Our evaluation provides evidence that UserLM-2.0 produces more realistic and task-faithful user behavior than prior user simulators and prompted assistant models.

Downstream uses

Potential research applications that were not implemented in the accompanying work include:

1. User modeling, such as predicting user responses to a set of questions.
2. A foundation for fine-tuning judge models.
3. Synthetic conversation generation in conjunction with an assistant model.

Out-of-scope uses

UserLM-2.0 is not an assistant model. It is unlikely to be useful to an end user who needs direct help completing a task; an