Claude Code Leaked. I Looked Under the Hood.

There are posts circulating that Claude Code accidentally shipped a map file that exposed a large portion of its codebase. I missed the leak. It's already been patched. I'm not digging through mirrored zip files from anonymous sources to search for secrets.

But it got me thinking. What can we actually find just by pulling the live npm package? So I pulled it and looked under the hood.

What This Shows

The direction is very clear. AI agents are becoming systems. A move from chat and copilots to actual systems that run on their own, respond to events, and coordinate work across multiple agents without anyone sitting at the keyboard.

Most people still think of AI as a conversation. You ask something, it responds, you close the tab. That model is already outdated.

What's actually being built are systems that run on schedules, respond to events like deployments failing or files arriving, and coordinate multiple agents working on different parts of a task at the same time. The interaction model is shifting from pull to push. Instead of you going to AI when you need it, AI runs continuously and acts when something happens.

What That Looks Like Inside a Company

A finance system that builds reports every morning before anyone opens their laptop. A sales system that generates a working prototype environment before every prospect call. An ops system that watches incoming files and structures the data automatically without anyone touching a spreadsheet.

Instead of one person prompting one chat thread, a team of agents coordinates on a codebase. One plans the approach, one writes the code, one reviews it. They share memory. They hand off tasks. This is not hypothetical. This is what the tooling is moving toward.

What I Found in the Code

The CLI already has multi-agent team coordination, cron-style scheduled execution, remote triggers that run agents in the cloud via API, push-based workflows where external systems send events to agents in real time, and a dual-model architecture where one model guides or reviews another. These aren't concepts on a roadmap. They're implemented features with flags, telemetry, and endpoints.

Other Fun Finds

Beyond the major features, the bundle is full of interesting details that tell you a lot about where this project is headed and how it's being built internally.

There's a whole set of CLI flags hidden from claude --help. These are experimental or internal features that exist in the codebase but aren't documented. The multi-agent flags alone include team names, agent colors, teammate execution modes, and a flag that forces agents to plan before they implement anything.

The bundle has hardcoded references to specific model versions including Opus 4.6, Sonnet 4.5, Sonnet 4.0, Sonnet 3.7, and Haiku 4.5. More interesting is the fallback system built around them. If Opus is unavailable, the CLI automatically falls back to an alternative and tracks the event through telemetry.

Every telemetry event in the bundle is prefixed with tengu_, which appears to be the internal project codename for Claude Code. The scheduling system is codenamed KAIROS. The enterprise privacy system is called Grove. There's even a "Penguin Mode" with org-level controls that looks like a compliance or restricted operation mode. The sheer scope of instrumentation across agents, teams, memory, billing, and performance tells you this is being treated as production infrastructure.

The Shift

This is a shift from using AI when you need it to AI systems running continuously inside the business. The current model is reactive. You open a chat, ask a question, get an answer. What's being built is persistent. Agents that run on schedules, respond to events, coordinate with other agents, and carry memory across sessions.

We've moved from better chatbots to real infrastructure.

The Gap

Most companies aren't set up for this. Not because of the tools. The tools are already here, implemented in the CLI right now. The gap is that no one owns building these systems. No one is looking at the daily workflows and asking which of these should be running automatically, or which should be reacting to events instead of waiting for someone to remember to check.

Moving fast with AI isn't about better prompts. It's about building systems. Systems that run, react, and improve over time. That requires someone who owns it.