The operational realities of massive context lengths are increasingly forcing deep architectural corrections. From subtle state-restoration bugs surfacing in hybrid attention runtimes to open-source developers dissecting precisely how auxiliary lookup tables hide gigabytes of true model weight, deployment infrastructure is rapidly maturing to catch edge cases that initial benchmarks missed on The Bandwidth-Bound.
An issue filed in the xcena-dev/maru repository on Tuesday, November 3, 2026, details a critical bug in `MaruWorkerConnector._gather_states` where recurrent states for Mamba and Gated DeltaNet layers fail to persist unless a scheduler step aligns exactly with a chunk boundary. When prefill kernels write states mid-step—such as FlashInfer's GDN backend on vLLM 0.32.1rc0+ or Mamba2 layers in vLLM 0.32.0—the engine fails to preserve state checkpoints for single-step prefilled prompts. Subsequent requests sharing these prompt prefixes encounter complete cache misses, impacting Gated DeltaNet models like Qwen3.5 and Qwen3-Next as well as Mamba2 hybrids including Nemotron-H, Granite-4.0-H, Falcon-H1, and Zamba2. Workarounds currently require switching the GDN prefill backend to Triton.
Why it matters
Prefix caching is essential for maintaining interactive speeds in multi-turn sub-agent interactions that reuse long prompt contexts. When boundary state offloading fails silently, the serving framework discards the recurrent state, forcing expensive full re-prefills on subsequent turns. Identifying backend-specific kernel mismatches allows practitioners to apply targeted configuration overrides like switching to Triton backends rather than assuming model weights or prompts are flawed.
Repository maintainers point out that the issue arises from conflicting assumptions between vLLM's internal step scheduler and kernel-level state writes during prefill. System developers emphasize that as hybrid attention architectures proliferate, serving engines must establish standardized state-passing interfaces across Triton and FlashInfer execution pipelines.
An engineering report submitted to the `sglang-inference` repository (issue #37) on Monday, November 2, 2026, documents that prefilling a prompt tail over a restored recurrent state alters generation probability distributions in hybrid models like Nemotron-omni and Qwen3.8. Evaluation using first-token top-5 logprob deltas demonstrated that while single-turn full hits or decoding a single token from a restored state match baseline outputs, prefilling additional tokens onto a restored state causes logprob divergence up to 4.4 nats. Tests across CUDA and ROCm stacks confirm this divergence stems from the mathematical structure of chunked Gated DeltaNet and Mamba2 prefill kernels when initialized with non-zero recurrent states.
Why it matters
State restoration and prefix caching are foundational optimizations for serving hybrid linear-attention architectures efficiently. Discovering that tail-prefilling over non-zero initial states shifts token output distributions reveals a subtle non-determinism risk in multi-turn agent workflows. Local-LLM developers and serving engineers must account for state drift when designing multi-step conversation caches or verification loops.
The issue author emphasizes that non-zero state initialization in chunked recurrence creates numerical discrepancies that do not appear during standard zero-state prefill. Framework developers argue that mitigating this requires refining chunked state accumulation math in Triton and FlashInfer backends to ensure bit-exact state continuation.
JetBrains released Mellum2.1-12B-A2.5B-Thinking-MTP on Tuesday, November 3, 2026. The 12B parameter Mixture-of-Experts model activates 2.5B parameters per token across a 131K token context window and includes a built-in Multi-Token Prediction (MTP) head natively within its safetensors architecture. Following extensive reinforcement learning in repository environments equipped with shell and file tools, the model scored 47.0% on SWE-bench Verified (up from 2.0% in the prior release). It delivers 1.4–1.8x speculative decoding speedups on CUDA via vLLM and llama.cpp while consuming 8.3 GB of memory under Q4 quantization on Apple Silicon.
Why it matters
Embedding an MTP head directly inside an open-weight MoE architecture enables native speculative decoding without requiring a separate draft model checkpoint or complex multi-engine routing. For local-LLM practitioners, pairing 2.5B active parameters with a small memory footprint makes real-time repository editing feasible on consumer hardware. The jump in benchmark performance underscores the effectiveness of execution-grounded RL post-training for lightweight coding models.
JetBrains maintainers emphasize that integrating MTP directly into the primary model checkpoint simplifies local inference deployments and guarantees draft alignment. Open-source practitioners note that fully leveraging the native MTP head requires updated execution kernel support in engines like llama.cpp and vLLM.
Researchers from MIT CSAIL published code and experimental results on Monday, November 2, 2026, demonstrating 'Weight-Space Programming' with GPT-6 Astra. The technique allows language models to read, interpret, and modify raw binary weights of smaller neural networks directly without backpropagation or gradient descent. In one experiment, the authors edited 0.016% of Qwen3.5-0.8B's weights to resolve reasoning loops, increasing its MATH-500 score from 7.9% to 48.1%. On Tuesday, November 3, independent experiments on Gemma-3-270M confirmed that pushing along single activation directions in layer 8 reduced sentence repetition from 32% to 2%, while noting that distributed translation errors in a 4B model resisted weight-level edits and required prompt-level context.
Why it matters
Direct weight-space manipulation provides a novel paradigm for fixing localized structural failure modes without running full fine-tuning loops or storing large adapter weights. For interpretability researchers, these findings establish a clear functional boundary: isolated behavioral loops map to specific rank-1 directions that can be surgically edited out, whereas semantic knowledge errors remain distributed across multi-layer activation spaces. Versioning these weight changes as lightweight delta files offers a practical method for sharing model patches.
The MIT CSAIL authors argue that direct weight manipulation bypasses traditional optimizer overhead and enables automated model debugging via language reasoning. Interpretability researchers urge caution, noting that while single-direction edits successfully eliminate repetitive loops, altering raw weights risks introducing unmonitored out-of-distribution performance degradation.
Research published on Tuesday, November 3, 2026, evaluated Sparse Autoencoder (SAE) features across Gemma 4 E4B-IT and Gemma-2-2B, uncovering a structural dissociation between value-reading features and causal steering levers. The authors demonstrated that SAE features tracking numeric personality tags and symbolic control values are nearly orthogonal to dense Contrastive Activation Addition (CAA) directions. Steering along these top-activating value features produced zero behavioral change in model outputs, whereas disjoint affect and rumination features successfully actuated traits. This dissociation did not extend to semantic concepts like safety refusal, where tracking features retained causal control.
Why it matters
Mechanistic interpretability toolkits often assume that high-activating SAE features function automatically as causal intervention levers. Proving that correlation and causation diverge for numeric and formatting controls demonstrates that feature extraction must be paired with independent intervention testing. Probing toolkits must validate steering vectors causally before deploying them for runtime activation control.
The study authors emphasize that researchers cannot rely on passive feature detection alone to build intervention tools. Interpretability practitioners note that while semantic features retain causal alignment, formatting and control tags require dense activation addition methods.
Building on the sub-agent effort controls introduced in version 2.1.316, Anthropic released Claude Code version 2.1.317 alongside Python Agent SDK version 0.2.177 on Tuesday, November 3, 2026. The update introduces an `onFailure: 'block'` parameter for Agent SDK hook callbacks, forcing the runtime to halt agent tool execution if custom governance or security callbacks throw exceptions. The release adds new OpenTelemetry spans (`anthropic.plan`, `anthropic.seat_type`), explicit prompts before sending emails, and a cost analytics endpoint at `GET /v1/organizations/analytics/cost`. The Python SDK enforces strict version alignment, raising a `CLIConnectionError` if paired with an outdated CLI.
Why it matters
Previous agent hook implementations defaulted to non-blocking behavior when runtime exceptions occurred, allowing automated tools to execute unverified actions if a validation script crashed. Enforcing fail-closed execution guarantees that security boundaries remain intact during unexpected tool failures. For developers building unattended agent loops, combining strict exit codes with expanded OpenTelemetry metrics simplifies debugging and provides clear audit trails across multi-agent sessions.
Anthropic engineers frame the update as a necessary hardening step for enterprise sub-agent deployments where unhandled exceptions must not bypass local sandboxes. Independent developers note that strict version lock-in between the Python SDK and local CLI binaries increases maintenance overhead for custom containerized agent runners.
Anthropic released FlashProve on Monday, November 2, 2026, an open-source cryptographic system using zkSNARKs to generate zero-knowledge proofs of LLM execution without exposing model weights. Evaluated on a 400B-parameter Llama 4 Maverick MoE model running 4-bit quantization on a single H100 GPU, the system generates proofs at approximately 110 tokens per second with an average proof size of 19 MB per 1,024-token request. The open-source repository includes protocol documentation and top-level formal verification statements written in the Lean programming language.
Why it matters
Verifiable inference solves a fundamental trust challenge in cloud and agentic deployments by providing mathematical proof that a prompt was processed by a specific model checkpoint without execution swapping or silent quantization downgrades. For systems engineers, integrating Lean-verified zkSNARK circuits into model serving pipelines provides auditability for regulated workflows without incurring prohibitive latency penalties.
Anthropic researchers frame FlashProve as a foundational tool for cryptographically transparent AI deployment and automated model auditing. Cryptographic engineers point out that while a 19 MB proof size is manageable for batched API interactions, transmitting proof payloads across high-concurrency local agent loops introduces nontrivial network bandwidth considerations.
Anthropic launched message threads in public beta for the Claude API on Monday, November 2, 2026, using the `message-threads-2026-08-12` header. The feature allows developers to submit full conversation context once and pass subsequent turns using append-only requests referencing a previous response ID. Benchmark traces show a 30-turn agent session reduces uploaded conversation payload size from over 1.1 million tokens to 53,000 tokens, yielding a ~35% reduction in pre-reply wait times for 500K to 1M token contexts. System prompts and tool definitions are locked to the initial thread fingerprint and cannot be modified mid-session. Server-side thread state is encrypted and expires five minutes after inactivity, requiring clients to maintain local history for replay fallback upon receiving 404 or 400 error codes.
Why it matters
Repeatedly transmitting large context histories during iterative tool-use loops creates severe network latency and bandwidth overhead. Server-side message threads optimize the transport layer for long-running agent interactions without modifying API pricing models. However, the five-minute memory expiry window and strict fingerprint immutability require agent developers to maintain robust local state management rather than treating the API as persistent storage.
Anthropic technical documentation frames the beta as a targeted transport optimization that significantly slashes time-to-first-token in deep coding loops. Independent developers emphasize that because system prompts and tools cannot be altered mid-thread, dynamic agent frameworks must implement explicit fallback paths to handle mid-session prompt modifications.
A paper published on Monday, November 2, 2026, introduced SessionFarmer, an automated framework that converts developer-agent conversational logs ("vibe coding") into hermetic, executable software engineering benchmarks. The pipeline parses commit histories and chat traces to establish episode boundaries, builds isolated Docker execution containers, and auto-authors evaluation rubrics and unit tests. The authors released CropChat (242 tasks across 61 repositories in 14 languages) alongside CropEnterprise. Audits by enterprise developers confirmed high accuracy in automated boundary detection, while test refinement improved evaluation accuracy by 7 to 9 percentage points.
Why it matters
Static coding benchmarks suffer from data contamination and fail to capture multi-turn human-agent interaction patterns. SessionFarmer automates the creation of repository-grounded evaluation suites from real developer sessions, providing a scalable method for building domain-specific benchmarks to test open-weight agent harnesses.
The researchers emphasize that mining real developer logs produces benchmarks that reflect genuine software engineering challenges rather than synthetic puzzles. Benchmark maintainers point out that ensuring hermetic container isolation for complex multi-language repositories requires continuous environment maintenance.
A research paper released on Monday, November 2, 2026, introduced CR-Bench, an evaluation framework that recasts software engineering issues into full-repository pull request code review tasks. Containing 584 instances (including a 174-instance CR-Bench-Verified subset), the benchmark pairs pull requests with known defects to measure actionable bug detection. Evaluating eight code review agents across four foundation backbones revealed that top agent configurations achieved a Known-Defect Detection Rate (KDDR) of only ~33%, while Gemini Code Assist scored 8.1%.
Why it matters
Evaluating AI code review tools using simple text similarity or synthetic diffs rewards surface-level commentary while missing critical bugs. CR-Bench provides a grounded methodology to quantify whether automated review agents catch functional defects across full codebases before patches are merged.
The benchmark authors state that current review agents struggle with tasks requiring multi-file context and deep architectural understanding. Enterprise developers observe that low defect detection rates highlight the need for better repository indexing and static analysis integration in review harnesses.
A patch set for llama.cpp named tandem.cpp was released on Monday, November 2, 2026, optimizing inference for Mixture-of-Experts models that exceed available VRAM. Benchmarked on an Intel i5-12400F with a single RTX 4090 (24GB VRAM) and 64GB DDR5 host RAM, tandem.cpp accelerated Qwen3.8-Flash-Next generation from 29.8 to 97.3 tokens per second (a 3.27x speedup). The system caches frequently activated experts in VRAM while keeping cold experts in host RAM, using asynchronous CPU execution and PCIe streaming to prevent GPU stalls.
Why it matters
Offloading large MoE architectures to CPU memory traditionally results in severe PCIe transfer bottlenecks that stall generation. By dynamically tracking expert usage frequencies and overlapping CPU expert processing with GPU execution, tandem.cpp allows local practitioners to run massive open-weight MoE models at interactive speeds on consumer desktop hardware.
The patch author asserts that intelligent expert caching renders static layer-wise VRAM offloading obsolete for sparse architectures. Local inference maintainers observe that performance gains depend heavily on host RAM bandwidth and CPU single-core speed.
Documentation published on Monday, November 2, 2026, introduced `kvhandoff`, an out-of-tree vLLM plugin that disaggregates prompt prefilling and autoregressive decoding across heterogeneous hardware. The framework routes compute-bound prefill passes to NVIDIA GPUs before streaming calculated KV cache tensors over local networks to Apple Silicon Macs running EXO for memory-bound decoding. Benchmarks on Llama-3.3-70B and DeepSeek V4 Flash show significant reductions in time-to-first-token compared to standalone Mac execution.
Why it matters
Disaggregating inference across heterogeneous hardware combines the high FP16 compute density of datacenter GPUs for prefill with the high unified memory bandwidth of Mac Studio hardware for decoding. For local practitioners managing hybrid clusters, `kvhandoff` offers an open-source mechanism to optimize inference pipelines without purchasing expensive multi-GPU setups.
Plugin developers highlight that decoupling prefill and decode across hardware boundaries maximizes the unique strengths of both CUDA and Metal execution architectures. System integrators note that network bandwidth between nodes remains the primary latency bottleneck during high-concurrency KV cache handoffs.
Engineers merged PR #56492 into vLLM on Monday, November 2, 2026, leveraging the CUDA virtual memory API to reserve KV cache address space and map physical pages dynamically after CUDA graph capture. By deferring physical mapping until after graph capture and warmup steps complete, the engine recovers previously lost allocation headroom, adding 4.9 GiB to 11.3 GiB of usable KV cache per GPU across GB200 hardware. Empirical measurements demonstrate a 7.5% increase in available KV tokens for Qwen3-8B and a 4.1% increase for DeepSeek-V4-Flash. Engine initialization latency dropped between 21% and 34%, cutting Qwen3-235B-A22B-FP8 startup times under the V2 runner from 76.1 seconds down to 50.1 seconds.
Why it matters
Reserving VRAM statically prior to CUDA graph capture forced serving engines to leave gigabytes of safety margin on the table to avoid out-of-memory faults during warmup execution. Dynamic physical memory mapping directly reclaims this memory bandwidth and capacity without requiring model-specific configuration tweaks. For local-LLM practitioners and systems developers, this optimization increases concurrent request density during heavy agentic decoding runs. The substantial reduction in initialization delay also improves iteration speed when restarting local serving daemons during harness testing.
Maintaining maintainers noted that binding physical allocation to post-capture address reservations eliminates inaccurate static estimates across diverse model families. Conversely, low-level runtime engineers highlight that relying heavily on advanced CUDA virtual memory APIs increases hardware platform dependencies and requires careful validation when backporting changes to ROCm or non-NVIDIA execution backends.
A paper published on Tuesday, November 3, 2026, introduced LoopVQ, a vector quantization scheme tailored for looped transformer architectures that codes channels across loop steps jointly to reduce KV cache footprints to 0.25–0.5 bits per element. By exploiting channel redundancy along the recurrent loop axis and applying loop-aware fine-tuning, LoopVQ preserves generation quality on long chain-of-thought reasoning tasks. Integrated into SGLang via custom Triton kernels, the method cut decode latency nearly in half at 32K context and increased serving throughput up to 6.1x on Ouro baselines.
Why it matters
Looped transformers reduce model weight footprints by reusing layer parameters across iterations, but their memory savings are typically erased by linear KV cache growth during long-context decoding. LoopVQ resolves this bottleneck by converting temporal loop repetition into a compression vector, proving that architectural loop structures can enable sub-1-bit state representation. This allows local-LLM practitioners to scale context lengths on single-GPU hardware without running out of VRAM.
The authors highlight that joint channel coding across loop steps captures temporal correlations that standard per-layer quantizers miss entirely. Systems maintainers caution that deploying LoopVQ requires custom Triton kernel integration, limiting immediate adoption to supported engines like SGLang.
Verified across 2 sources:
alphaXiv(Nov 3) · GitHub(Nov 3)
Click Copy for AI above, then paste the prompt
into your favorite AI chatbot — ChatGPT, Claude, Gemini, or
Perplexity all work well.
Expanding the quantization ecosystem for DeepSeek-V4.1-Flash-1017 beyond the Unsloth GGUF builds we recently tracked, a 1.55 bits-per-weight EXL3 quantization build emerged on Monday, November 2, 2026, targeting a 117.2 GB backbone footprint. Built specifically for ExLlamaV3 on GPU-resident setups, the release achieved a 70.27% average across eight HMMT benchmarks and outperformed alternative quants on five of eight AIME tasks while supporting context windows up to 262K tokens. However, unlike cross-platform GGUF and GSQ-RCO builds, EXL3 remains restricted to native GPU runtimes and lacks CPU or Metal execution backends.
Why it matters
Ultra-low bitwidth quantization for 700B+ Mixture-of-Experts models is bifurcating into GPU-focused formats like EXL3 and cross-platform formats like GGUF. For local practitioners operating single-node GPU workstations, EXL3 delivers high token generation speeds at 1.55 bpw. However, developers deploying across heterogeneous Apple Silicon or CPU setups must balance raw GPU throughput gains against backend flexibility.
ExLlamaV3 enthusiasts highlight that EXL3 maximizes GPU memory bandwidth utilization for ultra-low-bit MoEs. Cross-platform maintainers point out that GGUF and GSQ-RCO remain superior for mixed system RAM and Metal offloading environments.
We previously noted that the DeepSeek-V4.1-Flash architecture includes a 196B parameter Engram lookup table alongside its 552B MoE layers. An architectural audit of ISTA-DASLab's 2-bit GGUF releases published on Monday, November 2, 2026, revealed that advertised '2-bit backbone' specifications exclude this auxiliary Engram table, which is actually stored at 4.5 bits (IQ4_NL). When accounting for all tensors, the true storage footprint of the IQ2_XXS build is 2.66 bits per weight rather than 2.00 bits. Tensor header inspections show that dense paths receive higher bit precision (~5.9 bits average) while routed experts are heavily compressed using mixtures of IQ1_M and IQ2 formats.
Why it matters
Evaluating ultra-low-bit MoE checkpoints requires inspecting full tensor allocation tables rather than relying on headline backbone bit-rates. Auxiliary lookup tables like Engram significantly increase system memory requirements during local offloading. Auditing complete GGUF layouts ensures accurate hardware sizing and prevents memory allocation failures on VRAM-constrained setups.
The analysis authors argue that transparent byte accounting is essential to prevent practitioners from miscalculating hardware requirements. Quantization maintainers note that protecting non-routed dense layers with higher precision is necessary to maintain baseline reasoning quality.
A developer demonstrated running eight concurrent coding agents with 250K-token context windows on a dual NVIDIA RTX 3090 workstation on Monday, November 2, 2026. The implementation uses custom Triton kernels to maintain a rank-64 key sketch on the GPU while offloading the full INT4-quantized KV cache to 128GB of host system RAM. Patches applied to HyperQwen (a vLLM fork) allow the serving engine to alternate dynamically between dense and sparse attention steps based on key sketch scores, achieving aggregate decoding speeds of 545 to 790 tokens per second.
Why it matters
Storing full attention KV caches in VRAM severely limits context length and concurrency for local agent execution. By maintaining a compact key sketch in GPU memory and fetching only hot key-value blocks from host DRAM via Triton kernels, local practitioners can execute deep long-context agent loops on consumer hardware. This architecture bypasses high-VRAM enterprise GPU requirements for concurrent multi-agent workloads.
The project developer highlights that dynamic switching between dense and sparse attention passes maintains retrieval accuracy while slashing VRAM footprint. Systems engineers note that relying on host DRAM transfers increases PCIe bus utilization, making throughput sensitive to motherboard topology.
Researchers from Tsinghua University and Zhipu AI introduced FlatCake on Monday, November 2, 2026, a KV cache serving system that eliminates traditional tiered hierarchies (GPU HBM to DRAM to NVMe) in favor of a flat address space treating DRAM and SSD as peer media. Evaluated against Mooncake using production traces from DeepSeek-V4-Flash on NVIDIA B200 GPUs, FlatCake achieved a 94% cache hit rate (compared to 64% for Mooncake) and improved mean time-to-first-token (TTFT) and throughput by 1.6x. The system uses immutable write-once blocks assigned at allocation time to eliminate staging contention and leverage GPUDirect Storage directly into GPU memory.
Why it matters
Multi-tier cache systems assume strong temporal locality that agentic tool-use patterns frequently violate, causing DRAM staging contention and read amplification. FlatCake's write-once design maps session data directly across host DRAM and NVMe drives, providing a blueprint for serving engines like SGLang and vLLM handling long-duration agent sessions.
The Tsinghua research team demonstrates that treating SSDs as peer memory media via GPUDirect eliminates staging bottlenecks in long-context serving. Infrastructure engineers caution that implementing FlatCake requires NVMe hardware with direct peer-to-peer DMA support.
China’s Ministry of Commerce and Ministry of Science and Technology published draft Announcement No. 48 on Monday, November 2, 2026 (following initial disclosures on October 16), proposing export controls across 23 AI categories. The framework mandates formal government approval for exporting model weights, source code, and training methodologies for models exceeding 2 trillion parameters, 10^26 training FLOPs, or a top-10 global capability ranking. The public comment period closes November 15, 2026. The draft explicitly carves out exemptions for public open-source model weights, API services, and instant-approval open-source releases.
Why it matters
Establishing formal export licensing for multi-trillion parameter checkpoints creates regulatory boundaries around frontier model releases. Explicitly exempting open-source releases and API endpoints ensures that existing open-weight downloads remain accessible to international developers, while setting clear compliance requirements for enterprise-scale weight distributions.
Legal analysts emphasize that carving out explicit exemptions for open-source weights preserves international ecosystem participation for Chinese labs. Policy researchers observe that setting parameter and FLOP thresholds establishes clear boundaries for state oversight of frontier AI artifacts.
Recurrent State Initialization Exposes Hidden Divergence in Hybrid Caching As serving engines integrate hybrid Gated DeltaNet and Mamba-2 architectures, state restoration over non-zero initial states and boundary offloading bugs are exposing output distribution drift during tail prefilling.
Language-Guided Weight Editing Bypasses Gradient Descent Probing experiments show that frontier models can directly inspect and edit binary weights in smaller networks to resolve specific loops and bugs, introducing a parameter-space alternative to QLoRA fine-tuning.
Fail-Closed Execution Protocols Standardize Agent Governance Tooling frameworks and Agent SDKs are shifting from non-blocking warning loops to strict fail-closed exception hooks and Lean-verified proofs to guarantee execution boundaries.
Sub-1-Bit Vector Quantization Tackles Recurrent Memory Growth Novel quantization schemes like LoopVQ and RoLaQ exploit cross-step channel correlation and joint subspace rotations to compress KV and recurrent states down to sub-1-bit levels.
Heterogeneous KV Handoffs Bridge Disaggregated Workstation Clusters Serving frameworks are adopting flat memory abstractions and cross-vendor KV offloading to split compute-bound prefill on datacenter GPUs from memory-bound decode on high-bandwidth unified memory.
What to Expect
2026-11-15—Public comment period closes for China's MOFCOM Draft Announcement No. 48 regarding frontier model export controls.
2027-06-30—Expected enterprise sampling timeframe for Qualcomm's Dragonfly AI250 High Bandwidth Compute accelerator platform.
How We Built This Briefing
Every story, researched.
Every story verified across multiple sources before publication.
🔍
Scanned
Across multiple search engines and news databases
503
📖
Read in full
Every article opened, read, and evaluated
129
⭐
Published today
Ranked by importance and verified across sources
19
— The Bandwidth-Bound
🎙 Listen as a podcast
Subscribe in your favorite podcast app to get each new briefing delivered automatically as audio.
Apple Podcasts
Library tab → ••• menu → Follow a Show by URL → paste