Overload control is usually built around a bad assumption. Most systems watch global signals like queue length or tail latency and react at the front door by throttling new arrivals or dropping random requests. This works when CPU or network is the bottleneck. It fails when the real problem sits deeper inside the application. In practice, many overload incidents come from one or two requests that monopolize an internal logical resource like a buffer pool, a lock, or a thread-pool queue. These rogue whales distort the system. One ill-timed dump query can thrash the buffer pool and cut throughput in half. One backup thread plus a heavy table scan can stall writes in MySQL. None of this shows up in CPU metrics. The Atropos paper (SOSP’25) offers a simple fix. Instead of punishing victims at admission time, Atropos watches how tasks actually use these internal resources and cancels the ones causing the collapse. The key observation is that most real systems already have safe cancellation hooks. What’s been missing is a principled way to decide whom to cut. Atropos supplies that missing piece and shows that killing a single rogue whale can unblock the whole system.