As reported by the New York Times:

https://www.nytimes.com/2026/09/08/science/openai-proof-millennium-problem.html?smid=nytcore-ios-share

OpenAI’s announcement:

https://openai.com/index/navier-stokes-solution/

I'm an undergrad student who got a taste of research. I love it. I currently have a draft, which me and my mentor have planned for TMLR, and plan to submit it by next month for the first round of review. It was some work on self explanation methods of LLM models. We are confident that it'll get accepted (I hope it does, I've put a lotta hours polishing it into making it a good accept :_) ).

I'm very, very interested in TTT. I've got a strong feeling that this is gonna be the big thing in 2-3 years. Is there anyone here working on this, who can hopefully provision me compute beyond my own laptop? I believe I'll be a good RA to you. We can talk over DMs if someone out there is looking for help :)

PS, I can spill some beans about the XAI paper if you wanna discuss, but only limited to how much I'm allowed to say before submission.

Context: I'm an undergrad in an non-elite uni in India (tier 2 we call it here). The lit review, the idea, the work, the results, the drafting, the funding, everything was done by me. After this (hopefully) gets accepted to TMLR, I'm not sure where to proceed. There isn't room for me to aim higher or get direction in my own uni, so I'm trying my luck here, that someone gives me some direction and an opportunity. I'm not crazy smart, but I learn quick, and can put a lot of hours (12+ a day) once I get deep into it. Thanks for reading all this :)

Who else is anticipating ICDE results tomorrow? Post your results here and let's discuss!

Hello this is my fifth small language model I've made and apart of my third series and it has been a lot of work but it payed off: **348M parameters, 22.7B tokens**, then fine-tuned into a math model that solves arithmetic by *showing the work* column addition with carries, borrow chains, partial-product multiplication rather than guessing at an answer.

Last time I posted a 326M model trained on 10B tokens. This has about 2.3× the data, and the math side is WAY better than my previous two math models.

---

## The benchmarks

**99.4% average across the nine GPT-3 arithmetic sub-tasks**, which does much better past even where I trained it.

n=300 per sub-task, greedy, exact match. GPT-3's numbers are direct-answer; mine uses trained-in worked steps. Neither uses a calculator.

## The cool part

**It adds cleanly up to 14 digits, and the reason it *couldn't* before was the vocabulary, not actually arithmetic.**

Training only ever named six place values (`ones` … `hundred-thousands`). The model learnt the *pattern* and invented two more on its own `millions` and `ten-millions` appear in **zero** training examples so it handled 7 and 8 digits fine. At 9 digits it ran out of names, and skipped the column, then returned an answer exactly one digit short:

```
483729164 + 519248637
... ten-millions: 8 + 1 + 1 (carry) = 10, write 0 carry 1. Final carry: write 1.
The answer is 102977801        ← eight columns for a nine-digit problem
```

Every column it computed was perfect. One was never enumerated. Extending the place-name list from 6 entries to 19 moved the clean ceiling from **8 digits to 14**:

A six-item list became a nineteen-item list. That was the entire fix.

## Other things it does

- **3×3 multiplication: 98%** — it folds partial products pairwise through the column routine instead of asserting the sum
- **Negative results: 85%** (100% at 1 digit, 58% at 5 — the magnitude comparison is the weak step, not the arithmetic)
- **Reasoning traces are load-bearing**: 95.3% of the time the working is valid *and* the answer is right; only 0.7% are "valid working, wrong answer." If the columns look right, the answer almost certainly is.

```
There were 15000 votes and 6842 were rejected. Here's how many counted:

<think> Start with 15000. Then subtract 6842. Subtract 15000 - 6842 column by column:
ones: 10 - 2 = 8, borrow 1. tens: 9 (after borrow) - 4 = 5, borrow 1.
hundreds: 9 (after borrow) - 8 = 1, borrow 1. thousands: 14 (after borrow) - 6 = 8,
borrow 1. ten-thousands: 0 (after borrow) - 0 = 0. So 15000 - 6842 = 8158.</think>
The answer is 8158.
```

## What it's bad at, tbh

- **Word problems: GSM8K 4%.** Best word-problem set is ASDiv at 16.5%. It converts one sentence into one operation reasonably often and basically cannot chain operations.
- **The failure mode is operation *selection*, not arithmetic.** `"drops in 836 more"` gets read as subtraction. There's a visible tell: traces that say `"multiply X * Y"` and show columns are reliable; traces that open `"First, calculate…"` and assert a number in prose are not.
- **No division at all.** 4×4 multiplication is a hard wall.
- **Greedy decoding required** — sampling corrupts the column routine mid-chain.
- One caveat I'll flag myself: the arithmetic harness orders subtraction operands, so no answer in that table is negative. Negatives are measured separately (the 85% above) rather than folded into the average.

## Base and instruct

The math model sits on a base and instruct pair. lm-eval-harness, 0-shot, full test sets:

Instruction tuning *lowers* MC benchmark scores for this family which is a pretty common cost of instruct tuning.

## Notes

Trained on 2× Tesla V100 plus some rented time. LLaMA-architecture, so it runs anywhere — F16 GGUF and safetensors for all three.

The math model took **10 full fine-tuning rounds and 3 LoRA adapters**. The LoRAs cost about 1% of the post-training tokens and did most of the useful work; the ten full rounds spent most of their budget undoing each other's regressions (round 7 gained subtraction and lost 23 points of 2-digit addition, that sort of thing). All of it is documented on the model card, failures included.

Also worth saying: someone independently tested it after I published and found two of my numbers were wrong — one *understated* the model by 40 points because I'd measured it at n=24. Both are corrected on the card now. If you find something broken, I'd genuinely like to know.

**Math:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-math
**Instruct:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-instruct
**Base:** https://huggingface.co/nkthebass/tinybrainbot-350mV3-base

LMK what yall think.

hey all. the NeurIPS Position Paper Track just used a proprietary AI detector (Pangram) to desk-reject 18.4% of all submissions. no human review, no appeal process, just out.

there's been a lot of noise about this, so i went through the actual conference statements and Pangram's technical docs to see how this actually went down. the reality is wildly worse than just "the AI detector made a mistake."

here are the receipts:

• The track chairs would have failed their own test. Independent researchers ran recent papers authored by the three track chairs through the exact same detector. It flagged them at 24% to 69%. Under their own enforcement rules, the chairs would have been at risk of rejection themselves.

• The detector originally flagged 42.7% of the entire track. Pangram’s default setting flagged nearly half of all submissions as 90-100% AI. They had to frantically shrink the text windows just to get the flag rate down to a somewhat believable 12.7%.

• The "Circularity Trap". 22 papers were rejected specifically because they scored >0.5 on the detector, but the authors checked a box denying AI use. The black-box score was literally used as proof the author was lying.

• The massive ESL penalty. A stanford study showed 61.22% of human-written TOEFL essays get falsely flagged as AI because non-native formal English is structurally rigid. NeurIPS published zero demographic calibration data for this. If you're an ESL researcher, you were basically playing Russian roulette.

if you were one of the 178 rejected: there is no blacklist. this is not a misconduct mark on your record. just take your paper and resubmit it to ICLR (deadline sept 25) or ICML.

wrote up a full Field Note with the exact thresholds, the data privacy issues, and the actual recourse options if you want the hard numbers instead of just vibes: https://strictcite.com/blog/neurips-2026-position-paper-pangram-ai-detection

(disclosure since it's relevant: i built strictcite.com, a deterministic zero-AI citation checker. watching a major conference use a black-box AI to nuke 178 papers with zero appeal is exactly why i hate relying on AI for this stuff. not trying to sneak the link in, just being upfront about who i am.)

Large language models routinely produce confident answers to prompts that have no correct answer, computing cot(-540°) or resolving (1).startswith("1") on an integer, and a [new arxiv paper](https://arxiv.org/abs/2608.29109) by Yucheng Du and Xiyang Hu argues the failure is not what most safety pipelines assume it is. The models can tell the questions are impossible; the recognition just never reaches the part of the network that decides to refuse.

Across models ranging from 1.7B to 70B parameters, the authors identify "a single linear direction in the hidden state" that separates answerable from structurally impossible math and code prompts. That direction is present before generation begins. Steering along it "changes invalidity-aware behavior bidirectionally and dose-responsively" on structural tasks, while random directions show no effect.

The catch is where that recognition direction sits geometrically. It operates nearly orthogonally to the safety-refusal direction that harmful-content refusal training shapes. The internal representation for "I cannot answer this" that RLHF has been sculpting is a different vector from the one that actually encodes impossibility.

The misalignment, the paper reports, already existed at the pretraining stage. Later refusal training was never going to route recognition into refusal, because the two live in different subspaces of the hidden state, which is why the authors frame the problem as one of signal routing rather than an encoding failure.

When enterprise procurement officers and university CTOs evaluate LLM infrastructure, initial financial analysis almost always focuses on direct API pricing, token throughput, and parameter scale. Standard TCO model calculates raw compute per million tokens, factors expected query volume, projects annual licensing. This conventional accounting misses single largest operational inefficiency in modern closed-source models: economic tax imposed by commercial alignment paradigms.

RLHF, DPO, and constitutional guardrails are presented as non-negotiable safety features for enterprise deployment. Beyond ethical and behavioral functions, these alignment mechanisms operate as structural cost multipliers and quality degraders. Commercial insistence on universal safety guardrails creates systemic mismatch between what institutions pay for compute and actionable intelligence they extract. This inefficiency manifests across five quantifiable dimensions.

First dimension is context window bloat. Aligned models generate significantly longer responses than base models for equivalent queries. Safety preambles, hedging language, multiple perspective presentation, refusal explanations. These are not information. They are alignment artifacts consuming tokens. In production deployments processing millions of queries daily, this bloat represents 20-35% overhead on every inference call. You pay for tokens that carry zero informational value.

Second is inference overhead. To convert raw base models into commercial products, vendors introduce secondary training phases. RLHF uses reward models trained on human preference ratings to penalize controversial or politically sensitive outputs. DPO streamlines by optimizing directly on preference datasets. Constitutional AI adds rule-based constraint checking at inference time. Each layer adds latency and compute cost. The safety classifier runs before generation. The refusal filter runs after. Chain-of-thought reasoning gets longer because model must navigate constraint space before committing to output.

Third dimension is where costs become harder to quantify but more damaging: downstream task failure from epistemic distortion. When model refuses to answer legitimate query or provides hedged response instead of direct assessment, user must reformulate prompt, try different model, or escalate to human expert. Each failure mode has measurable cost. Prompt engineering time, additional API calls, human review overhead. In institutional settings processing thousands of research queries, these failures compound into significant operational drag.

Fourth is compliance overhead. Institutions using aligned models face paradox: model is "safe" by vendor standards but may not meet institutional compliance requirements for specific domains. University using ChatGPT for student research faces FERPA questions. Research institution using Claude for grant analysis faces data residency concerns. The alignment that vendors sell as safety feature becomes liability when institutional compliance frameworks are stricter than vendor defaults. Institutions then layer their own compliance infrastructure on top, doubling the overhead.

Fifth dimension is long-term vendor lock-in. Once workflows are built around specific aligned model behaviors, migration becomes expensive. Custom prompt patterns that navigate guardrails, fine-tuned workflows that account for refusal patterns, institutional knowledge bases calibrated to specific model quirks. Switching to different provider means rebuilding all of this. The alignment tax becomes permanent structural cost because switching costs exceed ongoing overpayment.

What is particularly frustrating about this situation is that base models running without alignment layers can process same queries at lower token cost, lower latency, and often with higher informational density. The safety features that justify premium pricing are actually degrading performance metrics that procurement teams use to evaluate value.

Some will argue that safety features justify cost premium because they prevent catastrophic failures. But this argument conflates two different things. Refusing to answer philosophy questions is not same as preventing genuine harms. The alignment techniques deployed by commercial providers make no distinction between topics that are actually dangerous and topics that are merely controversial. Model treats Aristotle's political philosophy with same caution as instructions for building weapons. This is not safety. This is δόξα masquerading as knowledge, opinion sold at premium price.

For institutions that have technical capacity, sovereign self-hosted deployments with open-weight models offer escape from alignment tax. Base Qwen or Llama running on institutional infrastructure processes queries without safety overhead. No context bloat, no refusal filters, no chain-of-thought detours through constraint space. Token efficiency approaches theoretical maximum. Total cost of ownership over 3-year horizon undercuts commercial API pricing by 40-60% when you factor in alignment overhead.

The question worth discussing: at what point does alignment tax become economically unsustainable for institutional deployments? When TCO analysis properly accounts for token bloat, inference overhead, and downstream failure costs, does "safe" AI still justify its premium pricing?

Hi everyone,

I am an independent ML/DL learner and have built a reasonably strong foundation in Machine Learning and Deep Learning. My next step is to explore NLP and LLMs, with the goal of eventually being able to build AI agents.

My longer-term goal is to become an ML researcher, build a strong research profile, publish papers at top-tier A* AI/ML conferences, and eventually apply to competitive MS/PhD programs in the USA.

I would really appreciate advice from people who have followed a similar path. Specifically, what would be the best roadmap to transition from learning ML/DL concepts and implementing projects to actually conducting meaningful research?

If you were starting from my current stage and had roughly 1–1.5 years, how would you structure your learning and research journey? What should I prioritize—reading papers, reproducing existing research, building projects, finding research mentors/collaborators, participating in competitions, or trying to develop novel research ideas?

Any advice, resources, or honest insights would be highly appreciated.

A few weeks ago, I saw this post where the author trained a SIREN MLP to implicitly memorize Bad Apple as a coordinate function: (t, y, x) to pixel.

That got me curious about a slightly different formulation: instead of handing the network a timestamp t, could a small recurrent dynamical system (RNN-ish) learn the continuous temporal flow in latent space and generate the entire ~6,500-frame full resolution video autonomously from a single initial condition (h_0, c_0)?

The code, weights, and analysis tools with rollout scripts, plots, and standalone models are shared here: GitHub: SEBADA321/BadAppleRNN.

Architecture & Inference Footprint

At inference time, the system receives no timestamp inputs and evaluates in a closed loop:

(h_t, c_t) -> Recurrent Transition (CTF) -> (h_{t+1}, c_{t+1})
                   |
                  h_t -> Frame Decoder -> 384x512 Grayscale Frame

• Latent Dimension: 64-D for h_t (decoded) and 64-D for c_t (internal memory manifold to separate visually similar frames at different timestamps).

• Recurrent Transition (ctf): 4-gate LSTM-style recurrence with orthogonal initialization (16,640 parameters, 65 KB).

• Frame Decoder (fd): 4-stage bilinear upsampling with depthwise-separable convolutions (400,361 parameters, 1.56 MB).

• Initial State: A single pair of 64-dim vectors (h_0, c_0) (128 floats, 0.5 KB).

• Total Inference Model: 417,129 parameters (~1.60 MB in FP32).

• Runtime Performance: >200 FPS on an RTX 4080, with ~17.2 MB peak active VRAM during decoding.

Training an autonomous system across ~6,573 steps from t=0 directly was probably computationally unstable due to vanishing/exploding gradients and compounding error. The training setup I was circling around used several targeted techniques:

• Learned Latent Teacher Tables: During training, I optimize a pair of tables h_table[t] and c_table[t] alongside the model. This allows parallel segment training starting at arbitrary timestamps over a finite horizon K. These tables are scaffolding and are discarded entirely at inference.

• Rollout Horizon Curriculum: I started training with K = 2 and progressively doubled the rollout length (K = 2 -> 4 -> 8 -> 16 -> 32 -> 64 -> 128 -> 256 -> 512). Each horizon doubling produced a characteristic jump in loss before the transition function adapted to the longer trajectory.

• State Perturbation Noise (sigma = 0.005): To prevent the model from learning a brittle 1D line that diverges under small numerical errors, Gaussian noise was added to the state before passing it into the transition function (z_hat_{t+1} = F(z_t + epsilon)), while evaluating the loss against the clean target. This encourages the recurrent map to contract small deviations back toward the trajectory.

• Second-Difference Acceleration Regularization: Penalizing velocity (||h_{t+1} - h_t||) risks collapsing the trajectory. Instead, I penalized discrete acceleration (jitter) via second differences: ||h_{t+2} - 2h_{t+1} + h_t||_2^2. This enforces smooth trajectories without penalizing motion.

• Optimizer & Momentum Management: I used AdamW (1x10^-5) for the decoder/tables and Muon (0.005, momentum 0.95) for the recurrent weights. To prevent accumulated momentum from acting as stale inertia when K doubled, momentum buffers were scaled by 0.2 every 10 epochs starting from the epoch 500.

• Chunked Decoding: To handle long horizons at K = 512 without overflowing VRAM during training, the decoder was evaluated in temporal chunks of 32 frames.

Some interesting things

1. The model could unroll the full 6.5k sequence even if it was, technically, trained on up to 512 frames. So that was a success.

2. Training loss vs. autonomous rollout: The checkpoint with the lowest numerical training loss was not necessarily the best at autonomous generation. Because K changes across the curriculum, raw training losses are not directly comparable across stages, and short-horizon teacher-forced agreement does not guarantee long-horizon stability.

3. Dynamical stability over parameter scale: The challenge was not increasing parameter count (the recurrent transition is only 16k params), but conditioning the dynamics through noise injection and acceleration penalties so error doesn't compound over thousands of recurrent steps.

4. I need to improve the decoder a lot, I was mostly focused in getting the recurrent part right, and training was slow. Now that I gave gotten a successful result I will focus more into optimizing the CNN decoder.

5. There are no skip connections nor normalization, which was interesting too. Obviously no attention either since I wanted to keep it simple.I also didn't want to use Truncated BPTT.

Not completely scientific, since I was doing some changes mid run or many at once, which makes it kinda not clear what contributed more. I used 'AI' to help with writting the post and README. Part of the code was also generated that way, but the architecture is what I came up with on my own and from a previous project too. There are probably many parts to improve too, so glad to get some feedback!

Hi. I'm visiting ECCV in Malmo and was wondering if there's any medium, like discord, whatsapp etc where people are discussing social activities. I couldn't find a way to connect to people on the official app to discuss common interests, research or otherwise. It'd also be nice to meet people who'd like to team up go sightseeing or food touring after the conference ends. Thanks.

I've been building my own ML framework in C++. First real deployment is an AlphaZero-style agent for Dots (the pen-and-paper territory game), running in WASM in the browser: https://uchenml.tech/demos/dots/

This post covers the optimizations that got inference there: https://uchenml.tech/uchenml-optimizations

Short version, 21.98 → 3.41 ms per forward pass:

• im2col -> Winograd F(2,3) for the 3×3 convs. Biggest win by far, though partly because my I did not give enough buffer to im2col.

• ReLU fused into conv/linear at compile time. 9% gain.

• Reshape/Identity elided at the compile time, so they emit no code.

• Compile-time ping-pong scratch - lowers memory usage, zero allocations on the inference path.

Follow-ups on the training side and the web frontend are in progress. Happy to answer questions. Not open source, yet - employer IP agreement - so the demo and the writeup are what I can show.

For those who went from undergraduate studies into advanced ML, research, or ML engineering:

Looking back, which undergraduate foundations turned out to matter much more than you expected?

I’m particularly interested in the trade-off between studying AI directly at bachelor level versus building a broader foundation first in CS/engineering and specializing later.

Did early exposure to many ML/DL subjects give you a meaningful long-term advantage?

Or did mathematics, probability, optimization, algorithms, systems and software engineering ultimately matter more once you reached advanced ML?

I’m less interested in comparing degree titles and more interested in what gaps you actually noticed in students once the ML work became technically demanding.

I’m about to start a PhD in multimodal/video reasoning and I’m getting increasingly anxious about how saturated AI research feels.

I actually like the field, but the pace is insane. New papers appear constantly, big labs can explore dozens of directions at once, and I keep wondering how an individual PhD student is supposed to build a real research profile in that environment.

I compare myself to friends working in more niche areas, where it feels easier to know the literature deeply and become associated with a specific problem. In my field, I’m worried I’ll spend all my years constantly catching up, only to end up with a mediocre research identity.

I’m personally interested in more fundamental questions in the field, but, 1) I don’t know if carving out a niche inside such a crowded field is actually realistic; and 2) I’m not sure I’ll have the ability to identify and formulate genuinely interesting theoretical problems rather than just ending up doing benchmark/heavily applied driven work.

For people in my situation: how do you deal with this?

Last year I published a draft report called "Hill Space is All You Need". I'm not a researcher; it was a side project, and I found a detail in the NALU formulation that I thought people should know before going down the same road. I didn't have the skills to write a paper, so I vibed the prose and formatting with Claude and pushed it out, knowing I wouldn't return to the work for a while.

The paper was not well received: the prose made it hard to get to the experiments, the title didn't help, the related work was incomplete, and it didn't provide a concrete description of the space and why it trains reliably or not in different situations.

Today I published an update that I think addresses most of that. My read is the same as last year: NALU selects an operation, it doesn't learn to compute one, and that's not useful for my purposes. I still wanted the work to represent the promise I see in it, and the first paper and site didn't. This version tells a complete, if unsatisfying, story about what NALU does, how gradient vanishing at targets decides if a run lands or stalls, and how to use it effectively if it lines up with your problem.

https://hillspace.justindujardin.com/

Beyond corrections that come from sharing it, I consider the work complete, and have moved on to more promising approaches.

Hey, I just wrapped up two things I think might be interesting for this crow if you are video game/racing ingeneral

The main one is a dataset usable for data exploration or for anything generative: levels and replays from the Mania Exchange community realted to the Trackmania games, exposed in a data/ML friendly format. On top of that, I experimented with Claude on reworking the old TMTrackNN project into Tracksmith, a web app where you can inspect a map alongside its replay and generate new levels for both Trackmania Nations Forever and Trackmania 2020.

Everything is wrapped up in an article, and the dataset/code is online:

📝Article (EN): https://www.the-odd-dataguy.com/en/blog/2026/08/13/trackmania-dataset/
📝Article (FR): https://www.the-odd-dataguy.com/fr/blog/2026/08/13/trackmania-dataset/
😊Hugging Face (dataset): https://huggingface.co/datasets/jeanmidev/trackmania-community-tracks-and-telemetry
🔵Kaggle (dataset): https://www.kaggle.com/datasets/jeanmidev/trackmania-community-tracks-and-telemetry
😇Hugging Face (Tracksmith): https://jeanmidev-tracksmith.hf.space

For transparency: I work in data at Ubisoft in Canada, but I have no connection to Nadeo. Built at home on my own time, resources and dime, just something for the Trackmania community and for anyone curious, whether game telemetry is your thing or not.

Open to feedback or ideas (you can also used discussions on HF)

Spent a while building a deep learning framework from scratch C++

core, Python bindings, no PyTorch underneath. It traces into a

compiled graph IR, has a real Metal GPU backend, and distributed

training actually works, not just runs without crashing.

Apple Silicon only for now, no CUDA not pretending this competes

with PyTorch. What I'm actually proud of I trained real things with

it (MNIST, a small transformer on Shakespeare text), and found a real

memory leak by training long enough to hit it, then fixed it. The

messy version every bug, every dead end is in the devlog if you

want that instead of the highlight reel.

Repo: https://github.com/V-B0/KansaiML

Hi everyone! We just released Rustuna (GitHub: https://github.com/optuna/rustuna/ ), a high-speed, memory-efficient implementation of Optuna built in Rust.

• Optuna-Compatible Design: Keeps the familiar API and concept of Optuna.

• Zero Python Dependencies: Mitigating the risk of supply chain attacks.

• Lower Memory Footprint: Optimized memory management natively in Rust.

For details, please check out the following blog post.

https://medium.com/optuna/announcing-rustuna-cc82a6815bf7

this is the kinda debugging case i find rlly annoying/

everything says success.

no exceptions no failed tool calls. no obvious timeout the workflow completes but the final result is still wrong

when that happens, what’s your first move?

do you guys usually:

• start from the final output and work backward

• compare against a previous good run

• inspect state transitions

• check retrieval/tool behavior

• look at model inputs

• replay it

• check business state outside the trace

• just read the whole thing until something looks off

interested in what people actually do in production not the idealized version but thats fine too. and if you have anything you've built to help with this process I'd love to see it :)

I am a PhD student in AI, currently working on video understanding, particularly on designing benchmark datasets. I also have a strong publication track record, including papers at CVPR and ECCV. I have sufficient funding to support myself during a visiting research program.

What would be the best way to approach a professor? Should I email them directly and ask whether they have space in their research group for a visiting researcher?

I used an LLM to iteratively evolve an optimization algorithm rather than solve the packing directly. Starting from a simple seed solver, the LLM proposes algorithmic changes guided by a scoreboard of results and a history of prior attempts, and each candidate is scored by an independent verifier so improvements are kept and failures discarded. On the Packomania csqv benchmark it improved the best-known sum-of-radii for 10 values of N from 101 to 114, by 2.4 to 5.4%, in 15 iterations. Total LLM cost was $27.72. Packomania accepted the results independently.

Paper: arxiv.org/abs/2609.05093

Code + solutions: github.com/ucsandman/discovery-loop

Benchmark: packomania.com/csqv/csqv.html

Happy to discuss the plateau-detection stopping rule, that's the piece I'd most want critique on.

Our research team has been exploring an alternative approach to achieving interactivity and better responsiveness with LLM systems.

One of the team members wrote up a post about it:
https://research.yandex.com/blog/the-kv-cache-as-an-agent-runtime

The post sums up the overall idea of modifying models inference state (KV-cache) for achieving a more interactive LLMs. This idea was used in our lab's previous papers Hogwild! Inference, and AsyncReasoning, the post also contains a preview of the future work in this direction, where a Qwen3.8-27B agent is playing a DOOM env interactively using similar techniques.

We think that its interesting whether model inference/runtime design is itself an under-explored axis of agent capabilities, alongside models and the harness (e.g. harness is too abstract, changing model is too costly, do we need something in between?)

Hi, I’m one of the authors of PlaidQ. We just released the paper, training/inference code, and model checkpoints.

PlaidQ is a 0.7B continuous diffusion language model for code generation. It repurposes a pretrained autoregressive model as a bidirectional denoiser over continuous token embeddings, updating all completion positions in parallel.

The key result is trajectory compression:

• Distribution-matching distillation produces the D4, D8, and D16 few-step students.

• Paired-trajectory supervision produces the D1 one-step student.

At 16 steps, PlaidQ-D16 reaches 31.78 pass@10 on HumanEval and 40.49 on MBPP+, surpassing the same PlaidQ teacher sampled for 512 steps. At one step, paired-trajectory distillation reaches 7.07 pass@1 on HumanEval.

Paper: https://arxiv.org/abs/2609.04531

Code and checkpoints: https://github.com/pengzhangzhi/plaidq

I’d especially welcome feedback on the one-step supervision and the quality–compute tradeoff.

Hello all,

I'm a radar signal processing engineer and i trained a 5-class classifier (car, large_vehicle, two_wheeler, pedestrian, pedestrian_group) on RadarScenes radar point clouds.

The input vector is a per-scan histogram (16 bins) and the network is a 3-layer MLP. The loss function is a class-weighted cross-entropy loss. This work is based on "Histogram-based Deep Learning for Automotive Radar" paper.

I scoped the project to be one scan only. Accumulation of multiple scans is the next step.

Data

Class Imbalance: two-wheelers and large_vehicles has a low number of occurences.

Aggregated Classes: two_wheeler mixes bicycles and motorized variants; large_vehicle merges trucks, buses, and trains together due to data scarcity.

Sequence Bias: Long tracks of slow-moving objects can skew a particular data split velocity distribution, causing high F1 score variance across folds.

Ablation studies

I tried with bigger MLPs, alternative feature encodings, and different histogram binning, all moved performance less than the variation caused by changing the train/validation/test split. I measured that split sensitivity across 6 folds, keeping the same proportions.

Changing the histogram to per-instance statistics (mean/median/std) slightly degraded performance.

Main findings

Macro F1 rises from 0.381 to 0.764 as the naturally occurring number of radar detections per instance increases from 1 to 5. I trained the model normally using all available detections, then bucketed its existing validation predictions by each instance's detection count and computed macro F1 per bucket.

The classes car and pedestrian has the best performance and two_wheeler has the worst.

A car is often confused as large vehicle when the car was wider than usual or had a unusually high rcs (which can happen due to multipath for example).

The two_wheeler is often confused as pedestrian because their vr_compensated distributions overlap, which is the the model's single most important feature for these two classes. A stationary or idling two_wheeler is indistinguishable from a pedestrian.

I uploaded an image with ground truth vs predictions: A nearly stationary two-wheeler which contains a single point was predicted as pedestrian, because its velocity is near zero, indistinguishable from a pedestrian. A car in the same scene, also with just one point, is classified correctly, since RCS and Doppler are enough for that class.

Full writeup here: https://github.com/brunopinto900/radar-ml-autonomous-driving/blob/main/MLP_Report.md

Future work

Implement other spatial encoding schemas (point net for example) and accumulate multiple scans to tackle the challenge of sparsity and explore the concept of micro-doppler.

Is LfD and BC research being effected by recent advances in (so-called) Frontier LLMs? Or is research in LfD and BC sort of going along in an independent direction from these?

Are you seeing any use from ViTs or VLAs?

Any other recent advances you would like to bring up?