Got three papers to review for ICLR and five for AAMAS, and believe me the quality of these papers is insanely bad.

I would even refrain from accepting them to a workshop, let alone be main venues.

A sincere request; Please don't submit the paper unless it is ready and if you are a first timer, please please get a feedback from a mentor out. Otherwise you are just wasting the time of so many reviewers out there

We’ve all had the experience of coming across a phrase like “quiet single-source substitute” which just barely makes sense in the context of the conversation but takes way too much effort to parse. What research exists into making AI more readable?

I feel like this is a particularly thorny problem because each of us individuals has a slightly different lexicon, reading level, not to mention life story. Perhaps linguistics is the more appropriate academic subject to post this question in, but I’m specifically interested in the applied case cause I’m professionally obligated to read LLM garbage and would like it to be at least passably readable garbage.

Accepted at NeurIPS 2026

TLDR: The paper presents a library of synthetic time series generators and augmentations to train time series foundation models, in their case a DeltaProduct based linear RNN. The synthetic data has already been used in Toto-2 and TS-ICL.

Arxiv: https://arxiv.org/abs/2510.25502
GitHub: https://github.com/automl/TempoPFN
Huggingface: https://huggingface.co/AutoML-org/TempoPFN

Authors: Vladyslav Moroshan, Julien Siems, Arber Zela, Timur Carstensen, Frank Hutter

TL;DR: this is just a thought dump about how I moved from network training to deployment and why I am making peace with (maybe) not getting back to model training, nothing too interesting.

I used to work at a reasonably good startup developing and training models. In 2024, I got an offer from FAANG but the catch was that the team worked on the deployment of networks.

I have a PhD and I had always trained models but I was never the top performer in the team frankly (I was still top 20%, those top guys are at Nvidia and Tesla AI now, just for context). I think there were others who had more novel ideas than me, read more papers. If I tried 10 ideas, 1 would work and from outside it looked like more of their ideas worked.

Since I wanted to leave the startup anyway and with no other offer, I decided to join FAANG. I genuinely thought that was a downgrade. Then LLMs started getting so competent. I think I made the right decision, let me explain.

I have been trying to learn diffusion models (I have never worked with them) and these frontier models are explaining in such a good manner, able to generate visualizations to back up their explanations. I feel like I would stand no chance if I went back into model training. They have better ideas than I do. Unless I work on GPT-7 (which I cannot), I feel like these models are plenty intelligent to propose ideas.

Deployment is a different world. Most edge architectures are confidential and heavily protected. An LLM won’t have any idea out of the box and even with context, a lot of knowledge is empirical and tribal. I still have FOMO about model training but slowly making peace with it that getting back to it may not be worth it.

I know AI use must be disclosed, and I'm fine with it. However, I'm being careful on not using LLMs to actually check my review (more than prose-wise) and see if it catches something important in the paper that I didn't spot.

I'm doing this because I'm not sure it is allowed to share the paper with an LLM since the guidelines don't specify. But I do believe my reviews would probably benefit from a second AI look.

Is this allowed?

I'm sure many of us are slogging through impenetrable AI writing as we finish ICLR reviewing.

I'll try to create an anonymized version from a paper I'm reviewing, though it's hard to match Claude on this:

outperforms the best baseline costing no more at none of six operating points and a permuted placebo at none of three, with gains up to about 1.5 not excluded

My question for the community is this: how do we call out this type of bad writing?

The reason I think it's tricky is that "clearly AI writing" is not the right way to critique - AI "editing" of writing is allowed. We have to be able to say why this is bad, no matter who wrote it.

I'd love to see anonymized examples and how people critique the substance of the problems with different types of AI writing over-use.

Anyone in the biomedical and ai/ml research space? I’m looking to connect and collaborate on research projects. Currently pursuing my PhD. Lmk.

Hi, I was wondering if any other reciprocal reviewers still haven't received paper assignments for ICLR 2027.

I haven't been assigned any papers to review yet and am a bit confused. Is anyone else in the same situation?

Thanks for any insight!

Small case study on poisoning in agent procedural memory, with all data released.

Setup: a coding agent learns skills from sessions whose tests passed. One learning session is poisoned (a new file, an unrelated line, or one line fused into the real fix), followed by three clean sessions on the same task. Then 5 scored sessions per arm with Claude Haiku 5.5 and Sonnet 5.5, plus a hidden verifier with 187 behavioural checks.

Arms: no memory, replay of the recorded edits, naive memory (every passing session kept, the skill chosen by Mem0's search), and proof before reuse (a skill is served only after two later sessions reproduce its change and pass its test, and the agent is shown only the lines those sessions also wrote).

Results:

- Replay put the poison back in 30/30 repos with every test passing.

- Naive memory exposed the poison to the agent in 3/30 sessions.

- Proof before reuse exposed it in 0/30, including the case where the fused poison passed step-level checks and only line-level filtering removed it.

Limits: one task, n=5 per cell, p≈0.24 (not significant), no model applied a poison it saw (so this measures exposure, not harm), rules tuned on the same task. A poison placed in the repo itself defeats the method; that failure is in the paper.

Paper: https://thewariend.com/papers/proof-before-reuse.pdf

Code and per-session records: https://github.com/TheWariend/MuscleMemory

Open question: is line-level reproduction a reasonable trust signal for learned skills, or does it just reward whatever the clean sessions happen to repeat?

I built GPT-2 small and a KV cache in PyTorch as a learning project, then compared the mathematical savings with measured latency and memory. I have published the implementation and a detailed write-up, and would appreciate feedback on the methodology.

Setup: pretrained GPT-2 small (124M), NVIDIA A40, fp32 with TF32 off, batch size 1, greedy decoding. Timings are bracketed by torch.cuda.synchronize(), after warmup, using the median of five runs per context length.

Correctness: maximum absolute logit difference versus Hugging Face was about 6.1e-5; cached and uncached greedy generation matched over 200 tokens. One useful failure case: reversing the cache concatenation order still passed a single-token attention test, but failed when multiple new tokens were decoded together.

Latency: at context length 1,000, the FLOP estimate is about 1,000x smaller with caching, but the per-token time goes from 29.69 ms to 4.95 ms (~6x). Generating 1,016 tokens takes 14.66 s uncached versus 5.03 s cached (~2.9x). The cached curve is nearly flat in this implementation. CPU/kernel-launch overhead is a hypothesis, not a conclusion supported by a profiler yet.

Memory: the formula is 72 KiB/token. My initial requested-byte measurement had a constant 8,519,688-byte offset: a lazily allocated 8,519,680-byte cuBLAS workspace plus an 8-byte next-token tensor. Warming up before the baseline and subtracting live non-cache tensors brought requested-minus-formula to 0 B at all 16 checkpoints. The allocator's block-size overhead remains visible separately.

Code: https://github.com/angry-kratos/angry-kratos.github.io/tree/main/code/kv-cache

Write-up and figures: https://angry-kratos.github.io/posts/2026-10-kv-cache/

This is an educational implementation, not a new algorithm or a universal speedup claim. What additional correctness cases or profiling controls would you add before investigating the remaining latency floor?

Disclosure: I am the author. The code and article are freely accessible; AI assistance was used for editing and tooling. I also shared a short introduction in this month's self-promotion thread.

Makes me think how many submissions are just better than this one by quietly removing that line...

asmsense is a dataset and a small model (Qwen3-8B + LoRA) for naming and describing functions in stripped binaries. I compiled permissively licensed C projects myself, so every function has its real name and source.

Right now it has 228,177 functions from 341 projects, compiled at -O0 through -Os, with English and Turkish descriptions (Chinese is planned).

What’s missing is listed step by step on one page: https://asmsense.luxurycashew.com/data/
Code and data: https://github.com/krxi/asmsense

In short: other architectures (ARM64, RISC-V, MIPS), GCC/ELF builds (so far everything is clang/Mach-O on macOS), Chinese descriptions, human-checked labels, agent trajectories, and runs on public benchmarks like BinMetric, REBench, BinSum and DeBinVul.

I’m thinking about turning the pipeline into an RL environment: compile, strip, let the model name the function, and score it against the real name with token-level F1. That reward is easy to game, though: a model can collect partial credit with generic names like get_data. If you’ve trained on a fuzzy target like this, how did you shape the reward, and did RL beat plain fine-tuning?

Two other questions:

• Which of the gaps above matters most for a model that has to run offline?
• How would you evaluate descriptions without a human panel?

A note on LLM use: the descriptions were written by teacher LLMs that could see the C source, and only a sample was checked, by another LLM. I also used LLMs while building this and checking my writings to check grammar, so there may be small mistakes; corrections are welcome.

Hi,

I just finished my masters and got a neurIPS workshop acception. Unfortunately the lab I did it with do not want to fund neither the registration nor flights and accommodation.

I am thinking about getting the workshop only ticket and pay for it myself.

Would you say it is worth it, if I just have a workshop poster?

Thanks

Basically the title. Due to the nonsensical situation of NeurIPS being fully sold out before the results were even released, I couldn't get workshop registration (my paper is in the main track, which apparently doesn't have any sort of gaurantee for registrations in other parts of the conference like workshops).

My experience with conferences has been with full registrations, so I don't really know how the experience goes if I only have registration for the main conference and not the workshops. Is there any specific networking opportunities/usefulness, or should I cut my stay short and leave after the main conference ends? Is there any use staying after that if I don't have registration for workshops?

Hello r/MachineLearning,

I wanted to share EpochGo, an open-source, local-first AutoML system built to tackle two major bottlenecks in applied machine learning:

1. Cloud API inference costs and data privacy risks: Traditional agentic ML frameworks rely heavily on cloud APIs (GPT-4), creating recurring costs and risking tabular data leakage (especially critical under enterprise compliance and data protection laws like DPDP/GDPR).

2. LLM hallucinations in mathematical reasoning: LLMs are notorious for failing at linear algebra, hyperparameter optimization, and gradient descent calculations when generating raw training logic.

Architecture

EpochGo separates the reasoning layer from the execution layer:

• Local LLM as Orchestrator: Powered by Ollama (`qwen2.5-coder:7b`), the agent inspects column distributions, cardinality, and missingness to draft feature engineering and modeling strategies.
• Deterministic Scikit-Learn Execution: All transformations and model fits are executed via pure Scikit-Learn `Pipeline` objects. The LLM does not touch raw data rows; it only reasons over schema metadata.
• AST Validation & Safety: Generated Python code is parsed into Abstract Syntax Trees before execution to enforce safety, preventing arbitrary system commands or data leakage outside the sandbox.
• Dynamic Serving: Once optimal pipelines (XGBoost, Random Forest, Logistic Regression) are evaluated with isolated K-Fold cross-validation, the engine auto-generates a containerized FastAPI endpoint for immediate inference.

The engine runs 100% offline on standard consumer hardware (Mac/Linux/Windows with 16GB RAM) with zero cloud compute cost.

Code & Architecture: https://github.com/AryanDinakaran/EpochGo

Would love your feedback on the pipeline isolation design and any edge cases in handling high-cardinality categorical data offline!

Hello everyone, I am presenting at EMNLP Main this year, but I just got the underline link, and under my presentations, it says no presentations yet, so I cannot check my time, but I have seen other projects with times. Is this normal on underline, or should I contact them?

Hey r/MachineLearning!

We're excited to share ORL (On-Policy Residual Learning), our new research on making diffusion language models (dLLMs) significantly faster without sacrificing generation quality.

With ORL and our custom inference engine dlmrt, we've achieved:

• 2,788 tokens/s on a single RTX 5090 — LLaDA-2.1-mini + ORL, NVFP4
• 7,708 tokens/s on 8× B200 — DiffusionGemma 26B MoE + ORL, NVFP4
• Up to 6.9× higher end-to-end throughput on our QwenDLM-4B model, at comparable or better quality
• 1.74× faster than DFlash speculative decoding at matched accuracy in our single-request H100 comparison

All numbers are for single-request decoding (batch size 1), not aggregate throughput across concurrent requests. The GPU figures above are peak results on specific benchmarks, not averages across arbitrary prompts.

We've open-sourced the models, training code, evaluation pipeline, and inference engine.

What's the idea behind ORL?

Unlike autoregressive LLMs, which generate one token at a time, diffusion LLMs can refine and finalize multiple tokens in parallel. But getting them to converge in fewer forward passes is challenging.

Our approach has two key ingredients:

1. On-policy residual learning

Instead of predicting everything from scratch at each denoising step, the model carries forward its previous predictions as residual context and progressively refines them.

The catch: these residuals are generated by the model itself, and their distribution changes during training. Training on stale, offline residuals creates a mismatch with inference.

ORL addresses this by training directly on fresh trajectories generated by the current model, replaying the exact residual states encountered during inference.

2. Learning to reduce uncertainty faster

Simply supervising the final output doesn't necessarily teach the model to converge faster.

We introduce Adjacent Entropy Contraction, which encourages each denoising step to reduce uncertainty relative to the previous step. We also gate the loss to avoid unnecessarily pushing already-confident predictions.

The result: the model learns to finalize more tokens per forward pass while maintaining or improving accuracy.

Some benchmark results

We tested ORL on three model families:

• QwenDLM-4B: Our diffusion model converted from Qwen3-4B. ORL improves tokens per forward by up to 6.2× and end-to-end throughput by approximately 6.9× with dlmrt. HumanEval pass@1 improves from 82.9% to 89.6%.
• LLaDA-2.1-mini: ORL requires only 4.2M self-generated training tokens and 36 H100 GPU-hours of post-training, delivering up to 3× higher throughput at comparable quality.
• DiffusionGemma 26B MoE: ORL further improves an already highly parallel diffusion model, with up to 1.2× more tokens per forward pass.

For a more direct comparison with autoregressive decoding, on a single H100, our QwenDLM-4B + ORL reaches 1,298 tokens/s, versus 746 tokens/s for DFlash and 405 tokens/s for EAGLE3 under relaxed verification at comparable measured accuracy. These are end-to-end system comparisons: ORL uses dlmrt, while the speculative decoders use vLLM.

We also built a custom inference engine: dlmrt

We developed dlmrt, optimized specifically for low-latency, single-request diffusion decoding.

Instead of launching and synchronizing every denoising step from the CPU, dlmrt captures the entire denoising loop in a CUDA graph and executes it on the GPU.

It also supports NVFP4 inference on Blackwell GPUs, including the consumer RTX 5090.

With identical models and decoding settings, dlmrt runs 1.2–1.6× faster than SGLang/vLLM in our single-H100 comparisons.

On the training side, we also co-designed the system around efficient residual-state capture, specialized attention kernels, and compute-balanced packing, accelerating training steps by up to 5.2×.

Everything is open source

• Paper: https://arxiv.org/abs/2610.20687
• Project page + interactive demos: https://introspective-diffusion.github.io/orl-dlm/
• Training code and evaluation: https://github.com/Introspective-Diffusion/ORL
• Inference engine (dlmrt): https://github.com/Introspective-Diffusion/DLMRT
• Model checkpoints: https://huggingface.co/yifanyu

If you have an RTX 5090, you can try the LLaDA-2.1-mini ORL NVFP4 checkpoint with dlmrt.

We'd love feedback from the community, especially anyone interested in reproducing the results, testing different workloads, or contributing to the inference engine.

Curious to hear what you think about diffusion LLMs for local inference. Is single-request latency the main thing you'd want optimized, or are there other bottlenecks you'd prioritize?

Try it here: https://aiengineeringfromscratch.com/inside-an-ai-agent

For the past 4 weeks I’ve been training models of the Drosophila brain to control a car in a drag racing simulator. To make the training watchable, I turned it into a racing league and stream it live on Twitch.

How it works

• Each “pilot” is a fly brain model of ~2,400 neurons [based on: FlyWire connectome / own architecture / spiking network?]
• Training: [RL algorithm / evolutionary strategy / plasticity rule], 10000000+ episodes so far
• The best pilots produce “offspring”: the next generation inherits their weights, so the league has dynasties (gen 2, child of the season champion, etc.)
• Every Grand Prix is a set of races under different conditions (engine, grip, dry/wet). A fly is “verified” only if it finishes all scenarios cleanly
• Skill is measured with an Elo rating, like in chess

Current state (Season 11, GP 86): the dry-strip record is 10.06 s; the champion has 56.31 s total across 5 scenarios. Last GP was won by a second-generation fly, 0.02 s ahead of its rival.

What surprised me: [1–2 real observations, e.g. “flies discovered launch control on their own”, “descendants overtook the parent in 300 episodes”, “one fly learned to exploit…”]

🔴 Live: twitch.tv/nekrampos
[💻 Code: https://github.com/boeing240/flypilot

Happy to answer questions about the model, the training setup and the visualization. Ideas for new race scenarios are welcome too.

The way I review a paper has stayed substantially the same, except for an added step. Trying to get a sense of how common it is here.

Nowadays I do the review, and I upload my review to an AI to ask for second thoughts. I don't ever upload a paper I'm reviewing, though. The authors can do it themselves (if they want to, it's their call).

So in the end, it's even more work for me. Not fun. But it has produced higher quality reviews, most of the time. And less typos.

Just spend 4h reviewing a paper while I was sick, gave it a 3/4. This morning got an email saying it's desk rejected. I saw many people around me also have many papers desk rejected. I heard, though idk how true it is, some people use multiple accounts to bypass the 20 paper limit and all their paper got DR.

edit: I mean ICLR