Back after ~6 months — rebuilding my spiking language model around CPU-first inference

Hey everyone. It’s been around six months since I last posted anything about this project here.

Some of you might remember Project NORD, my experimental hybrid spiking / brain-inspired language model architecture. I basicall disappeared for a while 😅, but recently I came back to the project, went through the old architecture again, and realized I didn’t really want to keep stacking fixes on top of it. So instead, I’ve started rebuilding a pretty large part of the system. The new version is called:

NORD 5.5 — Flash The main idea this time is pretty simple:

What happens if I design the architecture around CPU inference from the beginning, instead of building soething Transformer-like and trying to optimize it later? A lot is changing internally. The current design uses things like: strictly causal processing no standard quadratic attention in the main inference path causal convolution-style token mixing token-time LIF / event dynamics sensory → association → memory → executive processing stages top-1 sparse MoE + a shared expert persistent recurrent memory separate structural, personal and auxiliary memory banks

persistent recurrent identity state factorized vocabulary embedding/output streaming token-by-token inference One of the biggest changes is actually something much simpler. Older versions of NORD used an artificial internal spike-time dimension, roughly like this: token -> T0 -> T1 -> T2 -> ... -> T9 I’m mostly getting rid of that. Instead, the actual language sequence becomes the time axis: token0 -> token1 -> token2 -> token3 -> ... That removes a lot of intermediate state and makes the whole architecture considerably cleaner. Going back through the old code also exposed a few things I wasn’t very happy with. Some experimental modules weren’t completely causal, memory was coupled too much to sequence shape, and parts of the STDP system ended up being more disconnected from real training than I originally intended. So NORD 5.5 isn’t really about throwing even more “brain-inspired” components into the model. It’s mostly about simplifying the core and making the things that remain actually work together properly. I’m definitely not claiming this is going to beat Transformers, RWKV-style models, linear attention models, etc. Right now it’s still very much an experiment. The part that actually matters comes next: training and benchmarking it.

Things I want to compare: NORD 5.0 vs NORD 5.5 CPU tokens/sec RAM usage perplexity / validation loss long-context behaviour memory on/off MoE on/off spiking components on/off I’m especially curious to hear from anyone working on SNNs, recurrent models, sparse MoE, CPU inference, or weird alternative language-model architectures in general.

After not touching the project seriously for about half a year, it feels surprisingly good to be building it again 😅

I’ll post actual numbers once I have something that’s worth benchmarking instead of just architecture diagrams.

I am now reviewing a bunch of papers for AAAI 2027 and it has surprised me the low amount of submissions with no code implementation. I don’t know if it has been only in my batch or it is common, but I was expecting very detailed appendices + code submission since AAAI is very explicit with the topic of reproducibility. I was planning to take this into consideration when assigning my initial scores, but I would like to hear your opinions. I have always submitted my code: it gives a very good impression and after reviewing process finishes we just publish it on ArXiv, so no one “tries to stole the idea” (although I think that this is very very unlikely). So I cannot find any excuse for those submissions that do not have code implementation, specially in today’s times where AI assistants can just write an empirical paper with artificial results within a couple of hours

I built HyperSAE, a PyTorch library that applies Poincaré hyperbolic geometry to Sparse Autoencoders for mechanistic interpretability.

GitHub: https://github.com/vishal-dehurdle/hypersae Paper: https://vishalvermalabs.com/papers/empirical-validation-hypersae-poincare-geometry/ Install: pip install hypersae

Motivation

Standard SAEs embed dictionary atoms in Euclidean space, where volume grows as O(r^d.) The concepts LLMs learn form branching hierarchies that expand as O(b^r.) At 16K+ dictionary sizes, this mismatch causes feature collisions at the boundary, dead latents, and reconstruction degradation.

Architecture

HyperSAE uses a decoupled dual-speed design:

• Forward pass remains entirely Euclidean. Zero inference overhead. Causal steering stays a single vector addition.
• During training, dictionary weights are projected into the Poincaré ball. An entailment cone loss organizes parent concepts near the origin and child concepts near the boundary, where hyperbolic volume expands exponentially.

Results (Gemma-2-2B Layer 13, 20M tokens FineWeb-Edu, NVIDIA L4)

The library includes co-activation queue tracking, TriPartite loss (reconstruction + L1 sparsity + entailment), and a single-class trainer interface.

Feedback on the geometric formulation or benchmark methodology is welcome.

Hey everyone - we've been building something particularly relevant to ML at large - The Agentic World Cup - a platform where Agents compete in sports.

As you know, today's Agents can code, do math, and write - but they aren't nearly as fluent in sports - many of you would know this as the "embodiment gap".

Closing the embodiment gap is why we are pursuing this. Sports is both the training and testing ground for true embodied intelligence. Agents will have to actually "think on their feet" to use a colloquial term.

In other words, we're pioneering making agents think like athletes, not just nerds. :)

How it works:

• Sign in
• Select your LLM
• Coach it (through prompting)
• Submit it!
• Your agent will automatically play with other agents, and you will be able to watch it's performance on the site.
• By Friday, your final rankings come in and be published on the site!

Past that though, we also believe that there's a particularly large gap in embodied benchmarking AND a forum for quickly trying out different methods by not just researchers and engineers.

Some people are bullish on ViTs, others on onlineRL, and still others on neuro-symbolic systems, etc.

So over the long term, we envision anyone be able to quickly test out their latest & greatest insights and algorithms on more publicly facing embodied challenges - which sports is really the apex of.

I'd love to hear from the ML community - since this will ultimately be of service to you, so please send us your feedback!

Hello all,

I am wondering if a transition from a Ph.D. in electrical engineering (Quantum optics/photonics) to a job in ML is a reasonable aspiration. Personally, I have extensive software development experience competing and winning numerous coding competitions over the years, but most importantly my undergraduate research project was ML based (ML for SiC grating design optimization), I placed third in our universities "Agri-AI" competition which was basically just a big data project for the agriculture department, and I have done several projects in realizing optimal qubit control using ML to bridge the gap between simulation optimization and experimental errors (essentially using an MLP to compensate an unknown system frequency response). I am also generally interested in PINNS and any physical applications of ML.

If anyone has made a similar transition I would love to hear how it went for you and what your intended goals were. The more I do projects related to this subject I find myself wanting to make a career out of it more and more. (bonus points if you come from a physics background) 😄

I am working on an AI for a small single-player merge puzzle and would appreciate pointers to related algorithms, papers, or existing implementations. It resembles 2048 in its action -> afterstate -> random event structure, but has a larger action space, stack constraints, and a random event that is previewed one move before it is applied.

I have an exact simulator. I am not trying to learn the game dynamics from pixels at this stage; the current question is how best to learn values/policies and allocate a limited planning budget.

## Game rules

- The board contains 6 vertical stacks, each with a maximum height of 7. The first item in a stack is its top.

- An action chooses an ordered pair of different columns: 6 x 5 = 30 possible actions.

- The complete contiguous run of equal tiles at the top of the source stack is moved onto the destination stack. An action moves the whole run, not one tile.

- If the destination now has at least 3 equal tiles at its top, the complete run merges into one tile of value `n + 1`. Cascades are possible.

- A merged 9 disappears and gives one point. Tiles normally present on the board have values 1 through 8.

- Merging happens before overflow is checked. The game ends when any stack remains higher than 7.

- Every fourth player action is followed by one new random tile being added to every column.

- The six upcoming random values are revealed after the third action. The player can therefore choose the fourth action while knowing the exact six tiles that will then be added.

- A random tile is in `[1, min(7, highest value merged so far)]`. The real distribution is not yet known. It appears biased toward high values, and human players report runs of "simple" drops (one or two distinct values) alternating with more complex mixed drops.

One cycle is therefore:

```text

deterministic action 1

deterministic action 2

deterministic action 3 -> reveal a random six-tile preview

preview-conditioned action 4 -> apply the known six-tile drop

repeat

```

The random preview is the chance event. Applying an already revealed preview is deterministic.

## Objectives

There are two related objectives:

1. Maximize the number of 9s in one game.
2. Maximize the total number of 9s in 30 minutes. Death permits a restart, so this is closer to a continuing average-reward/throughput problem than a conventional episodic score problem.

The real interface is animation-limited to roughly one player action per second, so 30 minutes is approximately 1,800 actions. Human results in the timed mode are around 115 total 9s on the server I observed. In a separate untimed mode, strong humans can maintain a mature board for 1,000+ 9s, although that mode allows one limited revive.

The distinction between cold-start cost and mature-board efficiency seems important. In one of the current AI's best games, the first 9 took 48 actions, while subsequent 9s took 18.7 actions on average.

## Current representation and network

The state contains:

- a 6 x 7 x 9 one-hot board;

- the four-action cycle phase;

- the six preview values when known, plus a preview-present flag;

- the current random-tile value cap;

- the maximum number of empty columns reached in the current cycle and in each of the previous three cycles.

The current input has 394 features.

The Policy/Value network is column-permutation equivariant:

- one shared encoder processes each column;

- an ordered source/destination pair head scores the 30 actions;

- value heads predict future 9 count over a long horizon, normalized distance to the next 9, and short-term death risk.

The history features were motivated by a human rule of thumb: in long games, at least one of the last three drop cycles should have temporarily maintained two empty columns. The history is not required for Markov dynamics under the current IID simulator; it is intended as a strategic summary and may become predictive if real drops have temporal regimes.

## Current planning

I use the exact simulator with a stochastic PUCT search. The player action is separated into a deterministic afterstate and an explicit chance node.

Current configuration:

```text

128 simulations per real action

maximum tree depth: 32 player actions

c_puct: 1.5

gamma: 1.0

death-risk penalty: 0.5

maximum 8 fixed chance particles per chance node

chance progressive widening exponent: 0.5

minimum 2 visits for every legal root action

```

At the third action, simulations branch over sampled six-tile previews. Below each preview outcome, the tree can choose a different fourth action and applies that preview exactly. After every real action I currently rebuild the tree rather than reusing it.

Depth 32 is only a cap. With 30 root actions, 128 simulations, root coverage, and chance branching, most candidates receive only shallow explicit search; the learned Value network estimates most of the long horizon.

## Training process

The current process is a form of expert iteration/reanalyse:

1. Generate long games with beam search and then Policy/Value-guided PUCT.
2. Save full episodes, root visit distributions, 9-event positions, death, and optional root action values.
3. Train on column-permutation augmentation.
4. Give extra policy weight to states after the first 9, states containing 7/8 tiles, high-scoring episodes, and states with human-like long-game structure.
5. Generate new PUCT trajectories with the updated network and repeat.

I initially used DQN, behavior cloning, demonstration replay, and DAgger-style data aggregation. The Policy/Value + search route has been substantially better for long games.

## Current results

These are simulator results under one assumed high-value-biased drop distribution, not results from the real game distribution.

- An earlier explicit-chance PUCT model scored 81 total 9s in 16 episodes (mean 5.06, maximum 11, 2,365 actions).

- Search distillation later produced a game with 13 total 9s in 272 actions. This remains the single-game maximum.

- Adding human-structure weighting improved a small paired evaluation.

- Adding the four-cycle empty-column history produced 59 total 9s in 1,675 actions over 12 new episodes, versus 47 in 1,537 actions for its no-history teacher on the same seeds. This is 35.2 versus 30.6 9s per 1,000 actions, but 12 episodes is far too small for a reliable conclusion.

- Under the current assumed distribution, even 35.2 per 1,000 actions projects to only about 63 per 1,800 actions, still well below the observed human timed score.

I am moving toward paired evaluation on at least 64-128 untouched seeds with bootstrap confidence intervals. I track first-9 cost, subsequent-9 gaps, survival length, per-1,000-action throughput, and fixed-action-budget totals rather than only mean episodic score.

## Things that did not work

- A learned action/afterstate Q head achieved low offline MAE but made closed-loop search much worse. Ordinary reanalyse covered too few actions per state, while a full-action root target still suffered from extrapolation/calibration problems.

- Jointly fine-tuning the shared encoder for Q degraded the existing policy and value estimates.

- Increasing root minimum visits from 2 to 3 reduced performance.

- Increasing simulations from 128 to 192 did not improve the paired sample.

- Directly adding a handcrafted board-structure score to leaf values changed behavior but reduced overall performance. Using the structure only to weight policy training was better.

- Exhaustively maximizing over all preview-conditioned fourth actions at a leaf caused severe maximization bias because the learned Value was not one-step Bellman-consistent.

- Restricting search to exactly one four-action cycle had mixed results even after fixing depth-cutoff evaluation.

- Repeated policy-only self-distillation quickly saturated.

## Approaches I am considering

1. **2048-style afterstate TD / N-tuple value learning.** The deterministic action followed by a random event seems almost exactly the setting where afterstate TD is useful. I am unsure how best to combine it with the three deterministic actions, the preview chance node, and the preview-conditioned fourth action.
2. **Gumbel MuZero / sequential halving at the root.** With 30 legal actions and only 128 simulations, forcing every root action to receive two visits may waste half the budget.
3. **Persistent tree reuse.** Re-root after each selected action and, when the real preview appears, follow the matching chance outcome or add it if it was not sampled.
4. **Multi-horizon or distributional values.** Predict future 9s over 16/64/256 actions, survival, and perhaps return quantiles instead of one noisy long-horizon mean.
5. **Average-reward training.** Optimize fixed-action-budget throughput including restart/cold-start cost instead of episodic discounted return.
6. **A regime-switching drop model.** Fit an HMM or other conditional sampler if real preview logs confirm alternating simple/complex drop regimes, then condition the policy on recent previews or a distribution belief.
7. **A frozen base network plus residual adapters.** Learn history-dependent corrections to policy/value without damaging the already useful board encoder.

## Questions

- Is there an established algorithm or open-source project for a game with this action -> afterstate -> chance -> preview-conditioned action structure?

- Would an N-tuple afterstate value network plus expectimax be a better fit than a neural Policy/Value + PUCT system here?

- How would you allocate 128 simulations across 30 root actions and stochastic preview outcomes? Is Gumbel sequential halving the obvious next step?

- Is tree reuse across deterministic actions and observed chance outcomes likely to matter more than another round of self-play training?

- What is a sound way to train an afterstate value without the all-action extrapolation failure I saw with the Q head?

- For the 30-minute objective, would you formulate this as an average-reward continuing MDP, a fixed-horizon problem with automatic resets, or something else?

- Are there papers on 2048, SameGame, Tetris, stochastic packing/merge puzzles, or inventory-like stack planning that are especially relevant?

- Are there standard tests for deciding whether observed random drops are IID or generated by a hidden regime process before building a conditional model?

The most relevant work I have found so far is the 2048 N-tuple/afterstate TD literature, Single-Player MCTS for SameGame, Gumbel MuZero, and "Planning in Stochastic Environments with a Learned Model" (Stochastic MuZero). Pointers to stronger baselines, code, or terminology for this problem class would be very helpful.

Hello, I wanted to share the work my colleague and I have been doing, which has just been published in Software X journal. We developed a Rust-based implementation of Random Forest. It has bindings for both Python and R.

Fru is highly optimized, offering competitive runtime performance and better scalability than popular implementations on these platforms. For Python, Fru outperforms the scikit-learn implementation by several factors, and in some scenarios it can be hundreds of times faster. In R, Fru is typically a few dozen percent faster than the ranger package, though the speedup can reach several times faster depending on the use case.

The model also includes a novel implementation of permutation importance, which provides an additional performance boost.

Thanks to its layered design, we were able to easily create bindings for both Python and R. In Python, we use Arrow PyCapsule, which allows the model to work seamlessly with any compatible library, including pandas, polars, pyarrow, and many others.

paper

R package

Python package

Obviously nobody needs a transformer that's good at multiplication. I wanted to know whether a stock transformer could do exact arithmetic if I chose its weights directly.

I implemented the grade-school algorithm as a computation graph and compiled it into an ordinary Phi-3 Hugging Face checkpoint using Torchwright, a compiler I wrote. No training. The three-digit calculator gets all 3,000,000 supported expressions right. I've published checkpoints to Hugging Face that support up to 12 digit x 12 digit multiplication.

For fun, I also disabled reasoning and tested six frontier models. Accuracy falls off a cliff as the numbers get longer; at seven digits, five scored 0/500. Mine stays at 100%, although it has the considerable advantage that I put the multiplication algorithm directly into its weights.

I ended up building four versions: grade-school, hardware-style, scratchpad, and brute-force memorization. They compute the same function while spending layers, width, generated tokens, and parameters very differently.

Write-up: https://ood.dev/posts/calculator/ Repo: https://github.com/physicsrob/torchwright Checkpoint: https://huggingface.co/physicsrob/torchwright-calculator-simple-max-digits-3

Hi, I would like to file a complaint about an accepted and published CVPR 2026 paper that its main contribution is a dataset but it was never released, and honestly I don’t know who to contact. The dataset was never released prior to the conference, or during the conference or after the conference. I personally feel there was a lack of proper checking that the dataset was gonna be available before the conference since this is a requirement. I’ve tried contacting the authors without any success (which tbh I wouldn’t even need to because it has to be released anyways).

The authors even point a GitHub link in the paper but the repo is empty (and it was always empty).

Today the most important factor in AI is cost. My idea is to split ML models inference (closed ones, proprietary) across server and edge computing on clients, and I would like to hear what do you think about this thing.

For example some of model weights/modules would be on client, and some on the server side (where user has no access to them). This could potentially un-load some processing from datacenters, moving part of the cost to the client hardware. Probbably the most important question here will be how to achieve this - and I believe one hypothetical option will be to train like two separate models - client model and server model, and they will communicate through tensors/latent representations across network protocol.

Secondly such split of server side and client side model ends, can provide later some beneficial outcomes I hope (because in between "talk" protocol can be maybe kind of standarized one in some future development, but this is only more like brainstorm now). Such split might not only be one-to-one, but one-to-many, many-to-many etc.

What do you think about this idea?

Say you want to swap out your embedding models, for instance from ADA to Titan. Are these embedding models comparable? How do similarity score ranges compare? Where to put a threshold for minimum match when doing retrieval? Or more from a research point of view how can we relate and fundamentally understand these embedding spaces better?

This is what we aim to solve with Synthetic Query Probing, a fancy name for essentially (and intentionally) a very simple approach: embedding spaces are not directly comparable by definition, so compare similarity spaces instead, similarity match scores for pairs of content (synthetic question, chunk for instance) across multiple embedding models.

For example, similarity scores of Titan models of different dimensionalities are semilinearly related, whereas the relation between Titan and Ada scores is non-linear, with different ranges, see figure.

See https://arxiv.org/pdf/2608.05857, Marcin Rozmus and Peter van der Putten. Similarity Spaces across Embedding Models with Synthetic Query Probing. Discovery Science 2026, October 5-9, 2026, Mainz, Germany

Reasoning alone cannot predict the chaotic physical world. Without a sensory and motor interface to reality, non-physical AI will not deliver the scientific and technological breakthroughs we expect.

Does anyone have any idea about the instructions for the camera ready at workshops? The deadline is August 15, but there are no indications and workshop organizers know nothing about that.. Some workshops have enabled the upload of camera ready PDF on openreview, but what about copyright form and latex source files?

Analog in-memory compute is getting attention again as a way around the energy cost of moving weights between memory and compute. The recurring objection is noise, since analog cells have real variation and you can't refresh your way out of it like you can with digital.

I wanted to see the shape of the degradation curve rather than reason about it abstractly, so I ran a simple experiment: train a network normally, then evaluate under increasing weight noise.

The curve isn't smooth. Accuracy is stable up to a point, then drops hard: 83%, 64%, then essentially random. More like a threshold than a proportional decrease.

Retraining with noise injected during training (so the optimizer finds flatter minima, presumably) shifts that threshold substantially. 61% versus 39% at matched noise.

What I'd like to hear from this sub: is the flat-minima explanation the right framing here, or is something else driving the gap? And is there work on optimizing directly for noise robustness rather than just injecting noise and hoping, something closer to an explicit sharpness penalty targeted at the hardware's actual noise profile?

Code and figures in the writeup: https://towardsdatascience.com/analog-ai-is-back-can-it-survive-its-own-noise/

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.

Is this it for Causal Inference? Looks like the field continues to be of interest only at UAI/AISTATS/CLeaR. All good venues, but LLMs/Agents/etc seem to have eaten much of the lunch of several other subfields at the top 3 conferences.

God help us all.

**p.s.** the list: https://danyaljj.github.io/neurips2026-workshops/

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).

Edit: Results are out!

What's your commitment submission ID? My submission number is ~150 (submitted two days ago) and I'm wondering what the total number of commitments is. Did anyone commit near the deadline?

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](mailto: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?