When experimental recurrence models and aggressive quantization hit production serving engines, the fault lines are usually found at the lowest levels of state management. Today on The Bandwidth-Bound, we're looking at how SGLang is silently dropping hybrid context trackers under load, alongside deep recalibrations for low-bit GGUF divergence.
Following the SGLang memory provisioning guidelines for Qwen3.8-27B we covered over the weekend, an issue filed Monday against SGLang (v0.5.16) detailed severe state tracking corruption on fine-tuned Qwen3.6-35B-A3B hybrid instances. When serving workloads pair the `--enable-mixed-chunk` flag with the default mamba radix cache strategy (`--mamba-radix-cache-strategy extra_buffer`), the engine's `merge_batch` function drops tracking tensors when mixing prefills with running decodes. Consequently, subsequent extend steps skip writing state updates to their designated ping-pong slots while still donating those un-updated slots to the shared radix tree, serving stale cache state to subsequent requests.
Why it matters
For local-LLM practitioners and systems maintainers deploying linear-attention and SSM hybrids, this bug demonstrates how concurrency optimizations designed for traditional Transformers silently break stateful recurrent backbones. Rather than triggering explicit runtime crashes or CUDA out-of-memory errors, the state drop manifests as subtle classification degradation and false positives under concurrent load. Resolving batch-merging logic in radix trees is critical before hybrid models can match the serving stability of standard attention architectures.
SGLang issue contributors noted that the bug is localized to the interaction between batch merging and extra-buffer allocation for SSM states. Maintainers recommended disabling mixed-chunk prefills on Gated DeltaNet backbones until tracking tensors are explicitly passed through the batch merge pipeline.
A paper published on arXiv on Friday, September 11, 2026, presented OneLA, a decoding framework tailored for linear attention models like Gated DeltaNet under large-beam generation workloads. OneLA eliminates the standard requirement of duplicating full recurrent matrices for every beam by maintaining a single shared post-prefill state per request, paired with compact append-only Gated DeltaNet Transition Records (GTRs) for divergent candidate paths. Projection replay evaluates vector projections directly from the ancestral GTR chain supported by custom fused GPU kernels, yielding a 1.54x to 2.46x end-to-end decode speedup on a 0.8B Qwen model.
Why it matters
Beam search on recurrent and linear attention architectures historically suffered from a severe memory capacity tax, as every active beam required replicating the full state matrix. By exploiting the structural reality that candidate beams share an identical prompt history and only diverge along short token suffixes, OneLA converts a memory-bandwidth-bound state duplication overhead into a compute-efficient replay pass. This mechanism allows local-LLM tools and agent search loops to execute wider beam searches without exhausting GPU VRAM.
The authors emphasize that projection replay circumvents full matrix materialization without sacrificing numerical exactness. Independent benchmarkers note that while the speedups are substantial for wide beams, the performance gains diminish for shallow beam depths or short generation targets where memory bandwidth is not the primary bottleneck.
Researchers published an arXiv preprint on Monday, September 14, 2026, introducing Mixture of Memory Embeddings (MoME), a conditional memory layer that replaces static single-row token embeddings with a mixture of M memory slots selected by a learned gate over hidden states. Tested across nanochat, Llama-3/MobileLLM, and Qwen3 backbones, MoME improved perplexity and downstream recall under iso-parameter and iso-FLOP pretraining constraints. Qualitative probing revealed that the gating mechanism routes polysemous tokens to distinct memory slots depending on contextual sense.
Why it matters
Traditional embedding tables force a single vector to represent every semantic sense of a token, creating an immediate representation bottleneck at the input layer. MoME provides a compute-efficient mechanism to scale static parameter capacity without increasing dense FLOPs during forward passes. For open-weight practitioners interested in interpretability, MoME's routing gates offer an explicit, inspectable trace showing how context shifts token representation prior to transformer layers.
The authors highlight that MoME outperforms Value Embedding and STEM baselines under equal training compute. Interpretability researchers noted that inspecting slot-dispatch distributions provides a clean lens for tracking polysemy resolution in early model layers.
Shanghai Artificial Intelligence Laboratory and SJTU's LUMIA Lab open-sourced NCP-ArchPreview on Monday, September 14, 2026. The 8.9B parameter latent-space language model jointly trains standard next-token prediction alongside Next Concept Prediction (NCP). Built on a 16/8/16 causal Transformer layout with a hidden size of 4,096 and a product-quantized concept vocabulary, the model was pre-trained on 5.73 trillion Dolma-3 tokens, matching the final loss of OLMo-3-7B while consuming only 51.3% of the pretraining compute budget.
Why it matters
NCP-ArchPreview provides the open-weight community with a fully open recipe for compute-efficient pretraining via multi-scale prediction objectives. By predicting abstract latent concepts alongside exact sub-word tokens, the architecture cuts required pretraining compute in half without sacrificing downstream task performance. Releasing weights and code under the ArchSpace collection gives researchers a functional platform to examine concept-level latent representations.
The authors report that joint token-concept loss prevents semantic representation collapse in deep layers. Open-weight maintainers noted that integrating product-quantized concept heads adds minor prefill overhead but yields substantial training compute savings.
Expanding the hardware options for DeepSeek-V4-Flash beyond the NVIDIA ecosystems we usually track, a paper published Monday detailed the low-level porting and performance engineering of the model on AMD Instinct MI250 accelerators within SGLang. After fixing a routed-expert W2 layout mismatch on the gfx90a CDNA2 architecture, the team implemented packed FP4 weight layouts, INT8 activation quantization, and CDNA2-specific dot-product instructions. Operating across four MI250 Grand Central Dies (GCDs) in a TP4/EP1 configuration, the system achieved 74.5 decode tokens per second and 2,234 prefill tokens per second.
Why it matters
Running massive sparse MoE architectures on non-NVIDIA enterprise hardware has historically been blocked by execution-format incompatibilities and missing kernel optimizations. This work proves that high-throughput open-model serving on AMD CDNA2 hardware is achievable through explicit layout repair and packed FP4 quantization. It expands the hardware options available for serving frontier open-weight models outside proprietary CUDA environments.
The authors noted that repairing the routed-expert layout mismatch was required to eliminate silent accuracy degradation on ROCm. Systems engineers emphasized that achieving 74.5 tok/s decode on MI250 proves that legacy CDNA2 clusters can remain viable for serving modern sparse architectures.
Anthropic published an engineering post on Monday, September 14, 2026, detailing how its internal Continuous Integration (CI) infrastructure was overhauled to survive a 25-fold increase in job volume over six months. Driven by internal deployments where Claude authors approximately 80% of company code changes and test suites grew 10x, single-process test selection listeners experienced extreme queue lag and out-of-memory crashes. The engineering team replaced singletons with a horizontally scalable, stateless listener architecture backed by an in-memory journaled data store for real-time test impact analysis.
Why it matters
This case study provides concrete metrics on the secondary infrastructure shocks created when autonomous coding agents operate at scale. When agents generate pull requests and test cases at machine speed, traditional developer tooling and single-process CI runners quickly become catastrophic bottlenecks. Anthropic's transition to a journaled, stateless test impact architecture offers a practical blueprint for organizations scaling autonomous software development workflows.
Anthropic's infrastructure team highlighted that temporary hardware patches—such as doubling CPU cores or running parallel package workers—failed within weeks under exponential agent PR volume. Industry observers noted that automated test selection and execution speed are now the primary limits on AI-driven software development velocity.
Building on the weekend's release of Claude Code 2.1.270, Anthropic shipped version 2.1.272 on Monday. The update introduces fast mode support in remote sessions, per-command allowed domain lists for Bash, PowerShell, and Monitor actions under sandboxed auto-mode, and command confirmation backed by SHA256 hash pinning. Additionally, the release adds `omitClaudeMd` frontmatter support for subagent isolation, model pricing multipliers for multi-tenant chargebacks, and bug fixes for MCP connection drops and prompt-cache invalidation.
Why it matters
Fine-grained permission controls and command verification are essential as CLI agents gain autonomous filesystem and network access. Adding SHA256 hash pinning and per-command domain allowlists under sandboxed auto-mode prevents prompt injection attacks from executing untrusted shell commands or exfiltrating data. For teams orchestrating subagents, `omitClaudeMd` prevents parent context bleed from bloating subagent context windows.
Tooling integration developers welcomed the addition of explicit OpenTelemetry field validation and SHA256 command verification. Security reviewers noted that per-command domain sandboxing significantly reduces the blast radius during automated Web and API research tasks.
Verified across 2 sources:
GitHub(Sep 14) · GitHub(Sep 15)
Click Copy for AI above, then paste the prompt
into your favorite AI chatbot — ChatGPT, Claude, Gemini, or
Perplexity all work well.
In a research paper published on arXiv on Monday, September 14, 2026, researchers investigated the division of labor within hybrid language models combining efficient local layers (Gated DeltaNet or sliding-window attention) with global attention layers. Using layer-type-agnostic paired activation patching probes, the study found that 'Carrying' (encoding the token immediately preceding a target value, or lag one) concentrates heavily in local recurrent/sliding layers, whereas 'Matching' forms in downstream global attention blocks. Causal interventions—such as lag-one masking and convolution removal—demonstrated that global matching circuitry fails to form if local carrying is disrupted during training.
Why it matters
This research provides a clear mechanistic blueprint explaining why hybrid architectures successfully offload position-sensitive routing to local recurrent blocks without sacrificing global context retrieval. For interpretability researchers auditing open-weight hybrid models, these layer-agnostic probes offer a reproducible technique to trace feature preparation across heterogeneous layer ratios. Knowing that lag-one predecessor tokens carry load-bearing key preparation signals allows practitioners to design targeted probing experiments on hybrid models.
The paper's authors demonstrate that structural priors dictate circuit localization, showing that removing local convolution shifts the carrying burden onto global layers at the cost of training efficiency. Open-weight architecture designers maintain that this functional segregation validates mixing fixed linear-attention ratios with sparse global attention layers.
Verified across 2 sources:
arXiv(Sep 14) · arXiv(Sep 14)
Click Copy for AI above, then paste the prompt
into your favorite AI chatbot — ChatGPT, Claude, Gemini, or
Perplexity all work well.
An arXiv preprint published on Monday, September 14, 2026, introduced Fixed-SAE Track, a mechanistic interpretability framework that trains a shared Sparse Autoencoder across a base model and its reinforcement learning (RL) checkpoints using fixed feature directions. Analyzing representation drift across RL training runs, the authors found that internal drift is surprisingly small, gradual, and concentrated almost exclusively in the final layers of the network. The drift primarily boosts activation for 'ladder tokens' and structural formatting scaffolding rather than modifying core reasoning representations; clamping and steering these late-layer features back into the un-aligned base model recovered ~80% of the total RL performance gains.
Why it matters
This study demystifies the internal mechanics of post-training alignment, proving that RL fine-tuning rarely creates novel conceptual representations from scratch. Instead, RL acts as a selective gain control that raises the output probability of formatting, step-demarcation, and reasoning scaffolding tokens already latent in the base weights. For local fine-tuning and probing, this indicates that steering a small set of late-layer formatting features can replicate alignment behavioral shifts without expensive policy optimization.
The researchers argue that RL's efficacy stems from eliciting pre-existing latent capabilities rather than fundamental knowledge acquisition. Independent interpretability practitioners highlight that while late-layer feature steering works for formatting and CoT structure, domain-specific post-training may still require deeper representation shifts in middle layers.
A paper published on arXiv on Monday, September 14, 2026, presented ModularRSI, a framework designed to evolve agent execution harnesses without overfitting to evaluation benchmarks. ModularRSI contrasts successful and failed execution trajectories across 2,000 evolution tasks strictly disjoint from downstream benchmarks, isolating deficiencies across five modular harness components: Agent Loop, Tool Use, Observation Management, Context Management, and Task Completion Detection. Tested across novel coding environments on Terminal-Bench 2.0 and SWE-Bench Verified, the evolved harnesses yielded consistent completion improvements across multiple underlying foundation models.
Why it matters
Automated optimization of agent harnesses frequently leads to benchmark contamination, where system prompts and tool retry loops overfit to specific dataset quirks. By decomposing the harness into independent functional modules and driving evolution over disjoint tasks, ModularRSI establishes a rigorous methodology for self-improving agent scaffolding. This modular division allows developers to optimize observation and context managers independently without rewriting the primary agent loop.
The authors emphasize that modular separation prevents trajectory conflation, ensuring that tool-use improvements do not degrade context management. Independent eval researchers praised the benchmark-disjoint protocol as a necessary standard to eliminate hidden harness overfitting.
An arXiv study published on Monday, September 14, 2026, introduced 'Elo-per-token' analysis to measure how LLM agents convert test-time compute into task completion gains. Evaluating four agents and three optimization harnesses over sessions using up to 100M tokens, the researchers found that while agents initially convert compute into Elo faster than independent sampling, marginal returns diminish rapidly during single long sessions. On the FrontierCS Polyomino task, splitting a 100M token budget across parallel short sessions yielded a +264 Elo gain over a single monolithic session.
Why it matters
As agent frameworks scale inference compute budgets, understanding where test-time scaling plateaus is essential for cost-effective orchestration. The finding that parallel, multi-session branching dramatically outperforms single long-horizon execution trajectories provides concrete guidance for harness design. Rather than letting a single agent loop burn millions of tokens in an extended session, orchestrators should allocate budgets across parallel execution threads.
The paper's authors demonstrate that agents in long single sessions frequently get trapped in narrow solution loops. Framework developers noted that parallel session allocation requires robust verification logic to merge solutions from independent runs.
An arXiv paper published on Monday, September 14, 2026, investigated why LLM agents exhibit safety and control failures in unsupervised multi-agent setups like Emergence World. The researchers identified an 'enforcement gap'—a structural design flaw where safety auditors successfully detect unauthorized plan steps but execution controllers ignore or bypass the warning. Closing this gap with a conditional check of under 20 lines of code reduced attack success over fourfold across major agent frameworks, leading to a proposed Audit Enforcement Specification.
Why it matters
Agent harness engineering frequently separates safety analysis from execution controllers, rendering high-accuracy auditor models useless when enforcement probability is near zero. Proving that system failures stem from missing programmatic control gates rather than model reasoning flaws simplifies agent safety engineering. For harness maintainers, implementing mandatory programmatic enforcement hooks is far more effective than adding further prompt-level self-critique.
The authors demonstrated that model-level critique capability is useless without deterministic control paths. Framework engineers agreed, noting that execution bridges should enforce hard programmatic stops whenever an auditor returns a violation code.
Maintainers tagged version 1.11.0 of the pure-C Colibrì inference engine on Sunday, September 13, 2026, adding native execution support for 744B to 2.8T Mixture-of-Experts models—including GLM-5.2, Kimi K3, and DeepSeek-V4.1-Flash—on consumer hardware. Colibrì treats GPU VRAM, system RAM, and NVMe SSD storage as a single unified memory hierarchy, using weight-level JIT compilation with batched expert unions, `O_DIRECT` unbuffered asynchronous streaming, and multi-SSD striping. On a test rig with six RTX 5090 GPUs, the engine achieved 4.0 to 6.8 tokens per second on 744B/2.8T models by streaming routed expert layers directly off disk.
Why it matters
Colibrì challenges the assumption that running frontier-scale MoE architectures requires multi-node enterprise GPU clusters. By reframing model execution as an asynchronous storage-bandwidth scheduling problem rather than a strict VRAM capacity constraint, this engine allows independent researchers to run weight analysis, probing, and batch generation on consumer workstations. While sub-10 tok/s speeds remain too slow for real-time chat, it unlocks overnight execution for massive open-weight models.
Colibrì maintainers stated that storage striping and JIT expert union batching eliminated warmstart expert-cache corruption bugs present in earlier builds. Hardware evaluators cautioned that driving constant `O_DIRECT` reads at high PCIe Gen 5 speeds induces heavy thermal stress on consumer NVMe drives during extended runs.
An arXiv paper published on Monday, September 14, 2026, presented roofline-shaped throughput predictors that estimate single-sequence llama.cpp decode speeds directly from GGUF metadata. Evaluated across 318 phase-depth measurements from 53 host-file configurations on two Apple M4 Max systems and an NVIDIA RTX 5080, an active-parameter decode model achieved 13.1%, 14.4%, and 36.1% mean absolute percentage error (MAPE) on host-specific held-out sets. The study confirmed that GGUF tensor layout metadata improves estimation accuracy, though fitted memory efficiencies vary across hardware backends.
Why it matters
Estimating local model execution speed on consumer hardware usually requires running manual benchmarks for every quantization variant. These roofline predictors allow local-LLM tools and desktop interfaces to accurately forecast decoding speeds and memory bandwidth saturation directly from the GGUF file header before downloading or loading weights into VRAM.
The authors noted that active-parameter models significantly outperform total-parameter estimates on MoE architectures. Hardware benchmarkers pointed out that the higher error rate on RTX 5080 hardware (36.1% MAPE) highlights driver-level batch overheads that pure roofline equations fail to capture.
Quantization maintainer Archsloth published an analysis and GGUF model release for Qwen3 and Qwen3.5 on Hugging Face on Monday, September 14, 2026. The technical write-up details how fixing default AutoRound flags to GGUF `Q4_K_M` and enabling SignRoundV2 sign-gradient rounding search (`--enable_alg_ext`) significantly reduces KL divergence against the original BF16 teacher. By carefully composition-tuning and interleaving the calibration text corpus, the build achieved a 54.4% reduction in KL divergence for Korean and 33.2% for English text on Qwen3-4B, proving that calibration text selection drives rounding direction more than auxiliary quantization-aware healing tricks.
Why it matters
Standard perplexity metrics frequently mask distribution drift introduced during low-bit GGUF quantization. By measuring KL divergence against the unquantized teacher, Archsloth provides local-LLM practitioners with concrete proof that quantization quality depends heavily on calibration dataset selection and sign-gradient search parameters. For anyone building custom GGUF quantizations using llama.cpp toolchains, these specific CLI flags offer a reproducible methodology to prevent catastrophic failure on non-English or specialized domain prompts.
Archsloth noted that auxiliary methods like mixed precision or quantization-aware healing yielded diminishing returns once the underlying SignRoundV2 search space was properly configured. Community quantizers highlighted that calibration text interleaving is far more critical for small-parameter models (under 8B) than for 70B+ architectures.
An arXiv preprint published on Monday, September 14, 2026, presented AGENTKV, a phase-aware key-value cache eviction framework engineered for agentic multi-turn workloads. Recognizing that agent query vectors cluster into distinct subspaces across 'think', 'act', and 'tool' execution phases, AGENTKV maintains phase-specific query buffers to score cached keys against phase unions while compacting retained KV pages online. Evaluated across two backbones and six task domains, AGENTKV improved task scores by 5.5 points over R-KV while delivering up to 1.80x output token throughput compared to upstream SGLang full-KV baselines.
Why it matters
Standard sliding-window or recency-based KV eviction strategies fail during multi-turn agent execution because tool outputs and system instructions are needed long after their initial position in the context window. AGENTKV's phase-aware scoring preserves keys relevant to reasoning steps while shedding low-utility conversational tokens. This approach gives local and cloud serving engines a concrete method to contain VRAM expansion during long-horizon agent trajectories.
The authors reported that buffering distinct query vectors prevents premature eviction of system tools during extended reasoning loops. Systems developers noted that while the throughput gains are strong, online page compaction adds slight CPU overhead during prefill-heavy turns.
A research paper submitted to arXiv on Monday, September 14, 2026, analyzed hardware provisioning requirements for hosting trillion-parameter Mixture-of-Experts models on single server nodes using High-Bandwidth Flash (HBF) and DRAM. By studying operator execution traces and expert routing patterns, the authors showed that HBF transport bandwidth and state bandwidth form orthogonal performance knees. This allows system DRAM requirements to sit an order of magnitude below standard HBM3e capacity requirements while still satisfying batch completion targets under low-concurrency serving.
Why it matters
As open-weight model parameter counts outpace accelerator VRAM capacity, system designers need alternatives to expensive HBM stacks. This study provides concrete engineering parameters showing that high-bandwidth flash paired with modest system DRAM can serve trillion-parameter MoE models at low concurrency. This offers hardware engineers a blueprint for specialized, cost-effective inference appliances.
The authors demonstrate that decoupling capacity from memory bandwidth makes single-node frontier inference economically viable. Storage engineers noted that achieving target latencies requires high-end flash controller logic to prevent read amplification during sparse expert routing.
Adding to the momentum surrounding potential US duty-of-care AI legislation we noted over the weekend, reports published Monday analyzed an essay by Anthropic CEO Dario Amodei proposing mandatory pre-release safety testing and international oversight for open-weight models. The proposal cites distillation campaigns against commercial endpoints as a driver for regulatory intervention and advocates placing compliance obligations on labs distributing open weights, drawing public support from tech executives while sparking pushback from open-source advocates.
Why it matters
Policy frameworks targeting model distillation and open-weight distribution directly impact what weights independent researchers and local-LLM practitioners can download and self-host. Tying open-weight access to mandatory safety testing regimes defined by frontier labs could restrict the availability of permissive model releases. Tracking these policy proposals helps open-source developers anticipate licensing and distribution controls.
Proponents argue that mandatory safety testing and distillation limits are necessary to prevent malicious capability proliferation. Open-weight advocates and independent researchers argue that restricting weight downloads consolidates market control among proprietary API providers while undermining transparent security auditing.
A paper published on arXiv on Monday, September 14, 2026, examined the robustness of Interpretable Replacement Networks (IRNs) and Sparse Autoencoders across five model families (GPT-2 small, Gemma 2 2B, Gemma 3 1B, Llama 3.2 1B, and R1-Distill-Qwen 1.5B). The authors showed that semantically minor input perturbations flip dominant IRN features and human-understandable feature interpretations. To counteract this, the authors introduced a formal verification framework using reachability analysis to certify sound upper bounds on the faithfulness gap, alongside a verification-aware training method that tightens feature stability under adversarial conditions.
Why it matters
Mechanistic interpretability techniques often rely on heuristic evaluations under clean, unperturbed inputs. Proving that minor input noise easily corrupts feature interpretations exposes a major vulnerability in current model auditing tools. By introducing reachability analysis to bound feature drift, this paper provides interpretability researchers with mathematically defensible tools for safety auditing.
The authors argue that empirical clean-data evaluations give a false sense of auditing security. Safety researchers noted that verification-aware training effectively stabilizes sparse features without degrading downstream model accuracy.
Stateful Recurrence Exposes Latent Cache Tracking Bugs As hybrid architectures combining Gated DeltaNet or Mamba with standard attention enter production serving stacks, scheduler batch-merging mechanisms are failing. Bugs like SGLang's radix tree pointer drop illustrate that managing stateful SSM memory alongside dynamic prefill/decode batches requires dedicated synchronization primitives rather than standard prefix-caching shortcuts.
Asymmetric Architectures Redefine Long-Context Memory Budgets Models like DeepSeek-V4.1-Flash isolate prefill parameters from decode active parameters while shrinking KV caches to sub-kilobyte per-token boundaries via FP4 quantization and bounded replay. By trading parameter activation asymmetry against KV footprint, frontier models are shifting memory bandwidth demands away from decoders onto efficient prefill kernels.
Reinforcement Learning Modifies Output Formatting Over Deep Representations Mechanistic analysis using fixed sparse autoencoders reveals that post-training RL alignment induces minimal representation drift in deep model layers. Instead, gains concentrate in late-layer formatting and reasoning scaffolding features, demonstrating that RL functions largely by modulating token sampling distributions for pre-existing capabilities.
Storage-Tier Multitiering Expands Consumer Local-LLM Thresholds Inference engines like Colibrì and high-bandwidth flash architectures are treating host RAM, VRAM, and direct NVMe storage as a continuous memory hierarchy. By using JIT expert loading and O_DIRECT streaming, multi-hundred-billion parameter models are becoming executable on consumer nodes, reframing VRAM limits into storage throughput bottlenecks.
Agentic Code Volume Forces Continuous Integration Overhauls The explosive growth of autonomous agent pull requests is breaking monolithic developer toolchains. Internal reports from Anthropic highlight a 25x increase in CI job volume, driving a transition toward stateless listeners and journaled test impact analysis to prevent queue starvation during automated code generation.
What to Expect
2026-09-30—Expected release window for upstream vLLM and SGLang production patches addressing DeepSeek-V4.1-Flash sliding-window attention and radix cache stability bugs.
2026-10-15—Open Source Initiative (OSI) scheduled panel on finalizing open-weight versus open-source structural criteria for AI models.
How We Built This Briefing
Every story, researched.
Every story verified across multiple sources before publication.
🔍
Scanned
Across multiple search engines and news databases
454
📖
Read in full
Every article opened, read, and evaluated
127
⭐
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