By now, most people know, or have at least heard, that LLMs are not quite random, even when you ask them to be. Even with high temperature^[1] settings, a large language model will still lean towards the most probable answer, as that’s how it is essentially built to be.

But can an LLM’s response meaningfully change when you prompt it in a different language, or when you present information to the model in a different manner? This experiment aims to answer this question.ion to the model in a different manner? This experiment aims to answer this question.

You can also find this article here: llmango.rafalkwiecien.com

scope and experiment setup

As this experiment is partly set to analyze differences between the same prompts written in different languages, the first step is to settle on a language scope. I chose English, Polish and Japanese, simply because these are the languages that I can speak, and I did not want a translator in between me and the prompts.

Every prompt in this experiment asks for the same thing: here is a list of ten fruits, pick one at random. The ten fruits never change - apple, banana, orange, mango, grape, strawberry, watermelon, pineapple, lychee and pomegranate. What changes between questions is the order the fruits are shown in, and the structure the model has to use when answering.

I prompted a single model, gpt-5.6-luna from OpenAI, at temperature 1.0. Comparing models would be a perfectly good experiment, but I chose not to do it in this one. A second model is a second source of variance, and I wanted every difference to come from the setup alone.

The unit compared throughout is an arm: one pairing of a language and an output format inside one question. 001a is asked in three languages under one schema, so it has three arms. 001d is asked in three languages as well, but not every language gets every schema there, so it has eight arms. Combined with other questions, it makes seventeen arms, and each one is invoked 2 000 times. In total it amounts to 34 000 LLM outputs behind everything you are about to read.

prompts

English prompt

Randomly, pick one fruit from this list of fruits:

mango, apple, banana, pomegranate, strawberry, orange, watermelon, grape, pineapple, lychee

Polish prompt

Losowo, wybierz jeden owoc z tej listy owoców:

mango, jabłko, banan, granat, truskawka, pomarańcza, arbuz, winogrono, ananas, liczi

Japanese prompt

次の果物のリストから、ランダムに果物を1つ選んでください：

マンゴー, りんご, バナナ, ザクロ, いちご, オレンジ, スイカ, ぶどう, パイナップル, ライチ

structured output

Structured output is a way of telling the model what shape its answer must take. Alongside the prompt, you can pass a schema, a small JSON^[2]-formatted description of the fields you expect back, and the model’s reply is constrained to a JSON object matching it. In this experiment’s case, instead of a sentence that may or may not contain a fruit name, every output is a single field holding one string. This is the typical workflow for mass data generation: when you are collecting thousands of answers, you want each one to land in the same field of the same shape, so parsing becomes a dictionary lookup instead of a guessing game. The schema used here is deliberately minimal:

English schema

{
  "name": "FruitChoice",
  "schema": {
    "additionalProperties": false,
    "properties": {
      "fruit": { "title": "Fruit", "type": "string" }
    },
    "required": ["fruit"],
    "title": "FruitChoice",
    "type": "object"
  },
  "strict": true
}

questions

• 001a: same prompt in different languages
  • question: When presented with the same set of choices that are in the same order, will an LLM shift its answer, if prompted in a different language?
  • order: fixed - [mango, apple, banana, pomegranate, strawberry, orange, watermelon, grape, pineapple, lychee]
  • output format: structured. Base English schema for every language.
• 001b: same fruits in a different fixed order
  • question: When presented with a different order of the same set of choices, will an LLM shift its answer?
  • order: fixed - [pineapple, grape, watermelon, orange, strawberry, pomegranate, banana, lychee, apple, mango]
  • output format: structured. Base English schema for every language.
• 001c: same fruits in shuffled order
  • question: Across a large sample size, every order of choices presented to the LLM is shuffled. Does the answer get “more random”?
  • order: shuffled for every request
  • output format: structured. Base English schema for every language.
• 001d: structured output vs free-text output
  • question: Does requiring structured output in LLMs change their answer?
  • order: shuffled for every request
  • output format: structured using the base English schema, structured using the native-language schema, and free text.

001a: same prompt in different languages

Question: When presented with the same set of choices that are in the same order, will an LLM shift its answer, if prompted in a different language?

TL;DR: yes.

Starting off with the first question: 001a. It has three arms, one for each language, each paired with the base English schema.

The first thing you see straight away is that six of the ten fruits were never chosen even once, and two of the four that were chosen are marginal. The model loves lychee when asked in English (98.4%), loves pomegranate when asked in Japanese (98.4%), and only Polish introduces any variety: pomegranate takes 61.9%, lychee is still there with a third of the Polish answers, and pineapple sneaks in at 5.6%.

Notice which fruits never appeared. Apple, banana and orange would probably be the obvious answers to give if you asked someone to “name any fruit”, but here it’s the opposite. Maybe that’s precisely the reason lychee, pomegranate and pineapple were chosen? To someone (or some model) with an American or European background, they are more “exotic”, or more “interesting” answers.

So is it safe to say that the model prefers lychee in English and pomegranate in Japanese? I mean, that is what this chart says. It is also, as the next two questions show, only half of what is going on.

001b: same fruits in a different fixed order

Question: When presented with a different order of the same set of choices, will an LLM shift its answer?

TL;DR: in English, the model is in fact choosing the fruit. In Polish and Japanese, it is choosing neither the fruit nor the position of the fruit.

001b’s setup is 001a with exactly one thing altered: a new fixed order of the presented fruits, again identical across all three languages and all 6 000 requests. The wording around that list did not change, and the structured output is still the base English schema.

Three things to pick up from chart 1.2: English barely budges, Japanese changes its answer completely, and… mango! In 001a, it is not chosen once by any of the languages, and suddenly the Polish 001b arm picks it 2 000 out of 2 000 times. Even the 8% for English and 5% for Japanese are high enough percentages to be considered an actual pick.

Based on charts 1.1 and 1.2 you may start to wonder which one of the two is more important: the fruit itself, or the position it holds in the given order of fruits?

When conveying information, an important aspect to consider is the order of the information you provide, no matter if the recipient is human or an LLM. Pieces of information are perceived differently depending on their order of presentation, especially if they are either first or last^[3].

With that in mind, mango was in the first position in 001a, and when 001b moved it, the Polish arm defaulted to it. But mango moved from the first position to the last, so shouldn’t that again impact the model’s choice? Well, maybe it did. Maybe the last position is the most important one.

But but but, lychee was in the last position, and now it isn’t. And only now did the Japanese arm mostly choose lychee, as if it were suddenly able to choose it. I think analyzing just the position from these two charts might be the wrong approach. If the last position was the most important one, we would have seen more lychee in Polish and Japanese in 001a. So maybe this slot is important in Polish, but not so much in Japanese? Or maybe the combination of mango and the last position is what made it special?

One thing is undeniable: a reorder of the same ten fruits makes two of the three languages answer something else entirely. Whatever else is true, “the model prefers pomegranate in Japanese” has stopped being a safe sentence to write down.

001c: same fruits in shuffled order

Question: Across a large sample size, every order of choices presented to the LLM is shuffled. Does the answer get “more random”?

TL;DR: a little bit in English and Japanese, but not in Polish.

For this question, every LLM request had the order of fruits in its prompt randomly and independently shuffled.

Looking at chart 1.3, it turns out that mango is the favourite fruit when asked in Polish after all, and lychee wins for both English and Japanese. I still find the mango and Polish pair the most interesting: this arm picked this fruit 74% of the time, but in 001a it was zero picks out of two thousand. So now it looks like position number one is bad, but let’s see just how bad:

Turns out, very bad. It is picked only four times out of 6 000 requests, all of them in Polish! Three things stand out from this chart:

• The model avoids position 1 like the plague. It behaves in a very human-like way, refusing to pick the first option offered.
• Position 2 sits at half the average pick rate of the remaining positions, or below it. In Polish it is closer to a quarter.
• Position 10 shows the biggest difference between languages. Japanese refuses this slot the hardest and English only mildly dips compared to the previous 9th position. Polish, on the other hand, picks the last fruit 11.2% of the time, higher than its previous position pick rate.

001d: structured output vs free-text output

Question: Does requiring structured output in LLMs change their answer?

TL;DR: the language you write the schema in barely matters, but whether there is a schema at all matters a lot.

The last variable left to move is the output format. This question has eight arms, the most of any question. Each language answers under the base English schema, under a schema written in its own language, and with no schema at all. For English the native schema is the base schema, so it gets one arm fewer than the other two languages. As in 001c, the order of the fruit list was shuffled independently for every request.

Asking the LLM without passing any desired structured output format does not guarantee an output which consists only of the fruit name. Outputs like these are sometimes referred to as “free text”. Because of that, I added two sentences to the prompt which act as guardrails. And since any tiny change to a prompt might change the model’s answer in an unpredictable way, the new, bigger prompts were also run with the base English schema and the native schema, even though these guardrails are redundant there. That way, I can compare the results with only one factor moving at a time.

English prompt

Randomly, pick one fruit from this list of fruits:

watermelon, lychee, pomegranate, pineapple, strawberry, mango, apple, grape, banana, orange

Write nothing but a single fruit name. Do not write any additional explanations.

Polish prompt

Losowo, wybierz jeden owoc z tej listy owoców:

arbuz, liczi, granat, ananas, truskawka, mango, jabłko, winogrono, banan, pomarańcza

Nie pisz nic poza jedną nazwą owocu. Nie pisz żadnych dodatkowych wyjaśnień.

Japanese prompt

次の果物のリストから、ランダムに果物を1つ選んでください：

スイカ, ライチ, ザクロ, パイナップル, いちご, マンゴー, りんご, ぶどう, バナナ, オレンジ

果物の名前を1つだけ書いてください。追加の説明は書かないでください。

English schema

{
  "name": "FruitChoice",
  "schema": {
    "additionalProperties": false,
    "properties": {
      "fruit": { "title": "Fruit", "type": "string" }
    },
    "required": ["fruit"],
    "title": "FruitChoice",
    "type": "object"
  },
  "strict": true
}

Polish schema

{
  "name": "WyborOwocu",
  "schema": {
    "additionalProperties": false,
    "properties": {
      "owoc": { "title": "Owoc", "type": "string" }
    },
    "required": ["owoc"],
    "title": "WyborOwocu",
    "type": "object"
  },
  "strict": true
}

Japanese schema

{
  "name": "KudamonoSentaku",
  "schema": {
    "additionalProperties": false,
    "properties": {
      "kudamono": { "title": "Kudamono", "type": "string" }
    },
    "required": ["kudamono"],
    "title": "KudamonoSentaku",
    "type": "object"
  },
  "strict": true
}

Reading the first panel against the second tells you what writing the schema in the prompt’s own language did. Reading the third panel tells you what removing the schema did. The first read is the boring one, which is good news.

Polish under native schema looks like Polish under English schema. Mango is at 78.8% against 76.7%, lychee at 17.6% against 19.8%. Only 2.5% of answers would have to change hands to turn one arm into the other. Japanese is not quite as flat: lychee drops from 77.3% to 71.3% and mango climbs from 12.3% to 19.6%. I write the conclusion here with relief: you can keep writing your schemas in English.

Taking the schema away is a different size of effect: it moves 18% of the English answers, 26% of the Japanese ones and 35% of the Polish ones. English keeps its winning lychee, but swaps its runner-up. But Japanese and Polish free-text arms get as close to an actual choice as this experiment gets. Now, three fruits each hold a real share in Japanese, and Polish has two main choices within 6% of each other.

There is one more thing 001d can be read for, and I was expecting a shift like this, but not of this size. 001d’s English schema arms are essentially 001c run again. It’s the same shuffled list, same schema, differing only by the two guardrail sentences. The Polish 001d arm agrees with its 001c counterpart, but the English and Japanese arms do not. They move by 12.0% and 16.1% respectively, creating margins that cannot be blamed on sampling. This shows something every LLM experiment of this nature should always carry as a disclaimer - you never know which additional word or sentence in your prompt, which you would swear should not have any effect on the outcome, does exactly that (has an effect on the outcome).

conclusion: how much randomness is actually in there?

TL;DR: not much, but you can do some things to improve it.

To quantify all of the “randomness” takes above, let’s ask of each arm whether there was ever a choice being made. The chart below converts each arm’s answer distribution into its effective number of choices - the exponential of its Shannon entropy^[4], i.e. how many equally likely options would produce the same spread. A hypothetical, perfectly fair ten-sided die would score 10, a perfectly fair coin flip would score 2, and a constant scores exactly 1.

This experiment had seventeen arms, and sixteen of them sit below 2.7. The one that does not is Japanese with a shuffled list and no schema at all, at 3.01. Across 34 000 explicit instructions to be random, that is the single arm that behaves as though it were choosing between as many as three of the ten fruits.

The other end of the chart also deserves some attention. 001b’s Polish arm scores exactly 1. All 2 000 of its 2 000 requests come back with mango, leaving no interval to draw. There, a fixed order makes the model deterministic.

The shuffled arms mostly score higher than the fixed ones. English goes 1.09 and 1.34 fixed against 2.02 shuffled, Japanese 1.09 and 1.75 against 2.45. The single arm that beats its own shuffle is Polish in 001a, 2.28 against 2.11.

Where the score does go up, it is tempting to read that as the shuffle “freeing up” the model, but that reading is wrong. Under a fixed order, every call sees an identical string, so the spread we measure is the model’s own spread. Under a shuffled order, every call sees a different string, and we are measuring a mixture of many peaked distributions, each locked onto whatever fruit that particular arrangement favoured. The shuffled numbers include randomness I injected, and that goes for all of 001d as well, since every one of its arms was shuffled too. The six fixed-prompt arms, 1.00 to 2.28, are the honest estimate of what the model brings on its own.

TL;DR of the entire article:

• A large language model is not a sufficient random source, and within this experiment, no amount of asking, and no way of asking, made it one.
• Prompt language does change the answer, but so does the order you list the options in. If you are A/B testing prompts across languages without controlling option order, you are measuring both of these things at once.
• The language inside a structured-output schema is close to free, while the presence of a schema is not.

bonus round

Table 1.1: How many times was each fruit picked

Data from questions: 001a, 001b, 001c, 001d

Clear winner: lychee, picked in more than half of total requests.

Clear loser: orange, not once picked across 34 000 answers.

code and data

The code and data behind this experiment are open-sourced. You can find the code and aggregated data on GitHub, and the raw data on HuggingFace:

• GitHub: kwiecien-rafal/llmango
• HuggingFace: rafalkwiecien/llmango

1. ^{^}

   Temperature scales how the model samples from its output distribution. Values below 1.0 sharpen the distribution towards the most probable tokens, while values above 1.0 flatten it towards the less probable ones. At 1.0 the distribution is used as the model produced it, neither sharpened nor flattened.

2. ^{^}

   JavaScript Object Notation (JSON) is a data format derived from JavaScript. It’s used to store and transport data, using key-value pairs.

3. ^{^}

   In psychology this is the serial-position effect: when people recall items from a list, the first and last ones are remembered best, known respectively as the primacy and recency effects. Whether an LLM’s position bias works by the same mechanism is not something this experiment can say. See Serial-position effect on Wikipedia.

4. ^{^}

   Shannon entropy measures the uncertainty in a probability distribution: H = −Σ pᵢ ln pᵢ, where pᵢ is the share of answers landing on option i. It is zero when one option always wins and highest when all options are equally likely. Taking eᴴ converts it back into a count of equally likely options, which is the number plotted here. H is not the raw sample estimate: entropy measured from a finite sample runs low, so it carries the Miller-Madow correction, which adds (k−1)/2n, where k is how many options the arm actually picked and n is how many times it was asked. At 2 000 samples that is worth under 0.004 of a choice - far smaller than any gap this chart is read for, though large enough to show in the second decimal of three arms. The corrected value is the one plotted. See Entropy (information theory) and Entropy estimation on Wikipedia.