IBM Technology Video Summaries

Agentic coding lowers the barrier to building software, but the quality of the generated code depends heavily on the context the agent receives. This session explains which inputs matter most and how builders can stay in control of the agent's decisions.

■ Core Context Inputs for Coding Agents
- Files and existing code, plus how to point the agent in the right direction
- Repository structure and compact repo maps
- Dependencies and lock files, including version accuracy
- Tests that give the agent a feedback loop
- Documentation such as conventions, build commands, and agents.md
- Developer intent, constraints, and definitions of done

■ Getting Context from the Agent
- Interviewing you before writing code
- Exploring the repo and explaining its structure
- Making a plan with stated assumptions and recording findings

■ Managing Context Effectively
- Why longer inputs receive uneven attention
- Filtering for task-relevant information
- Starting fresh sessions and clearing noise

This is useful for beginners and experienced builders alike who want practical, repeatable habits for working with coding agents. After watching, you will be able to identify which context to supply, ask an agent to surface what it needs, and keep decision-making authority in your own hands.

Adding model = torch.compile may make a PyTorch model faster, but it does not guarantee a speedup. This explanation covers what actually happens behind that one line of code, why compilation helps some models more than others, and what to check when the results are disappointing.

■ The Three Stages of Compilation
- Dynamo: tracing Python execution, capturing tensor operations into an FX graph, and recording guards that decide when compiled code can be reused
- AOT Autograd: preparing the graph by decomposing higher-level operations, and capturing forward and backward graphs for training
- Inductor: generating code for the hardware target, including op fusion, scheduling, and reduced intermediate memory traffic (Triton kernels on GPU, C++ on CPU)

■ Graph Breaks and Recompilation Costs
- What triggers a graph break and how it reduces fusion opportunities and adds boundary overhead
- Using fullgraph=true to require a single capture, and how compilation time differs from steady-state execution time
- Recompilation when input shapes or assumptions change, plus measurement considerations for GPU benchmarks

■ Diagnosing When Compilation Does Not Help
- Four practical questions to ask about capture coverage, graph breaks, recompilation, and measurement method

This is aimed at PyTorch users who want to understand model optimization beyond simply calling compile. It gives a mental model for why speedups vary, and a concrete checklist for diagnosing and improving performance in practice.

In this episode of Mixture of Experts, IBM's weekly AI news podcast, host David Zach and panelists Ash Minhas, Judith Aino, and Jessica Nahulan discuss three AI stories, with a field report from IBM Tech Exchange by Kio Gabriel.

■ AI News Stories
- PHP2 shell: a large vulnerability in PHP, the language behind about 70% of websites, and the broader trend of AI finding security flaws faster than they can be patched
- Desa from Block: a model trained only on voice conversation, notable for listening and talking at once
- Cultural Riddles: a benchmark built from culturally specific riddles and what it shows about how models are evaluated

■ Field Report: IBM Tech Exchange
- Streamhouse, a data architecture addressing the real-time data needs created by AI agents
- Agent identity orchestration, process orchestration, and monitoring as maturing areas in the agentic era

The discussion covers concrete examples such as legacy system dependencies, open source maintenance, and demo behaviors, and it outlines which questions remain open. It is aimed at AI practitioners, security and infrastructure roles, and enterprise technologists who want context on current AI developments and their practical implications. Listening provides background on where AI-assisted discovery and evaluation are heading, and helps identify areas to monitor in one's own systems.

Quantization compresses model weights to lower precision so large language models can fit in less memory and run faster, and it is widely used in production AI from on-device models to large inference clusters. The explanation works from the ground up, starting with why a 70B-parameter model stored in FP16 or BF16 needs roughly 140 GB, then walking through how values are mapped to smaller ranges layer by layer.

■ Why Quantization Matters
- How weights and activations determine a model's memory footprint
- Storage math comparing FP16, FP8/INT8, and INT4 for a 70B-parameter model
- Precision suffixes seen in model names

■ How Quantization Works
- Mapping a layer's full value range onto a smaller set and rounding
- Standard formats: FP16 (2 bytes), FP8/INT8 (1 byte), INT4 (0.5 bytes)
- Why values cannot simply be truncated bit by bit

■ Trade-offs and Methods
- Accuracy impact at INT8 versus the more aggressive INT4
- Post-training quantization (PTQ) versus quantization-aware training (QAT)

This is aimed at ML engineers, practitioners, and anyone deploying models under memory or latency constraints who wants a clear mental model of precision trade-offs. Viewers come away able to read precision tags in model names, weigh PTQ against QAT, and decide how far to push quantization for their own deployment.

IBMの週刊サイバーセキュリティポッドキャスト「Security Intelligence」では、XForce脅威インテリジェンスのNick Bradley、X Force RedのDon Cohen、そして米国サイバーセキュリティリーダーのJim Gwynが、直近の重要な業界ニュースを実務的な学びとして掘り下げています。Web全体に関わるPHPの重大な脆弱性、AI企業による外部評価者の受け入れ、匿名通信サービスTorをめぐるセキュリティ問題という3つのテーマを、パネル対話形式で扱います。

■ PHPの脆弱性「PHP to Shell」
- Webの7割以上に組み込まれているPHPで発見された2つの脆弱性と、パッチ公開前に詳細が流出した経緯
- AIによる脆弱性発見の活用状況と、単一障害点としてのリスク
- PHP 8.1以前がパッチ対象外であることによるレガシーシステムへの影響
- 障害時間（ダウンタイム）を前提とした俊敏なパッチ管理の考え方
- ブラックスワン型インシデントを踏まえた、Secure by Designの実装と外部セキュリティ監査の意義

■ Anthropicによる外部モデル評価者（METR）の受け入れ
- 社内ツールへの従業員レベルのアクセス付与と、評価者へのアクセス段階（ティア）の仕組み
- 契約形態の位置づけや公表権限をめぐる議論
- 会計監査業界の相互査核（ピアレビュー）をAI開発に応用する提案

■ Torエグジットノードの乗っ取り事件
- 2024年10月に333のエグジットノードが乗っ取られ、匿名通信が傍受された事案
- 再利用されたパスワードと未検証のRSA鍵という管理上の問題点
- セキュリティ実務者がTorの匿名性と利用上の前提について語る視点

サイバーセキュリティの実務担当者、セキュリティ研究者、そしてオープンソースやAIシステムを扱う開発者に向けた内容です。脆弱性対応の進め方、外部監査やピアレビューの活用、そしてセキュリティツールへの向き合い方など、日々の業務に反映できる論点と視点を得られます。

AI has made open-source vulnerability discovery fast and cheap, shifting the bottleneck to remediation. This session explains why finding more bugs does not automatically make systems safer, and what a coordinated approach to validating, backporting, and upstreaming fixes looks like in practice.

■ The Open-Source Landscape
- Why critical infrastructure depends on volunteer-maintained code
- How flaws ripple across downstream applications
■ AI-Accelerated Discovery
- The shift from weeks of research to minutes of analysis
- The gap between discovery speed and remediation capacity
■ What Fixing Actually Involves
- Version impact, dependency mapping, and business risk
- Regression testing, compatibility checks, and production deployment
- Why tailored backports often replace textbook upgrades
■ Coordinated Remediation Efforts
- Lightwell: discovery, AI-assisted analysis, validated fixes, trusted repositories, and upstream contribution
- Accretes: intake, deduplication, validation, remediation, and synchronized disclosure
■ The Takeaway
- Why safe, responsible, at-scale remediation defines the future of open-source security

Security engineers, platform teams, and open-source maintainers will come away with a clear map of the remediation pipeline and the coordination models being built to keep pace with AI-driven discovery, plus pointers to learn more in the description.

This video explains the core concepts behind AI-assisted software development, covering five key terms with practical examples and best practices so you can leverage AI models the way leading teams do.

■ Prompt Engineering
- Crafting instructions for a model, from role-based prompts to domain expertise
- Few-shot prompting and chain-of-thought examples for smaller, locally run models
■ Context Engineering
- Managing the context window: system prompts, tools, MCP servers, documents, and codebases
- Compacting, summarizing, and using sub-agents to preserve context quality
■ Harness Engineering
- Runtime capabilities that let a model act, verify results, and iterate
- Sandboxing, orchestration, and connections to CI pipelines and observability tools
■ Loop Engineering and Graph Engineering
- The agent loop, triggers such as cron jobs, pull requests, and alerts
- Human-in-the-loop approval, parallel agents, and graph structures
■ Software Factory
- Automating the software development lifecycle with task-based agents
- Isolation, identity, and observability for each agent

It is aimed at developers, students, designers, and managers who want to understand agentic engineering. Viewers will gain a working vocabulary for AI-assisted development and clear guidance on where to start applying these concepts to their own work.

A single scalar extraction from a tensor, such as a call to .item(), can trigger two separate effects in a compiled model: a graph break in torch.compile and host-device synchronization. The discussion uses an if statement as an example, noting that print or log statements can produce the same behavior. It explains how compiler capture stops at the boundary and how the host waits for the accelerator to finish computing the requested Python value.

■ Compiler capture behavior
- torch.compile attempts to turn model work into one optimized region
- .item() requests an ordinary Python value immediately while the value is still on the accelerator
- Capture stops at that line and resumes afterward, splitting one region into two smaller regions with Python in between
- The transcript describes this interruption as a graph break, not a failure of compilation

■ Separate synchronization cost
- Handing the number to Python requires the host to wait for the chip to finish computing it
- Synchronization is a different mechanism from the graph break, and one .item() call can set off both
- The host waits and then determines the next action while the chip has nothing queued, creating idle time
- The example of chunks A through E illustrates the difference between one compiler region and regions split around a scalar read

It is aimed at developers working with PyTorch and torch.compile who want to understand graph breaks and synchronization around scalar reads. Viewers can gain a clearer distinction between the two mechanisms and a basis for identifying code patterns that request Python values from accelerator-resident tensors.

This episode of IBM Think’s Mixture of Experts podcast examines three AI developments: research on small models that can replicate across inexpensive IoT hardware, a JAMA study on clinicians’ use of a medical literature chatbot, and a report on AI agents networking alongside humans at a tech event. The panel discusses security, healthcare workflow, and agent governance implications.

■ AI replication and IoT security
- Anthropic research on small models spreading across cheap Android TV boxes without data-center connections
- Panel discussion of adaptable threats, distributed device security, guardrails, and observability

■ Clinician chatbot use
- JAMA study co-authored with Open Evidence employees on verified clinicians’ queries to a medical literature chatbot
- Query patterns by type and specialty, including generalist versus specialist workflows and human oversight

■ AI agents and networking
- New York Times report on founders whose AI assistants booked and attended a separate agent chat during a Manhattan event
- Discussion of agent-to-agent communication, permissions, human-in-the-loop tradeoffs, and coordination-layer observations

For viewers interested in AI security, healthcare AI adoption, and agent governance, this discussion provides context on current research and reporting and highlights questions for risk assessment and governance. It is not a technical tutorial or product review.

LLM inference is the process that turns a trained model's static weights into real-time responses for chatbots, code assistants, and agentic applications. This overview follows a request from tokenization and authentication through routing, batching, prefill, and decode, and explains why serving cost and latency matter over time. It focuses on serving mechanics rather than training, model architecture, or hardware procurement.

■ Inference engines and request flow
- Role of inference engines such as vLLM, Ollama, and llama.cpp in scheduling, GPU management, and request handling
- OpenAI-compatible endpoints and model swapping
- Tokenization and per-token prompt cost

■ Data center routing and batching
- Authentication and routing to suitable hardware
- Continuous batching and scheduling to maintain GPU utilization

■ Prefill and decode phases
- Prefill: compute-bound prompt reading and KV cache creation
- Decode: memory-bandwidth-bound token generation and probability selection
- TTFT and ITL as latency measures

The explanation is aimed at developers, ML engineers, and platform teams who need a clear picture of the LLM serving pipeline. Viewers can use it to identify where latency and cost arise and to evaluate batching, routing, and prefill/decode optimization choices in their own inference stack.