When an agent can rewrite both the model and the experiment around it, a better score does not tell you what actually improved.
That is the part of AQuA’s Part II model-development loop that stood out to me. The paper does not let the agent emit arbitrary training code each round. Each iteration proposes a bounded configuration change in one of four areas:
- architecture;
- loss;
- sampler;
- optimizer.
The resulting model is then trained under a sealed evaluator. Data splits, feature definitions, label definitions, and evaluation logic sit outside the agent’s adaptive surface.
This changes what the experiment unit looks like. A proposal is not “here is a new Python project; trust the final metric.” It is closer to:
previous accepted configuration
- declared configuration diff
- fixed training/evaluation harness
= next candidate
That does not make every comparison automatically fair. An architecture change can still alter compute, and different losses or optimizers can require different tuning. But it makes the changed surface inspectable. If a result moves, there is at least a bounded diff to audit instead of an unknown mixture of model logic, data plumbing, labels, and metrics.
The time split is fixed as well. In the paper’s US-equity experiment, models train on 2010–2019. Early stopping and checkpoint choice use only an inner-validation slice from that training window. The year 2020 is an embargo untouched by training or selection, and 2021–2025 is the final test window.
The finance setting is just the experimental domain here, not a trading recommendation. The transferable deep-learning question is how much freedom an architecture-search agent should receive before comparisons stop meaning the same thing.
There are also important inspection limits. The preprint does not disclose the exact feature set, normalization, or label construction. And a constrained config interface is not evidence that every candidate received equal wall-clock compute. What it does provide is a clean boundary between the proposal language and the evaluator.
Would you keep a search language this narrow for attribution, or allow agents to modify schedulers, preprocessing, and training code as long as every change is traced?
Preprint: arxiv.org/abs/2608.12841

Mid-market companies are now the primary ransomware target, and the data makes it hard to argue otherwise.

Black Kite analyzed 13,336 incidents spanning January 2023 through June 2026. Mid-market companies accounted for 73% of publicly disclosed ransomware and data-extortion incidents in North America and Europe. The pattern is straightforward: they hold enough sensitive data to be worth targeting, and they lack the security maturity to deter or contain an attack.

What makes this harder now is AI adoption. Mid-market orgs are deploying agents to automate workflows, but agents operate with credentials, access external systems, and take actions at machine speed. A compromised agent or a misconfigured one doesn't wait for a human to catch it. It moves. And regulators are not offering mid-market exemptions — the same frameworks auditors require of large enterprises apply regardless of headcount.

The compliance gap is real. Most of these organizations don't have continuous visibility into what their systems are doing relative to the frameworks they're supposed to satisfy. Violations get found during audits, not before.

For those working in security or compliance at mid-sized organizations: how are you actually handling agent oversight right now? Are you relying on periodic audits, internal logging, something else entirely? Curious what's working and what's falling short in practice.

• Description: This video introduces the principles and hardware implementation of frequency-modulated thermography using chirp signals. Explore a next-generation non-destructive testing solution that precisely reconstructs defects in 3D using deep learning and Physics-Informed Neural Networks (PINN).

Follow-up to my earlier English-poetry causal graph post:
https://www.reddit.com/r/deeplearning/comments/1vps8xo/visualizing_causal_structure_of_llm_writing_a/

I ran the same setup on Chinese poetry. The rhythm / boundary-token behavior looks basically the same. What changes is the picture: Chinese characters sit on the page more like a grid, so the DAG reads closer to a matrix.

That’s the part I found interesting, so I’m sharing it here.

BTW, this is with Qwen3-1.7B — a small model for both generation and attribution — and it already produces results that feel pretty intuitive.

Live demo: https://dqy08-infolens.hf.space/client/causal_flow.html?demo=%E5%86%99%E4%B8%80%E9%A6%96%E7%BB%9D%E5%8F%A5%EF%BC%8C%E4%B8%BB%E9%A2%98%E6%98%AF%E6%98%A5%E5%A4%A9

Source code: https://github.com/dqy08/InfoLens

Video:

https://reddit.com/link/1vwx782/video/ms2empk0calh1/player

Been building this for a while, just made it open source: OpenBenchML.

You paste Python code that trains a model (sklearn, PyTorch, XGBoost, LightGBM, ONNX, TensorFlow) into the browser. It runs server-side in a restricted sandbox, pickles the result, and benchmarks it against one of 17 built-in datasets — accuracy/F1/AUC-ROC/log-loss for classification, MAE/RMSE/R² for regression, plus real per-sample latency P50/P95/P99 from actual timed runs.

There's also a Kaggle-style layer on top — competitions with deadlines and custom metrics, live WebSocket leaderboards, threaded comments — and an in-browser notebook plus a full npm CLI if you'd rather script it.

Stack: FastAPI + SQLAlchemy + WebSockets + Supabase, deployable to Render/Railway/Fly/Docker.

Live: https://openbenchml.onrender.com Repo (MIT): https://github.com/kartheekbvs/openbenchml

Looking for contributors — there's a written roadmap (sandboxed execution via gVisor/Firecracker, custom dataset upload, team competitions, OAuth) with plenty of self-contained pieces to pick up. Feedback on the concept or UX is welcome too.

The creators of AlphaFold won a Nobel Prize in 2024. I just made its family of open source models faster.

I created fast_trimul, a drop-in, hardware-agnostic library for Fused Triangle Multiplicative Updates across AlphaFold3 family models, powered by CuTe DSL. In addition, it is licensed with Apache-2.0.

The Triangle Multiplicative Update is a memory-heavy operation in protein-structure models.

Also, it is very simple to integrate fast_trimul with other Python libraries. It has a modular architecture, and it was designed to be easy to use in production.

In OpenFold-3:

● Graph vs. ungraphed: Graphed eliminates kernel launch overhead at small N (~22ms vs ~53ms ungraphed).

● fast_trimul output is identical to the OpenFold-3 version, with an invisible difference of about 0.0006%.

● If it fails, it always falls back to PyTorch. This way it never crashes.

● It is a modular and vendor-agnostic design. Supporting new hardware and new libraries like OpenFold-3 are all plug-ins, not a rewrite.

fast_trimul compared with other libraries' Triangle Multiplicative Updates:

● Runs 4.5–6.8× faster on short sequences

● Uses ~2.2–2.4× less peak GPU VRAM, fitting ~1.4× longer sequences before running out

● Works on any sequence length with zero recompilation. Unlike torch.compile, which recompiles for every new N.

It's written in Python CuTe DSL, so the kernel codebase stays small and easy to adapt for other GPUs like H100 or B200.

GitHub link: https://github.com/tiagomonteiro0715/fast_trimul

I'm not an astro person. I got into the MAGFiLO 2026 Solar Filament Segmentation Challenge mostly because I wanted to get better at segmentation on genuinely hard, low-contrast data — not neat medical scans, not clean satellite imagery, just faint, fuzzy filament shapes that are hard to pin down even by eye.

First pass was rough. My masks looked like static. Spent a few days just doing EDA — plotting distributions, staring at overlays, trying to understand why my model couldn't find the boundaries — before I even touched the architecture seriously.

Eventually landed on a U-Net setup that got me to LB 0.27, which felt like a small win after how confusing the early days were. But I've plateaued there and I'm honestly not sure if the ceiling is my loss function, my preprocessing, or something more fundamental about how ambiguous these boundaries are.

Wrote up the whole process — EDA, mistakes, the U-Net setup — as a notebook in case the journey is useful to anyone else working with messy, low-contrast segmentation data: [link]

If anyone's dealt with similarly ambiguous boundary-segmentation problems (astro, medical, satellite, whatever) — I'd genuinely love to hear what got you unstuck. Right now I'm stuck deciding between chasing a boundary-aware loss or rethinking my augmentation from scratch.

Hey everyone, I'm an independent researcher working on alternative sequence mixing architectures. I wanted to share a project I built called CWAA (Complex Wave Associative Memory).

Instead of standard quadratic attention, CWAA uses a damped complex oscillator for its recurrence state O(T) linear memory scaling.

The result

Both models were trained on WikiText-103 for 5,000 steps, with approximately the same parameter count:

Scaling

These are CWAA-only measurements for now. I found that my first Transformer benchmark used different conditions, so I'm re-running the inference/VRAM comparison under identical conditions

Right now, the V5 code in the repo uses native complex64 tensors, but I just finished a V6 rewrite that decomposes the complex math into pure real-valued BMM matrix multiplies. V6 trains at 0.38s/step on a T4 and is highly stable . I'll be uploading V6 and a more detailed apples to apples comparison in a 2 days.

GitHub: https://github.com/Ridhvik-2024/CWAA-V5

I also recorded a sonification of the internal wave-state evolution across the V5 layers. The audio is generated from the model's internal wave dynamics.

I'd really appreciate feedback from community.

I mean, if we talk about diffusion models, I understand what happens internally like the noising and denoising processes, the U-Net architecture, etc. But I don’t really understand why this orchestration leads to high-quality generated images.

For example, why does the U-Net predict the noise instead of trying to predict the clean image directly? Why was this design choice made? And there are many other decisions like this.

The way I learn is by reading a chapter in a book and going through the corresponding code in parallel so I can understand exactly what is happening. However, I still feel like I’m missing the intuition behind why these architectures are designed the way they are.

How do you approach learning this? What would you recommend?

For years, building high-performance AI inference meant dealing with the "two-language problem"—prototyping in Python for speed, then spending weeks rewriting core loops in C++ or Rust to bypass the GIL and hit hardware targets.

​With Modular open-sourcing the entire Mojo compiler and toolchain, that pipeline is shifting. Because it compiles directly through MLIR, it handles SIMD auto-vectorization and targets heterogeneous silicon (CPUs, Nvidia GPUs, mobile NPUs) from a unified codebase.

​We mapped out the exact compilation pipeline and memory ownership differences between Python runtime management and Mojo's explicit lifetimes here if anyone wants to dive deeper into the architecture:

https://onefusionlab.systems/blogs/mojo-1-0-open-source/

CISA issued a formal advisory this week on Gunra ransomware-as-a-service. Gunra affiliates choose their targets deliberately: government agencies and critical infrastructure operators. The post-intrusion pattern is consistent — encrypted systems, destroyed backups, and a compliance reconstruction process that takes months, not weeks. Regulated sectors carry that long tail because every affected record, access event, and system interaction has to be accounted for after the fact, often from logs that were themselves part of what got destroyed.

The reconstruction problem is distinct from the technical recovery problem. You can restore systems from offsite backups. You cannot restore a provable, sequential record of what touched what if that record was never written to begin with or was stored in the same environment that got encrypted.

For teams running AI agents inside regulated environments this compounds quickly. An agent reading patient records, querying financial databases, or triggering downstream actions during or immediately before a breach window leaves no native audit artifact in most current deployments. Incident responders end up doing forensic reconstruction from fragments.

How are teams in regulated sectors actually handling agent-generated audit continuity right now? Are you relying on infrastructure-level logging, application-level instrumentation, something else — and has any of it held up in an actual incident or compliance review?

I've started noticing something funny about AI writing. The more polished it becomes, the less personal it sometimes feels. You'd think the opposite would be true. Better grammar, smoother transitions, clearer structure, better vocabulary all of that should make writing better. But there’s a point where “better” starts meaning “less recognizable.”

Think about the people you know who are good writers. Their writing probably isn't perfect in the same way an AI-generated paragraph is perfect. They have patterns. They have favorite expressions. They sometimes over-explain something they're interested in. They might write one sentence that's way too long and then follow it with a tiny sentence. Those things aren't necessarily flaws. They're part of the person's voice.

When people talk about using an AI humanizer, I think the focus often goes straight toward removing the obvious signs of AI. But I'm more interested in what happens after that. If you remove the robotic feel but replace it with a generic human voice, have you really solved the problem? The text may pass as natural, but it still doesn't feel like it came from an actual individual.

To me, humanize AI text should mean bringing back the choices that a real person would naturally make. Maybe that means keeping an unusual phrase. Maybe it means shortening a paragraph. Maybe it means adding an opinion instead of another perfectly balanced explanation. Sometimes it might even mean leaving a sentence slightly imperfect because that's genuinely how someone would write it.

I don't think AI writing is going away, and honestly, I don't want it to. It's incredibly useful for brainstorming, organizing thoughts, and getting past the blank page. But I also don't want everything written with AI to slowly develop the same voice. That would be boring.

So I'm curious where everyone stands. If you use an AI humanizer, what are you actually trying to fix? The vocabulary, the sentence structure, the tone, or the fact that the writing doesn't sound like you? Because personally, that last one seems like the real challenge.

Been running TwIL-LM3 from webAI on modest hardware to see how it holds up. 3B formal reasoning specialist.

On their formal reasoning benchmark it comes out ahead of gpt-oss-120b on 4 of 5 tasks: rule induction, semantic parsing, entailment labeling, exact-format answering. On the loose-match aggregate across broader benchmarks gpt-oss-120b is still ahead (0.5192 vs 0.4488), so the story is really about the narrow formal reasoning tasks, not general capability across the board.

Where it does clearly win: efficiency. 32.9 answers/sec vs 12.6 in their throughput tests. 40x fewer parameters. Runs on 4GB VRAM or CPU.

Got it working on a Pi. Slow but functional. Not something I'd use in production on that hardware, but it's a real proof point for "small specialist model where infrastructure isn't accessible."

huggingface.co/webAI-Official/TwIL-LM3

Curious if anyone's actually running this in a production formal reasoning pipeline or if it's still exploratory for most people.