LLM-based Human Simulations Have Not Yet Been Reliable

In plain words

Researchers increasingly use language models as stand-ins for people: a model plays a patient, a trader or a participant in a study, and the results are used to learn something about real people. This paper argues that these stand-in simulations are not yet trustworthy. Their answers often differ from what real people do, and the paper points to two kinds of cause. One is the models themselves, which can be biased, act inconsistently across a conversation and forget earlier context. The other is how the simulations are built, which often reduces people to simple categories and checks the results too weakly.

The paper does not build a new model. It describes what a more careful simulation would need: richer data about real people, better model behaviour, and checks at the level of single agents, groups and the whole system. It condenses this into a loop that runs the simulation and validates it as it goes. The paper runs no experiments of its own; its examples come from earlier studies.

TL;DR

• Position paper: the authors argue that LLM-based human simulations are not reliable enough to trust yet §1.
• The gaps come from LLM limits (bias, inconsistency, memory) and simulation-design flaws (oversimplified states, weak incentive modelling, weak validation and monitoring) §3, §4.
• Proposed fixes: richer and synthetic data, bias and memory work, and multi-level validation, condensed into one loop §5, alg. 1.
• No new experiments, no code, and the loop is not evaluated; treat it as a checklist, not a method.

Problem

LLM agents are used as proxies for humans in social, economic, policy and psychological simulations, and to generate or evaluate training data §1. The authors say the outputs diverge from observed human behaviour. Their evidence is a table of six cited studies, for example a diagnosis accuracy of 40.18% for an LLM, a GPT-4 trading return of 28% against 39% for human traders, and an adversarial attack success rate of 27% for GPT-4-Turbo against 6% for humans tab. 1. These figures are quoted from other papers, not re-run here.

Without a validation step, a simulation's output cannot be checked against how people actually behave. The paper's concern is that many studies assume that adequate-looking results are enough §6.

Method

The paper has no algorithm of its own to implement. Its content is:

1. A formal view of a simulation as an environment, a set of LLM agents and rules §2.1, eq. 1.
2. A per-agent policy that maps a message and the current state to an action §2.1, eq. 2.
3. A review of four domains, each with its LLM capabilities, design choices and limitations §2.2–§2.5.
4. Two groups of gaps, from LLM limits §3 and from simulation design [§4, tab. 2].
5. Three solution areas §5, condensed into Algorithm 1 alg. 1.

Formalisation §2.1. The simulation is a tuple of an environment, the agents and rules. The environment has a state space and evaluation procedures. Each agent is an LLM-based policy.

\mathcal{H} = (\mathcal{E}, \mathcal{F}, \mathcal{R}) eq. 1

f_i: (m, s) \mapsto a eq. 2

Here \mathcal{E} = (\mathcal{S}, \mathcal{V}), with state space \mathcal{S} and evaluation procedures \mathcal{V}; \mathcal{F} = \{f_1, \dots, f_n\} are the LLM agents; \mathcal{R} holds the interaction, transition and evaluation rules; m is an incoming message and a an action §2.1.

Solution area 1, data foundation §5.1. Wearable sensors can supply physiological, fine-grained behavioural and environmental signals §5.1.1. LLMs can synthesise data for scenarios that are hard, unsafe or unethical to observe, and vary behaviour through parameters such as personality, emotion and culture §5.1.2.

Solution area 2, LLM abilities §5.2. For bias: diverse and multilingual data curation, debiasing during training, and occupation-aware post-training §5.2. For cognition: an internal reflection step that checks a planned reply against the persona and past actions before output, and separate modules for planning, reasoning and emotion §5.2. For memory: an external store (vector store or database) plus layered short-term and long-term memory §5.2.

Solution area 3, validation §5.3. Build the simulation from modules that can be tested and monitored on their own. Validate at three levels: individual (against human distributions), group (against known social phenomena) and system (automated metrics plus periodic expert review) §5.3.

Algorithm 1 alg. 1 puts these together. It is a loop over agents, with validation at a fixed interval, anomaly correction and a history record:

# Simulation loop  [alg. 1]
# Input:  agents F, environment E, metrics V, human data D_human
# Output: validated environment E, history H, metrics V

def run_simulation(agents, environment, metrics, human_data):
    # Start with an empty history H  [alg. 1]
    history = []
    while not simulation_complete():
        for agent in agents:
            # Agent perceives the environment and the history  [alg. 1]
            percept = perceive(agent, environment, history)
            # Agent produces an action from its percept  [alg. 1]
            action = agent(percept, environment)
            # Score the action against human patterns  [alg. 1]
            score = behavioral_validation(action, human_data)
            # Recalibrate actions that score below the threshold  [alg. 1]
            if score < threshold:
                action = adjust(action, human_data)
            # Apply the action to the environment  [alg. 1]
            environment = apply(action, environment)
            # Store the step in the agent's memory M_i  [alg. 1]
            agent.memory.append((percept, action, environment))
        # Every validate_interval steps, run validation  [alg. 1]
        if time % validate_interval == 0:
            # Individual-level check of the actions  [alg. 1]
            individual = individual_validation(actions, human_data)
            # Group-level check against social data  [alg. 1]
            group = group_validation(environment, social_data)
            # Expert review, marked optional in the source  [alg. 1]
            expert = expert_assessment(environment, history)
            # Adjust agent parameters from the three checks  [alg. 1]
            agents = calibrate(agents, [individual, group, expert])
        # Find unrealistic patterns and correct the environment  [alg. 1]
        anomalies = detect_anomalies(environment, history, agents)
        environment = correct(environment, anomalies)
        # Record the actions, state and metrics in the history  [alg. 1]
        history.append((actions, environment, metrics))
    # Return the environment, history and metrics  [alg. 1]
    return environment, history, metrics

Figure 1 summarises the paper's flow: review the simulations, identify the causes of the gap, then propose targeted solutions fig. 1. Figure 2 shows the three solution components: enriched data foundations, improved LLM capabilities, and simulation design built around robust validation fig. 2.

Hyperparameters

The paper runs no experiments, so it has no model, dataset or training settings §1. The algorithm's free parameters are all unstated:

Results

Author-reported, and not produced by this paper. The paper's own table summarises the findings of six cited studies tab. 1. Models and setups vary between rows.

The paper's design-level evidence is a qualitative table of five drawbacks (oversimplified psychological states, incomplete coverage of lived experience, weak incentive modelling, validation gaps, limited monitoring), each with a cited example tab. 2. There are no numbers to compare there.

Paper vs code

No official code. The paper and its abstract link only a curated list of papers and resources, github.com/Persdre/awesome-llm-human-simulation. A check of that repository found a literature list (MIT, maintained by an author), not an implementation, so it is not recorded as code. A GitHub repository search for the paper's title and for "llm human simulation" found no implementation of the framework or Algorithm 1. No discrepancies between a paper and code can be checked.

Pitfalls

• Nothing here is evaluated. The framework and Algorithm 1 are proposals. The paper states that future empirical work is needed to weigh computational cost against gains §Limitations. Do not describe them as improving reliability.
• Algorithm 1 uses undefined symbols. D_human, D_social, threshold, validate_interval, time and the functions adjust, calibrate, correct, detect_anomalies, apply and perceive are not defined alg. 1. The memory M_i and the first value of V in the return are not initialised. The stopping condition is not given.
• Direction of the threshold check is ambiguous. The paper writes v_i < threshold to trigger recalibration alg. 1. It does not say whether a higher v_i means more human-like.
• Scope of {a_i}. The validation steps refer to the set of actions {a_i} after the agent loop alg. 1. Read literally, the loop variable is the last agent only. Collect all actions in one list when implementing.
• Validation cost is not stated. Algorithm 1 checks every action against human data and runs three validations per interval alg. 1. The paper itself names API cost and the need for specialised models as limits §Limitations.
• Table labels are inconsistent. The human-likeness row is labelled "Accuracy" but reports a rating tab. 1. The rows also mix tasks, models and metrics, so the table shows the scale of the gap, not a like-for-like comparison.
• Do not cite the adversarial figure as bias evidence. The gender-bias paragraph in §3.1 gives the 27% vs 6% attack success figure, citing adversarial-attack work §3.1. That number is about attacks, not gender.
• Appendix is empty. The compiled paper has an appendix heading but no content in the source. There are no further hyperparameters.
• Ground truth is contested. The paper rebuts the view that human behaviour has no definitive ground truth, and the view that adequate performance on niche tasks is enough §6. Expect this framing in its citations.

Lineage

• Builds on: none stated. The paper positions itself against the literature on LLM-based simulation reviewed in §2.
• Compared against: the "functional adequacy" position (cited works park2024generative, yang2025twinmarket, wang2023roleplay) and the "no ground truth" position §6.
• Superseded by: not known from content in this wiki.