Why Does ChatGPT Give Different Answers to the Same Question?

ChatGPT gives different answers to the same question because it never looks up stored replies: it generates each response word by word, and every word is picked probabilistically. On top of that, OpenAI’s servers can route your message to a different model than last time, your saved memories and plan tier shape the response, web searches pull fresh results, and the models themselves keep changing. Change any one of those ingredients and the output changes with it.

Here’s what actually moves the needle, how much of it you can control, and where you can’t.

ChatGPT writes every answer from scratch: nothing is “looked up”

The root cause is sampling. Sampling is how a language model writes: for each next word, it calculates a probability for every word it knows, then draws one: usually a high-probability word, but not always the same one. Ask the identical question twice and the draw lands differently. OpenAI says this outright in its developer docs: “Chat Completions are non-deterministic by default”. The consumer app runs on the same engine.

The dial behind that randomness is temperature. Temperature is a setting that rescales the word probabilities before the draw: low values make the top pick nearly certain, while higher values spread the odds and produce more varied, sometimes sloppier text. Here’s the part most people miss: ChatGPT doesn’t let you touch it. There’s no temperature slider in the app, and custom GPT builders don’t get one either. Only the OpenAI API exposes the setting, and OpenAI’s reasoning models don’t accept a temperature parameter at all: the reasoning documentation lists reasoning effort levels and nothing about temperature.

Even pinning the dial to zero doesn’t buy you a lock. Thinking Machines Lab, an AI research startup, published the cleanest demonstration: run 1,000 identical requests at temperature 0 on a large open model and you get 80 distinct completions.

1,000 identical requests at temperature 0 produced 80 different completions. Same weights, same settings: different arithmetic.

Why? Your request shares a server with other people’s requests. Batch size depends on live traffic, and it changes the order of floating-point operations inside the model. Since floating-point math isn’t associative (the order of addition changes the result by tiny amounts) those wobbles can flip a near-tie word choice, and a different word early in a response cascades into a visibly different answer. The experiment was on an open model, not OpenAI’s, but the mechanism applies to inference in general. Treat “temperature 0 means identical answers” as a myth.

Why does ChatGPT give different answers in a new chat?

Because a new chat is not a clean reset. Three things ride along, and one of them is doing more work than most people realize.

Memory is OpenAI’s feature that stores facts and preferences from your past conversations and injects them into new ones. OpenAI launched it in February 2024 and later expanded it so ChatGPT can reference all of your past chats, not just saved facts. WIRED reported that what ChatGPT “thinks it knows about you” (including stale or plain wrong memories) quietly biases its answers. Memory even reshapes web searches: OpenAI’s help center uses the example of a saved vegan-food preference turning “restaurants near me” into a vegan-restaurant search.

Custom instructions persist across every chat on your account. If you wrote “keep answers short” six months ago, that instruction is still attached to the brand-new chat you just opened.

Your plan changes the setup too. Per OpenAI’s help center, Free and Go users default to GPT-5.6 Luna, while GPT-6 Pro (powered by GPT-6 Astra) is reserved for Pro, Business, and Enterprise. The release notes for October 29, 2026 describe a tone update toward more concise, less flattering answers that applied to Free, Go, and logged-out users, but on Plus and Pro it applied only to the fallback model you get after hitting message limits. Same question, different plan, different instructions to the model.

Your message can land on a different model than last time

This is the cause people underestimate most. ChatGPT routes messages between models and can switch mid-conversation.

Since the GPT-5 launch, ChatGPT has run as “a single auto-switching system”: one picker, with a router deciding what handles each message. OpenAI also routes conversations showing signs of distress to reasoning models, per the October 2025 release note. When you select GPT-6 in the picker, the help center explains that “GPT-6 Sol powers Instant, Medium, High, and Extra High; Pro uses GPT-6 Pro, powered by GPT-6 Astra.” Terra and Luna aren’t even selectable in standard chats: they show up only where routing decides.

Fallbacks do the rest. If you hit a thinking limit, “ChatGPT may continue with another available model”, on Pro $200, exhausting the GPT-6 Pro weekly allowance switches you to GPT-5.6 Thinking at Medium automatically. ChatGPT will tell you which model is active if you ask; that’s a documented promise in the release notes.

And the roster itself keeps moving. Between early September and late October 2026 alone, OpenAI introduced GPT-6 Astra (its new flagship), launched GPT-6 Sol and GPT-6 Luna on September 22 at $2/$10 and $0.10/$0.50 per million API tokens, announced GPT-6.1 Sol at DevDay on September 29, and rolled out GPT-6.1 Terra on October 26. Retired models don’t vanish from your old chats either: they “automatically continue on the corresponding current model,” per the March 2026 release note. The conversation you started in July gets answered by a different engine in November.

Is OpenAI also A/B testing responses on live users? Researchers and users have documented behavior consistent with experiments: Daniel Paleka described it in his own usage in late 2025, and OpenAI community threads speculate freely. The docs don’t confirm specific tests. Treat this as plausible and commonly reported rather than proven. What’s proven is that backend configurations change often: the API exposes a system_fingerprint field: a code identifying the exact backend configuration: precisely so developers can tell when “changes we’ve made on our systems” have altered outputs.

What’s changing your answer, and what you can actually do

Cause of variation	How much you control it	Practical control
Random sampling (temperature)	None in ChatGPT: fixed per model	API only: lower temperature on non-reasoning models; cross-check in separate chats
Server batching noise	None	Re-ask; treat near-identical answers as equivalent
Model routing and fallbacks	Partial	Pin a specific model and thinking level in the picker instead of Auto or Latest; ask “which model are you?”
Model updates and retirements	None	Check the model release notes; re-verify anything you saved months ago
Memory and custom instructions	Full	Audit Settings → Personalization; use Temporary Chat; delete stale memories
Chat history and context	Full	Fresh chat per question; paste the full prompt verbatim
Web search results	Partial	Ask ChatGPT to “search again using a specific source, date, or location”. OpenAI’s own suggestion; or paste the source in yourself
Plan-tier setup and backend changes	None	Can’t opt out; via API, compare system_fingerprint values to detect changes

One nuance: ChatGPT usually doesn’t search with your exact words. The help center says it “typically rewrites your query into one or more targeted queries” sent to search providers, using your general location and your memories to shape them. Live results, shifting rankings, rewritten queries: that’s a lot of moving parts between your question and the sources it cites.

When variability actually matters: and when it doesn’t

Variability is harmless when you’re brainstorming taglines at 11 p.m. It’s a problem when a single wrong number can cost money, health, or a deadline: research claims, calculations, legal or medical questions, anything you publish.

The cleanest evidence comes from a 2024 study in the European Journal of Investigation in Health, Psychology and Education. The researchers asked 450 Amboss medical exam questions three times each in fresh chats, 2,700 queries total. GPT-4 averaged 85.7% accuracy, but it answered correctly in all three rounds for only 77.8% of questions. GPT-3.5 managed that just 44.9% of the time. Translation: even a strong model flips its answer on roughly one question in five across three identical runs.

Two takeaways. First, any single answer is a single sample: the one you happened to get. Second, weaker and older models flip far more often, so if consistency matters to your work, model choice matters as much as prompt wording. And the standard flag applies: for medical, legal, or financial decisions, ChatGPT’s variability is one more reason to treat it as a research assistant rather than an authority: a licensed professional should make the call.

How to get more consistent answers from ChatGPT

You can’t make ChatGPT fully deterministic. You can make your comparisons fair and your results much steadier. Here’s the procedure, based on how each variable behaves:

1. Start a fresh chat for every run. Old context (including your own follow-ups) is a hidden variable. The medical study above used a fresh session per question for exactly this reason.
2. Switch on Temporary Chat. OpenAI documents that temporary chats don’t create or update memories and stay out of your history, so past sessions can’t leak into the answer. (They can still read existing memories, so consider clearing those first.)
3. Pin the model and thinking level. Pick the same specific model in the picker (say GPT-6 Sol at High) instead of Auto or Latest. Auto hands your message to whatever the router chooses that day.
4. Paste the prompt verbatim from a saved template. Identical wording, identical attachments, every time. Small phrasing shifts are a documented source of different outputs.
5. Demand structure. Ask for a fixed format: “respond using exactly this table” or a JSON skeleton. Structured responses make differences between runs obvious instead of hiding them in prose.
6. Run it three times and compare. If the substance matches, you’re reasonably safe. If it flips, you’ve found an edge case: investigate before trusting either answer.
7. If it must be truly reproducible, use the API. Set the seed parameter and keep every other parameter identical; OpenAI calls this “(mostly) deterministic”: note the hedge. Verify the system_fingerprint matches across responses, use Structured Outputs to lock the format, and log the fingerprint with each result. Azure OpenAI’s reproducibility guide documents the same recipe.

That last point is the honest boundary: seed and pinned parameters get you “mostly” identical outputs, not guaranteed ones. For pipelines where a changed word breaks something (pricing copy, regulated documents, automated reports) treat any LLM output as an input to check, not a finished artifact.

Some variance is normal: and often what you want

A model that returned the same paragraph every single time would be a poor writing partner. The variation is the same mechanism that lets ChatGPT adapt tone, restructure an argument, or offer a second angle you didn’t ask for. For everyday questions (drafting, explaining, summarizing) the wobble is noise around a usually-stable core.

The real failure mode isn’t variance itself. It’s variance you didn’t know about: quoting a number from last week’s chat that the model wouldn’t produce today. The fix is a habit, not a setting: treat ChatGPT’s answer as a draft, and verify anything load-bearing.

What to do next

• Everyday use: ask once, judge the answer on its merits, and move on. Some drift is normal.
• Work where consistency matters: fresh chat, Temporary Chat on, pinned model, saved prompt template, three runs. That combo removes every variable you can remove.
• Developer or automation needs: move to the API with a fixed seed, identical parameters, Structured Outputs, and fingerprint logging. If outputs still differ, the fingerprint will tell you whether OpenAI changed the backend or your prompt did.

FAQ

Why does ChatGPT give different answers to the same question in a new chat?

Because a new chat isn’t a blank slate. Your saved memories, custom instructions, and plan tier ride along, and OpenAI’s routing can send the message to a different model than last time. Underneath all of that, every answer is generated word by word with probabilistic sampling, so even a perfectly clean context produces slightly different wording run to run.

Can I change ChatGPT’s temperature setting?

No. ChatGPT’s app has no temperature control, and custom GPTs don’t offer one either. The setting is only available through the OpenAI API, and OpenAI’s reasoning models don’t accept a temperature parameter at all: the reasoning guide lists effort levels instead. Inside ChatGPT, asking for “more creative” or “more precise” answers nudges behavior; it doesn’t change the parameter.

Is ChatGPT deterministic at temperature 0?

No. In a Thinking Machines Lab experiment, 1,000 identical requests at temperature 0 produced 80 different completions, because shared servers process requests in variable-size batches, which changes the order of floating-point operations. OpenAI’s seed parameter promises only “(mostly) deterministic” outputs, and the system_fingerprint field exists specifically to flag when backend changes alter results.

Why did ChatGPT’s answer change from last month?

Most likely the model behind your chat changed. OpenAI retired GPT-4o, GPT-4.1, o4-mini, and GPT-5 Instant/Thinking from ChatGPT on February 13, 2026, and release notes say old conversations “automatically continue on the corresponding current model.” OpenAI also shipped several GPT-6-family models between September and October 2026, plus tone updates like the October 29, 2026 change toward more concise answers.

Does ChatGPT give different answers to different users?

Yes. Memory, custom instructions, location, and plan tier all differ between accounts, and each shapes responses. Free and Go users default to GPT-5.6 Luna, while Pro, Business, and Enterprise plans get GPT-6 Pro powered by GPT-6 Astra, per OpenAI’s help center. OpenAI’s October 29, 2026 tone update applied to Free and Go users but only to fallback models on Plus and Pro.

How do I get the same answer from ChatGPT every time?

You can get close, but never guaranteed. Start a fresh chat, enable Temporary Chat to exclude memory, pin a specific model and thinking level instead of Auto, paste a verbatim saved prompt, and run it three times in separate chats. Developers needing stricter reproducibility should use the API with a fixed seed, identical parameters, and matching system_fingerprint values.

Does ChatGPT’s memory change its answers?

Yes, by design. Memory stores facts and preferences from past conversations and injects them into new chats. OpenAI launched the feature in February 2024. WIRED has reported that outdated or incorrect memories quietly bias responses, and OpenAI’s own help center notes that a saved food preference changes restaurant searches. Audit memories in Settings, Personalization, or use Temporary Chat to opt out per conversation.

Does OpenAI A/B test ChatGPT responses?

OpenAI doesn’t publish most experiments, so nothing official is confirmed. Researchers and users have documented behavior consistent with A/B testing. Daniel Paleka described it in his own usage in late 2025, and OpenAI community threads report users seeing different behaviors at the same time. What is documented: backend configs change often enough that the API exposes a system_fingerprint field to detect it.

Which ChatGPT answers should I double-check?

Anything load-bearing: numbers, calculations, citations, legal or medical guidance, and facts you plan to publish. A 2024 study in the European Journal of Investigation in Health, Psychology and Education asked 450 medical exam questions three times each and found GPT-4 answered correctly in all three rounds only 77.8% of the time. If an answer matters, re-ask in a fresh chat and verify against primary sources.

What should I do when two ChatGPT answers disagree?

Treat disagreement as a signal, not noise. Run the same prompt in two or three fresh chats with the same model pinned, and compare. If the substance matches, you’re fine. If it flips (especially on a number or a citation) the question is probably near the edge of the model’s reliable range, so verify with a primary source or a professional before acting.

Sources

• OpenAI: Introducing GPT-6 Sol and Luna
• TechCrunch: OpenAI launches GPT-6 Sol and Luna
• OpenAI: GPT-6 Astra announcement
• OpenAI Help Center: GPT-6 and other models in ChatGPT
• OpenAI Help Center: Model Release Notes
• OpenAI Help Center: Searching the web with ChatGPT
• OpenAI: ChatGPT plans and pricing
• OpenAI API docs: Advanced usage (reproducible outputs, seed, system_fingerprint)
• OpenAI API docs. Reasoning
• OpenAI API docs: Structured model outputs
• Thinking Machines Lab. Defeating Nondeterminism in LLM Inference
• Funk et al., 2024. ChatGPT’s Response Consistency: A Study on Repeated Queries (European Journal of Investigation in Health, Psychology and Education)
• OpenAI: Memory and new controls for ChatGPT
• WIRED. What ChatGPT Thinks It Knows About You Is Affecting Its Answers
• Microsoft Learn. Reproducible outputs with Azure OpenAI
• Daniel Paleka: A/B testing could lead LLMs to retain users instead of helping them