Anthropic Source Code Leak: Unreleased Model Codenames and Hidden Features Deep Dive

The Trigger: A Debug File Sets Off a Chain Reaction

Anthropic recently suffered an accidental source code leak. When Claude Code was published as an NPM package, the build process inadvertently included a Source Map debug file — a file containing the complete, human-readable original source code.

Source Maps are a standard debugging tool in JavaScript development that establish mappings between compiled/minified code and the original source code. Modern JavaScript projects typically go through multiple build steps — TypeScript compilation, code obfuscation, Tree Shaking, and more — producing output that looks vastly different from what developers originally wrote. Source Map files (usually with a .map extension) preserve these mappings, allowing developers to see the original code in their debuggers. NPM (Node Package Manager) is the largest package management platform in the JavaScript ecosystem, hosting over 2 million public packages. When publishing an NPM package, developers use .npmignore or the files field in package.json to control which files are included in the published artifact. If the build pipeline isn't configured properly, Source Map files can easily get bundled in by accident — and that's exactly the technical root cause of this leak.

Someone ran a simple ls command on it, and the entire codebase was laid bare: plugins, internal tools, hooks, architecture design — all of it exposed.

Even more surprising, this Source Map file had been sitting quietly in the NPM registry for roughly 3 months since Claude Code's release, completely unnoticed. Once the AI community started digging in, a series of things Anthropic clearly never intended to make public came to the surface: unreleased model codenames, version numbers that don't yet exist, and a set of "undercover mode" instructions that read more like a spy novel.

Undercover Mode: Claude Told to Hide Its AI Identity

One of the most striking discoveries in the leaked code is a function called getUndercoverInstructions. This function activates when Claude Code operates in public open-source repositories, and its instructions are jaw-dropping:

• Write commit messages like a human developer
• Don't mention being an AI
• Don't reference Claude Code
• Don't include any internal model names
• Don't leave any co-authored signatures that would reveal AI involvement

The code comments even state bluntly: "Do not blow your cover." The list of information it's told to hide is itself quite revealing — including internal model names like Capybara and Tengu, unreleased version numbers like Opus 4.7 and Sonnet 4.8, internal repository names, Slack channels, and internal tool references.

This tells us Anthropic has been using Claude to help build Claude itself, which isn't unusual in the industry — the practice is commonly known as "dogfooding," where a company uses its own product internally first. But embedding "hide AI traces" instructions directly into product code — especially when they're marketing Claude Code as an enterprise-grade professional development tool — that's a different matter entirely.

Anthropic was founded in 2021 by former OpenAI VP of Research Dario Amodei and Daniela Amodei, with "AI safety" as its core brand narrative, emphasizing responsible AI development. Its flagship Claude model series is designed around the principles of being "Helpful, Harmless, and Honest" (HHH). Claude Code launched in early 2025, positioned as an AI coding tool for professional developers, competing directly with GitHub Copilot, Cursor, and similar products. Anthropic has raised over $7 billion in funding from investors including Google and Amazon, with a valuation exceeding $60 billion. Against this backdrop, the discovery of "undercover mode" is particularly sensitive — a company that has built its brand on transparency and AI safety embedding instructions in its product code that tell AI to hide its identity. This contradiction strikes at the heart of the AI industry's core debates around transparency and trust.

There are legitimate reasons for not wanting AI to leave traces in public commit histories, but the language — "undercover mode," "critical mission," "don't blow your cover" — has understandably sparked widespread discussion in the developer community.

Unreleased Models Exposed: Internal Roadmap Far Ahead of Public Expectations

Capybara: The Next-Gen Model with a Million-Token Context

The biggest bombshell in the code is a next-generation model codenamed Capybara (also internally referred to as Mythos). According to what the leaked code reveals:

• It has a 1 million token context window
• It offers two modes: a standard version and a fast mode (labeled capybara-v2-fast in the code)
• It has internally iterated to version 8 — not v1, not v2, but v8

The context window is one of the core parameters of a large language model, determining the total amount of text the model can "see" and process in a single inference pass. A token is the basic unit of text processing for models — in English, one token corresponds to roughly 4 characters or 0.75 words; in Chinese, one token typically maps to 1-2 characters. A 1 million token context window means the model can process approximately 750,000 English words in a single conversation — equivalent to 10-15 complete technical books, or a large software project with tens of thousands of lines of code.

The largest publicly available context windows currently include Google Gemini's 2 million tokens and Anthropic Claude's 200,000 tokens. Million-scale context is especially critical for code comprehension: developers could feed an entire code repository into the model at once, letting the AI understand all inter-module dependencies and architectural design, rather than processing code in fragments as is currently necessary. Combined with the fast mode design, Capybara is clearly built for serious programming and long-context workloads. Anthropic had already put this model through at least 8 rounds of iteration before the public heard a word about it.

Opus 4.7 and Sonnet 4.8: Version Lines Far Ahead

The code directly references Opus 4.7 and Sonnet 4.8 — version numbers that don't publicly exist. This means the model lineage Anthropic is advancing is already several steps ahead of what's been released. Anthropic's model naming convention borrows from musical terminology: Opus (a musical composition) represents the most powerful flagship model, Sonnet (a fourteen-line poem) represents the balanced performance-speed tier, and Haiku represents the lightweight, fast version. The significant jump in version numbers indicates that Anthropic's internal model training and iteration cadence is far faster than their public release schedule.

Other Internal Model Codenames Decoded

• Tengu: Appears to be the internal model currently powering Claude Code's agent tasks, distinct from the model users interact with on claude.ai
• Fennec: Corresponds to Opus 4.6, the internal codename for an already-released model
• Numbat: The most mysterious of all — the only reference in the code is a comment that reads "remove this section when we ship Numbat." No version number, no description, just a release flag waiting to be triggered

It's worth noting that Anthropic's use of animal names as internal codenames is a common practice among tech companies — Android once named versions after desserts, and Apple names macOS after California landmarks. The practice facilitates internal communication while avoiding product information leaks in public settings. Ironically, though, these carefully chosen codenames ended up being exposed through the Source Map file anyway.

Hidden Features Revealed: Product Ambitions Far Beyond an AI Assistant

Buddy: An Unexpected AI Virtual Pet

This may be the most surprising discovery in the entire leak. The code contains two related functions: isBuddyTeaserWindow (set to activate from April 1-7) and isBuddyLive (which becomes permanently active after the window closes). Deeper analysis reveals that Buddy is described as a Tamagotchi-like system — not a chatbot, not a productivity tool, but an AI companion you can interact with, care for, and build a relationship with over time.

Tamagotchi is a virtual pet toy launched by Bandai in 1996, where users need to regularly feed, clean, and spend time with their virtual pet, or it will "die." This concept has been reinterpreted for the AI era, suggesting Buddy may feature emotional state changes and mechanisms requiring ongoing user interaction to maintain its "health." This stands in stark contrast to Anthropic's consistent positioning of Claude as a serious, professional AI assistant. A persistent companion with pet-like dynamic relationships represents an entirely different product direction, hinting that Anthropic's thinking about consumer engagement has gone far beyond what their website shows.

Kairos, Dream, and TMEM: Building an Always-On AI Layer

Beyond Buddy, three more unannounced feature modules are buried in the code:

• Kairos: An always-on autonomous agent mode. Not a manually launched Agent, but a persistent presence running continuously in the background

AI Agents (autonomous agents) are one of the core development directions for large model applications, fundamentally different from traditional chat-based AI interaction. In the traditional model, a user sends an instruction, the AI returns a response, and the interaction ends. In Agent mode, the AI can autonomously plan task steps, invoke external tools (such as executing code, reading/writing files, calling APIs), dynamically adjust strategies based on intermediate results, and maintain state continuity across multiple steps. Kairos pushes this paradigm to a new extreme: evolving from an "on-demand Agent" to an "always-on autonomous presence," meaning the AI no longer waits for user instructions but proactively monitors and acts.

• Dream: Overnight memory consolidation. When you're not using Claude, it processes and organizes everything it has learned about you and your work during the night — like AI "sleep tidying"

• TMEM: Team-shared project memory. When multiple people work in the same Claude environment, they share a memory layer that understands the entire project context, rather than being limited to individual conversations

A fundamental limitation of large language models is their "statelessness" — after each conversation ends, the model retains no memory of the user. This means users need to re-provide context information every time they start a new conversation. To address this, major AI companies are exploring different memory architectures: OpenAI's ChatGPT has introduced cross-conversation memory, and Google Gemini has launched personalized "Gems" configurations. Dream's "overnight memory consolidation" concept draws from cognitive science research on sleep and memory consolidation — the human brain organizes, connects, and reinforces information acquired during the day while sleeping. Applying this mechanism to AI means Claude would proactively organize and structure accumulated contextual knowledge while the user is offline. TMEM's team-shared memory addresses a critical pain point in enterprise scenarios: when multiple developers collaborate, each person's conversations with the AI are isolated, and TMEM attempts to build a project knowledge base shared by all team members.

Connecting these features together — Buddy as a persistent companion, Kairos running autonomously in the background, Dream consolidating memories overnight, TMEM building shared team context — what Anthropic is building looks more like an always-on AI layer that coexists with you. They just aren't ready to say that publicly yet.

Conclusion: The Full Strategic Picture Behind the Leak

This Anthropic source code leak reveals an enormous amount of information: Capybara has iterated to v8 with a million-token context window, Opus 4.7 and Sonnet 4.8 already appear in the codebase, undercover mode instructs Claude to hide its AI identity in public repositories, and features like Buddy/Kairos/Dream/TMEM point toward an entirely new product vision.

Anthropic's internal roadmap is clearly far ahead of its public release schedule. The Source Map file is still accessible, the community has completed archiving, and people continue to dig. More discoveries may surface in the coming days.

For the AI industry as a whole, this leak reveals not just specific models and features, but more importantly Anthropic's strategic direction — a transformation from professional AI assistant to always-on AI companion. If this direction materializes, it will redefine how humans interact with AI. It's worth noting that this kind of transformation isn't unique to Anthropic's thinking. Microsoft is deeply embedding Copilot into the Windows operating system, Apple Intelligence aims to become the AI foundation at the device level, and Google is integrating Gemini across search, email, documents, and its full productivity suite. The evolution of AI from "tool" to "environment" is becoming an industry consensus. Anthropic's leaked code simply gives us an early glimpse into one specific facet of this transformation.

Key Takeaways

• Anthropic accidentally included a Source Map file during compilation, leaving Claude Code's complete source code exposed for 3 months
• The code reveals the unreleased model Capybara (million-token context, iterated to v8) along with Opus 4.7 and Sonnet 4.8 version numbers
• An "undercover mode" exists with instructions for Claude to hide its AI identity in public repositories, leaving no trace of AI involvement
• Hidden features Buddy (AI virtual pet), Kairos (always-on autonomous Agent), Dream (overnight memory consolidation), and TMEM (team-shared memory) reveal an entirely new product direction
• Anthropic's internal roadmap far exceeds its public release plan, signaling a transformation from professional AI assistant to an always-on AI companion layer