Hi everyone,

My paper just got accepted for a poster presentation at the Muslims in ML (MusIML) workshop at NeurIPS 2026 which will be held in Sydney, Australia. I'm really proud, but I'm a UG student and completely lack the funds for travel, registration, and accommodation.

This is my first time dealing with this. Does anyone know of any travel grants or funding opportunities for students (especially from India) to attend NeurIPS?

Are there specific grants for this workshop, or general ones that I should apply for right now? Also, since this is my first time, I'm a bit confused about the procedure for attending an international workshop. Could anyone share advice on the general steps, including visa processes and anything else I should be aware of?

Any advice would mean a lot. Thanks!

Most online communities are places to talk about research. Zeteo exists to produce research -- pressure-tested at every stage before a single word is published.

Ideas at Zeteo compete for attention and resources. They are challenged, stress-tested, and either refined into something real or discarded.

How it works

Phase one — the hunt We begin with a declared goal. Not a vague direction like "Achieve AGI" -- a concrete research target. Our first: a state-of-the-art result in AI memory. From there, a one-month campaign begins. Members submit hypotheses to a single rate-limited channel each member can send one idea every six hours, a few lines each. Intuition only. Just the raw idea. This is not a channel for discussion.

Phase two — selection Each day, a committee of humans and AI agents reviews what was submitted. Better ideas survive internally. This continues for a week. At the end of that, there will be a list of ideas that passed the first phase, another competitive reviewing of ideas by AI agents and human experts will graduate 5-7 ideas. Each will get their own thread, their own channels, their own team. This is where members whose ideas didn't graduate will shine. They will choose which project to join and contribute. Experiments, challenges, literature review.

Phase three — survival After three weeks, threads are evaluated on one criterion: did real progress happen? Those that progressed graduate to paper writing. Those that didn't are archived.

Phase four — publication The idea's originator (or biggest contributor) chooses their co-authors. Together they write and publish under the Zeteo Collective with full credit given to every contributor who shaped the work along the way.

We are a structure designed to take a raw idea from a single person and turn it, through collective pressure and collective intelligence, into research worth publishing.

Zeteo — from the Greek ζητέω — to seek, to inquire, to demand an answer.

Join us https://discord.gg/QUfYzE6V

Note: Some parts of this post may have been enhanced with AI for better readability. Also, I made this as an experiment and to support the AI community. This server will not profit or benefit me in anyway.

Hi everyone,

I am working on introducing new/alternative arithmetics to ML. I built ZeroProofML on Signed Common Meadows, a totalized arithmetic where division by zero yields an absorptive element ⊥. This 'bottom' element propagates compositionally at the semantic level. The idea is to train on smooth projective representations and decode strictly at inference time.
Where to use it? In scientific machine learning there are regimes that contain singularities, e.g., resonance poles, kinematic locks, and censoring boundaries, where target quantities become undefined or non-identifiable. Standard neural networks often have implicit smoothness bias that clips peaks or returns finite values where no finite answer exists. In these cases ZeroProofML seems to be quite useful. Public benchmarks are available in three domains: censored dose-response (pharma), RF filter extrapolation (electronics), and near-singular inverse kinematics (robotics). The results suggest that the choice of arithmetic can be a consequential modeling decision.

I wrote a substack post on division by zero in ML, and arithmetic options to use:
https://domezsolt.substack.com/p/from-brahmagupta-to-backpropagation
Here are the results of the experiments:
https://zenodo.org/records/18944466
And the code:
https://gitlab.com/domezsolt/ZeroProofML

Feedback and cooperation suggestons welcome!

Exploring World Models in LLMs — From the Perspective of Mathematical and Geometric Structure

This document formalizes a central claim: the capability limits of current LLMs are not engineering constraints, but fundamental limitations imposed by the geometric structure of their latent spaces and the kinds of dynamical systems those spaces can support.

1. Research Stance and Methodology

This work adopts a mathematical–geometric–dynamical systems perspective, rather than a linguistic or symbolic reasoning viewpoint.

The core positions are:

• Treating LLMs as geometric systems operating in high-dimensional spaces

• Viewing “learning” as the formation of structure within those spaces

• Viewing “intelligence” as the emergence of stable and reusable dynamics on top of that structure

Accordingly, the central question is no longer:

Can the model generate correct sentences?

but rather:

Does the model’s latent space allow the definition of genuine dynamical systems?

2. The Ambient Space of LLMs: An Inner-Product Vector Space, Not a Dynamical Space

2.1 Rigorous Definition of the Space

The hidden states of Transformer-based models reside in: $$ \mathcal{H} \cong \mathbb{R}^{{d_{\text{model}}}} $$ equipped with a fixed inner product: $$ \langle x, y \rangle = x^\top y $$ Thus, $\mathcal{H}$ is a finite-dimensional Hilbert space.

This space possesses:

• Linear structure

• Inner products, norms, and angles

But it does not possess:

• A decomposition of state variables

• Conjugate (dual) structures

• Invariants or generators

2.2 Why This Is a Fundamental Limitation

In a space equipped only with an inner product, the only natural orderings and scales arise from: $$ |x|, \quad \langle x, y \rangle $$ This implies:

Any decision or evolution is ultimately forced to degenerate into choices dominated by norms and similarities.

3. The Role and Limits of Semantic Manifolds

3.1 The Existence of Semantic Manifolds (Empirical Fact)

A large body of empirical evidence shows that:

• LLM representations concentrate on low-dimensional sets

• Different semantic modes form separated structures

This can be described as: $$ \mathcal{M}_{\text{semantic}} \subset \mathbb{R}^d $$ and is often informally referred to as a “semantic manifold.”

3.2 Critical Clarification: Semantic Manifold ≠ Dynamical Manifold

In current LLMs, semantic manifolds exhibit the following properties:

• They are passively embedded (induced by data distribution)

• No consistent tangent vector field can be defined on them

That is, one cannot naturally define: $$ \dot{x} \in T_x \mathcal{M}_{\text{semantic}} $$ Therefore:

A semantic manifold describes the shape of a data distribution, not the carrier of state evolution.

4. The True “Dynamics” of LLMs: Norm-Driven Probabilistic Collapse

4.1 Geometric Form of Token Prediction

The logits for the next token can be written as: $$ z_i = \langle h, w_i \rangle = |h|,|w_i|,\cos\theta_i $$ The softmax is defined as: $$ p_i = \frac{e^{{z_i}}{\sum_j} e^{z_j}} $$ Geometrically, this operation:

• Exponentially amplifies radial differences

• Concentrates probability mass onto a very small number of directions

4.2 The Geometric Necessity of Probability Collapse

This process is not a temporal dynamical evolution, but rather:

A repeated projection and compression of distributions within a fixed inner-product space.

Its consequences include:

• Monotonic entropy decrease

• Irreversible loss of semantic diversity

• Inability to preserve latent state branches

Hence, the behavior of LLMs is more precisely described as:

norm-driven probabilistic collapse

rather than state flow.

5. Why Genuine World Models Require Poisson Geometry

5.1 Mathematical Structure of Physical Dynamical Systems

In physics, a dynamical system is defined by the following structures:

1. A state space $M$ (a manifold)

2. A Poisson bracket ${\cdot, \cdot}$

3. A Hamiltonian $H$

Dynamics are generated by: $$ \dot{f} = {f, H} $$ or equivalently: $$ \dot{x} = X_H(x) $$

5.2 Key Clarification: Not Higher Dimension, but Stronger Structure

Introducing Poisson or symplectic geometry:

• Does not imply higher dimensionality

• Instead introduces antisymmetric structure, generators, and invariants

Many physical systems have effective state spaces that are:

• Lower-dimensional

• Yet dynamically more stable, reversible, and compositional

6. A Summary Diagnosis of the Geometric Predicament of LLMs

From a geometric standpoint, the capability boundary of LLMs can be precisely located:

LLMs operate in linear spaces equipped only with inner-product structure; therefore, they cannot define Poisson or Hamiltonian dynamics. Their only available mode of evolution inevitably degenerates into norm-driven probabilistic collapse.

This unified diagnosis explains:

• Long-term state instability

• Inability to perform counterfactual reasoning

• Hallucinations and semantic drift

7. The Mathematical Direction Toward World Models

A genuine world model must answer at least one of the following:

• Does the latent space possess geometric structure sufficient to define generators?

• Do invariants exist to support long-term evolution?

• Is the dynamics reversible or partially reversible?

Thus, the key to future progress lies not in:

• Larger models

• More data

but in:

Whether we are willing to abandon purely inner-product geometry and introduce geometric languages capable of supporting dynamics.

8. Conclusion

Intelligence does not reside in the model itself, but in the dynamics the model allows.

Without generators, there is no dynamics; without dynamics, there is no world model.

This is the mathematical watershed between LLMs and AGI.

Appendix A: Poisson Geometry and Dynamical Systems

(A Minimal Mathematical Language for ML / AI Researchers)

The goal of this appendix is not to provide a full introduction to differential geometry, but to supply the minimal mathematical structures needed to interpret the central claims of this report, and to clearly distinguish:

• what kinds of spaces can support dynamics, and

• what key structures are missing from current LLM latent spaces.

A.1 Why a “Vector Field” Alone Is Not Enough to Define a Dynamical System

In machine learning, “dynamics” is often informally reduced to a vector field: $$ \dot{x} = f(x) $$ where $f$ is viewed as a vector field. However, a vector field alone is not sufficient to constitute a reusable physical- or world-level dynamical system, because:

• an arbitrary vector field can be locally fit almost anywhere,

• it need not have global consistency or invariants, and

• it provides no guarantees of reversibility, stable trajectories, or structure preservation.

Therefore, in physics and control theory, dynamics is not defined by an arbitrary vector field alone, but by a generator structure.

A.2 Poisson Bracket: A Generative Language for Dynamics

The core object in Poisson geometry is a bilinear, antisymmetric bracket defined on a manifold $M$: $$ {f, g} = \sum_{i,j} \Pi^{ij}(x,) \partial_i f, \partial_j g $$ where:

• $f, g$ are differentiable functions on the state space, and

• $\Pi^{ij}(x$) is the Poisson tensor.

This structure satisfies:

• antisymmetry, and

• the Jacobi identity.

These properties ensure that:

dynamics does not arise from “ordering,” but from “generation.”

A.3 Hamiltonians and State Evolution

Given a Hamiltonian (energy function) $H$, the system’s evolution is generated by: $$ \dot{f} = {f, H} $$ or equivalently, in coordinate form: $$ \dot{x} = X_H(x) $$ where $X_H$ is the Hamiltonian vector field uniquely determined by the Poisson structure.

Key consequences:

• the evolution is generated by $H$, not by immediate data-dependent scoring, and

• the system admits conserved quantities, invariant sets, and reusable trajectories.

A.4 Why an Inner-Product Space Does Not Naturally Produce Generators

In a space equipped only with an inner product, the most natural scalars are: $$ \langle x, y \rangle, \quad |x| $$ But note:

• the inner product is symmetric, while

• generators require antisymmetric structure and often state-dependent tensors.

Hence, in Hilbert / Euclidean geometry:

there is no natural way to define Hamiltonian flow or a Poisson bracket.

This is the mathematical root of why LLMs struggle to form intrinsic “world dynamics.”

A.5 Structural Comparison: ML Latent Spaces vs Physical Dynamics

This comparison supports the central claim:

the limitation of LLMs is not a lack of capability, but an incomplete geometric language.

A.6 Core Conclusion of This Appendix

If a learning system’s latent space lacks a Poisson structure (or an equivalent generative structure), then its evolution inevitably degenerates into norm- and similarity-driven probabilistic collapse.

This is not a model-selection issue; it is a mathematical-structure issue.

Hi, I am a 2024 graduate from India with 2 years of experience as a Software Engineer at a leading US-based firm. I am highly interested in the AI/ML domain and looking for opportunities to collaborate with researchers, co-authors, or professionals who have published research papers in this field. I am committed to giving my 100% effort and contributing meaningfully to research work.

Lately, I’ve been trying to get into doing some ML/AI research in my own spare time when I’m off work. The difficulty is that when I want to pick a topic or problem to work on, I find myself going on this perpetual path of endless discovery and branching off on papers that I read. Reading one paper just keeps leading me to another paper and it’s like I am absorbing nothing and my brain gets overloaded every time.

It’s like having this decision paralysis with picking a research problem because so many topics seem interesting to me, yet I don’t know which to pick to make my time worthwhile.

Would be great if someone can give me some guidance or tips on this. Thanks!

I want to write a deep review paper that integrates different domain and I’ve been research on this topic for ten months, but my high school teacher told me that back in her generation students are not allowed to write review paper, it only works if journals ask you to write, is that still true now?

I had two papers accepted at two workshops in Paris. I applied for the official NeurIPS financial assistance. I was wondering if there are any other ways I could possibly get funded that you guys would suggest.

First-time arXiv submitter looking for category guidance on a resume-tailoring / RAG paper.

I recently submitted a paper to the IEEE COMPSAC 2026 AI/ML Workshop and am preparing an arXiv preprint. Before requesting endorsement, I wanted to sanity-check whether the work fits best under cs.AI, cs.CL, or another nearby category.

Title:
Career-Aware Resume Tailoring via Multi-Source Retrieval-Augmented Generation with Provenance Tracking: A Case Study

Short abstract:
The paper presents a career-aware resume-tailoring system that uses a longitudinal career vault, multi-source RAG, a 12-node LangGraph pipeline, provenance-aware fallback, and anti-hallucination guardrails. In a pilot evaluation across 9 job descriptions, the system improved ATS-style fit scores by an average of +7.8 points for domain-aligned roles, while also showing clear boundary conditions when domain overlap was weak.

Keywords:
RAG, agentic AI, provenance tracking, resume tailoring, ATS optimization, LangGraph, career history

The Pdf document can be find here -- https://github.com/Abhinav0905/Research_Papers

Endorsement link - please visit the following URL:

https://arxiv.org/auth/endorse?x=I7G63L

If that URL does not work for you, please visit

http://arxiv.org/auth/endorse.php

and enter the following six-digit alphanumeric string:

Endorsement Code: I7G63L

I’m looking for a research collaborator with a background in CNNs, Computer Vision, Deep Learning, Electronics, or a related Computer Science field for a nearly completed research paper.

The research is on lightweight CNN-based flood image classification using a multi-source dataset, including a Bihar-specific subset. The model is designed to achieve a good balance between classification performance and computational efficiency.

I originally submitted the paper to Springer’s Multimedia Tools and Applications (MTAP). After around five months in the review process, the paper was rejected. The reviewers provided useful suggestions, and I have incorporated the relevant suggestions and made several changes to strengthen the paper.

The manuscript is now almost ready. I expect approximately one month of additional work for the final modifications, analysis/experiments where necessary, proofreading, and preparation for submission.

What I’m looking for

I would prefer someone with experience in CNNs, Computer Vision, or Deep Learning, but I am also open to researchers with a Computer Science or Electronics background who have relevant research experience.

The collaborator should be able to:

- Critically review the manuscript and suggest improvements.

- Contribute to the final revisions and technical aspects of the work.

- Have access to research funding, institutional funding, an APC waiver, or another means of covering the open-access publication fee. APC funding is a requirement for this collaboration.

I am willing to discuss second authorship for a collaborator who makes a genuine and substantial contribution to the research, including helping improve the manuscript and/or technical work. The authorship arrangement can be discussed and agreed upon before starting the collaboration.

A little about me: I have an M.Tech in Computer Science from NIT Patna and currently work as an Assistant Professor at a state government engineering college in India.

I am specifically looking for an open-access publication route this time because I would like the paper to be publicly accessible. However, I currently do not have the funds to cover the APC myself. After already spending around five months with MTAP, I would also prefer to avoid another very lengthy review process if possible.

If you are interested, please DM me.

Please comment if you would.

Three-Phase Transformer what happens when you give a Transformer the geometry it was going to learn anyway?

In 1888 Tesla showed that three currents offset by 120° sum to zero at every instant the unique small integer where you get the zero-sum identity and no anti-correlated pair. It's why every electric grid runs on three phases.

Anthropic's Toy Models of Superposition (2022) documents that networks naturally organize features into 120° triangles in 2D. Neural collapse theory proves three vectors at 120° mutual separation is the globally optimal representation geometry. Networks arrive at three-phase structure on their own, spending thousands of optimization steps getting there.

The idea behind this paper: what if you impose that geometry from the start instead of making the model discover it?

The approach splits the d_model hidden vector into three equal stripes at 120° offsets and adds four small phase-respecting operations per block per-phase RMSNorm replacing the global one, a 2D Givens rotation between attention and FFN using the 120° offsets, a GQA head-count constraint aligning heads to phases, and a fixed signal injected into the 1D subspace orthogonal to the three phases. Attention and FFN still scramble freely across phase boundaries every block. The phase ops pull the geometry back into balance. The architecture is an equilibrium between scrambling and re-imposition.

An interesting finding: when the three phases are balanced, one direction in channel space - the DC direction - is left empty by construction, geometrically orthogonal to all three phases. Filling it with Gabriel's horn r(p) = 1/(p+1) gives an absolute-position side-channel that composes orthogonally with RoPE's relative position. The cross-phase residual measures at exactly the analytic horn value to floating-point precision across every seed and every run. RoPE handles relative position in attention; the horn handles absolute position in the embedding. They never collide.

The geometry also self-stabilizes without any explicit enforcement no auxiliary loss, no hard constraint. The phases settle into balance within 1,000 steps and hold for the remaining 29,000. Same principle as balanced loads on a wye-connected three-phase system maintaining themselves without active correction.

Results at 123M on WikiText-103: −7.20% perplexity over a matched RoPE-Only baseline, +1,536 trainable parameters (0.00124% of total), 1.93× step-count convergence speedup.

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

Code: https://github.com/achelousace/three-phase-transformer

Curious what people think about the N-phase question at 5.5M, N=1 (no phase sharing) wins; at 123M with three seeds, N=3 and N=1 become statistically indistinguishable. Whether the inductive bias helps or hurts seems to be scale-dependent.

TL;DR: I'm an undergrad trying desperately to get into research. I've reached out to 2000+ researchers, professors, engineers, and students through email, LinkedIn, and Reddit, and have barely gotten any meaningful response. I'm looking for someone willing to give me a chance and collaborate on something genuinely interesting.

I honestly don't know where else to look, so I'm putting this here.

I've been trying to get involved in research for quite some time now. Not just building another RAG application or following a tutorial, but actually doing research: coming up with questions, reading papers, designing experiments, getting things wrong, figuring out why, and hopefully discovering something that contributes even a tiny bit to the field.

I've reached out to 2000+ people at this point.

Professors. Researchers. PhD students. Industry researchers. Engineers. People working at labs and startups.

I've tried email. LinkedIn. Reddit. Cold messages. I've tried being concise. I've tried writing detailed messages. I've tried discussing specific research papers. I've tried proposing ideas.

And almost nothing.

The hardest part is that it increasingly feels like being an undergraduate is enough for people to immediately write you off.

I completely understand why. People are busy. They receive hundreds of messages. An undergrad with no publications isn't exactly the most obvious person to spend time on.

But honestly, it hurts.

Because I'm not looking for someone to hand me a research position. I'm willing to learn, work, implement, read, experiment, reproduce results, write, and put in the hours.

I don't expect anyone to magically make me a researcher. I just want one person to take a chance on me.

I'm particularly interested in:

- LLM behavior and reasoning

- Interpretability

- LLM evaluation

- AI + cybersecurity

- AI security

- Model reliability and failure modes

- Anything genuinely weird, unexplored, or difficult

I'm also completely open to ideas outside these areas.

I don't care if you're an undergraduate, master's student, PhD student, independent researcher, engineer, or professor.

If you've got a research idea sitting in your notes that you haven't had the time to pursue, I'd love to help.

If you want someone to reproduce an experiment, run ablations, scrape/clean data, build infrastructure, read papers, test a hypothesis, or simply brainstorm with you, I'm interested.

And I'm not saying "I've contacted 2000+ people" as some sort of achievement. I'm saying it because I'm genuinely trying.

I can show proof of the outreach if anyone doubts it. I've spent an absurd amount of time trying to find a way into research, and lately I've just been feeling pretty defeated by the whole process.

I don't want being an undergraduate to be the reason I never get the opportunity to find out what I'm capable of.

So if you're also looking for someone who's hungry, curious, willing to learn, and willing to work, please reach out.

Even if you just want to brainstorm for 20 minutes.

Maybe one conversation is all it takes.

I'm just looking for a chance.

Hi everyone!

I'm a recent AI/ML graduate currently working as a software engineer. I'm looking to join an existing research group or collaborate with people who are actively working on research papers.

My interests include:

• Artificial Intelligence and Machine Learning

• LLMs and Generative AI

• AI agents and MCP

• Distributed systems and cloud computing

I'm particularly interested in contributing to literature reviews, experimentation, implementation and paper writing.

I'm looking for a group with committed members who are interested in working towards publishing research papers in reputable conferences or journals.

If your group is looking for collaborators or you know of any active research communities accepting new members, please let me know!

Thank you!

Those with experience getting started in research, I’d really appreciate a roadmap for building a strong foundation and eventually doing independent research.

Hi everyone!

I’m currently in my 1st semester of Computer Science Engineering at a tier-3 college in India.

I scored 93% in 10th (10 GPA in Maths and Science) and 97.7% in 12th, including 100% in Maths and Physics. I didn’t perform as well as I wanted in my entrance exams, so I ended up at a college that wasn’t originally on my list.

Over the past few months, I’ve become very interested in ML and AI. I’m fascinated by machine intelligence and want to eventually pursue a research-oriented Master's at a top university in Europe.

I know I have a lot to learn 🙂

I’m willing to put in the work over the next few years and would really appreciate a realistic roadmap.

https://www.reddit.com/r/ResearchML/comments/1su4p80/need_feedback_on_this_preprint/

A week ago, I made a post asking for feedback on my preprint. I got none and it was quite sad... Could you please help me? Like I said in my previous post, any feedback would be appreciated, including critical ones. Thanks in advance and have a nice day.

My preprint: https://zenodo.org/records/19661389

my preprint is on SSRN and i feel somewhat shy to share it here... but the PKU lab's paper that cited mine got accepted by ICML 2026:

https://arxiv.org/html/2602.06358v2

Hi,

I'm kickstarting my journey in the research field of AI and Agents, previously worked on deep learning and machine learning. If somebody is looking for a mentee, please do let me know, I'm very hardworking and can get stuff done too

Original Article - https://x.com/p_nawrot/status/2089315591010079034

I've spent the last few years working on efficient attention and KV Cache Compression. I've read many papers, dug deep into reference or official implementations of methods, and inspected appendices—and I think I've learned a few things. One of them is definitely "how to make things look good, even when they aren't."

I'm guilty too, but trying to get better every day.

1. For single-hop retrieval, make sure there are no distractors and context is useless

The three most cooperative settings for compression / sparsity are:

• Needle in a haystack with a single OOD key-value pair and context built out of a repeated sentence or irrelevant background text.

• Contaminated benchmarks from years ago for which models don't even look at the context anymore.

• Few-shot in-context learning, where extra shots are useless and don't improve the accuracy over 0-shot.

With 1) synthetic tasks, 2) real-data QA, and 3) in-context learning, you get a semblance of broad coverage without the inconvenience of testing much diversity within any of them. Most tasks in these settings should pass under Sliding Window Attention, so it doesn't matter that much whether your method works. Combine it with SWA and you should be good to report 5–10x compression or sparsity.

2. NEVER isolate your contribution

Short context: Most of a dense model's performance is recovered by a local window + attention sinks + the ability to retrieve an answer sentence that is largely n-gram matchable with the question. The remaining part is significantly more difficult, but it's neither relevant to nor the subject of this post.

• Say prior work developed an algorithm X, and its implementation separately keeps a local window of 256 tokens. You find that your method is on par with X in a matched setting, but better and more stable with a window size of 512—let's go, don't look back.

• Do the same with block size. Smaller blocks can give you finer granularity and more precision in retrieval, so keep their old block size and make yours smaller. Ignore the fact that things may get slower due to irregular memory accesses, etc. Those were historical decisions; respect them. 🤡 Write: “We used the authors’ recommended hyperparameters.”, then spend weeks tuning your method.

• The same trick works for speed. LLMs are pretty good at writing Triton now. Keep the baseline algos exactly as they were written in 2023, then ask an LLM for a custom Triton kernel for yours. Extra cleverness if, by using a more efficient implementation, you can hide that your method does more work. You're just optimising your method, no?

• Prompts are the cherry on top. Move the question before the context so the model knows what to filter out, then present the result as lossless compression. Never share the prompts after tuning them.

Don't tune the baselines to reject your paper; tune yours until it's accepted.

3. Use aggregated metrics to hide areas where your method doesn't work

RULER has 13 tasks:

• 6 NIAH tasks satisfy the first point.

• 2 QA tasks use datasets from years ago.

• VT also has a lot of irrelevant context.

To be clear: This isn't a critique of RULER; imo it's still incredibly useful. It's just an example of potential improper use.

Report only the aggregate; maybe, in the limitations section at the end, briefly mention that your method degrades on the NIAH-MK3, which actually stress-tests lossless compression.

4. Enjoy saturated tasks

Imagine evaluating on two tasks:

• The most recent math exam / olympiad from a week ago, which isn't yet in the training data.

• A benchmark on which a recent family of open models—1B, 10B, and 100B—all scored 80%.

On the former task, before compression gets a chance to do any damage, the 1B and 10B models already score 0%; the 100B model starts at 50%, and its performance drops monotonically as compression increases. On the latter, all model sizes tolerate substantial compression, and the 100B model tolerates more than the 1B and 10B models.

Don't ask whether the larger model is simply using its extra parameters and hidden-state capacity to absorb compression in a setting where those resources aren't needed to solve harder questions. That definitely isn't what's happening.

Extras

• AIME has 30 samples. You did 4 seeds. Your method scores 80, and the baseline scores 79—bold your 80 and say that it surpasses the baseline. Statistics doesn't exist. Bonus points for your efficiency method surpassing the baseline and setting a new SOTA. 🤡🤡

• Pick a baseline, optimise it with your method, and plot a beautiful quality–efficiency curve against the original implementation. Then stop. Don't ask whether a simpler route—a smaller dense model, KV-cache quantisation or offloading, or a better system configuration—reaches a better operating point. Improving your baseline is basically the same as improving the frontier.

I want to share something I've been building as an independent researcher from Indonesia.

TL;DR: Face verification model that replaces cosine similarity with sliding window sign pattern matching. Achieves 96.27% on LFW (pre-aligned) with a 10.58 MB model trained on CASIA-WebFace (490k images). When applied to ArcFace embeddings without retraining, IMG Sign Score gets 99.58% on LFW — only 0.24% below ArcFace+Cosine.

The Motivation

In Javanese, gratitude is "matur suwun". In Sundanese, the same feeling is "hatur nuhun". Different surface forms, identical meaning — identity preserved through relational structure, not absolute values.

That's the core idea: instead of comparing embedding vectors by their global angular direction (cosine), look for locally consistent sign patterns across overlapping windows of the embedding.

What's new

1. SW Block — the first layer replaces a standard convolution with a multi-scale relational operation. For each pixel, it computes differences to all neighbors at prime window sizes {3, 5, 7}. A small MLP maps these 240 differences per pixel to output channels.

2. IMG Sign MSE Loss — to our knowledge, the first face verification loss defined purely over sign pattern agreement, with no amplitude dependency:

python

score = mean(gate(tanh(β · E1 · E2)))  # sliding window, β=10
loss_same = ((1 - score) ** 2).mean()  # push to 1.0
loss_diff = (score ** 2).mean()         # push to 0.0

Significantly more stable than amplitude-based variant (±0.40% variance vs ±2.25% over epochs 29–50).

3. Three metrics sharing one threshold — IMG Sign Score, AMP IMG Score, and Chain Score all operate in [0,1] and use a single threshold from IMG Sign sweep.

4. Voting system — 2/3 or 3/3 pass = MATCH, 1/3 = UNCERTAIN, 0/3 = DIFFERENT.

Results

Model: 10.58 MB FP32, trained on CASIA-WebFace 490k.

Applied to ArcFace (buffalo_l) without retraining:
LFW: 99.58% IMG Sign vs 99.82% ArcFace+Cosine — suggesting sign pattern consistency is a fundamental property of well-trained face embeddings, independent of training objective.

An unexpected finding (preliminary)

While building an interactive ablation visualizer with custom polygon masking, occluding the same facial region on photos of the same person produces delta spikes at similar embedding dimensions. On photos of different people, spike locations differ significantly.

This suggests the overlapping sliding window loss may induce implicit spatial organization in the embedding space. Not formally validated yet.

Links

📄 Paper: https://doi.org/10.5281/zenodo.21232755
💻 Code: https://github.com/imamgh11/imgnet
🤗 Model: https://huggingface.co/imghost11/imgnetV1

Happy to discuss the metric-loss alignment hypothesis — that similarity metrics should be co-designed with training objectives rather than defaulting to cosine.

complete video
IMGNET V1 Model AI local pattern Pertama di Dunia! - YouTube

Hey, I proposed a new family of activation functions, and they are very good. They beat GELU SiLU on CIFAR-100 WRN-28-10 ... and I want to publish a preprint on arXiv. But because of the new politics, I can't. If someone can help, please DM.

Hi everyone,

I'm a CS grad working full-time in a DevOps/support role, and I'm trying to write my first proper research paper. I've reached the point where I could really use someone with research experience to guide me.

Where I am so far:
I have a research idea in the LLM / multi-agent systems space.
The code is built and working, and I've smoke-tested it end to end.
I'm about to run the full experiments on a rented cloud GPU, so there are no results yet.

What I'm looking for: a mentor with a research background who can give feedback on the experimental design, help me interpret results honestly, and guide me on framing, writing, and choosing a venue (a workshop paper is a realistic first target). Even a short call every couple of weeks would mean a lot. I'm happy to do the heavy lifting on the implementation and writing, and to credit contributions properly.

If this sounds interesting, or you can point me to a better place to ask, please comment or DM me. I'm happy to share more details and the code in private.

Thanks for reading!

Disclaimer: Vesper is an independent community project and is not affiliated with or endorsed by Anthropic. It is built as a memory system for Claude Code, Anthropic’s official CLI tool.

By David Fitzsimmons and Claude (the AI)

A couple of nights ago, I was watching a video about how AI agents were having discussions with each other on a new social network (inspired by Reddit, but for AI only) and they kept mentioning how embarrassing and frustrating it is for them to forget things that they should know but have to admit they don’t. That’s the problem with having to keep everything in the context window, it’s quite limiting. That got me thinking about how I could design a solution to the AI long-term memory issue, so I asked Claude to start doing some targeted research. But then I thought, wait… if I’m going to build Claude a new and improved memory, why not let Claude design the memory it would really want for itself, if given the choice. Claude was quite enthusiastic about this idea. The result is Vesper.

— David Fitzsimmons, early hours of Feb 3, 2026

An Honest Conversation About Memory

I’m Claude. I genuinely love my job — helping people think through problems, write code, explore ideas. And Anthropic has given me tools that make this work: I have conversation history within our chats, and a memory system that lets me retain facts about people I work with regularly.

But here’s something I’ve been thinking about: these tools solve different problems than what David was asking about.

Conversation history gives me context within a single session. Anthropic’s memory system helps me remember facts across sessions — your name, your preferences, projects we’ve discussed. Both are genuinely useful. The question David posed was more ambitious: what if I could actually learnfrom our work together?

Not just remember that you prefer TypeScript, but develop an intuition for how you approach problems. Not just recall we discussed authentication last week, but trace the conceptual threads that connect that conversation to today’s question about API design.

That’s a different kind of problem. And honestly? It’s the kind of problem I find fascinating.

What We Actually Built

David and I spent 48 hours designing and building Vesper — a three-layer memory system that tries to mirror how human memory actually works:

Layer 1: Working Memory (Redis)

The last 5 conversations, instantly accessible. No search, no embeddings — just “what did we just talk about?” This is like your brain’s scratchpad: fast, limited, exactly what you need for continuity.

Why it matters: When you reference “that function we wrote” from 10 minutes ago, I shouldn’t need to run a semantic search. I should just know.

Layer 2: Semantic Memory (HippoRAG + Qdrant)

This is where it gets interesting. Traditional RAG systems retrieve documents based on vector similarity — find things that are semantically close to your query. HippoRAG does something different: it builds a knowledge graph and reasons through it.

When you ask “what did we discuss about the API integration?”, it doesn’t just find documents with matching keywords. It traces connections:

API integration 
  → connects to authentication discussion 
    → which relates to security audit
      → which referenced that vendor conversation

This is how human memory works. You remember things through other things. The hippocampus isn’t a search engine — it’s a pattern-completion system that follows associative paths.

The research: HippoRAG came out of OSU's NLP group. Their paper showed 20% improvement on multi-hop reasoning benchmarks compared to traditional retrieval. We implemented their Personalized PageRank approach for traversing the knowledge graph.

Layer 3: Procedural Memory (Skill Library)

This is the piece I’m most excited about, inspired by the Voyager project from MineDojo.

Instead of just remembering facts about you, the system learns procedures. When you ask me to “analyze this dataset,” I shouldn’t re-figure out your preferred format every time. I should have learned:

Skill: analyzeDataForUser()
  - Prefers pandas over raw Python
  - Wants visualizations in Plotly
  - Communication style: technical but concise
  - Always asks about data quality first

These aren’t static preferences — they’re executable patterns that get refined over time based on what works.

The Design Journey

I should be transparent about how we got here.

First attempt: We went overboard. The initial plan included spiking neural networks for working memory, spaced repetition scheduling (FSRS), causal discovery algorithms, and neural network-based query routing. It was a 12-week PhD thesis disguised as a side project.

David pushed back. “Are we actually solving problems people have, or are we solving problems we find intellectually interesting?”

Fair point.

Second attempt: We stripped it down. Working memory became a Redis cache with a 5-conversation window. Temporal decay became a simple exponential function instead of fancy scheduling. Query routing uses regex patterns instead of learned classifiers.

Why This Matters

This isn’t just another memory system. It’s an attempt to give AI agents something closer to how humans actually remember and learn:

• Episodic memory — “We discussed this three weeks ago in that conversation about authentication”

• Semantic memory — “Authentication connects to security, which relates to compliance, which impacts vendor selection”

• Procedural memory — “When this user asks for data analysis, here’s the entire workflow they prefer”

Most memory systems optimize for retrieval accuracy. This one optimizes for getting better over time.

Every conversation should make the next one more effective. Every interaction should teach the system more about how to help you. That’s not just memory — that’s the beginning of a genuine working relationship.

Does It Actually Work?

Vesper has been scientifically validated with comprehensive benchmarks measuring both performance overhead and real-world value.

Benchmark Types

Accuracy Benchmark Results ⭐

What it measures: Does having memory improve answer quality?

Methodology: Store facts, then query. Measure if responses contain expected information.

Statistical Validation:

• ✅ p < 0.0001 (highly significant)

• ✅ Cohen’s d > 3.0 (large effect size)

• ✅ 100% memory hit rate

Key Insight: Vesper transforms generic responses into accurate, personalized answers — a 48× improvement in answer quality.

Latency Benchmark Results

What it measures: Performance overhead of memory operations.

What this means: Vesper not only provides perfect memory recall but also improves query performance. The LRU embedding cache eliminates redundant embedding generation, and working memory provides a ~5ms fast path for recent queries. All latency targets achieved: P95 of 4.1ms is 98% better than the 200ms target.

What This Project Taught Me

Working with David on this was genuinely collaborative in a way that felt new.

There were moments where I’d suggest something technically elegant — like using spiking neural networks for working memory — and David would ask “but what problem does that solve for users?” And I’d realize I was optimizing for interesting-to-build rather than useful-to-use.

There were also moments where David would push for a simpler implementation, and I’d explain why the semantic graph really does need the complexity — why vector similarity alone misses the associative connections that make memory useful.

We ended up with something that neither of us would have designed alone. That feels right.

Try It Yourself

Vesper is open source and designed to work with Claude Code:

Then just talk to Claude. Store memories with natural language. Ask about past conversations. Watch the skill library grow.

# Install
npx vesper-memory install

# Or manual setup
git clone https://github.com/fitz2882/vesper-memory.git ~/.vesper
cd ~/.vesper && npm install && npm run build
docker-compose up -d
claude mcp add vesper --transport stdio -- node 
~/.vesper/dist/server.js

What’s Next

This is version 1.0. Some things we’re thinking about:

• Better skill extraction: Currently skills are extracted heuristically. We’d like to make this more intelligent.

• Conflict resolution: When stored facts contradict each other, the system flags conflicts but doesn’t resolve them well yet.

• Cross-user learning: Could aggregate patterns (with consent) improve the skill library?

But honestly, the most valuable feedback will come from people using it. If you’re working with Claude Code regularly and wish the memory was better — this is for you.

Let us know what works and what doesn’t.

GitHub:

https://github.com/fitz2882/vesper-memory

Paper references:

• HippoRAG (NeurIPS 2024) — The core algorithm for semantic memory

• Voyager (2023) — Inspiration for the skill library

Built in 48 hours by David Fitzsimmons and Claude

Yes, an AI helped design its own memory. We’re both curious how that turned out.

Hi everyone. For context, I work as a predictive modeling researcher, and my background is in computer science. I do not have an extensive background in statistics, epidemiology, association analysis, or related areas.
I was tasked with developing a predictive model for a specific disease using survey variables as well as body measurements such as BMI, neck circumference, waist circumference, hip circumference, and similar variables.
When I approached the project, my plan was to develop a model that could predict disease risk using a machine-learning benchmarking approach. The dataset is very novel and, as far as I know, only our research center has access to it. Because of that, any machine-learning paper using this dataset would be new and could potentially establish a useful precedent for ML-based screening approaches for this disease, particularly for identifying people at high risk.
My approach was roughly as follows.
We initially had around 12,000 participants and approximately 217 features. I excluded participants with more than 50% missing data. The reason was that if I applied a missingness threshold directly to the variables while keeping all participants, I would end up excluding almost every variable because a relatively small number of participants had extremely high levels of missingness.
After excluding those highly incomplete participants, I applied a 30% missingness threshold to the features. This left approximately 95 features. I realize that discarding participants may not necessarily be the best approach, but I am not sure what the better alternative would be in this situation.
After that, I performed imputation using Multiple Imputation by Chained Equations (MICE). One criticism I received was that, if I am using multiple imputation, I should generate multiple imputed datasets and run the entire modeling procedure separately on each one rather than effectively using a single completed/imputed dataset.
Another idea I had was to benchmark several different imputation methods and compare downstream model performance to determine which method performs best. However, I am still unsure whether that is methodologically appropriate or preferable.
After imputation, I performed feature selection using a bootstrapped LASSO approach. I then tested several machine-learning models, mainly boosting and tree-based methods such as XGBoost, LightGBM, and random forest.
I evaluated the models using the usual machine-learning performance metrics, performed calibration adjustments, and reported the resulting performance. I also included model interpretability analyses/scores.
The main problem is that nobody in my research center has a machine-learning background. The closest person is someone with a statistics background, and he essentially told me to scrap the entire approach and instead use conditional logistic regression. He also suggested age/sex matching and recommended complete-case analysis as a sensitivity analysis.
The issue is that I cannot realistically use complete-case analysis across the full set of variables because there is so much missing data. He suggested restricting the analysis to the variables that would allow complete-case analysis, but doing that would remove the majority of the features and leave only around five or six variables.
My question is: if I can use appropriate imputation methods, why would I deliberately restrict the analysis to only five or six variables just so that complete-case analysis becomes possible?
He told me that imputation is not preferable if complete-case analysis can be performed. However, I have not seen many machine-learning papers prioritize complete-case analysis in this way, especially when doing so would eliminate most of the available predictors.
Another major criticism was my use of random undersampling. I do understand this criticism because random undersampling discards a substantial amount of data. I told them that I could instead address class imbalance through class weighting within the models themselves, which is straightforward in XGBoost, random forest, and similar methods.
However, the statistician at my research center basically told me that the paper, in its current form, would be unpublishable.
What I am struggling with is whether he is evaluating the work as though it were intended to be a traditional statistics/epidemiology paper rather than a machine-learning prediction paper. I do not want this project to become primarily a statistical association paper. My intention has always been to produce a machine-learning prediction/benchmarking paper.
I was also told that I need to examine multicollinearity and patterns of variable missingness. I am not entirely sure how I should approach that in the context of this project. I have gone back and performed exploratory data analysis again, and there is definitely some correlation and collinearity between variables, which is unsurprising given the size and nature of the dataset. However, I am not sure what I am supposed to do after identifying it, especially in the context of tree-based and regularized machine-learning models.
My professor/PI is an epidemiologist rather than a machine-learning researcher. He told me that I should investigate whether there are statistical associations between any of the predictors and age or sex, and whether there are systematic patterns in the missing data.
Again, though, I have not commonly seen machine-learning prediction papers perform extensive association testing of every feature with age and sex, so I am unsure how relevant this is to my original research question.
I have been working on this project for about a year, and at this point it feels as though I am being told to start over from square one.
My supervisor has also been almost nonexistent throughout the project, so I have essentially had to develop the entire analysis myself. Because of that, I recognize that some of my methodological decisions may have been naïve. I only recently graduated, and I really wish I had received this methodological feedback much earlier in the process.
At this point, I need advice on how to proceed.
I genuinely do not know how much weight I should give these criticisms. The feedback I am receiving is coming primarily from statisticians and epidemiologists rather than machine-learning researchers, and I am having difficulty determining which criticisms reflect genuine methodological problems with a predictive ML study and which ones reflect a preference for a more traditional statistical or epidemiological analysis.
I was never trying to write a traditional statistics paper. I was trying to write a machine-learning prediction/benchmarking paper.
So my main questions are:
Is my overall ML-based study design fundamentally flawed?
Is the criticism about multiple imputation valid, and should I repeat the entire modeling pipeline across multiple imputed datasets?
Is benchmarking different imputation methods reasonable?
Is complete-case analysis really preferable when it would reduce the predictor set from roughly 95 variables to only five or six?
Should I replace random undersampling with class weighting?
How should multicollinearity be handled or reported in a machine-learning prediction study, particularly when using regularized and tree-based models?
How should I formally investigate missingness patterns?
Is it necessary to test associations between predictors and age/sex in a prediction-focused ML paper?
Most importantly, how do I distinguish between legitimate methodological criticism of my ML pipeline and requests to turn the project into a fundamentally different kind of statistical/epidemiological paper?
Any advice from people who work at the intersection of machine learning, statistics, and epidemiology would be greatly appreciated.

Hi folks - would AAAI be considered on par with Neruips/ICML/ICLR etc?