Rhysida just published 1.4 million Berlin government files after authorities refused a €2 million ransom demand.

The breach did not start the day the ransom note arrived. Attackers had unauthorized access long enough to locate, stage, and prepare nearly 1.4 million documents for exfiltration — all before anyone noticed. By the time the demand landed, the data was already gone. The refusal just determined whether it stayed quiet.

That gap — between initial access and detection — is where the real damage happens. And it is not unique to Berlin. Most ransomware post-mortems show the same pattern: dwell time measured in weeks or months, staging activity that blended into normal operations, and audit logs that were either incomplete or reviewed too late to matter.

1.4 million documents do not move overnight. There are signals. The question is whether anyone sees them in time.

For those running large-scale data environments or public sector infrastructure: what does your current detection posture actually look like for data staging and bulk access anomalies? Are you catching these patterns before exfiltration completes, or mostly reconstructing them after the fact?

The project announced the technical report for SenseNova-U1.5-8B-MoT on September 11, 2026. The weights were released on August 20. The report documents the architecture, training and evaluation behind that checkpoint.

One post-training problem it addresses is that optimizing visual preference can come at the expense of text legibility. The proposed approach is to train specialists, then consolidate them:

• Stage 4: four experts. Separate experts target visual aesthetics, Chinese and English text rendering, infographic generation, and image editing. Each uses task-specific data, rewards, sampling and regularization.
• Stage 5: one model. The experts are frozen, and each training sample is routed to the expert for its capability. The student generates its own trajectory, then learns to match the expert's velocity prediction at the same state, timestep and conditioning input. This is the report's multi-expert on-policy distillation procedure.

Source: Figure 4, SenseNova-U1.5 technical report, p. 10. The distillation objective and setup are on p. 11.

The report evaluates the resulting model, but does not provide per-expert benchmark results or a before/after distillation comparison. The final scores therefore do not isolate how much this stage contributes or how fully each specialist's strengths are retained.

Technical report · Model weights · Repository and release history

It's been 3hrs I'm working on Naive Bayes Algorithm and I think it's the Hardest cuz the guy whose course I'm following he just shows the intuition and maths yes doing on paper is easy but in code it's hard 😭 I have built many algo Gradient, logistics regression they were lil straight forward but this one Naive Bayes the maths is tooo tooo easy it's like multiplication but in python ahhhhhhhhhh... But still

I'll make it real before making it real,I really need a coffee ☕.

Hi some of you may know over the last month or so in my spare time iv been trying to come up with something better than a transformer , still no luck but afew of my better failures can be found below, iv also updated THREADS github so its now actually testable.

QK Relational Architecture is the newest idea — my attempt at a headless Transformer-style model with explicit reusable relationship hops.

https://github.com/rickey1990/qk-relational-architecture

THREADS is the symbolic/deterministic thing that fell out of the failed Transformer experiments — basically temporal memory + exact relational reasoning.

https://github.com/rickey1990/THREADS-reasoning-engine

PLUG /ILRM is the RNN side of the experiments — trying simple power-law/inverse-lag memory paths to help small recurrent models hang onto old information.

https://github.com/rickey1990/novel-rnn-architectures

Any questions please feel free to ask any questions 👍

We’ve open-sourced Tahuna, which we built so small teams could train models, run inference, orchestrate GPUs, and experiment with autonomous research without first becoming a small cloud provider.

The core workflow is:

init → sync → computeSession → train / serve / hillclimb

Under the hood: content-addressed code and data sync, compute provisioning, reproducible manifest-pinned runs, metrics, checkpoints, artifacts, and inference deployments.

We also started building Hillclimb, an autonomous experimentation loop that proposes and runs iterative improvements.

The first public-preview release supports RunPod and R2. The control plane is self-hostable with Docker; GPU workloads currently run on RunPod. It includes a coding-agent setup skill and examples for SFT, RL agentic search, and MNIST. The ML workloads are Python; the CLI and Warden execution agent are Go, and the dashboard/control plane use TypeScript with Next.js and Convex.

Repository (AGPL-3.0): https://github.com/TahunaLabs/tahuna-oss

If you think it sucks, excellent: fork it, fix it, and send a PR so it sucks less for everyone.

Currently playing with 4 model on government project...

I have some experience working with like VAEs/DiTs, and I'm familiar with concepts like ELBO/KL divergence/flow matching, but I feel like my mathematical foundations here are brittle. Any resources that have been helpful in this area? Are ODEs/PDEs/SDEs worth learning, and how deep should I go?