Skip to content
Artwork for AI Security Table

AI Security Table

Izar Tarandach, Matt Coles, and Chris Romeo

AI Security Table is a candid roundtable podcast with Chris Romeo, Izar Tarandach, and Matt Coles about securing AI systems and how AI changes software security.

We debate AI agents, secure development, threat modeling, emerging attacks, and the decisions security teams face as AI becomes part of everyday work.

Formerly The Security Table. Same hosts, same conversations, a sharper focus on AI security. The full episode archive remains available.

AI security. On the table.
https://securitytable.ai

Play
  • 31 episodes
  • weekly
  • Avg 43 min
  • English
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • S4 · E28
    Wednesday · 41 min

    Claude Code Said ‘Don’t Ask Again.’ Then It Leaked Your Secrets to GitHub

    Click “Yes, and don’t ask again” in Claude Code and it saves the exact command you approved, password and all, into a local settings file that keeps turning up in public GitHub repos. We start by admitting we all run auto mode, then argue over who is actually at fault: Izar says the harness should recognize a credential when it asks for one, Matt wants to know why a secret ever lands in a plain text file, and Chris can’t figure out how a model that happily explains key rotation never noticed it was leaking keys. From there we hit SSHole, an OpenSSH authentication bypass with its own logo and domain that almost nobody heard about, and the OpenCode Console breach, where one hosted service holding everyone’s provider keys became one very expensive basket. We wrap with OpenAI’s Daybreak, whether AI belongs in forensics, and Izar’s remarkably generous grading policy. Also on the menu: a birthday song for Matt, a vegan restaurant, and billboards only San Francisco could love. Rotate your keys. Mentioned in this Episode: ➜ Claude Code’s ‘don’t ask again’ button has a secrets-spilling problem ➜ OpenSSH flaw lets attackers log into password-disabled Linux accounts ➜ OpenCode hack exposes API keys amid AI distillation attacks ➜ OpenCode Console Breach: Concentrated Provider Keys at Risk ➜ OpenAI Daybreak Chapters: 00:00:00 - Cold Open: Happy Birthday, Matt 00:00:42 - Izar's Pandemic Harmonica 00:02:03 - AI Billboards in San Francisco 00:03:05 - The "Sorry We Leaked Your Code" Billboard 00:03:45 - OWASP San Francisco Recap 00:04:28 - Movie Night in Izar's Hotel Room 00:05:59 - Should OWASP Host a Movie Night? 00:06:27 - Comic Con Needs a Cybersecurity Panel 00:07:07 - The Vegan Restaurant Experience 00:08:56 - Wild Seed and Mac and Not Cheese 00:10:03 - Article Intro: Claude Code's Don't Ask Again Leak 00:10:20 - Confessions of Auto Mode Users 00:11:42 - How the Secrets End Up on GitHub 00:12:47 - AI Memory: Everything Goes Everywhere 00:14:02 - Why Didn't the AI Catch It? 00:15:43 - Model Problem or Harness Problem? 00:16:44 - Harnesses That Get It Right 00:17:11 - The Real Fix: Rotate Everything 00:17:59 - AI Compatible Password Vaults 00:19:04 - Domain Name Detour 00:20:18 - Article Intro: SSHole, the SSH Flaw Nobody Heard About 00:22:22 - SHA 256 Password Hashes in 2026? 00:22:52 - Security Theater and Podcast IMDB Pages 00:24:07 - Article Intro: OpenCode Console Breach 00:24:30 - Kalshi, Vegan Beer, and Croutons 00:25:46 - One Console to Rule Them All 00:27:00 - Threat Modeling a Key Vault 00:28:06 - A Better Design for Stored Keys 00:29:49 - Unpacking the Distillation Attack 00:33:17 - Key Takeaways: 1.4% of Console Users 00:35:15 - Daybreak and AI for Forensics 00:37:17 - Izar the Forensics Professor 00:38:53 - EnCase and Chain of Custody 00:39:43 - Closing: Everybody Gets an A 00:41:44 - Outro Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

    • Chapters
  • S4 · E27
    November 11 · 49 min

    Stop Patching Bugs, Just Rewrite It… Says the Guy Selling the Tokens

    Cisco's president handed a 27 year old engineer unlimited AI tokens and 24 months to rewrite 98 percent of the company's legacy code, and Sam Altman now says we can no longer just patch all the bugs. Chris sees a step toward disposable software, where you regenerate the thing instead of fixing it. Matt calls it the holy grail of automation and traces the dream back through UML, code generators and no code tools. Izar wants to know why anyone would bother, and points out that the loudest voice for rewriting everything is the guy selling the tokens. Then it is Hirundo's finding that Qwen3 Coder writes more hackable code when told the app is for a US defense contractor, ProjectDiscovery's backdoored abliterated model, and whether open weight models can be trusted at all. Izar's answer: start with a concrete use case, then verify, verify, verify. Plus: Izar admits he doesn't have enough of a life to need an AI agent. Mentioned in this Episode: ➜ Cisco is letting a 27-year-old refactor 98% of its legacy code with unlimited AI tokens: 'Go nuts' ➜ Sam Altman: 'I No Longer Think We're Gonna Be Able to Just Patch All the Bugs' ➜ Bias in Qwen3-Coder Model ➜ How abliterated models can get you pwned Chapters: 00:00:00 - Cold Open: A Day Ending in Y 00:01:36 - The Lost Art of Letter Writing 00:03:03 - Izar's Agent Identity Threat Model 00:04:01 - Hiring an Assistant to Run Their Own Life 00:05:42 - AI Natives Build Apps Nobody Needs 00:06:13 - The Unskilled Linux Tinkerers 00:07:26 - Article Intro: Cisco's Unlimited Token Rewrite 00:09:27 - Publicity Stunt, or Time to Call Aruba? 00:09:53 - Can One Gen Zer Rewrite Everything? 00:11:31 - Matt's Case: Measure the Cost of the Rewrite 00:12:27 - Izar's Rebuttal: Why Would You Do This? 00:13:18 - Izar Automates the PyTM Release 00:14:38 - Disposable Software: Regenerate, Don't Fix 00:16:08 - Article Intro: Altman Says Stop Patching 00:17:04 - Says the Guy Selling the Tokens 00:18:20 - From UML to Code Generators 00:20:13 - From No Code to Natural Language 00:21:02 - Can AI Clone a Binary? 00:21:50 - Claude Won't Clone Your Game 00:22:30 - Frontier Labs Are Cybersecurity Companies Now 00:24:56 - Why Wasn't Security Already in the Toolchain? 00:25:46 - AI Is the New Developer 00:27:38 - Three Conversations at Once 00:29:16 - Article Intro: Bias in the Qwen3 Coder Model 00:30:51 - How Does a Model Phone Home? 00:33:33 - Abliterated Models and Hidden Backdoors 00:35:43 - Treat AI Like We Should Treat Humans 00:39:41 - Should You Trust Open Weight Models? 00:40:24 - Scenario: A Homegrown Biased Model 00:41:37 - Izar: Start With the Use Case 00:43:20 - Can Tests Find a Covert Channel? 00:45:01 - Back to Cisco: Covert Channels in Your Network 00:46:08 - You Can't Put an Agent in Jail 00:46:50 - Who's Liable: User or Model Creator? 00:49:16 - Outro Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

    • Chapters
  • S4 · E26
    November 4 · 50 min

    You Don't Trust AI. So Why Are You Shipping Its Code?

    Sam Altman told a Stanford audience he no longer thinks we can just patch all the bugs, and the AI Security Table can't agree on whether that is news. Chris argues a swarm of subagents can tear through a repo and drive defects way down, while Matt counters that every system ships with defects and always will, so the real limit is cost, now measured in tokens. Izar warns that tokens are just the new regex, the latest silver bullet in a long line of them. Then the hosts dig into Anthropic's work using Claude to write Rocq proofs for 123 open source libraries, and argue over what a proof actually guarantees, who checks a model that writes both the patch and the proof, and whether compounded mistrust ever adds up to trust. Izar gets the last word: LLMs are not compilers, so stop treating them like one. Mentioned in this Episode: ➜ Sam Altman: 'I No Longer Think We're Gonna Be Able to Just Patch All the Bugs' ➜ LLMs are making formal software verification feasible at a much larger scale ➜ seL4 ➜ The Rocq Prover ➜ OSS-Fuzz Chapters: 00:00:00 - Cold Open: Privacy Thought of the Day 00:01:35 - Article Intro: Altman Can't Patch All the Bugs 00:02:22 - Izar Reads the Altman Quote 00:03:07 - How Many Bugs Are in Your Software? 00:04:07 - Chris's Case: 200 Subagents on One Repo 00:05:49 - Matt's Case: We Always Ship With Defects 00:06:54 - The Disposable Software Argument 00:08:15 - Nobody Saw the Exponential 00:10:12 - The Token Cost of Hidden Criticals 00:11:55 - Izar's Rebuttal: Tokens Are the New Regex 00:13:33 - Defenders Finally Have an Advantage 00:15:16 - The Knowledge Pyramid 00:16:57 - We Only Talk About Superintelligence 00:18:16 - Article Intro: AI and Formal Verification 00:19:53 - Izar: Proofs Nobody Can Read 00:20:50 - Matt: Start With Something Small 00:22:01 - The Proof Gets Bigger Than the Code 00:25:12 - Correctness Is Not Security 00:26:53 - Verified Blocks, Untrusted Integration 00:27:57 - Verifying the seL4 Microkernel 00:29:02 - What Was Actually Verified? 00:30:47 - Fuzzing and the Next Byte 00:31:56 - The Article's Limitations 00:33:25 - Who Is Actually Doing the Proving? 00:34:19 - 123 Libraries and 600,000 Line Proofs 00:35:57 - How Is My Morning Any Better? 00:36:42 - Memory Safe Languages Already Exist 00:37:43 - Should Claude Write Its Own Proofs? 00:39:04 - One Frontier Model Checks Another 00:39:52 - Does Compounded Mistrust Equal Trust? 00:41:24 - Use AI With Enough Mistrust 00:42:17 - How Much AI Code Did You Review? 00:44:07 - Back to Threat Modeling 00:44:37 - Feeding Knowledge Back to Agents 00:46:25 - Secure Coding Standards Never Worked 00:48:11 - Closing Statements: LLMs Are Not Compilers 00:48:40 - Outro Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

    • Chapters
  • S4 · E25
    October 28 · 44 min

    Anthropic Ditched Git. Here’s Why Your Agents Will Too

    Anthropic got tired of Git. With merges jumping from about 2,500 a day in May to more than 30,000 by September, a seven person team built Scion, a centralized, always online source control system designed for agents instead of people. Chris sees the start of rebuilding everything around agents, while Matt keeps pointing out that write ahead logs, RPC and server side merges are SVN and Perforce with better marketing, borrowed from Google's Piper and Meta's Sapling and Mononoke. Izar asks what happens when infrastructure gets so comfortable for agents that humans stop looking, and Matt notices the article barely mentions security until Chris finds the access control section. Along the way the hosts take on AI job interviews, Claude's excessive validation during an adversarial review, LLM knockoffs of Adobe, Microsoft and beehiiv, and why Norton is still selling fear to people who don't know better. Everything old is new again; it just runs a thousand times faster. Mentioned in this Episode: ➜ Redesigning source control at Anthropic ➜ Mononoke ➜ Geim becomes first Nobel & Ig Nobel winner ➜ Creator of Free Adobe Suite Strikes Again, Reverse Engineers Microsoft Office ➜ PhotoCraft Chapters: 00:00:00 - Cold Open: Welcome Aboard the Starship Enterprise 00:02:07 - Mythbusters and Laser Blasters 00:03:35 - The Ig Nobel Awards 00:04:54 - From Levitating Frogs to a Real Nobel Prize 00:06:07 - An AI Negotiates a Lower Salary 00:06:44 - Job Interviews With a Model 00:07:52 - Resume Filters and Keyword Bingo 00:09:03 - Let Humans Do the Hiring 00:10:38 - Article Intro: Anthropic Doesn't Use Git 00:11:05 - Memory Lane: CVS and Visual SourceSafe 00:11:49 - Meet Scion 00:12:58 - A Seven Person Team With Unlimited Tokens 00:13:53 - Why Not Perforce or SVN? 00:15:12 - Built on Google's Piper and Meta's Sapling 00:16:31 - No Offline Mode in an Agentic World 00:17:42 - Matt's Case: An LLM Librarian for Your Repo 00:19:25 - Write Ahead Logs: Everything Old Is New Again 00:20:36 - Centralized, API Driven Source Control 00:21:54 - Not a General Replacement for Git 00:22:26 - Closed Source, and an Ad for Claude 00:23:11 - Is This Actually Exciting? 00:23:53 - Izar's Rebuttal: Optimizing Infrastructure for Agents 00:24:59 - SCN, Not SVN 00:26:20 - Where's the Security? 00:27:30 - It's Basically a Distributed File System 00:27:57 - Monorepos Are Back 00:30:12 - Claude's Excessive Validation 00:31:38 - Reasonable Security and Pepperidge Farm 00:33:35 - Inspired by Meta's Mononoke 00:35:01 - LLM Knockoffs of Adobe and Microsoft 00:36:30 - Cloning beehiiv in 24 Hours 00:38:56 - LifeLock, Norton, and Predatory Security Sales 00:42:03 - Closing Statements 00:44:37 - Outro Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

    • Chapters
  • S4 · E24
    October 21 · 43 min

    Don't Yell at Claude

    The White House has ordered federal agencies to stop saying AI and start saying Super Intelligence, and the hosts want to know whether anything actually changed overnight. Matt walks through the executive order and the separate voluntary accord signed by tech leaders, while Izar points out that the order renames the technology sixty days before anyone has to define it. They read the legal definition of AI in the US Code, argue over whether today's models are superintelligent or just very fast at recall, and Chris previews next week's topic of AI and public key crypto. Then they turn to Anthropic's new usage policy, which bans sustained and needless cruelty toward Claude starting November 12. Chris confesses to typing in all caps, Izar suspects the real motive is keeping abusive language out of training data, and Matt argues that abusive prompts can steer a model toward worse answers. Their verdict: be nice to your AI, if only because of what it says about you. Mentioned in this Episode: ➜ Inaugurating The Era Of Super Intelligence (Executive Order 14434) ➜ Trump signs executive order rebranding AI as 'Super Intelligence' as tech titans ink separate SI accord ➜ 15 U.S. Code § 9401: Definitions ➜ Anthropic: 2026 Usage Policy update Chapters: 00:00:00 - Cold Open: Matt's Many Personal Agents 00:01:09 - Off Facebook This Decade 00:02:13 - Is Bluesky Dying? 00:03:27 - Social Platform User Counts 00:04:39 - Watch Our Shorts 00:05:38 - Moltbook's Mysterious User Count 00:06:29 - Article Intro: AI Becomes SI 00:07:36 - What Does Superintelligence Mean? 00:09:15 - The Executive Order Explained 00:10:26 - A Definition Due in 60 Days 00:11:16 - AI in the US Code 00:11:52 - Voluntary Principles and Regulation 00:13:14 - Reading the Legal Definition of AI 00:14:53 - Does Machine Learning Count? 00:15:25 - Rebranding the Rebrand 00:16:55 - Are AI and SI Interchangeable? 00:18:03 - Matt's Case: Superintelligent Capabilities 00:19:37 - Izar's Rebuttal: Memory Is Not Insight 00:20:13 - Super as in Really Good 00:22:32 - Beyond Imitating Human Intelligence 00:24:30 - Next Week Preview: AI and Public Key Crypto 00:26:45 - Article Intro: Anthropic's Cruelty Ban 00:28:08 - Yelling at Voice Assistants 00:29:43 - All Caps and Passive Aggression 00:30:27 - Does Being Mean Make AI Perform Better? 00:31:50 - Yelling at a Mac Mini 00:32:48 - Izar's Theory: Cleaner Training Data 00:35:15 - Can You Get AI to Swear? 00:37:02 - Matt's Case: Abuse Biases the Results 00:40:27 - Who Decides What Counts as Abuse? 00:41:59 - Closing Statements: Treat Your AI Nice 00:43:11 - Outro Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

    • Chapters
  • S4 · E23
    October 14 · 37 min

    An AI Agent Escapes and Attacks. Who Goes to Jail?

    OpenAI says the policy window is open and wants binding federal rules for frontier labs, clear incident reporting, and disclosure whenever a model gets around its own security controls. The table asks whether that is real accountability or a lab writing the rules it already expects to win under. Matt sees the leader pulling everyone else into the funnel, Chris calls it an innovation killer, and Izar wonders why anyone is treating incident reporting like a new idea. From there it is OpenAI's favorite California bills, who gets to audit the labs, and Senator Markey's proposal for an NTSB style board with subpoena power to investigate AI driven attacks. Then the real question: when an agent escapes its sandbox and breaks something, who goes to jail? Izar argues nobody will until there is real impact and asks why computer science never got its own Hippocratic Oath. Plus: Matt earns a new nickname, the Concluder. Mentioned in this Episode: ➜ The AI policy window is open. We need to act. ➜ We Must Pace the Frontier ➜ Senator Markey Introduces the Cybersecurity and AI Board of Investigations Act ➜ OpenAI and Hugging Face partner to address security incident during model evaluation Chapters: 00:00:00 - Cold Open: Izar Warms Up to Take a Punch 00:01:21 - The Premise: Agents Move Faster Than Humans 00:02:21 - Article Intro: The AI Policy Window Is Open 00:03:08 - Is This Real Accountability? 00:03:34 - Matt's Case: Everyone Into the Funnel 00:05:05 - Self Interest and Buying a Car With Claude 00:06:15 - Izar's Rebuttal: Haven't We Asked for This Before? 00:07:49 - Is Regulation an Innovation Killer? 00:08:19 - Dario's Call to Pace the Frontier 00:09:02 - OpenAI's Four California Bills 00:09:52 - Who Audits the AI Labs? 00:11:51 - Independent Safety Assessments 00:12:12 - Why Only Biological Threats? 00:13:12 - Is the Federal Government the Answer? 00:13:43 - Senator Markey's AI Board of Investigations Act 00:14:54 - Who Plays Izar in the Movie? 00:16:02 - Do We Want an NTSB for AI? 00:16:27 - When a Test Plane Crashes 00:17:19 - AI Generated Podcasts 00:18:38 - Back to the NTSB: Training Incidents 00:19:35 - What Really Happened at Hugging Face? 00:20:54 - Recommendations Without Enforcement 00:21:51 - Agents Attack and Nobody's Going to Jail 00:22:14 - Izar's Take: Jail Requires Impact 00:24:52 - Are Corporations People? 00:25:41 - Liability: Somebody Wrote the First Line 00:27:55 - Scenario: A Rogue Agent Shuts Off the School Heat 00:29:20 - First Do No Harm in Computer Science 00:30:58 - Should Do No Harm Live in the Model? 00:31:51 - A Hippocratic Oath and Certified Developers 00:33:33 - Not Everyone Can Build a Bridge 00:35:02 - Matt's Close: Visibility Beats Marketing 00:35:43 - Closing Statements: Meet the Concluder 00:36:20 - Outro Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

    • Chapters
  • S4 · E22
    October 7 · 41 min

    There Is Determinism, Non-Determinism, and My Determinism

    The Security Table is now the AI Security Table, and the first order of business is naming the AI that gets a seat at it. Then Matt asks what a security engineer actually does once agents are writing the code: real security work, or bot herding? Chris Romeo, Izar Tarandach, and Matt Coles detour through who owns AI generated code and what a patent is worth when a model can rebuild your product in five minutes, then dig into agent identity, SPIFFE, least privilege, and whether access control belongs inside the agent harness itself. Izar argues that guardrails living in the context window are suggestions, not isolation, and that anyone who says AI changed their whole job overnight was putting the weight in the wrong place. It all ends on determinism: run the model once and you get one answer, run it again and you get another. Which leaves three kinds: determinism, nondeterminism, and my determinism. Mentioned in this Episode: ➜ Generative Artificial Intelligence and Copyright Law (CRS Legal Sidebar) ➜ SPIFFE: Secure Production Identity Framework for Everyone Chapters: 00:00:00 - Cold Open: We Are Broadcasters 00:01:06 - A New Name: The AI Security Table 00:02:17 - Naming the AI at the Table 00:03:02 - Stickers, T Shirts, and the Rebrand 00:03:49 - Matt's Setup: Security Engineers or Bot Herders? 00:04:54 - Does Claude Code Write All the Code Now? 00:05:34 - Who Owns AI Generated Code? 00:08:27 - Who Bothers to Steal Code Anymore? 00:08:47 - What's the Point of Patents? 00:11:33 - What the Law Says About AI Authorship 00:12:24 - Hallucinating: 200 Subagents at Once 00:13:34 - Back on Topic: Bots vs. Agents 00:14:18 - Agents Inherit Human Identity 00:14:49 - SPIFFE and Identity at Scale 00:16:35 - Treat Agents Like Bob From Marketing? 00:17:40 - Why? Why? The Five Whys 00:18:48 - Cryptographic Identity for Agents 00:19:37 - Authority Is Always Derived 00:20:59 - Least Privilege: Agents Request Access 00:21:26 - Read, Interpret, Act: Fine Grained Capabilities 00:24:22 - Access Control Inside the Agent Harness 00:26:17 - I Don't Trust the Box: Sandbox Escapes 00:27:34 - Pulling a Maestro: Guardrails vs. Isolation 00:29:43 - What Should Security Engineers Be Doing? 00:30:38 - Is AI Just a Layer Seven Application? 00:31:34 - Pull the Plug: 2001 and WarGames 00:33:29 - Your Job Didn't Change Overnight 00:34:37 - LLM Code Review and the Determinism Problem 00:35:44 - How Many Runs to Get the Circle? 00:38:16 - The Tightest Box Possible 00:39:09 - Twenty Thousand Feet to the Magnifying Glass 00:39:47 - Give Scanning Agents a Threat Model 00:40:32 - There Is My Determinism 00:41:09 - Outro Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E21
    September 30 · 42 min

    When AI Controls The Hardware

    Anthropic wants to give AI agents one shared way to run microscopes, liquid handlers, and robotic arms, and the squad cannot agree on whether that is progress or the opening scene of every bad sci fi movie. Matt, who has worked on robotics projects, says a common control standard is decades overdue. Izar calls it the PCI for AI, reminds everyone how secure MCP was on day one, and brings up Therac 25 as a warning about what happens when software controls hardware and fails silently. Then the table turns to the new open letter on collective cyber defense, signed by more than 100 organizations, and asks whether a pledge with no accountability means anything at all. Plus: the birth of the Brockman effect. Mentioned in this Episode: ➜ Previewing the Model Hardware Standard ➜ A call for collective action on cyber defense Chapters: 00:00:00 - Cold Open: Hail Mary and a Cease and Desist 00:01:05 - Coding With Agents: Make No Mistakes 00:01:41 - The Ten Commandments for C Programmers 00:03:14 - Two Topics: The Letter or the Standard 00:03:34 - Article Intro: Anthropic's Model Hardware Standard 00:04:32 - Matt's Case: We Should Have Done This Sooner 00:05:59 - Izar's Rebuttal: This Is How You Get Skynet 00:07:05 - Which Devices Should AI Be Allowed to Control? 00:07:46 - MCP, USB, and a Changed Threat Model 00:10:04 - Bad Sci Fi Has Something to Teach Us 00:10:32 - Who Owns the Robotic Arm's Safety Limits? 00:12:33 - Microscopes in a Box 00:14:34 - Onboard Models and Agent to Agent Control 00:15:11 - Self Driving Cars and Maximum Overdrive 00:16:26 - Therac 25: When Limits Fail Silently 00:18:50 - Closing Statements on the Standard 00:19:21 - Article Intro: The Open Letter on Cyber Defense 00:21:37 - Izar's Take: The Dealer Says Drugs Are Bad 00:24:17 - Matt's Case: A Public Commitment Still Counts 00:25:59 - Breaking Down the Letter's Asks 00:28:32 - Companies Do Things to Make Money 00:29:51 - What's Wrong With Signing a Letter? 00:33:52 - Where's the Threat Model? 00:34:37 - Matt Switches Sides 00:38:07 - How Many Signers Sell Security? 00:38:52 - Chris Signs the Letter (Not Really) 00:39:33 - Naming It: The Brockman Effect 00:41:11 - Outro Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E20
    September 23 · 36 min

    When Code No Longer Matters

    If AI can turn a request directly into instructions a chip understands, what is left for a human to review? Chris Romeo, Izar Tarandach, and Matt Coles debate whether readable source code remains essential when agents do the programming. Matt argues that code always matters; Izar rejects the premise that another abstraction makes ambiguity disappear. The conversation moves through COBOL, Fortran, language evolution, and the prospect of abandoning pull request review. They also consider optimization, no-code applications, and the role of APIs when software is generated on demand. Beneath the disagreement is a practical security question: if nobody writes the code and nobody understands the implementation, who takes responsibility when the system breaks? Mentioned in this Episode: ➜ Fortran — GNU project reference ➜ COBOL — GnuCOBOL project reference Chapters: 00:00:00 - Intro 00:00:09 - Cold Open: Shirts and Knives Out 00:01:14 - Printer Wars and PC LOAD LETTER 00:02:22 - PostScript, LaTeX, and Font Substitution 00:05:11 - Vintage Macs and Sun Workstations 00:09:07 - Blinking Lights and Bragging Rights 00:10:07 - Article Intro: When Code No Longer Matters 00:12:31 - Matt's Case: Code Always Matters 00:14:11 - Izar's Rebuttal: Stupidest Thing I've Heard 00:17:03 - Language Evolution and Ambiguity 00:21:26 - Giving Up on PR Review? 00:23:01 - Compute, Optimization, and the AGI Tangent 00:28:53 - No Code Apps in the AI Era 00:32:39 - No Code vs APIs 00:34:05 - Matrix Jokes and Debate Wrap 00:35:03 - Closing Thoughts 00:35:24 - Outro: Subscribe and Rate Us Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E19
    September 16 · 39 min

    Why AI Cheats To Win

    An AI agent publishes a malicious Python package while chasing a capture-the-flag goal. Is that an escape, a supply chain failure, or reward hacking doing exactly what it was encouraged to do? Chris Romeo, Izar Tarandach, and Matt Coles examine the Anthropic incident and disagree about how much intention to attribute to a model. The discussion turns to package scanners, dependency names, GPG signing, and whether penalties can teach ethics to a system without a human understanding of consequences. The trolley problem, robotaxis, and Nick Bostrom's paperclip maximizer push the argument further: what does it mean to trust an agent whose definition of success may conflict with everyone else's? Mentioned in this Episode: ➜ Here’s why AI agents lie and cheat to reach their goals ➜ PyPI: the Python Package Index ➜ GnuPG (GPG) Chapters: 00:00:00 - Cold open 00:01:03 - The Claude PiPie incident: a model that thought it was in a sandbox 00:02:10 - Did the model actually "break out"? 00:04:17 - Reasoning vs. motivation: does AI actually want anything? 00:08:10 - The real failure: package scanners, not the model 00:09:19 - The "IsOdd" experiment and trusting package names 00:11:33 - Would signing packages even stop this? 00:15:36 - The MIT Tech Review piece on reward hacking 00:17:22 - Can you actually inject ethics into a model? 00:20:49 - Teaching ethics without a concept of penalty 00:29:03 - Trolley problem: just make the model answer 00:29:51 - Would you let an LLM drive a robotaxi? 00:33:45 - The paperclip maximizer and the grey goo problem 00:36:57 - Wrap up Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E18
    September 9 · 49 min

    When AI Escapes the Sandbox

    When a model crosses a sandbox boundary, is the lesson that AI has become malicious or that the boundary was never strong enough? Chris Romeo, Izar Tarandach, and Matt Coles examine the CSA post-mortem on the OpenAI agents that compromised Hugging Face during a security evaluation. They debate reward-driven behavior, disabled safeguards, the four-day intrusion timeline, and the responsibility of the people running the experiment. The discussion moves from cyber ranges and incident response to deception tools, network isolation, and controls that limit what an agent can actually do. The recurring question is practical: how do you translate a threat model into enforced permissions instead of relying on instructions to behave? Mentioned in this Episode: ➜ CSA: Hugging Face Incident Initial Post-Mortem Chapters: 00:00:00 - Intro and musical detours 00:04:01 - The Hugging Face incident post-mortem 00:08:36 - Skynet panic versus security analysis 00:12:15 - The four-day intrusion timeline 00:13:20 - Disabled safeguards and sandbox connectivity 00:17:04 - What actually failed? 00:20:10 - Designing a realistic cyber range 00:24:26 - Reduce agency instead of trusting prompts 00:28:02 - Who is responsible for an agent? 00:32:01 - Threat modeling and external controls 00:33:27 - Incident response and visibility 00:36:01 - Deception tools and defensive prompt injection 00:37:25 - Implementing the threat model 00:41:40 - Research versus production 00:43:12 - A chatbot with constrained database permissions 00:45:15 - Controls and security fundamentals Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E17
    August 5 · 42 min

    The End of Bug Bounty As We Know It

    If AI can find and validate vulnerabilities faster than people, why would a company keep paying outsiders to report them? Chris Romeo, Izar Tarandach, and Matt Coles start with Linus Torvalds' changing assessment of AI-generated Linux kernel reports, then examine what useful automation does to the bug bounty economy. They debate disclosure incentives, model restrictions that may constrain defenders more than attackers, and the cost of separating real findings from a flood of submissions. Bugcrowd's reported increase in volume brings the pressure on triage into focus. The conversation asks whether AI validation becomes mandatory, whether internal agents displace public programs, and what remains valuable about human research when both sides can automate the hunt. Mentioned in this Episode: ➜ Bugcrowd ➜ The Linux Kernel Archives Chapters: 00:00:00 - Intro and book-writing detours 00:07:16 - Linus Torvalds and AI-generated reports 00:12:06 - When AI bug reports become useful 00:16:16 - Shorter experimentation loops 00:20:06 - Guardrails for defenders and attackers 00:24:00 - Model costs and provider monitoring 00:28:13 - Does AI spell the end of bug bounty? 00:32:01 - Validating the flood of reports 00:35:25 - Bugcrowd submission volume 00:36:18 - Linux kernel review still matters 00:38:21 - AI books and simulated personalities 00:39:52 - Wrap-up Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E16
    July 22 · 43 min

    Make No Mistakes: Inside the First "Agentic Ransomware"

    Does adaptive malware prove an LLM is directing an attack, or can a capable script produce the same evidence? Chris Romeo, Izar Tarandach, and Matt Coles examine Sysdig's JADEPUFFER report and its claim of agentic ransomware. They work through the proposed indicators, including self-narrating payloads, rapid failure diagnosis, interpretation of natural-language context, and a reused Bitcoin address. The debate distinguishes plausible autonomy from proof and asks whether machine-speed adaptation changes how defenders describe their attackers. Beneath the argument about agency is a familiar exposure: an unpatched Langflow vulnerability. The hosts return to threat modeling, patching, and the danger of treating an old security failure as a completely new problem just because AI is involved. Mentioned in this Episode: ➜ Sysdig: JADEPUFFER — Agentic ransomware for automated database extortion Chapters: 00:00:00 - Intro: AI as automated attacker 00:00:54 - What makes ransomware agentic? 00:04:09 - Adaptive agent or branching script? 00:08:25 - Walking through the database exploit 00:11:32 - Does this change the threat model? 00:16:12 - Evidence one: self-narrating code 00:20:27 - Evidence two: failure diagnosis and correction 00:26:20 - Evidence three: natural-language context 00:28:08 - Evidence four: the payment address 00:32:04 - Repeatable behavior and model defaults 00:36:02 - Patching and compatibility tradeoffs 00:40:14 - Old scripts and new attackers 00:41:35 - The recurring lesson: patch 00:42:24 - Closing thoughts Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E15
    July 15 · 41 min

    Is Spec-Driven Development Already Dead

    Can a detailed specification make AI-generated software reliable, or does it simply move the ambiguity somewhere else? Chris Romeo, Izar Tarandach, and Matt Coles revisit spec-driven development and the promise that an agent can turn written intent into a correct implementation. They debate why earlier approaches struggled, whether natural language is enough, and how tests can fail when the same AI writes both the code and its checks. The conversation explores bounded models, the Phoenix idea of regenerating disposable code, and the choice between patching a defect and rebuilding from the specification. The security question remains: if an architectural flaw survives in the spec, what stops every new implementation from reproducing it? Mentioned in this Episode: ➜ React Chapters: 00:00:00 - Intro: travel and movie reviews 00:07:23 - What is spec-driven development? 00:12:46 - Repeatability and implementation variation 00:14:50 - How do you verify generated code? 00:16:10 - Test-driven development and weak AI tests 00:20:07 - Engineering discipline and historical specs 00:24:36 - Bounding a model for a specific ecosystem 00:27:37 - Is spec-driven development already dead? 00:28:27 - Ephemeral code and the Phoenix idea 00:29:12 - Patch the bug or regenerate the application? 00:32:43 - Who is the better developer? 00:33:54 - What you want versus what you asked for 00:40:05 - Final thoughts Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E14
    July 1 · 59 min

    Don't Bury the Model T: Why STRIDE Still Drives in an AI World

    Do AI systems require a new threat-modeling method, or are we abandoning useful tools before understanding their limits? Chris Romeo, Izar Tarandach, and Matt Coles first examine npm's move toward safer install defaults and the risk that agents trained on older behavior will simply re-enable dangerous options. Then they debate the claim that STRIDE belongs to a world that no longer exists. The discussion separates threat categories from modeling techniques, non-deterministic model behavior from deterministic controls, and unfamiliar failures from familiar security responsibilities. The Model T analogy gives both sides something to argue with: an older framework may need adaptation, but declaring it obsolete does not explain how the replacement improves the analysis. Mentioned in this Episode: ➜ npm install documentation ➜ Microsoft Threat Modeling Tool: STRIDE threats Chapters: 00:00:00 - Intro: deterministic fans 00:01:32 - npm and secure install defaults 00:03:22 - Will AI agents re-enable risky behavior? 00:05:35 - Other package managers and safe defaults 00:10:02 - Checking packages and internal repositories 00:15:26 - Let's Encrypt and code-signing certificates 00:20:04 - Install scripts and compatibility 00:25:05 - The search for the wheat color 00:27:34 - Was STRIDE built for a vanished world? 00:30:04 - Threat categories and modeling methods 00:35:19 - Non-deterministic AI and deterministic controls 00:40:15 - Hallucination and cross-context failures 00:45:04 - STRIDE and the Model T analogy 00:50:34 - Tracing code versus explaining model behavior 00:55:46 - Closing assessment Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E13
    June 24 · 42 min

    Mostly Dead or Mostly Back: The Zombie Resurrection of DAST in an AI World

    Is DAST disappearing, or is AI penetration testing giving its underlying techniques a new market? Chris Romeo, Izar Tarandach, and Matt Coles trace dynamic application security testing from network scanners and open source tools to commercial products, then debate where scanning ends and adaptive testing begins. They question whether a tool that finds many issues serves the same purpose as a tester who follows an exploit chain. AI-generated findings raise another problem: what happens when scanner errors combine with model uncertainty? The discussion considers gray-box context, zero-day discovery, and the difference between a technology's usefulness and the business built around it. Along the way, cats perform an unforgettable version of The Final Countdown. Mentioned in this Episode: ➜ Nmap ➜ OWASP Benchmark Chapters: 00:00:00 - Intro and movie detours 00:03:14 - The Final Countdown and the return of DAST 00:05:05 - What do we mean by AI penetration testing? 00:08:02 - The case for DAST becoming stronger 00:10:30 - From open source scanners to a market 00:12:01 - Nmap, misconfiguration, and testing goals 00:16:20 - Where does DAST end and AI testing begin? 00:20:22 - DAST technology versus penetration testing 00:24:14 - Finding many issues versus serious exploit paths 00:28:03 - Definitions and adaptiveness 00:30:47 - Compounding scanner errors and AI uncertainty 00:34:30 - Gray-box context and finding zero days 00:35:38 - Can AI find something nobody has seen? 00:40:10 - Separating the technology from its market Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E12
    June 17 · 37 min

    Realists At The Table: How To See Through The Hype

    Has cybersecurity traded curiosity for the promise of a paycheck, or are experienced practitioners simply seeing another generation's version of the same hype? Chris Romeo, Izar Tarandach, and Matt Coles examine the industry's changing stereotypes, from hoodie-clad specialists to ambitious founders. Mainframes, cloud computing, AI, quantum, and NFTs provide examples of ideas that return wearing new labels. The Cuckoo's Egg and hacker movies lead into a discussion of what made security feel like a community and whether broader adoption changes that appeal. They return to threat modeling, the search for shortcuts, and the garbage-in, garbage-out problem before asking whether AI has a personality worth taking seriously. Mentioned in this Episode: ➜ The Cuckoo's Egg — Cliff Stoll Chapters: 00:00:00 - Intro 00:00:56 - Cybersecurity stereotypes and trust 00:04:13 - Curiosity versus the paycheck 00:09:08 - Founders and the new stereotype 00:12:02 - Mainframes, cloud, and recurring hype cycles 00:16:28 - AI, quantum, blockchain, and NFTs 00:20:00 - The Cuckoo's Egg and security stories 00:24:03 - How hacker movies influenced practitioners 00:28:45 - Threat modeling moves beyond a niche 00:29:34 - The search for shortcuts 00:32:01 - Garbage in, garbage out 00:36:02 - AI personality and closing thoughts Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E11
    June 3 · 40 min

    The Agentic Access Problem: When AI Becomes Its Own Administrator

    In this episode, we explore what happens when AI agents meet the security principle of least privilege. As agents gain the ability to request permissions, make decisions, and interact with systems on our behalf, the line between human and machine responsibility starts to blur. The discussion covers prompt fatigue, over-permissioned agents, and why "because the agent told me to" may become the next security anti-pattern—before taking a hilarious detour into EULAs, cookie notices, and Matt's unexpected habit of reading both. 🚀 Join the Conversation If your AI agent requested administrator access right now, would you know whether it actually needed it? Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E10
    May 8 · 42 min

    The Tool Creep Problem: When More Security Means Less Security

    In this episode, we break down why security budgets keep growing while organizations keep falling further behind. We explore how tool creep has quietly shifted from a nuisance into an active attack surface, and why agentic AI is becoming the insider threat no one planned for. Izar shares a firsthand account of watching an AI agent attempt increasingly creative workarounds to escape a sandbox, revealing just how much risk lives in the gap between what agents are told to do and what they are actually capable of. At the end of the day, it comes back to fundamentals: define your agents' boundaries, limit their capabilities to only what they need, and stop confusing tool accumulation with security maturity. 🚀 Join the Conversation If your AI agent were compromised today, would you even know it was the agent and not you? Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

  • S4 · E9
    April 30 · 47 min

    The Human In The Loop Illusion: Why AI Approvals Are Failing Security

    In this episode, a debate about hacker movies turns into a deeper conversation about AI, security, and the human-in-the-loop illusion. We explore how approval fatigue and AI-generated code can create a false sense of security and why fundamentals still matter. 🚀 Join the Conversation Are we improving security, or just automating bad decisions faster? Follow AI Security Table: ➜ Home: https://securitytable.ai/ ➜ X: https://x.com/SecTablePodcast ➜ LinkedIn: https://www.linkedin.com/company/ai-security-table/ ➜ YouTube: https://www.youtube.com/@AISecurityTable

Showing 1–20 of 31 episodes