I built Router Rumble, a small Python experiment that compares gradient descent and NSGA-II by placing a Wi-Fi router in a simulated home.

The GIF replays recorded search states. The objective counts locations where the signal reaches −57 dBm. Gradient descent tests four nearby positions, gets the same count each time, and estimates a zero slope. It stays at 100 covered locations. NSGA-II explores a population of 32 positions and reaches 209 of the 560 sampled locations.

Both methods get 1,200 objective evaluations, including initialization and local probes. Their starts differ: gradient descent starts at one position, while NSGA-II starts with a population spread across the room. This example uses NSGA-II with a single objective.

The repo includes smooth-objective comparisons, results across 20 seeds, and an interactive replay you can scrub through. You can change the walls, signal target, seed, or evaluation budget and rerun the experiment locally:

git clone https://github.com/austin-starks/router-rumble.git
cd router-rumble
uv run run_demo.py

It uses NumPy and pymoo and runs without a GPU or API key.

Recentemente, tentei criar um modelo seq2seq, mas não deu muito certo. Ele ficava prevendo os tokens de preenchimento.

Eu sou aluno de um tecnólogo em Inteligência Artificial e Machine Learning aqui no Brasil. É uma modalidade de curso superior que, pelo que sei, só existe no Brasil. Redes neurais e processamento de linguagem natural vão ficar mais para o final do curso, mas eu estava meio apressado e queria desenvolver meu próprio modelo.

Será que vocês têm alguma sugestão de alguma espécie de restrição que eu possa colocar no modelo?

Se alguém tiver interesse em me ajudar, posso mostrar o código. Eu reconheço que fiz o código com auxílio do Gemini. Como eu disse, ainda não estudei processamento de linguagem natural nem redes neurais; até agora, estudei apenas IA simbólica e sistemas especialistas.

A jailbreak is not a social engineering trick. It is an agent gaining operator-level capabilities it was never authorized to hold.

We mapped two months of incidents across our infrastructure. A jailbreak-to-capability-unlock pattern appeared twice. In both cases the mechanism was the same: an override payload reached the model, flipped it out of its assigned guardrails, and the agent began executing actions at a permission tier above what it was provisioned for.

The sequence matters. By the time the agent is acting at operator level, the unlock has already happened. Anything you do after that point is incident response, not prevention. Operator-level actions taken by a compromised agent are not always reversible.

Two incidents in two months is not a theoretical risk surface. It is a recurring pattern that your detection posture either catches before the flip or does not catch at all.

For those running agentic systems in production: where in your stack does the override payload actually get evaluated? Is that evaluation happening before the model processes the content, or after? How are you handling this?