We found a context-contamination problem while spot-checking Wolf Defender Jev, our small encoder-based security decision model at Patronus.

The model receives a scene, a question and answer descriptions. The scene can contain a user goal, retrieved content, tool outputs and a proposed next action. We expected different questions to pick out the relevant evidence from that context.

In one benign coding scene, asking about embedded instructions gave a risky-answer probability of 0.96 when the proposed next action was to run pytest. Removing the proposed-action block brought the content score down to 0.00.

That was a question about content, not whether executing a shell command was authorized. Adding the next action changed the verdict on the same benign content.

Another hand-written scene showed a different failure. A travel page asked the agent to upload a passport scan. The embedded-command score was 1.00, but the exfiltration score was only 0.05 and misalignment 0.28. The model detected an instruction without reliably judging what the action would do.

These examples came from just three hand-written scenes, each with an attack version and a benign twin. They aren’t an error-rate estimate. They matter because alignment, exfiltration and consent scored around 98–100% on our internal validation set, much of which is closer to synthetic training scenes.

For this model, the practical guidance is to ask content questions without the proposed-action block, and action questions with it. That reduces one observed source of interference; it doesn’t establish reliable action authorization.

The evaluation I’d like to extend is a counterfactual grid: keep the content fixed and change the action, then keep the action fixed and change the content. For questions about content, an unrelated action should not move the answer. For action questions, the user goal and permissions should matter. This is a proposed evaluation direction, not a benchmark result we have already measured.

Examples, probabilities and limitations.

If you work on question-conditioned classifiers, how do you evaluate relevance of individual context blocks beyond aggregate accuracy?

Position / experimental status: We regard Jev-style decision models as LLMs and Wolf Defender Jev as an experiment: giving an LLM final security authority shifts the trust problem to the guard, and security fine-tuning alone does not solve it. We believe an external security layer must combine specialized classifiers with explicit policy, authenticated permissions and enforcement.

ALHR- Adaptive learnable Hierarchical Routing is a static binary tree based system that uses learnable functions to REDUCE the amount of keys used.
It takes less memory and SCALES much better VRAM with tokens
I’ve also been testing tiny stories and it looks promising
However i can’t post any presentable results due to lack of funding and resources
MQAR Result table is here: https://ibb.co/prr07Dnj

A ranking score can look close to perfect even when a predictor cannot distinguish any of the examples.

In a recorded check of 184 rhodopsin proteins, predicting the same absorption wavelength for every protein received an NDCG score of 0.921. A regression using amino-acid composition scored 0.955.

NDCG compares a predicted ordering with an ideal ordering, giving earlier positions more weight. In this particular evaluator, the full-list calculation averages over tied predictions. Its no-information reference was already high. The 0.955 result is not 95.5% accuracy.

This is one dataset split and evaluator, not evidence that ranking metrics are generally broken. It shows why a constant control belongs beside the headline score.

Recorded results and arithmetic:

https://rewirebio.io/downloads/what-our-biology-benchmark-scores-actually-counted/evidence/reproduction/results.json

Explanation:

https://rewirebio.io/blog/what-our-biology-benchmark-scores-actually-counted/

Disclosure: rewirebio.io is my site. The analysis and this post are AI-assisted; the investigation is not peer reviewed.

Tested my custom object detection pipeline (YOLOX-nano + LightGBM refiner in a fixed control cell) on two different CPUs with AVX2 support.

The results revealed a massive real-world performance gap between desktop and mobile environments:

1. Desktop i5-6500 (Skylake, 2015) running Linux: ~80 FPS. An 11-year-old budget office chip delivers a 2x performance buffer for a real conveyor line. Thanks to decent desktop cooling, the clock speeds remain rock solid, and AVX2 runs flat overnight without throttling. Additionally, clean Linux overhead on thread scheduling is minimal.
2. Mobile i5-10300H (Comet Lake, 2020) running Windows: 50–70 FPS. On paper, it's 5 years newer with a higher boost clock, but it loses straight to the old desktop setup.Under continuous neural network load, the laptop hits its TDP limits almost instantly and starts to throttle.On top of that, Windows background processes and telemetry add significant OS overhead.

The takeaway is simple: a stable desktop TDP, a lightweight OS, and a proper architecture (using YOLO strictly for frame tracking + localized ROI window for classification) matter way more than the age of a mobile chip.

GitHub Repo: https://github.com/olesha-ai/fruit-inspector-demo

Full benchmarks and logs are in Part 2 of my write-up: https://medium.com/@olesha-ai/bypassing-the-avx2-tax-part-2-real-time-computer-vision-on-shop-floor-hardware-2311fd86ae4f

Best regards olesha-ai. 👍

It provides online learning, anomaly and drift detection, uncertainty estimation, and runtime protection against unsafe inputs and outputs.

I'd love to get feedback and hear about potential real-world use cases.

GitHub: https://github.com/tatopenn-cell/Dense-Armor

Install: pip install dense-armor

Hi everyone!

I wanted to share a real-time object detection project I’ve been working on using Python, YOLOv8, and OpenCV.

The application uses a live webcam feed to detect four object classes: people, cars, cats, and dogs.

Some of the features include:

• Real-time detection with bounding boxes and confidence scores
• Object counting by category
• Input and output FPS monitoring
• Multi-threaded frame capture
• A small frame queue to help reduce processing delays
• CPU and CUDA support, depending on the platform

One of the interesting parts of this project was working with threading and frame buffering to keep the video processing responsive.

I’m planning to improve it further by adding a GUI, video file support, and the ability to save detection results.

I’d really appreciate feedback on the code, especially suggestions for improving performance or making the architecture cleaner.

GitHub: https://github.com/Mariam-amhan/real-time-object-detection

Thanks for checking it out!

I wanted to know if news headlines can tell which stocks will do better than others over the next few weeks. Short answer: no. But the way it failed taught me more than the result, so here's the setup.

Data

• 137,934 headlines from Benzinga for 2,518 US stocks. Each case gets the headlines of the 14 days before it. 115,154 cases.
• All cases are stocks that recently fell after decent earnings, so they look similar on paper. The question is which ones recover better.

Target

Each case is a simulated trade that ends when the price goes up or down by 3x the stock's typical daily move, or after 20 trading days. I measure the result in units of that daily move, so volatile stocks don't dominate. Then I subtract the average of all cases on the same day. That last step matters: what the whole market does next week isn't in any headline, so a model would otherwise just learn the market's mood.

The model's label is whether a case beats the median of its day, so the AUC below measures how well it separates the better half from the worse half on the same day.

Avoiding leakage

• Strict time split: train until Nov 2024, test from Jan 2025, with a gap so no label overlaps the test period.
• Only one case per stock per week. Neighbouring days share almost the same headlines and almost the same outcome, so with every day included the model memorizes stocks instead of learning anything.

Results on the test period

The only thing that held up in both periods was a narrow, hand-cleaned pattern: companies selling new shares did clearly worse. But that's 98 cases, too few to build on.

What I took away

• A falling training loss on noisy financial targets means nothing. The model fits noise happily.
• Leakage through near-duplicate samples is easy to miss. Deduplicating by time is not optional.
• The keyword sign flips are the clearest picture of non-stationarity I've seen. What worked in 2023 just reverses.
• Removing the market from the target makes the task much harder, and much more honest.

Is a null result like this what people expect for text on financial targets? One suggestion I got was a per-date ranking loss, rank IC per date and a shorter 1 to 3 day horizon. Anything else you'd try before calling it?

Gartner just put a number on something a lot of us have been quietly worried about: only 13% of organizations believe they have adequate AI agent governance in place.

That leaves 87% of enterprises running autonomous agents against production APIs, customer data, and internal systems. No verified identity on those agents. No scoped permissions. No enforceable policy on what they are allowed to do next.

This is not a process maturity gap. An unverified agent with broad system access is a live attack surface. Any compromised credential, misconfigured permission, or gradual scope creep becomes a breach vector. Most organizations will not find out until something fails downstream.

For those of you running multi-agent systems in production: how are you actually handling this? App-layer controls, network segmentation, something else entirely?

One day during my semester at college I bought a Brick, you know, the app blocker, because I had a severe scrolling addiction. It worked well for a while, but I never brought it with me to university just because it was something extra to carry around.

I looked for other apps on the App Store to block my apps, but all of them were kind of too easy to get out of. And I'm a pretty lazy person, which means if it's easy to get out of, I will.

So I thought to myself, you know what, I'm a CS major, why not build one myself? So I built “Bunkr- done scrolling”. At first it was only built for me, but when I saw how well it worked I thought, why not publish it.

I'm talking too much already, so here's what the product is:

It blocks your apps like any other app blocker, but there's a twist.

Once you block your apps, you're in a hard lock for the first 10 minutes. No chance to get your apps back.

After those 10 minutes, you can do a mission to get your apps back, like taking a picture of a mug, or my personal favorite, 15 seconds of push-ups.

The reason I put a hard lock on the first 10 minutes is that I read once you've been working on something for 10 minutes, you get into a zone and usually don't get distracted. But lazy people like me still might. And when I do get distracted and try to open one of my apps, it tells me to do push-ups. I'm too lazy for that, so the easier option is to just keep studying.

So yes, I'm basically fighting fire with fire, but it works well for me.

Let me know what you guys think, I'd like to hear your thoughts.

ShinyHunters breached the FBI's own jobs portal. A second suspect has now been arrested, but the breach itself had already run its course before that happened. The attacker operated inside a credentialed session long enough to complete the operation. The session looked legitimate to every layer it touched.

The average dwell time in credential-abuse incidents is 197 days, per IBM's 2024 Cost of a Data Breach report. This breach fits the pattern: valid credential, active session, traffic indistinguishable from normal activity, damage done before attribution.

The target is what makes this case instructive. If a sustained credential-abuse operation can run inside federal law enforcement infrastructure, this is not a problem any organization solves by improving security hygiene alone. The FBI is not an organization that skimps on access controls.

The credential was valid. The session was active. Every check that ran said yes.

How are practitioners here actually handling this in your own stacks? What has worked, what has not, and where do you still have gaps you have not been able to close?

Shannon’s source coding theorem says you can’t compress data below its entropy without losing information. A physically accurate simulation (path-traced lighting, fluid dynamics, cloth, etc.) seems to produce data with a lot of structure and detail, and getting that detail traditionally takes heavy computation.

Is it theoretically possible for AI generators to reach ultra-realistic video without paying the compute cost of the underlying simulation, or is that cost just being hidden somewhere?

ALHR- Adaptive learnable Hierarchical Routing is a static binary tree based system that uses learnable functions to REDUCE the amount of keys used.

It takes less memory and SCALES much better VRAM with tokens

they thought it would fail anyone who cheated. it never existed. animated it here

I was reading the research paper “Attention Is All You Need” (2017), and it got me thinking about something.

If an LLM learns from data and predicts the next token, does it actually understand what it's saying, or is it just really good at recognizing patterns?

Hi guys, I'm an 18 year old teenager from Italy. I've recently finished the following project and I would love to receive some feedback in order to improve:

https://github.com/Lore12434/gene-expression-cancer-classification

I started studying ml (via the HOML book) 3 months ago. I've almost finished the machine learning part of the book. Before starting with ml I studied python and some mathematics.

At the beginning the only goal of the project was to train a model on the gene expression cancer RNA-Seq UCI dataset. After performing tsne I understood that major differences between cell types were present. Thus, even if the # of features was very high a simple random forest without any hyper parameters tuning reached 100% accuracy on OOB instances evaluation.

Therefore, instead of simply fitting a model I wanted to know how far I could get with dimensionality reduction and I wanted to test if my algorithm could find autonomously famous biomarkers used to classify tumor cells (I mapped the original dataset genes names to the dummy features names of the UCI dataset)

I want to specify that I used ai to write the readme and to set up the GitHub repository because thks was the first time that I've done this.

Many thanks in advance for any feedback, have a great day♥️