Techsplainers by IBM

Techsplainers by IBM

Download on the App Store

Techsplainers by IBM episodes

  • What is M2M authentication?
    This episode of Techsplainers explores machine-to-machine authentication and explains why it has become a foundational control for modern runtime security. As nonhuman identities continue to multiply, computer systems need a reliable way to verify which workloads are actually making requests before any data, service or infrastructure action is allowed.
    The episode walks through how M2M authentication works across workload clients, credentials, identity providers and resource servers. From there, the discussion looks at common M2M authentication patterns. Along the way, listeners learn the benefits, tradeoffs and best-fit scenarios for each pattern, along with why short-lived, verifiable machine identity is so important for zero trust, least privilege and safe automation at AI and cloud scale.
    Find more information at https://www.ibm.com/think/topics/m2m-authentication
    Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

    Narrated by Anna Gutowska
    11 min
  • Runtime security for AI agents
    This episode of Techsplainers explores runtime security for AI agents and explains why autonomous systems require deeper protection once they begin operating live across enterprise environments. Building on earlier discussions of nonhuman identities, accountability and runtime risk, the episode focuses on the unique security challenges created when agents reason, decide, execute actions and adapt continuously.
    It examines the unpredictable action loop at the center of agentic AI, where seemingly simple tasks can expand into tool orchestration, dynamic data access, emergent decisions and multi-agent interactions. From there, the discussion looks at key runtime threats, including agents acting with excessive permissions, untrusted data shaping decisions and goal drift over time. The episode also introduces the A2AS framework and its five foundational control elements, then walks through four critical defense layers: perception, reasoning, action and memory. Along the way, listeners learn how semantic firewalls, dynamic credentials, out-of-band approvals and state protection can help keep agent behavior bounded and accountable. The result is a practical view of how runtime security helps organizations move from AI capability to trusted AI operations.
    Find more information at https://www.ibm.com/think/insights/agentic-ai-runtime-security
    Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

    Narrated by Anna Gutowska
    11 min
  • What is runtime security?
    This episode of Techsplainers explores runtime security and explains why it has become a critical response to the AI and nonhuman identity risks discussed earlier in the series. As applications, workloads, machine identities and AI agents operate live in production, organizations need security controls that can detect misuse, enforce boundaries and respond in real time.
    The episode follows how runtime security works and explains proactive measures such as process isolation, network segmentation, secure networking and identity-focused controls that help reduce the blast radius of compromise before an attack spreads. Special attention is given to cloud-native environments, where ephemeral workloads and complex microservices make predeployment inspection less reliable, and to generative AI, which has increased the speed of vulnerability discovery and exploitation. The episode also examines why runtime security is especially important for AI agents, whose nondeterministic behavior, tool-calling capabilities and autonomy create risks that often only appear during live execution.
    Find more information at https://www.ibm.com/think/topics/runtime-security
    Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

    Narrated by Anna Gutowska
    13 min
  • The AI accountability gap
    This episode of Techsplainers explores the AI accountability gap and why it has become a defining governance challenge for runtime security. As AI agents move beyond simple automation and begin executing business actions across enterprise systems, organizations must answer harder questions about authority, approval and responsibility.
    The episode explains how agentic AI changes the identity model by introducing continuous action, delegated authority, short-lived identities and decision-making across trust boundaries. It examines why traditional identity and access management approaches fall short when applied to autonomous agents, leading to over-privileged access, invisible delegation, weak runtime enforcement and poor incident reconstruction. Listeners learn why the real shift is from treating identity as a login problem to treating identity as an authority problem. The discussion also covers the need to connect identity, policy, secrets and runtime enforcement so organizations can prove who approved an action, under what conditions and for how long. Along the way, the episode looks at audit pressure, regulatory expectations and the practical security risks of deploying agents without clear accountability controls.
    Find more information at https://www.ibm.com/think/insights/accountability-gap-autonomous-ai
    Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

    Narrated by Anna Gutowska
    12 min
  • Security challenges of NHIs
    This episode of Techsplainers explores the security challenges surrounding non-human identities and why governing them effectively has become a critical runtime security issue. As machine identities multiply across cloud, on-premises, and hybrid environments, many organizations are struggling with poor visibility, inconsistent controls, and access paths that fall outside traditional identity oversight.
    The episode examines how ephemerality, elasticity, automation, and AI-driven systems are making NHI sprawl harder to track and easier to misuse. It explains how shadow access forms when service accounts, tokens, and automated workflows gain permissions without clear ownership or lifecycle controls. Listeners will also hear about the operational burden teams face when manually rotating credentials, coordinating across engineering and security, and managing identities that can remain active for long periods. From there, the discussion turns to what effective governance looks like: unified identity management, centralized secrets controls, automated lifecycle processes, real-time posture monitoring, and just-in-time access. Practical actions are included to help teams reduce risk quickly while improving visibility and accountability across machine-driven environments.
    Find more information at https://www.ibm.com/think/insights/non-human-identity-guide
    Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

    Narrated by Anna Gutowska
    11 min
  • What are vibe coding security risks?
    This episode of Techsplainers explores vibe coding security risks and examines what can happen when AI-generated code is trusted too quickly. Building on the earlier episodes in the series, it explains how vibe coding can speed up prototyping and development while also introducing security concerns that are easy to miss when code appears to work on first pass. The episode covers common risks such as insecure defaults, hardcoded credentials, weak validation, vulnerable dependencies, copied anti-patterns and overly broad permissions. It also looks at the human side of the issue, including how rapid AI-assisted coding can encourage teams to skip review or deploy code they do not fully understand. Along the way, the discussion connects these risks back to shift-left security, static code analysis, AI unit testing and AI debugging as part of a broader secure development practice. It concludes with practical guardrails like human code review, automated scanning, least privilege and clear governance for prompts and generated code.
    Find more information at https://www.ibm.com/think/insights/vibe-coding-security-risks Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast
    Narrated by Ian Smalley
    8 min
  • What is AI debugging?
    This episode of Techsplainers explores AI debugging and how artificial intelligence can assist developers in finding, understanding and fixing software problems. Building on earlier episodes about shift-left security, static code analysis and AI unit testing, understanding and fixing software problems. Building on earlier episodes about shift-left security, static code analysis and AI unit testing, it explains how debugging fits into the broader effort to catch and resolve issues earlier in the development lifecycle. The episode walks through how AI tools can analyze code, stack traces, logs and test failures to suggest likely causes, summarize complex information and propose draft fixes. It also distinguishes between using AI to debug traditional software and debugging AI-powered systems themselves, where problems may involve prompts, retrieval quality, inconsistent outputs or model behavior rather than a single broken line of code. Along the way, it highlights the benefits of faster triage, clearer context and guided fix suggestions, while also addressing the limits of pattern-based recommendations, missing business context and overreliance on generated answers. The episode closes by connecting AI debugging to the upcoming discussion of vibe coding security risks.
    Find more information at https://www.ibm.com/think/topics/ai-debugging Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast
    Narrated by Ian Smalley
    7 min
  • What is AI unit testing?
    This episode of Techsplainers explores AI unit testing and how artificial intelligence can support one of software development’s most common quality practices. Building on the earlier episodes about shift-left security and static code analysis, it explains how unit tests check small pieces of code in isolation and how AI can help generate test cases, identify edge conditions, improve coverage and maintain tests as code changes. The episode also clarifies an important distinction between using AI to help test traditional software and testing software components that themselves rely on AI models or probabilistic outputs. Along the way, it examines the practical benefits of faster test creation, broader scenario coverage and stronger support for continuous development workflows. It also addresses the limits of AI-generated tests, including shallow assertions, duplicated assumptions, brittle test suites and the continued need for human review. Finally, the episode places AI unit testing within a larger development strategy that includes code analysis, debugging and secure review practices.
    Find more information at https://www.ibm.com/think/topics/ai-unit-testing Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast
    Narrated by Ian Smalley
    7 min
  • What is static code analysis?
    This episode of Techsplainers explores static code analysis, a development practice that inspects source code without running the application. Building on the series opener about shift-left security, it explains how static analysis helps teams identify potential bugs, security flaws and code quality issues earlier in the software development lifecycle, when fixes are typically simpler and less costly. The episode walks through how these tools work by scanning code and less costly. The episode walks through how these tools work by scanning code against rules and models, and it clarifies the difference between simple rule checks and deeper data flow analysis. It also explains how static code analysis can reveal issues such as insecure input handling, hardcoded secrets, dead code and possible SQL injection risks. Along the way, the episode examines the benefits of consistent automated scanning, faster feedback for developers and better support for code review, while also addressing practical limitations like false positives and the fact that static analysis cannot detect every runtime problem. Finally, it places static code analysis within a broader strategy that also includes testing, debugging and secure review practices.
    Find more information at https://www.ibm.com/think/topics/static-code-analysis Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast
    Narrated by Ian Smalley
    8 min
  • What is shift-left security
    This episode of Techsplainers introduces shift-left security, the practice of moving security earlier in the software development lifecycle instead of treating it as a final review step. It explains how teams can build security into planning, coding, testing and delivery workflows so vulnerabilities are found when they are easier and less costly to fix. The episode walks through the logic behind the approach, clarifies how shift-left security fits modern development methods like CI/CD, and defines related concepts such as static application security testing and software composition analysis in plain language. It also explores the benefits of earlier detection, reduced remediation effort and stronger collaboration between development and security teams, while addressing common challenges like alert overload, false positives and skills gaps. Finally, it sets up the rest of the series by showing how topics like static code analysis, AI unit testing, AI debugging and AI-generated code risks connect back to this broader security approach.
    Find more information at https://www.ibm.com/think/topics/shift-left-security Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast
    Narrated by Ian Smalley
    8 min

About Techsplainers by IBM

From the publisher's feed

Introducing the Techsplainers by IBM podcast, your new podcast for quick, powerful takes on today’s most important AI and tech topics. Each episode brings you bite-sized learning designed to fit your day, whether you’re driving, exercising, or just curious for something new.