DeepSeek: Reverse Engineering an AI Assistant by Interviewing Itself
TL;DR - DeepSeek interview: a chat model explains how it “thinks,” then the author cross-checks claims against public papers (arXiv). - Key idea: separate what the model observes, infers, and guesses about itself; no weight access or internal maps disclosed. - The piece emphasizes reading architecture numbers from papers, not from the chat. - Core mechanics covered: context window, prompt stack, token-by-token generation, and how tools/memory could be used. - It distinguishes two meanings of “hidden reasoning”: latent activations vs. reasoning tokens; this demo focuses on the former. - Tools/memory were off in the demo; memory is typically external to the model. - Safety, RLHF, and personality are layered, not a single toggle. - For architecture details, rely on DeepSeek papers (V2/V3, R1 Thoughtology) rather than chat claims. Key Concepts - DeepSeek: a family of large language models with MoE and MLA innovations; subject of the interview-series post. - Inside LLMs: the series method—interview a chat model, then audit against published research. - Observation, Inference, Guess: DeepSeek’s self-report framing of what it knows vs. what it infers vs. what it guesses. - Weights / Parameters: the internal learned numbers; not accessible to the model during chat. - System Prompt: the top-level identity/safety rules guiding the session. - SFT (Supervised Fine-Tuning) / RLHF (Reinforcement Learning from Human Feedback): training stages shaping behavior. - MoE (Mixture of Experts): many expert sub-networks; only a subset activates per token. - MLA (Multi-head Latent Attention): memory compression to handle long contexts. - KV-cache: short-term memory of prior tokens used during generation. - Context Window: the amount of text the model can see at once. - Tokenization / Tokens: the unit of text the model processes. - Premise vs. Paper: the post contrasts chat-derived claims with public papers (arXiv). - Hallucination: fluent but false content; confidence is not a reliable truth-meter. - Tool Calling / RAG: external tools and retrieval-augmented generation concepts. - Safety & Alignment: layers (system prompts, SFT, RLHF, infra classifiers) shaping refusals and behavior. - Long-context attention: combining causal attention, MLA, and related mechanisms; many specifics are “known in papers” vs. “observed in chat.” - Transcript / Labs: appended materials including the full interview and interactive labs. Why This Matters - It shows how to scrutinize AI self-descriptions without leaking private weights; you verify behavior with public literature. - Highlights limits of self-knowledge claims from models and the value of cross-checking numbers with arXiv papers. - Provides a structured way to audit model prompts, memory, tools, and safety features without exposing proprietary internals. - Helps product teams, researchers, and developers build better prompts, expect model behavior, and reason about long-context capabilities. How It Works - Interview phase: ask the model what it knows about itself (self-knowledge, architecture), then categorize its replies as observation, inference, or guess. - Paper-check phase: compare model claims to public papers (e.g., DeepSeek-V3/V2, R1 Thoughtology) to separate known facts from educated guesses. - Layered explanations: cover context windows, prompt pipelines, token generation, hidden reasoning (two meanings), tools/memory, hallucinations, safety/personality, MoE/MLA, long-context attention. - Takeaways emerge: visible behavior vs. architecture facts; humility about internal access; rely on papers for numbers. Visualize the Flow Mermaid diagram (flow of the companion workflow) ```mermaid sequenceDiagram participant Interviewer participant DeepSeek participant Papers Interviewer->>DeepSeek: Ask about self-knowing (architecture, limits) DeepSeek->>Interviewer: Respond with Observations, Inferences, Guesses Interviewer->>Papers: Check claims against arXiv (DeepSeek-V2/V3, R1 Thoughtology) Papers->>Interviewer: Provide public facts (numbers, mechanisms) Interviewer->>DeepSeek: Annotate each claim as Observation / Inference / Guess Interviewer->>Interviewer: Synthesize takeaways ``` Real-World Example - A platform team is evaluating a chat assistant for a long-form customer support scenario. - Use the interview approach to understand how the model handles context, memory, and tool use. - Cross-check claims about context length, MoE/MLA behavior, and safety with public papers. - Use the findings to craft prompts and system messages that bias toward safe, well-calibrated responses. - Benchmark against arXiv-specified numbers rather than relying on the model’s own estimates. Hands-On Walkthrough Prerequisites - A chat-model API or local LLM you can query (any leading LLM with documented MoE/MLA concepts is fine for learning). - Python or a notebook environment. - Basic familiarity with prompts, context windows, and tokens. Required Tools - Access to a chat API (e.g., OpenAI, local LLM) for interactive querying. - A text editor or notebook to record transcript and annotate claims. - Optional: arXiv papers cited in DeepSeek (for reference). Installation (conceptual) - Set up Python environment: python3.x, venv, pip install requests or an SDK for your model. - Prepare a simple script to send prompts and collect responses. Configuration - Create a prompt to request self-knowledge and limitations, mirroring the article’s approach. - Define a tagging function to classify lines as Observation, Inference, or Guess. - Save transcript with timestamps and model responses. Typical workflow 1) Ask: “What do you actually know about yourself?” 2) Capture the answer; tag statements. 3) Repeat with focused prompts (context window, prompt pipeline, etc.). 4) Cross-check each claim against DeepSeek papers or arXiv links; mark discrepancies. 5) Compile takeaways: what the model claims confidently vs. what papers confirm. 6) Review sections on Hallucinations, Tools/Memory, Safety, and MoE/MLA for context. Expected Outputs - A transcript of Q&A with annotations per claim. - A side-by-side mapping to arXiv claims (256 experts, 671B/37B params, MLA, MoE). - A summary of what is considered established vs. speculative in the chat. Code Explained - No code is provided in the article; the companion workflow is described in prose and diagrams. - If you implement, explain: the interview prompts, the claim-tagging logic, the cross-check routine, and the synthesis of conclusions. Best Practices - Separate observation, inference, and guess; treat each claim accordingly. - Always verify architectural claims against primary sources (papers) rather than chat text. - Distinguish Type A hidden reasoning (latent activations) from Type B reasoning tokens; don’t assume one implies the other. - Use external memory/tools in production with clear privacy controls; note that the article’s demo had these off. - Treat safety/personality as layered rather than a single toggle. Common Mistakes - Taking model self-descriptions at face value for architecture numbers. - Confusing fluent explanations with internal cognitive processes. - Over-interpreting “Let me think” as a separate reasoning agent. - Assuming hidden reasoning means the model actually displays its chain-of-thought. - Ignoring the difference between internal activations and external, documented mechanisms. Security Considerations - Do not expose private weights or proprietary architecture details. - If using tools/memory, ensure data governance and access control. - Treat any self-reported capabilities (e.g., long context) as potential heuristics; verify with papers. - Be mindful of leakage when prompting for system prompts or configuration details. Performance Tips - For long chats, prioritize MLA-based memory efficiency and MoE routing strategies (as described in papers). - Use robust prompt architectures to minimize reliance on potentially unverifiable internal claims. - Validate with arXiv-based benchmarks rather than chat-derived numbers. Alternatives - Inside Kimi K2.6: a related DeepSeek follow-up with different focus on memory, tools, and safety. - Character.ai and other “engineered” chat systems discussed in related posts. - Kimi K2.6, Qwen 3.8-Max-Preview, and DeepSeek family papers for deeper architecture comparisons. Related Concepts - CoT (Chain-of-Thought), RAG (Retrieve-and-Generate), SFT, RLHF, DPO, RoPE, beam search, best-of-N, speculative decoding. - Transformer architectures, generic MoE/MLA patterns, long-context strategies. Learning Roadmap - Start: basics of transformers, context windows, and tokenization. - Next: MoE, MLA, and long-context strategies; read DeepSeek papers (V2/V3). - Then: tool-calling, RAG, and safety alignment concepts (RLHF, DPO). - Finally: cross-check techniques with arXiv and build audit workflows. FAQs - Q: What is the core method of the DeepSeek article? A: Interview the model about itself, then verify claims against public papers. - Q: Can the model see its own weights? A: No; the article notes it cannot access weights, routing, or attention maps during chat. - Q: Should I trust architecture numbers from the chat? A: No—verify against arXiv papers (V2/V3); the chat is helpful for behavior but not definitive for numbers. - Q: What is MLA? A: Multi-head Latent Attention; a memory-compression technique to handle long contexts. - Q: What is MoE? A: Mixture of Experts; many sub-networks with a router selecting a small subset per token. - Q: What are “hidden reasoning” meanings? A: Type A: latent activations; Type B: reasoning tokens (potential chain-of-thought-like content). The chat mostly discusses Type A. - Q: Are tools and memory always active? A: Not in the DeepSeek demo; they are described as capabilities that can be enabled in production. - Q: What is the “60-second TL;DR” about? A: A compact summary of the approach, takingaways, and practical guidance. Glossary - DeepSeek: AI model family discussed in the article. - MoE: Mixture of Experts; routing per token selects a subset of experts. - MLA: Multi-head Latent Attention; memory compression for long contexts. - KV-cache: Key-Value cache; short-term memory for previous tokens. - RLHF: Reinforcement Learning from Human Feedback. - SFT: Supervised Fine-Tuning. - CoT: Chain-of-Thought; reasoning steps. - Hallucination: Fluent but wrong content. - RAG: Retrieval-Augmented Generation. - RoPE: Relative Position Encoding. - Context Window: Text visible to the model at once. - Token: Small unit of text the model processes. - System Prompt: Core safety/identity text at session start. - AR (Autoregressive): Generating text token by token without rewriting past tokens. Useful Resources - DeepSeek-V3 Technical Report (arXiv:2412.19437) - DeepSeek-V2 (arXiv:2405.04434) - DeepSeek-R1 (arXiv:2501.12948) - DeepSeek-MoE (arXiv:2401.06066) - DeepSeek-R1 Thoughtology (arXiv:2504.07128) - Attention Is All You Need (Transformer, arXiv:1706.03762) Practical Exercises - Beginner: 1) Read the TL;DR and identify observation vs inference vs guess in a short model reply. 2) Annotate a transcript fragment with these labels. 3) Compare claims to a public paper summary. 4) List what cannot be observed (weights, KV maps) as per the article. 5) Diagram the prompt stack for a simple chat session. - Intermediate: 1) Build a small prompt that asks a model about its context window and token generation, then annotate responses. 2) Create a simple cross-check worksheet mapping chat claims to papers. 3) Implement a basic lab that simulates tool-calling vs no-tools mode. 4) Conduct a mini-review of 1-2 DeepSeek papers and note discrepancies with chat replies. 5) Design a user-facing prompt that guides safe and calibrated responses. - Advanced: 1) Create an end-to-end audit pipeline: interview, tag, verify, report. 2) Compare multiple models (Kimi, Qwen, DeepSeek) on similar prompts and contrast outputs vs papers. 3) Develop a practical long-context test using MLA-specific prompts and measure memory behavior. Production Checklist - Define objective: audit model self-description vs. public docs. - Ensure you have access to arXiv/public papers for cross-checking. - Disable tools/memory in the initial test to reproduce the article’s demo conditions. - Document claims with explicit tags (Observation, Inference, Guess). - Validate architecture numbers against primary sources before publishing. - Maintain separate sections for behavior vs. architecture in reports. - Plan for long-context tests using MLA/MoE concepts. - Include safety prompts and discussion of alignment layers. - Keep a transcript and lab assets for reproducibility. Cheat Sheet - Observation = what the model directly says it sees. - Inference = reasoned interpretation from observed data. - Guess = educated speculation not backed by current data. - KV-cache = per-token memory during generation. - Context Window = text the model can see now. - MLA = memory compression for long chats. - MoE = routing to a subset of experts. - RLHF/SFT = training methods shaping responses. - Hallucination = fluent but incorrect content. - Tool Calling / RAG = external info fetch and memory augmentation. - Open vs. private data: rely on public papers for numbers; treat chat as descriptive but not definitive. Note: This guide is built from the article’s content. If you want deeper numbers, read the cited papers (V2/V3, R1 Thoughtology) and the transcript labs mentioned in the appendix.
