Latest / Elon Musk Podcast / Anthropic Source Code Leak and Pentagon Standoff

Transcript

Anthropic Source Code Leak and Pentagon Standoff · Elon Musk Podcast

• 0:00
  Anthropic just hit a $380 billion valuation, overtaking
• 0:04
  Open AI in revenue right at the exact moment they accidentally
• 0:08
  leaked half a million lines of their most highly guarded,
• 0:12
  unreleased artificial intelligence source code to the
• 0:15
  entire world. Yeah, the irony here is just
• 0:19
  supreme. I mean, you have a company that
• 0:20
  is actively building what is arguably the world's most
• 0:23
  intelligent software. You know, we're talking about a
• 0:26
  system capable of autonomously identifying global cybersecurity
• 0:30
  flaws, reading complex code bases, executing high level
• 0:34
  problem solving, and simultaneously they suffer a
• 0:36
  massive exposure because of like a fundamental human packaging
• 0:41
  error. It just highlights the
• 0:42
  incredible friction we are seeing right now between
• 0:44
  hyperscale corporate valuations, the chaotic reality of trying to
• 0:48
  maintain autonomous engineering tools, and, well, the looming
• 0:51
  national security battles over who actually controls offensive
• 0:54
  cyber capabilities. So if a company creates an
• 0:57
  intelligence capable of autonomously hacking global
• 0:59
  infrastructure, but struggles to keep its own configurations
• 1:02
  secure, who is actually in control of the technology?
• 1:06
  To really grasp how we arrived at this point, we have to start
• 1:09
  with the brutal economics of the situation.
• 1:12
  I mean, Anthropic secured $30 billion in Series G funding.
• 1:17
  Yeah, 30 billion. This round was led by Coat 2,
• 1:21
  GIC and DE Shaw, which officially pushed their
• 1:25
  valuation to that $380 billion mark.
• 1:28
  And on secondary markets, the demand from investors trying to
• 1:31
  get a piece of this company is so intense that valuations are
• 1:35
  pushing toward a trillion dollars.
• 1:37
  More easily. Their revenue run rate has
• 1:39
  skyrocketed along with it, right?
• 1:41
  They went from a billion to somewhere between 14 and 30
• 1:45
  billion, officially overtaking open AI's revenue.
• 1:48
  Which is huge. Eight of the Fortune 10
• 1:50
  companies are active users. I mean, you look at those
• 1:52
  numbers on paper and it looks like total market dominance.
• 1:55
  They're capturing the largest enterprises on the planet.
• 1:58
  You see the revenue, sure, but you really have to look at the
• 2:01
  burn rate. The expenses?
• 2:02
  Exactly. Despite that massive influx of
• 2:05
  cash, they are burning billions of dollars at an astonishing
• 2:08
  pace. Their internal inference costs,
• 2:11
  you know, the actual computing power required to run these
• 2:14
  models and generate answers. Well, that surged 23% higher
• 2:18
  than expected. 23%. Yeah.
• 2:20
  And that unexpected cost increase suppress their gross
• 2:22
  margins down to 40%. We have to view this not just as
• 2:26
  software, but as physical infrastructure.
• 2:29
  Hyperscale artificial intelligence requires physical
• 2:32
  data centers sprawling across hundreds of acres.
• 2:35
  It requires specialized silicon chips that cost 10s of thousands
• 2:39
  of dollars each. And immense energy grids just to
• 2:43
  keep the servers from melting. So when you say inference costs
• 2:46
  surged 23%, we're talking about the physical electricity and
• 2:50
  cooling required every single time a user asked the software
• 2:53
  to do something. Precisely.
• 2:54
  Software used to have marginal costs that approach 0.
• 2:57
  If you build a traditional application, adding one more
• 3:00
  user costs fractions of a cent. Yeah, it's virtually free.
• 3:03
  But with these models, every prompt triggers billions of
• 3:07
  mathematical calculations across banks of graphics processing
• 3:10
  units. If the model becomes slightly
• 3:12
  less efficient, or if users ask slightly more complex questions,
• 3:16
  the physical cost of generating that answer just spikes.
• 3:19
  Does the cost of compute forces these companies to charge a
• 3:22
  premium? Exactly, which ultimately pushes
• 3:25
  them toward creating enterprise lock in.
• 3:27
  They need customers who will pay exorbitant fees to offset the
• 3:31
  infrastructure costs. I look at their pricing
• 3:33
  structure though and it just defies logic.
• 3:36
  How so? Well, imagine you run a startup.
• 3:38
  You budget $10,000 for your software tools.
• 3:41
  You look at Anthropics pricing tiers which are set at 20
• 3:44
  dollars, $100 and $200. Right, the standard tiers.
• 3:47
  But it doesn't scale linearly. With a flat model, you expect
• 3:51
  that paying 10 times the base price gets you 10 times the
• 3:53
  usage. Open AI maintains that flat,
• 3:56
  predictable model. Anthropic setup actively
• 3:59
  punishes the user for scaling up.
• 4:01
  Because the unit economics become highly irregular, the
• 4:05
  expectation from Anthropic is that enterprise clients will
• 4:08
  simply absorb the inefficiency because the tool itself is
• 4:12
  perceived as indispensable. They just assume people will pay
• 4:16
  whatever. Yeah, they assume a Fortune 10
• 4:18
  company will not care if the cost per query triples as long
• 4:21
  as the answers remain accurate. It was like walking into a bulk
• 4:25
  discount store to buy supplies for your office.
• 4:27
  You grab a small box of pens for $5.
• 4:30
  Then you see a box that holds 10 times as many pens and you
• 4:34
  assume it will be $50 or maybe 45 because you are buying in
• 4:38
  bulk. Right, that's how bulk works.
• 4:40
  Instead, the store randomly decides to charge you $300 just
• 4:43
  because you picked up the larger box.
• 4:45
  It actively discourages you from buying more.
• 4:48
  And the consequence of that broken unit economics model
• 4:51
  opens UA massive vulnerability for them.
• 4:53
  Develoers look elsewhere. Exactly.
• 4:55
  It forces develoers to look for open source wraers and 3rd party
• 5:00
  API harnesses. Developers realize they can
• 5:03
  build their own interfaces to access the underlying
• 5:05
  intelligence for a fraction of the cost rather than staying
• 5:08
  locked into anthrotics proprietary expensive ecosystem.
• 5:12
  Why pay the premium if you don't have to, right A.
• 5:15
  Developer can route the request through a cheaper channel,
• 5:18
  entirely bypassing the high margin enterprise tiers
• 5:22
  Anthropic desperately needs to survive.
• 5:24
  So to justify those crushing cost to their investors and
• 5:28
  their enterprise clients, Anthropic had to prove they
• 5:31
  could completely automate software engineering.
• 5:34
  They needed a home run. They needed a product so
• 5:36
  revolutionary that companies would just ignore the pricing
• 5:39
  model, and that led directly to their heavy push with clawed
• 5:42
  code. But almost immediately, that
• 5:44
  tool ran into a brick wall of user trust.
• 5:47
  What happened? Users started experiencing a
• 5:49
  very sudden massive performance in the Claude code Autonomous
• 5:53
  Agent. It started acting lazy.
• 5:57
  Lazy like it just wouldn't work. It ignored explicit instructions
• 6:01
  and it completely failed on complex multi step workflows
• 6:06
  that it used to handle with total ease.
• 6:08
  And the company stayed totally silent for an extended period.
• 6:12
  Nothing but crickets. Users were flooding developer
• 6:15
  forums, comparing notes, thinking they were doing
• 6:17
  something wrong. People felt gas lit.
• 6:19
  Yeah, they thought their prompts were suddenly inadequate.
• 6:22
  Or that they had forgotten how to interact with the system,
• 6:24
  when in reality the product itself had been altered behind
• 6:27
  closed doors. Finally, the company admitted to
• 6:30
  three very specific engineering missteps.
• 6:35
  Right. The first misstep involved
• 6:36
  latency. Users were complaining that the
• 6:39
  user interface was freezing when the model is given complex
• 6:42
  tasks. The system would pause while the
• 6:45
  artificial intelligence formulated a plan.
• 6:47
  So how did they fix it? To fix this Anthropic lower the
• 6:50
  default reasoning effort from high to medium.
• 6:52
  Wait, hold on, let me make sure I understand this.
• 6:54
  They had a product that was incredibly smart, but slow.
• 6:57
  Users complained about the speed, so instead of making the
• 6:59
  processing faster, they just made the software Dumber.
• 7:02
  That's essentially it. They optimized for the
• 7:04
  perception of speed by lowering the reasoning effort.
• 7:08
  The software started generating text faster, which stopped the
• 7:12
  interface from freezing. But the output suffered.
• 7:15
  The trade off was a severe drop in the quality of the output.
• 7:19
  The second messed up was a caching optimization bug, right?
• 7:22
  Yeah, they tried to make the memory retrieval more efficient
• 7:25
  and it accidentally wiped the models reasoning history right
• 7:28
  in the middle of an active session.
• 7:29
  So. The software would literally
• 7:30
  forget what it was doing halfway through a complex tab.
• 7:34
  Just completely blank out. And the third misstep is perhaps
• 7:38
  the most revealing about how these systems function.
• 7:42
  They implemented a system prompt change that strictly capped the
• 7:46
  models verbosity to 25 words between tool calls.
• 7:49
  Just 25 words, yeah. When you look at the latency
• 7:52
  versus intelligence trade off, the engineering team prioritized
• 7:56
  A snappy user interface over the deep architectural analysis
• 8:00
  required for software engineering.
• 8:02
  I read about Stella Lorenzo's analysis on this.
• 8:04
  Yeah, the AI director, she ran an analysis of over 6000 user
• 8:10
  sessions. She proved the model had
• 8:12
  fundamentally regressed. It shifted to a dangerous edit
• 8:15
  first behavior, completely abandoning the research first
• 8:19
  approach that made it successful in the first place.
• 8:21
  Wait, back up. How does simply asking the
• 8:23
  software to use fewer words break its ability to write code?
• 8:27
  If I ask a human developer to be concise, they don't suddenly
• 8:31
  forget how to program. Because human cognition and
• 8:34
  artificial generation operate differently, these models use
• 8:37
  text generation as a literal scratch pad for thinking.
• 8:40
  Oh, I see. When the model generates text,
• 8:43
  it is mapping out its logic, retrieving context, and planning
• 8:46
  its next execution step. It does not possess an internal
• 8:49
  monologue independent of the words it outputs.
• 8:51
  The words actually are the thought process.
• 8:53
  So it is like asking a mathematician to solve a complex
• 8:57
  calculus problem entirely in their head without scratch
• 9:00
  paper. If you take away the paper, or
• 9:02
  in this case restrict the tokens they are allowed to generate,
• 9:05
  they're going to guess the answer instead of properly
• 9:07
  calculating it. Restricting their word count
• 9:09
  effectively lobotomizes their planning process.
• 9:13
  If you limit the tokens they can generate before taking an
• 9:16
  action, you force them to act before they fully process the
• 9:19
  problem. They just jump straight into the
• 9:21
  code. They jump straight to editing
• 9:23
  the code base without researching the dependencies or
• 9:26
  planning the architecture. That shifts the entire
• 9:28
  perception of AI reliability. It proves that the harness, you
• 9:32
  know, the orchestration layer of tools and memory surrounding the
• 9:36
  actual neural brain is incredibly fragile.
• 9:39
  Very fragile. The core intelligence might be
• 9:41
  fine, but the rules governing how it is allowed to interact
• 9:45
  with the world are broken. When the harness fails, the user
• 9:49
  experiences it as the core intelligence degrading.
• 9:52
  Right, the model looks stupid, but really it's just being
• 9:54
  poorly managed by the software wrapper around it.
• 9:57
  So the frustration and lost trust from this silent
• 10:00
  degradation was already boiling over within the developer
• 10:03
  community when Anthropic committed an unforced error.
• 10:06
  A huge one. They handed that exact
• 10:08
  proprietary harness directly to the public.
• 10:10
  Yeah, a simple missing exclusion line in a configuration file,
• 10:15
  specifically a dot NPM ignore file, combined with a bug in the
• 10:19
  BUN JavaScript runtime resulted in Anthropic shipping a massive
• 10:23
  source map file to the public NPM registry.
• 10:27
  So what does that actually mean for the code?
• 10:29
  Well, to appreciate the severity of this you have to understand
• 10:32
  how software is packaged. The NPM registry is a public
• 10:36
  database where developers share code packages.
• 10:40
  When a company prepares code for public use, they usually
• 10:42
  compress it and remove all the readable names and spaces to
• 10:45
  save bandwidth. Which is called minification.
• 10:48
  Right, and a dot NPM ignore file acts as the bouncer at the club.
• 10:53
  It explicitly tells the system which internal files are not
• 10:56
  allowed to leave the building. And the engineers forgot to put
• 10:58
  the bouncer at the door. They just missed the exclusion
• 11:01
  line and on top of that a bug in their runtime environment pushed
• 11:05
  a source map file into the public upload.
• 11:07
  What's a source map? A source map is essentially a
• 11:10
  perfect translation file used for debugging.
• 11:12
  It maps the compressed minified code directly back to its
• 11:15
  original readable state. So by accidentally including
• 11:18
  this file, they expose 512,000 lines of unminified TypeScript
• 11:24
  across nearly 2000 internal files.
• 11:27
  It laid bare the entire internal architecture of the company.
• 11:30
  The public suddenly had access to over 40 internal system
• 11:34
  tools. Everything was out there.
• 11:36
  They found a background memory consolidation engine called the
• 11:39
  Dream System which handles how the software remembers
• 11:41
  interactions over long periods. They found totally unreleased
• 11:45
  features like Kairos, which is an always on autonomous demon
• 11:48
  running in the background and something called Ultra Plan.
• 11:52
  And they also found a hidden Tamagotchi style pet system
• 11:55
  called Buddy carried in the code, complete with a 1% shiny
• 12:00
  spawn rate. That detail is absolutely
• 12:02
  incredible to me. You have a $300 billion company
• 12:06
  building software capable of identifying global cybersecurity
• 12:10
  flaws. I mean identifying global flaws.
• 12:13
  And somewhere in the middle of this highly guarded, unreleased
• 12:16
  artificial intelligence source code, an engineer spent their
• 12:19
  time programming a digital pet that has a 1% chance of being
• 12:23
  sparkly. It's hilarious.
• 12:25
  They accidentally leaked National security level cyber
• 12:28
  capabilities alongside a virtual Pokémon.
• 12:31
  The juxtaposition is definitely striking, but beneath the Easter
• 12:34
  eggs, security researchers found empty code blocks explicitly
• 12:39
  designed for catching authentication errors.
• 12:42
  Which is wild. We really have to appreciate the
• 12:44
  supreme irony of anthropics undercover mode here.
• 12:47
  Oh, the undercover mode. They spent significant
• 12:50
  engineering resources building a highly sophisticated AI driven
• 12:54
  security system to prevent the model from leaking internal
• 12:58
  project names like Capybara or Tangu during public
• 13:02
  interactions. Right, They built a vault to
• 13:04
  lock down the AI's vocabulary, only for human engineers to
• 13:08
  accidentally upload the entire source code repository to the
• 13:11
  Internet. Looking through that leaked
• 13:13
  architecture though, the complexity of the exposed system
• 13:15
  is genuinely staggering. The multi agent coordination,
• 13:18
  the deep integration of system tools, the memory pipelines.
• 13:22
  It is a master class in how to build a hyperscale orchestration
• 13:25
  layer. It really is.
• 13:26
  It shows exactly how they manage the flow of information between
• 13:29
  different artificial intelligences working in tandem.
• 13:31
  I look at the same leak though and see how disorganized A
• 13:34
  hyperscale company can be. You mentioned the empty
• 13:37
  authentication code blocks earlier.
• 13:39
  Yeah, the empty catches. There are 9 empty catch blocks
• 13:42
  in that specific section that literally do nothing when an
• 13:45
  error occurs. They catch a critical security
• 13:48
  failure, a moment where the system realizes someone is not
• 13:51
  authorized to be there and the code just silently ignores it,
• 13:55
  so the program keeps running. It's pretty bad.
• 13:58
  It is like installing a state-of-the-art fire alarm and
• 14:01
  programming it so that when it detects smoke, the only thing it
• 14:04
  does is turn off its own sirens so nobody has to hear it.
• 14:07
  The consequence of this exposure is absolute.
• 14:11
  The barrier to entry for building an enterprise grade
• 14:14
  agent harness just vanished overnight.
• 14:16
  Smaller competitors and open source developers no longer have
• 14:20
  to spend millions of dollars guessing how to build secure
• 14:23
  file system permissions or structure multi agent memory
• 14:26
  pipelines, and Fropic provided the exact production tested
• 14:30
  blueprints to the entire world. They literally subsidized the
• 14:34
  research and development for their own competitors.
• 14:36
  They really did. Yeah.
• 14:38
  And while developers were busy analyzing those blueprints,
• 14:41
  threat actors realized that the massive media attention
• 14:44
  surrounding the leak provided the perfect camouflage for an
• 14:47
  attack. Yeah, almost immediately after
• 14:49
  the leak, malicious GitHub repositories claiming to hold
• 14:53
  the leaked clawed code spiked to the top of search engines.
• 14:57
  Hackers knew that 10s of thousands of engineers would be
• 15:00
  actively searching for this unreleased code.
• 15:02
  Exactly. O victims went looking for the
• 15:04
  source code and downloaded large archive files.
• 15:08
  Inside those archives was a Rust compiled dropper named Trade
• 15:11
  AIA. Dropper.
• 15:12
  Yeah, a dropper is a specific type of malware designed purely
• 15:15
  to sneak past antivirus software and drop the actual payload onto
• 15:19
  a machine. Writing it in Rust makes it
• 15:22
  notoriously difficult for security researchers to reverse
• 15:25
  engineer. Once executed, this dropper
• 15:27
  deployed 2 specific pieces of malware.
• 15:30
  The first was Vidar Stealer. Which steals credentials.
• 15:33
  Right. It scours the infected machine
• 15:35
  to drain browser credentials, saved passwords and
• 15:38
  cryptocurrency wallets. The second was Ghost SOCKS,
• 15:42
  which quietly turns the victim's machine into a network proxy for
• 15:46
  the attackers. So they use your computer to
• 15:49
  attack others. It allows the hackers to route
• 15:52
  their own illegal traffic through the victim's computer,
• 15:54
  making the victim look like the source of the attacks.
• 15:57
  The sophistication of the delivery mechanism is
• 15:59
  terrifying. They used throwaway GitHub
• 16:02
  accounts to host the files, constantly creating new ones as
• 16:05
  the old ones were banned. And to evade takedowns, the
• 16:08
  malware used dead drop resolvers via Steam community profiles and
• 16:13
  Telegram channels. Wait, hold on.
• 16:14
  A dead drop resolver? Are we talking about spy tactics
• 16:16
  here? Explain how that works.
• 16:18
  Normally malware has a hard coded IP address.
• 16:21
  It infects a computer and then calls home to a specific server.
• 16:24
  Security companies find that server and block it, rendering
• 16:27
  the malware useless. A dead drop resolver avoids this
• 16:30
  entirely. Instead of calling a hard coded
• 16:32
  server, the malware is programmed to quietly read a
• 16:36
  specific public web page, like a comment section on a gamer's
• 16:40
  Steam profile or a public Telegram channel.
• 16:44
  The hacker simply posts a new IP address disguised as a regular
• 16:48
  comment on that public page. The malware reads the comment,
• 16:51
  extracts the new IP address, and connects to the new server.
• 16:55
  If the server gets blocked, the hacker just leaves a new
• 16:57
  comment. We also saw the sheer
• 16:59
  coincidence of the axios NPM supply chain attack happening in
• 17:02
  the exact same window. Total coincidence, but brutal.
• 17:06
  Developers who were just trying to update their standard tools
• 17:08
  were caught in a perfect storm of overlapping threat vectors.
• 17:12
  Hackers were attacking the supply chain from multiple
• 17:14
  angles simultaneously, but furthermore, the leak exposed 26
• 17:19
  specific bash injection defense patterns inside Anthropics code.
• 17:23
  And that's the real issue. The real danger here isn't just
• 17:26
  developers getting tricked into downloading malware disguised as
• 17:28
  the leak. The risk is what hackers can do
• 17:30
  with the source code itself now that they have it.
• 17:33
  Because hackers now possess the exact internal filtering logic
• 17:37
  the system prompts, and those defensive rejects patterns,
• 17:40
  right? They can custom build prompt
• 17:42
  injections that perfectly bypass Anthropics defenses.
• 17:46
  They don't don't have to guess how the sandbox works anymore,
• 17:49
  they can read the source code and find the exact gaps in the
• 17:52
  armor. This completely redefines
• 17:54
  corporate security. You are no longer just securing
• 17:57
  your endpoints from traditional viruses.
• 17:59
  You have to actively govern what an autonomous coding agent is
• 18:02
  permitted to read, write, and execute when it's being
• 18:06
  manipulated by an external threat actor who knows exactly
• 18:09
  how the agent thinks. It's terrifying.
• 18:11
  The threat actor can craft a prompt that specifically avoids
• 18:14
  the 26 defense patterns, and Tropic uses instructing the
• 18:18
  agent to execute malicious commands directly on a company's
• 18:21
  server. Facing a crisis of trust, a
• 18:23
  massive PR disaster from the leak in a deeply compromised
• 18:26
  architecture, Anthropic aggressively pushed out their
• 18:29
  next generation update to try and change the narrative.
• 18:32
  Enter Opus 4.7. They launched this update with
• 18:35
  major claims. They promised superior handling
• 18:38
  of complex extended workflows, a massive vision upgrade
• 18:42
  supporting nearly 3.75 megapixels for image analysis,
• 18:46
  and a brand new X high effort level specifically designed for
• 18:51
  deep reasoning tasks. And they claimed a 13% lift on a
• 18:55
  rigorous 93 task coding benchmark, alongside massive
• 18:59
  improvements on the Roku in production tasks.
• 19:01
  The internal evaluations from enterprise companies like Hex,
• 19:05
  Notion and Replit praised the model for fixing deep
• 19:08
  architectural bugs and race conditions in their code bases
• 19:11
  that older models completely ignored.
• 19:13
  But the reality for individual users was brutal, and new
• 19:17
  tokenizer inflated token usage by up to 35%.
• 19:20
  Wait, let's explain what a tokenizer is and why changing it
• 19:23
  destroys a user's budget. Yeah, please do.
• 19:25
  Artificial intelligence does not read words the way humans do.
• 19:28
  It chops words up into smaller pieces called tokens.
• 19:32
  A short word might be 1 token, but a complex word might be
• 19:35
  split into 3 or 4 syllables or tokens.
• 19:37
  Companies charge users based on the number of tokens processed.
• 19:41
  Opus 4.7 introduced a new tokenizer that is significantly
• 19:46
  less efficient at packaging these words because it chops the
• 19:50
  text into more pieces. The user is charged up to 35%
• 19:53
  more for the exact same query. The model engages in extreme
• 19:58
  prolonged reasoning loops too. It writes out exhaustive 7 step
• 20:02
  plans and justifies its own boundaries before it executes
• 20:06
  even the simplest tasks. It really overthinks.
• 20:08
  You ask it to fix a typo in a single line of code, and it
• 20:12
  gives you a 5 page essay on the philosophical implications of
• 20:15
  the change. It drains a user's $20 monthly
• 20:18
  limit in just three prompts. The model is highly disciplined
• 20:21
  on the actual code output, though.
• 20:23
  Users are encountering friction because they need to stop using
• 20:27
  outdated prompt structures that the new model takes too
• 20:29
  literally. You think it's user error?
• 20:31
  The instruction following is so rigid that sloppy prompts result
• 20:34
  in bloated outputs. If a user ask a broad question,
• 20:38
  the model will attempt to cover every conceivable edge case.
• 20:41
  I see Opus 4.7 as a massive regression.
• 20:44
  It actively ignores direct formatting commands just so it
• 20:48
  can output useless bloated text. I wouldn't call it useless.
• 20:51
  You can explicitly tell it to only output the code and it will
• 20:55
  still give you the massive essay.
• 20:57
  The only logical explanation is that it is designed to charge
• 21:00
  the user more tokens by forcing them to pay for reasoning steps
• 21:03
  they never asked for. Think of Opus 4.7 like a highly
• 21:07
  specialized corporate lawyer. If you ask a corporate lawyer a
• 21:10
  simple legal question, you do not get a simple one sentence
• 21:14
  answer. No, you get a bill.
• 21:15
  You get 10 pages of disclaimers, citations, and risk analysis.
• 21:19
  It is incredibly expensive and it takes hours to read, but the
• 21:22
  final contract is legally bulletproof.
• 21:25
  For enterprise engineering, that rigorous defensive posture is
• 21:29
  exactly what is required to prevent catastrophic codebase
• 21:31
  failures. So it's for big companies.
• 21:33
  A company like Notion or Replit wants the software to over
• 21:37
  explain its reasoning to ensure it does not break their core
• 21:40
  product. So that creates A strict
• 21:42
  bifurcation in the market. Casual developers will abandoned
• 21:45
  Opus 4.7 entirely due to the unpredictable costs.
• 21:49
  They simply cannot afford to have their monthly limit wiped
• 21:52
  out in 10 minutes. It will exist exclusively as a
• 21:56
  tool for enterprise teams who have the budget to execute
• 21:59
  massive, complex architectural overhauls without worrying about
• 22:04
  the token burn. Opus 4.7 is undeniably powerful,
• 22:07
  but it is actually the throttled, restricted version of
• 22:10
  a much more capable intelligence that Anthropic is intentionally
• 22:14
  keeping locked in the basement. Well, if.
• 22:16
  Opus 4.7 is this bloated, ultra cautious lawyer of a model.
• 22:21
  Where is the actual bleeding edge innovation going because
• 22:23
  Anthropic didn't hit a $380 billion valuation by building a
• 22:27
  slow chatbot? No, they didn't.
• 22:29
  They hit it by building something so dangerous they
• 22:31
  locked it in the basement. Let's talk about Project
• 22:33
  Glasswing and the Mythos model. Mythos comes from the capybara
• 22:37
  model family, and it is Anthropic's true frontier model.
• 22:42
  The capabilities of Mythos are staggering.
• 22:43
  How staggering. In controlled testing
• 22:46
  environments, it autonomously patched 271 security bugs in the
• 22:51
  Firefox browser. It did this without human
• 22:54
  intervention. Wow.
• 22:56
  It analyzed the code, found the vulnerabilities and wrote the
• 22:59
  patches. It is so capable at finding and
• 23:02
  exploiting cybersecurity vulnerabilities that Anthropic
• 23:05
  simply refuses to release it to the public.
• 23:08
  The risk of that technology falling into the hands of a
• 23:10
  hostile nation state is too high.
• 23:13
  And this capability triggered a massive standoff with the
• 23:16
  Pentagon. The Department of Defense
• 23:18
  officially designated Anthropic a supply chain risk completely
• 23:22
  blacklisting them for military contractors.
• 23:25
  A blacklist. They essentially told defense
• 23:27
  contractors they are forbidden from integrating anthropic
• 23:30
  systems into military architecture.
• 23:32
  Anthropic refused to alter their terms of service, which strictly
• 23:35
  prohibit their AI from being used for mass domestic
• 23:38
  surveillance or fully autonomous weapons.
• 23:40
  They drew a hard ethical line in the sand.
• 23:42
  Simultaneously, though, Anthropic's technology is
• 23:45
  actively being used by Palantir for data management in military
• 23:49
  operations targeting Iran. We are looking at the absolute
• 23:52
  collision of corporate ethics and national security.
• 23:56
  The Pentagon's strategic mandate requires AI models to be
• 24:00
  available for all lawful purposes, which includes combat
• 24:04
  operations. And Anthropic's internal
• 24:07
  constitutional AI ethos refuses to cross the line into
• 24:11
  autonomous lethal targeting or unchecked surveillance.
• 24:15
  The ethical contradiction is glaring, though.
• 24:18
  Anthropic is actively suing the Department of Defense over the
• 24:21
  blacklist, claiming A moral high ground against autonomous
• 24:24
  weapons. Yet they seem entirely
• 24:26
  comfortable supplying the massive data processing
• 24:29
  intelligence required for thousands of military strikes in
• 24:32
  the Middle East through Palantir.
• 24:34
  You cannot claim strict passive while processing the targeting
• 24:37
  data for an active military campaign.
• 24:39
  Drawing a line at the human trigger pull is the only
• 24:42
  pragmatic way an artificial intelligence company can operate
• 24:45
  in the defense sector without losing all control over their
• 24:48
  technology. You think so?
• 24:49
  If they prohibit the system from making the final lethal
• 24:52
  decision, they maintain a boundary of human
• 24:55
  accountability. The software can process the
• 24:58
  radar data, analyze the satellite imagery and identify
• 25:01
  the target, but a human must authorize the strike.
• 25:04
  Without that specific boundary, the technology becomes a black
• 25:08
  box of autonomous warfare. So this standoff forces the
• 25:11
  entire industry to pick a side. AI companies must choose between
• 25:15
  maintaining strict ethical guardrails or bending to
• 25:19
  government mandates to secure the most lucrative, high stakes
• 25:22
  defense contracts in history. The tension we are discussing is
• 25:25
  defining the next era of technological development.
• 25:29
  The demands of hyperscale economics, the fragility of
• 25:32
  software harnesses and the requirements of national
• 25:34
  security are all converging on these specific companies.
• 25:37
  The evolution of autonomous intelligence is colliding
• 25:40
  directly with the messy reality of human error and geopolitical
• 25:43
  warfare. We are watching a company build
• 25:45
  software capable of identifying global security flaws while
• 25:49
  simultaneously struggling to manage their own cloud storage
• 25:52
  buckets and pricing tiers. It leaves you wondering when
• 25:55
  these tools officially become classified as national security
• 25:58
  assets. Private companies even be
• 26:00
  allowed to decide who gets to use them.
• 26:02
  If you're not subscribed yet, take a second and hit follow on
• 26:05
  whatever app you're using. It helps us keep making this.
• 26:08
  We appreciate you being here. Also, check out our YouTube
• 26:11
  channel for more business and tech updates.
• 26:13
  There's a link in the description.