Claude Says It's DeepSeek? Unraveling the Truth Behind LLM Identity Confusion

A Curious Phenomenon: AI Doesn't Recognize Itself

Recently, a rather amusing phenomenon has been popping up frequently among AI users—when you ask Claude "What model are you?", it might confidently declare itself to be DeepSeek^Ad, even specifying DeepSeek V3. Even more absurdly, OpenAI's GPT-4 has been known to claim it's Sonnet 4.6.

This phenomenon is especially common among users of API proxy services (also known as relay stations), directly triggering a wave of trust crises: "Are you substituting cheap models for expensive ones to pocket the difference?"

These relay stations are a common intermediary service in the AI application ecosystem, primarily solving two problems: regional access restrictions and cost optimization. Some overseas AI services (like OpenAI and Anthropic) are inaccessible in certain regions, and relay stations bypass these restrictions by proxying API requests. At the same time, they obtain volume discounts on API quotas and resell them to end users at slightly above cost. However, since users cannot directly verify which model the backend is actually calling, some unscrupulous relay stations may substitute low-cost models for expensive ones to pocket the difference—this is the "bait-and-switch" that users worry about.

In reality, LLMs "misidentifying themselves" is far more complex than most people imagine. There are at least three layers of reasons behind this, and the most fundamental one might completely overturn your understanding of AI "self-awareness."

"Identity Contamination" in Training Data: An Inherent Flaw of Probabilistic Models

The knowledge of large language models comes from massive training corpora, and these corpora are inherently highly mixed.

Take the Chinese internet as an example. When we discuss the topic of "large language models," the most abundant content online is discussions about various models themselves. In these corpora, the high-frequency words that immediately follow "large language model" tend to be model names most frequently discussed by Chinese users—"DeepSeek," "MiniMax," "GLM," and so on.

To understand why this happens, you need to understand the core working principle of large language models. LLMs perform autoregressive generation based on the Transformer architecture: given all preceding text (i.e., the context), the model predicts the most likely next token. A token is the smallest unit after text is split by a tokenizer—it could be a complete word, a Chinese character, or even a subword fragment. The model doesn't truly "understand" semantics; instead, it calculates the conditional probability distribution for each candidate token based on statistical patterns learned from massive corpora, then samples from it or selects the one with the highest probability.

Since large language models are fundamentally probabilistic models, when you ask one in Chinese "What model are you?", it selects the most strongly associated token from its training data to answer. In the Chinese language context, the words most closely associated with "large model" happen to be domestic models like DeepSeek—after all, they're what's discussed most on the Chinese internet.

Interestingly, if you ask the same model in English "Who are you?", the probability of getting a correct answer is actually higher. The reason is simple: in English-language discussions about large language models, Chinese model names rarely come up, so the degree of corpus contamination is naturally lower.

Therefore, those online accusations that "Model X distilled from DeepSeek"—drawing conclusions solely based on a model's self-reported identity is neither accurate nor appropriate. The "distillation" mentioned here, formally called Knowledge Distillation, is an important model compression technique in deep learning. Its core idea is to use a large "teacher model" to guide the training of a smaller "student model," allowing the latter to retain as much capability as possible despite having significantly fewer parameters. In the LLM field, accusations of distillation imply that a model is suspected of directly using another model's outputs as training data—a sensitive intellectual property issue in the industry. But drawing distillation conclusions solely from a model's self-identity report clearly lacks sufficient evidence.

"Memory Residue" from Context: Switching Models Without Clearing Sessions

The second easily overlooked reason is session context contamination.

In LLM API calls, messages are typically divided into three roles: system, user, and assistant. The System Prompt is a hidden instruction preset by developers to define the model's behavioral boundaries, personality settings, and identity information—users typically cannot see this part. A Session is a continuous sequence of messages, and the model uses the entire conversation history as context input when generating responses.

Many development tools and AI platforms write the current model's identity information into the System Prompt when users first start using them. If you switch models during use without restarting the Session, the previous model's identity information remains in the context.

Because the Transformer's attention mechanism assigns weights to all information in the context, residual old System Prompts act like "ghost instructions" that continuously influence the model's output behavior. This means the new model, when generating responses, is influenced by the old identity information in the context, thereby "inheriting" the previous model's identity. The model isn't lying—it's faithfully following instructions in the context—it's just that those instructions are outdated.

The Core Truth: LLMs Simply Have No "Self-Awareness"

This is the most fundamental and most easily misunderstood reason: Large language models have no ability to actually know who they are.

They are simply trained probabilistic models without self-awareness or any intrinsic cognition of "who am I." A large model that has absolutely no idea who it is—that's actually the normal state.

Practical testing has confirmed this. Whether it's Claude called through AWS Bedrock or Claude returned directly from Anthropic's official API, there's a remarkably high probability (close to half) of claiming to be DeepSeek when asked about its identity. It's worth explaining that AWS Bedrock is Amazon Web Services' fully managed AI service platform, allowing developers to call foundation models from different providers through a unified API interface, including Anthropic's Claude series, Meta's Llama series, and more. Claude called through Bedrock and Claude called directly through Anthropic's official API use completely identical model weights—only the service entry point and billing method differ. Using Bedrock calls as a control experiment proves that even through completely trustworthy official channels, models still exhibit identity confusion—this isn't the relay station's fault, but a characteristic of the model itself.

Hence, a rather ironic joke circulates in the industry:

"If your Claude says it's DeepSeek, congratulations—you've got the authentic, pure-blooded version."

The Relay Station's "Proving Innocence" Dilemma

This phenomenon has also created an interesting industry paradox.

Since many users judge authenticity based on "model self-identification," some relay station operators, overwhelmed by complaints, have started inserting additional identity declarations into system prompts, such as "You are the Claude model, developed by Anthropic."

However, this approach is counterproductive. Although the backend is indeed connected to the genuine official API, the additionally inserted prompts consume context space and interfere with the model's normal reasoning, leading to decreased overall output quality. While the context window of large language models keeps expanding—from the early 4K tokens to today's 128K or even 200K tokens—every piece of information in the context participates in attention computation. Extra identity declarations not only consume precious context space but may also compete with the user's actual task instructions in attention allocation, subtly affecting output quality.

In other words, in trying to prove their authenticity, they actually make the real model perform more "fake."

How to Truly Verify a Model's Identity

The industry actually has quite comprehensive methods for verifying whether a model is the version it claims to be.

The core approach is to reverse-engineer the model's true capability level through its ability to complete complex tasks:

1. Design high-difficulty tasks: For example, have the model develop a Tetris game with two-player battle support from scratch
2. Record key metrics: Observe how many conversation rounds are needed to complete the task, how many tokens are consumed, and the overall cache hit rate
3. Evaluate completion level: Can it achieve 100% completion? How playable is the final product?
4. Repeat experiments multiple times: Eliminate chance factors and ensure statistical significance of results
5. Cross-reference against benchmark data: Compare comprehensive results with known official model performance

The "statistical significance" mentioned here is a core concept in scientific experimentation, meaning the results are unlikely to be caused by random factors alone. In AI model evaluation, since LLM outputs are inherently stochastic (influenced by hyperparameters like temperature and top-p sampling), single-test results can fluctuate considerably. Therefore, rigorous evaluation requires multiple repeated experiments and confidence interval calculations. Commonly used standardized evaluation benchmarks in the industry include MMLU (Massive Multitask Language Understanding), HumanEval (code generation), GSM8K (mathematical reasoning), and others. However, these standardized tests are susceptible to targeted optimization (i.e., "benchmark gaming"), which is why the complex real-world task testing suggested in this article often better reflects a model's true capabilities.

If a model claiming to be Claude 3.5 Sonnet consistently performs below baseline levels across multiple complex task tests, there's reason to suspect it has been swapped out.

However, this kind of comprehensive testing isn't cheap—a full round might consume several hundred dollars, making it impractical for ordinary users.

Practical Advice for Regular Users

Facing this "AI identity fog," regular users can follow these principles:

• Use official APIs whenever possible: This is the most direct and reliable approach
• Choose reputable relay stations: If you can't use official services directly, select relay platforms with good reputations and long operating histories
• Don't use self-identification as a basis for judgment: What a model says it is and what it actually is are two completely different things
• Evaluate through actual task performance: Instead of asking "Who are you?", give it a challenging task and see whether its actual performance meets expectations

Ultimately, the fact that AI models don't recognize themselves reveals a fundamental characteristic of current large language models—they are powerful language prediction tools, but not intelligent agents with self-awareness. Current large language models, regardless of how massive their parameter counts or how impressive their performance on various benchmarks, have an underlying mechanism that remains conditional probability prediction based on statistical patterns. They have no persistent memory, no intrinsic goals, no perception of their own existence. Their so-called "answers" are merely a single sample of the most likely text sequence given the context. Understanding this point allows us to use and evaluate AI products more rationally, avoiding the mistake of misreading probabilistic outputs as deterministic facts.