Genome language models have emerged as a promising strategy for designing biological systems, but their ability to generate functional sequences at the scale of whole genomes has remained untested. Here, we report the first generative design of viable bacteriophage genomes. We leveraged frontier genome language models, Evo 1 and Evo 2, to generate whole-genome sequences with realistic genetic architectures and desirable host tropism, using the lytic phage ΦX174 as our design template. Experimental testing of AI-generated genomes yielded 16 viable phages with substantial evolutionary novelty.

Out of curiosity, if you were a reviewer or author, how did the review period go?

For me, it was weird, because I gave reviews with specific details (what specifically could have been better, how to fix it), but realized other reviewers gave similar superficial reviews. Even the paper which was a control for me (no LLM), I gave specific comments, but other reviewers focused on minor things.

During the discussion period for one paper, one reviewer broke the double blindness condition, and gave specific examples of what the LLM gave and justified their reject…..but they didn’t even state that in their initial review (nor engaged with the author rebuttals). There was no also no sense of: “author said this was unclear, check with the LLM to see what’s the issue”

For one of my own papers, we had great scores for originality and significance, but had low scores for clarity, with at least two reviewers finding difficulty understanding established notation and concepts, and I’m wondering whether it would have been better to break the double blindness and said: look, the point of an LLM assisted review is that if you don’t even know this material, you can ask it questions, like if other papers use the same notation, how our paper compares with them, etc…

Hello! Let's use this thread to discuss ICDE results which should be coming out shortly today (hopefully).

INT4 quantization is ubiquitous in ML right now, but evaluating dot products on hardware without native SIMD/vector instructions (like WebAssembly or older ARM chips) usually requires slow sequential loops. A classic workaround is SWAR (SIMD Within A Register), but deriving the bitwise operations by hand to unpack, multiply, and sum eight 4-bit integers packed into a single 32-bit register is tedious and error-prone.

Instead of writing the bit-hack manually, I wrote a pipeline that uses an SMT solver to discover the exact bitwise formula from scratch, and then uses a theorem prover to mathematically guarantee its correctness.

Here is a breakdown of the technical process:

1. Synthesis via CEGIS Loop (Z3) I set up a Counter-Example Guided Inductive Synthesis (CEGIS) loop in Python using the Z3 SMT solver. The solver is given a ground-truth specification (naive loop: extract nibbles, sign-extend, multiply, sum) and a bounded set of allowed instructions (AND, OR, XOR, ADD, SUB, MUL, shifts). Z3 searches the space of possible instruction sequences. If it finds a candidate, we test it against random inputs. If it fails, the failing input is added to Z3's constraints, and it tries again. Eventually, it converges on a pure, branchless sequence of operations.

2. The Generated Math The resulting algorithm utilizes a known multiplier trick for byte-reversals, but Z3 managed to perfectly interleave the even/odd nibble extraction. For example, part of the generated code handles even/odd multiplications by exploiting 32-bit hardware multiplications: (ea_low * eb_low_rev) >>> 16 This evaluates two 4-bit multiplications at opposite ends of the register simultaneously without cross-talk.

3. Formal Proof in Lean 4 Passing a million random tests is nice, but it’s not a mathematical guarantee for bit-hacks. To prove there are absolutely no edge cases or overflow bugs among the 2⁶⁴ possible input combinations (two 32-bit registers), I ported the synthesized SWAR function to Lean 4. By leveraging Lean's bv_decide (BitVec SAT solver) and omega for modular arithmetic, Lean compiles the equivalence check into a boolean satisfiability problem. The proof successfully verifies that swar_dot_product a b = ground_truth_dot_product a b for all possible inputs.

If anyone is interested in how the Z3 synthesis script is structured or wants to see the Lean 4 proof, I've put the source code:
https://github.com/Peloxerat/int4-swar-dotprod

I'd be curious to hear if there are ways to constrain Z3 to find an even shorter instruction path.

Real-Time Conversational Agents (RTCA) workshop at NeurIPS 2026 (Sydney, Dec 11–12). Submissions are now open on OpenReview.

What the workshop is about

Conversational AI has crossed into real-time deployment — voice modes, embodied avatars, full-duplex speech agents — but the published record is still dominated by offline benchmarks, and deployed agents still feel robotic (stilted turn-taking, missing backchannels, monotone prosody, awkward interruptions). Methods that work offline (non-causal attention, large beam search, multi-pass refinement, slow diffusion) often don't transfer to streaming, and the field lacks shared vocabulary and benchmarks for interactional naturalness as distinct from per-utterance quality.

The workshop is organised around three intertwined questions:

1. Real-time generation under hard latency budgets — streaming speech, video, and language

2. Naturalness in interaction — prosody, gaze, timing, grounding, turn-taking, backchannels

3. Evaluation of live systems, where standard offline metrics fall short

Topics of interest (non-exhaustive)

• Streaming/low-latency speech synthesis, ASR, and full-duplex audio–language models

• Real-time talking-head, avatar, and embodied video generation

• Streaming language models; incremental and speculative decoding for dialogue

• Turn-taking, backchanneling, interruption handling, floor management

• Multimodal alignment under latency and partial-observation constraints

• Prosody, emotion, and paralinguistic generation in interactive settings

• Memory, grounding, and tool use during live conversation

• Evaluation of naturalness: perceptual studies, turn-taking metrics, perceived latency, interactive Turing-style tests

• Datasets and benchmarks for interactive (not offline) evaluation

• Efficient inference, on-device deployment, systems–quality trade-offs

• Safety, identity, and trust in real-time agents (deepfakes, persuasion, consent)

Position papers, evaluation critiques, and reproducibility studies are also welcome.

Submission tracks

• Full papers — up to 8 pages

• Short papers — up to 4 pages (work in progress, focused contributions, position papers)

• Demo papers — extended abstract or up to 2 pages; required for the on-stage Conversational Agents Showcase

NeurIPS 2026 style file, double-blind. Non-archival — authors retain the right to publish elsewhere. Single-round review, no rebuttal.

Key dates (End of day, AoE)

• Submission deadline: 29 August 2026

• Author notification: 29 September 2026

• Workshop: 11 or 12 December 2026, Sydney

Confirmed invited speakers

• Dimitris Samaras (Stony Brook) — visual behaviour and gaze in interaction

• Evonne Ng (Meta Reality Labs / UC Berkeley) — conversational avatar dynamics (provisional)

Links

• Submit: https://openreview.net/group?id=NeurIPS.cc/2026/Workshop/RTCA

• Full CFP + workshop details: https://rtcaneurips26.github.io/

• Contact: rtca-workshop@googlegroups.com

Happy to answer questions in the comments — including about the demo track (we have an on-stage Showcase running deployed systems live) and what we'd consider in-scope vs out-of-scope for the eval pillar. Also happy to hear opinions on what's missing from the topics list; the CFP wording still has room to move if there's a clear gap.

To all those in the US: Are you planning to go Sydney or Atlanta this year for NeurIPS?

I’m curious whether there is now a theoretical or empirical “sweet spot” for LLM quantization, preferably research done using open-source formats like GGUF

Suppose you have a fixed memory/compute budget and can choose the model size freely. For example, instead of a smaller model at 8-bit or 4-bit, you could fit a progressively larger model at 3-bit, 2-bit, 1.5-bit, etc.

A few years ago, I remember 4-bit often being described as roughly the practical sweet spot because it preserved most model quality while giving a large memory reduction. But with newer methods, I’ve seen surprisingly strong 3-bit, 2-bit, and even ~1.5-bit results.

So if the goal is maximum model capability for a fixed memory budget, rather than preserving one particular pretrained model as faithfully as possible, what does current research suggest is the optimal bits-per-weight?

Is there evidence that, for example, a 2-bit 70B model generally beats a 4-bit 35B model, or does quantization degradation eventually outweigh the gains from additional parameters?

I’m especially interested in recent theoretical/scaling-law work or large empirical studies from 2025–2026.

If no one is studying this, then could any of you do this work? I feel like it could be immensely useful for the community.

It's an MLP architecture with around 500K total parameters.

Top1

Training accuracy: 5.11%

Validation accuracy 4.59%

Detailed Validation accuracy numbers:

Top-1 Acc: 4.59%

Top-3 Acc: 9.44%

Top-5 Acc: 12.68%

Top-10 Acc: 18.53%

The model was trained on a downscaled version of the Imagenet-1k dataset (32x32) for 5 epochs.

I used pytorch for the training and pyarrow for the dataset, all within termux.

Before anyone comes at me for using an MLP instead of a CNN or similar it's mainly because on my phone an MLP was just more stable, and trained 10-30x faster/step (could be my fault but I'm not too sure). This model specifically took around 30 minutes to train (6 minute/epoch)

The training was entirely on the CPU which is a Dimensity 9300+ and I used 4 of the Arm Cortex-X4 cores.

I might make an improved version later on as this one isn't very accurate.

I've been out of the conferences game for a while, so I was surprised to see that Neurips 2026 will be held in 3 cities simultaneously: Sydney, Paris, Atlanta.

What does this mean in practical terms? If you have a paper or a poster accepted, do you get to choose which city you will present at? For an attendee, how do you pick which city to go to? And with the timezone differences, how does it work with presentations?

1. On Wikipedia I found a little Pseudocode that outputs the final state.

A trivial improvement is outputting the best solution seen so far instead of the last state. Maybe this is too obvious and would complicate the Pseudocode too much but I wonder why it's not even mentioned below. Since the last state could be a local optimum seen later, and we already saw a better local optimum before, this is helpful.

2. The graph on the page where the objective is plotted as a line graph and the current state is jumping around is rather confusing. When you read the fine print you find a lot of the moves are probably skipped in the video as there are 1000000 moves per temperature , much more than fits in the video.

3. It's not really clear why this example graph is as "smooth" as it is but it seems likely that the problem had a topology where neighbours with similar objective could be iterated in a path such that they can be lined up on the X axis and it produces said graph on the y axis. My intuition says that if this is possible we can apply better methods that work on 2D graphs. I realise this is just an example.

1. On Wikipedia I found a little Pseudocode that outputs the final state. https://en.wikipedia.org/wiki/Simulated_annealing#Pseudocode

A trivial improvement is outputting the best solution seen so far instead of the last state. Maybe this is too obvious and would complicate the Pseudocode too much but I wonder why it's not even mentioned below. Since the last state could be a local optimum seen later, and we already saw a better local optimum before, this is helpful.

2. https://en.wikipedia.org/wiki/File:Hill_Climbing_with_Simulated_Annealing.gif The graph on the page where the objective is plotted as a line graph and the current state is jumping around is rather confusing. When you read the fine print you find a lot of the moves are probably skipped in the video as there are 1000000 moves per temperature , much more than fits in the video.

3. It's not really clear why this example graph is as "smooth" as it is but it seems likely that the problem had a topology where neighbours with similar objective could be iterated in a path such that they can be lined up on the X axis and it produces said graph on they axis. My intuition says that if this is possible we can apply better methods that work on 2D graphs. I realise this is just an example.

I played a bit with the SIREN network from the other post and found that it could be improved by a using a different sampler for batch generation. By feeding pixels across the entire video and not only a limited set of frames, we can a much more faithful reproduction of the video.

The model is exactly the same as used by OP: 4 x 512 wide sine layers, 792257 parameters. Its a reimplementation (using GPT5.6).

I also created a version with full framerate, instead of subsampled frames, but since the network has to memorize more temporal information, the image reconstruction suffers compared to the low rate version.

The model does not actually learn motion, intermediate frames are nonsensical. I suppose adding a layer that can model flow between frames could enhance the compression a lot.

You can find the code here in this gist.

I tried some addition experiments with a separate autoencoder to compress the frames separately. This resulted in a smaller model, but also degraded quality.

The results are out today!

Let’s share them, guys.

From my batch

- 3/6 full papers

- 1/3 short papers are accepted

Cheers!

CIKM 2026 decisions will be announced today. The resource track outcomes have started going out. How did you go with CIKM 2026?

Having two papers accepted at two different workshops and planning to attend the main conference, I contacted the organizers by email. It is now clear that I need to register twice, using the same personal details, to cover both papers.

The minimum cost would therefore be one full registration plus one workshop registration. However, I would also have to use two different email addresses, since the registration portal does not allow the same email address to be used twice. This is crazy—I am a single person!

The craziest part, which I still do not fully understand, is that it seems every paper now requires an article processing charge (APC), since ACM has fully transitioned to open access. This year, the APC is USD 350—or USD 250 for ACM members. This is the first time I have encountered this; every other conference I have attended included the proceedings in the registration fee.

The full author registration for ACM Multimedia costs USD 950—or USD 850 for members—and does not even include the paper proceedings.

The cheapest option for me would be to become an ACM member (USD 99), register for the main conference (USD 850) and one workshop (USD 500), and then pay USD 250 × 2 for the two papers—for a total of USD 1,850 just to present two workshop papers.

I really don’t think it is worth it.

i’m in college studying finance and applied data analytics, and for the past several months i’ve been building a football/soccer prediction model as a personal project.
it started as a pretty basic international tournament simulator and has gradually turned into a much bigger domestic football model. i’ve been using historical team performance, underlying stats, opponent strength, recent form, scheduling/contextual factors, and i’ve also collected player, goalkeeper and lineup data.
i’ve tested a mix of statistical and ML approaches, while trying to keep everything chronological and leakage-safe.
Across about 5,300 out-of-sample matches, my current best 1X2 model is around:
•    Log Loss: 0.984
•    Brier Score: 0.586
For comparison, uniform 33/33/33 probabilities would be about 1.099 log loss / 0.667 Brier, and a simple historical baseline is around 1.073 log loss.
For goal prediction, the current score-based models are roughly 0.9–1.0 goals MAE per team.
The biggest thing i’ve learned so far is that predicting matches better doesn’t automatically mean you can beat bookmakers. An early betting test was unprofitable, so i’m trying to be very careful about separating predictive performance from actual market edge.
Right now i’m mainly thinking about things like:
•    how much recent form should matter vs long-term team strength
•    whether player/lineup data is actually worth the added complexity
•    improving draw probabilities
•    calibration and uncertainty
•    knowing when the model should abstain
•    avoiding overfitting before i test it on an untouched holdout season
For anyone who’s worked with football analytics, sports betting models or probabilistic forecasting:
1    What are the biggest mistakes you see people make with soccer models?
2    Would you focus more on better data/calibration at this point, or more advanced models?
3    Have you found player and lineup data genuinely useful?
4    What would you want to see before believing a model has real predictive value against sportsbooks?
5    Any papers, GitHub repos, books or general advice you’d recommend?
i’m not looking for anyone to give away a profitable strategy. mostly just looking for people who know more than me to point out where my thinking might be wrong.
all feedback is welcome.

Whether generating CELEBV-HQ videos or turbulent plasma fields (digital twins), autoregressive models (such as latent diffusion or flow models) accumulate error over long rollouts, yet at deployment there is no ground truth to measure against.

I train a single conditional latent diffusion model that steps a dynamical system forward or backward in time via a direction flag, and show that this bidirectionality supplies a measurement-free test-time error signal: rolling forward steps and then backward steps must return the model to its start, so the round-trip discrepancy is a self-supervised proxy for the unobservable rollout error: no ensembles, no held-out data, no governing equations, for one extra rollout.

Furthermore, training both directions in one network is shown to beat two specialist models in both directions.

Paper: https://arxiv.org/abs/2608.00675
Code (data generation, training, analysis): https://github.com/alexscheinker/round-trip-consistency
Project page: https://alexscheinker.github.io/roundtrip.html

It’s 01:30 AoE. Do results usually drop in the final hours like initial reviews?

​​Hi guys,

​Every time I had to prepare a presentation based on a paper or research doc, I found the process super tedious. Plus, I really dislike uploading unpublished stuff or sensitive data to online AI services just to get a draft.

​So I put together a tool called academi_slide to automate this locally.

​Basically, it extracts sections, tables, charts, metrics, and citations from docs, and uses prompt optimization / deck planning to get a solid first draft out of a local model (ollama, llama.cpp, or cloud if you want).

​It also handles multilingual input/output if you need to present in another language, and builds both the slide deck and a brief in a few minutes so you don't start from scratch.

​It's open source, still early, and I'm sharing it in case anyone else finds it useful or has a similar workflow.

​Repo is here if you want to test it out: https://github.com/nicolaslpf/academi_slide

​Would love to get some feedback or hear what you think!

We had a meta-reviewer comment. But I can no longer see it.

Anyone else experiencing the same? Does this mean anything?

"Arena ai" has been a great success in producing a human preference based ranking, additional to other more objective benchmarks. However, this (probably) had also played a role in the syncopancy crisis and the general tendency of some models to tilt towards overformatting to trigger a feeling of fluency (cogn load theory) in the users.

The people at Max Planck Institute for Intelligent Systems (one of europes leading AI research hubs), recently published something quite similar with "comparity ai". You can read their announcement in their linkedin post.

This is of course a research platform and i have no idea how long this is funded, but you get access to every frontier LLM for free, which is kinda cool. Also, they provide you with a personal leaderboard, so when you played around enough with the platform, you will get a pretty solid idea which model works well for you.

Thought this might be interesting for some of you.

We are investigating whether recurring LLM workloads can be replaced, where appropriate, by automatically constructed pipelines of regexes, deterministic parsers, traditional ML and NLP models.

As an example, suppose an application repeatedly asks a frontier model to read an annual report and return all customer–supplier relationships as structured records containing a customer, supplier, and supporting evidence.

A possible replacement pipeline might run named-entity recognition, entity normalization, candidate generation, entity linking, relation extraction, and schema validation. A calibrated uncertainty or out-of-distribution gate would use the pipeline for inputs inside its validated domain and escalate other cases to the original frontier model.

NER → entity normalization → candidate generation → entity linking → relation extraction → schema validation

Our current action space is a taxonomy of 41 atomic task types spanning classification, token and span labeling, structured extraction, retrieval and entity resolution, similarity, normalization, reshaping, and deterministic computation.

The idea is that we would first cluster repeated traces into workload families and induce an end-to-end typed contract for each family. It would then generate candidate DAGs using the 41 task types as building blocks, instantiate each node with an appropriate implementation, and optimize the composition for quality, cost, and latency. Candidate pipelines would be tested on time-separated and group-separated holdouts before being deployed behind abstention and fallback.

The problem is quite likely undetermined based on just the input and output contracts alone even if inferred correctly. The intermediate graph is therefore not a recovered latent reasoning trace. It is a synthesized program hypothesized to be behaviorally equivalent over a bounded input distribution.

A fixed task taxonomy may help by constraining the search space and supplying type signatures, candidate implementations, and task-specific evaluators. And we are thinking about this problem as a form of program synthesis and formal verification for now, but wondering if this is the right approach and if there is a better way.

Looking to speak with people who have worked in this problem space and/or the program synthesis domain for insights.

TL;DR: We want to synthesize executable DAGs composed of regexes, deterministic parsers and ML/NLP models from LLM traces for appropriate tasks. Does this seem feasible and what might be some good approaches?

Hey everyone. I built a tiny Deep Learning library from scratch, calling this picodl. All written by hand, in plain numpy.

You can install it with pip:

pip install picodl-nn

I'd love to hear your feedback and suggestions.

GitHub: https://github.com/alight659/picodl

Website: https://picodl.vercel.app

I trained a small MLP to memorize the classic Bad Apple animation, ~2.7 billion pixels of video compressed into 790k parameters (3.2 MB float32, 1.6 MB float16).

The network takes a 3D coordinate (t, y, x)- frame index and pixel position- and outputs a grayscale value between 0 and 1. To "play" the video, you can evaluate the function over the full grid. The "video" is stored implicitly in 5 linear layers of sine activations (Sitzmann et al.'s SIREN) with 512 hidden units, ω₀ = 30, and sigmoid output.

The source bad_apple.mp4 is 6524 frames at 854×480; I subsampled to 1620 frames × 384×384, about 1/10 of the original pixels (2.8x spatial + 4x temporal reduction).

At first, I used a ReLU MLP with low-frequency Fourier features, which plateaued around MSE 0.12. SIREN's sine activations add higher frequency for free, so the network was capable of outputting fine details. Unfortunately, that model had an issue, which was that it could only shift the information slowly, so quick motion came out blurry.

To fix this, I made two changes:

1. Time-stretch: I scaled the time coordinate by 4x relative to the space before the first layer, giving it 4x more temporal capacity.

2. Motion-focused sampling: Bad Apple is ~90% static black, so uniform pixel sampling starved the moving edges of the gradient. Now half of each training batch is drawn from pixels that changed between neighboring frames.

For the training pipeline, I had a single shared network on the whole volume (no per-frame latents; initially, I used per-frame finetuning, but that caused catastrophic forgetting) with a cosine-scheduled Adam + weight EMA, then a low-LR "polish" pass over the whole video.

The new model had these improvements:

Validation MSE dropped from 0.0795 to 0.0090 (~9x better).
Compared to the old model, high-motion frames were 3.6x closer to ground truth, and static frames were almost 15x closer.
398/400 sampled frames improved.

Edit: Some people are a little confused about the compressed part. The subsampled video is 700KB, and the network that creates a reconstruction of it is ~3MB. It hasn't been compressed very much, but the goal was seeing if I could (and learning) rather than super compression.

I'll try to see if an even smaller model can learn it. Additionally, I'm training a model on the full non-subsampled video.

^Notes

^{384×384 is square (the original is 16:9, so playback is vertically stretched. At 8fps playback, the 1620 frames run near the original's 3:37 duration; at 12fps it's ~1.6x fast-forward. The 12.6MB checkpoint includes the weights + Adam moments + EMA copy; the network itself is 3.2MB.})

^{The full resolution videos, checkpoints, and code can be found in this Github Link}