How a student caught an AI hacking attack in Texas

Last spring, a computer science student at the University of Texas noticed something odd in the network logs. A script was probing campus servers, but it wasn’t using the usual brute-force methods. It was adapting, learning from failed attempts, tweaking its approach in real time. That’s when he realized: this wasn’t just another script kiddie. Someone had built an AI to do the hacking for them.

The first red flag

The student, let’s call him Jake, was running a routine check on the university’s firewall logs. Most attacks followed predictable patterns: repeated login attempts, common password lists, or known exploit signatures. This one was different. The requests were spaced irregularly, and the payloads changed slightly after each failure. It looked like the attacker was testing different combinations, but with a level of variation that didn’t match human behavior.

Jake dug deeper. He set up a honeypot, a fake server designed to attract attackers, and mirrored the traffic. Within hours, the script had shifted its focus to the honeypot, probing for vulnerabilities with increasing precision. That’s when he knew: this was an AI-driven attack. The script wasn’t just following a pre-written list. It was analyzing responses and refining its strategy on the fly.

How the AI worked

The attacker had built a lightweight reinforcement learning model. It started with a basic set of credentials and exploit attempts, then adjusted based on server responses. If a login failed, it would try a slightly different username or password next time. If a payload triggered a 403 error, it would modify the request headers. Over time, it became more effective, not because the attacker was smarter, but because the AI was learning from its mistakes.

• The model used a small neural network, trained on public exploit databases and leaked credential lists.

• It ran on a cloud VM, likely rented with stolen credit cards, to avoid IP-based blocking.

• The script included rate-limiting to avoid triggering automated defenses, making it harder to detect.

• It targeted low-priority systems first, like student portals, to avoid immediate attention.

Stopping the attack

Jake didn’t panic. He isolated the honeypot, ensuring the AI couldn’t pivot to real systems, then contacted the university’s IT security team. Together, they set up a tarpit, a server that deliberately slows down responses, to waste the AI’s time. The longer the AI spent waiting for replies, the less effective it became. Meanwhile, they traced the originating IP to a cloud provider in Eastern Europe.

The cloud provider shut down the VM within hours, but not before Jake’s team captured the AI’s model. Analyzing it revealed a sloppy but functional design: the attacker had cobbled together open-source tools and a basic reinforcement learning framework. It wasn’t sophisticated, but it was effective enough to fly under the radar, until Jake noticed the patterns.

What developers can learn

This incident wasn’t an isolated case. AI-driven attacks are becoming more common, and they’re harder to detect than traditional hacking attempts. The good news is that the same principles that caught this attack can help defend against others.

• Monitor for irregular patterns, not just known signatures. AI attacks won’t follow the usual scripts.

• Use honeypots to lure and study attackers without risking real systems.

• Rate-limiting and tarpits can disrupt AI-driven attacks by forcing them to waste time.

• Collaborate with cloud providers to shut down malicious VMs quickly.

• Assume attackers are using AI. Build defenses that adapt, not just block.

The bigger picture

This wasn’t a nation-state attack or a high-profile breach. It was a low-budget experiment by someone testing how far they could push AI-driven hacking. The fact that a student caught it before it caused damage is a win, but it’s also a warning. As AI tools become more accessible, so do AI-powered attacks. Defenders need to stay ahead, not just by patching vulnerabilities, but by understanding how attackers are evolving.

Jake’s story isn’t just about one attack. It’s about the future of cybersecurity. The next time you check your logs, ask yourself: is this a human, or is this an AI learning how to break in? credit: @Leo_Marchandon Thomson Reuters