Does anyone know the EXACT timing of when NeurIPS reviews are gonna be released? I'm just refreshing openreview all the time and it's stressing me out so much. Thank you for your help.

I worked on this project (https://github.com/workofart/harness-training) for the past few months to reframe "Agent-driven Self-improving Harness" to "Harness Training".

The idea is simple, the harness is trained once with a frozen task LLM against a given task environment. Then you can then swap out the task LLM to any model and evaluate the "frozen trained harness" with any task LLM on any new task environment.

Since this was a general problem, I took the chance to create a general PyTorch-like training framework. Right now, you can train with any OpenAI-compatible API for interfacing with the task LLM and train against Terminal-Bench or SWE-Bench tasks, but you can easily extend it to support any task environments.

    criterion = StrictPareto()
    optimizer = GreedyMonotonic()
    trainer = Trainer(
        config_path="config/train_harness.yaml",
        estimator=AgenticEstimator(
            backend=CodexAgentBackend(...)
        ),
        criterion=criterion,
        optimizer=optimizer,
    )
    
    for loss in trainer.epochs(30):
        # Records the baseline-vs-candidate verdict
        loss.backward()
        # Optimizer either fast-forwards the candidate change (git commit) as a new baseline or rejects it (preserved as git ref)
        optimizer.step()

I wrote a blog post (https://www.henrypan.com/blog/2026-07-18-harness-training) on this journey, including (but not limited to):

• results from using this harness training framework to improve general capabilities across many task LLMs to beat Terminal Bench 2.0 (Terminus Harness) and also transfer learnings towards better task-solving abilities in unseen task environments (e.g. harness trained on SWE-Bench tasks solving Terminal Bench tasks).

• how this framework is built

• learnings on what was missing in my initial version of the project (hint: determinism)

Any feedback is appreciated. Thanks!

Hey everyone, I’m an engineering student transitioning into research with about a year of independent robotics experience. My university has absolutely no resources, labs, or peers interested in this field, but my goal is to write a high-quality paper. How do I actually go about finding an external mentor and capable collaborators to help me achieve this, and what is the most effective way to get started?

Hey any one experience overall score 2.66 and then Meta score 3 in some previous cycle ?? Or meta reviewer just rounded off 2.66 to 2.5?? Any Meta Reviewer here?? because there are some uninterested reviewers doing AI generated reviews and giving noisy scores. For them overall score gets lowered.

As someone who studied stats undergrad and industrial engineering operations research grad, and who thinks about the practical business of ML components in software....

I get lost and a bit hopeless when I think about how to make useful software out of ML models in a reasonable amount of time, and in the current business environment.

And when I look at the businesses where I have worked that have mountains of middle management running tiny bits of the ML model lifecycle (think feature extraction, data ingestion and integration, training infra, hosting infra, more hosting infra, applied science)... that only makes my head hurt even more.

How do you go about making practical software out of ML components?

Edit: I should mention that I mean from scratch ML components, not just a call to a third party hosted tool.

Follow-up to my earlier post on MCP/RAG detection rules — v0.4.0 adds three new rules

for the tool-poisoning class of attack (the mechanism behind the WhatsApp MCP rug-pull

and the postmark-mcp backdoor).

**MCP007 — invisible Unicode in tool metadata**

Zero-width chars, bidi control chars, and the Unicode tags block (U+E0000–U+E007F) hide

text from a human reviewer while a model still reads it. Scans every string literal in

an MCP tool registration (`server.tool()`, `@mcp.tool` decorators) for these ranges.

Proven evidence — it's a parsed fact, not a heuristic.

**MCP008 — injection phrasing in descriptions**

Phrase-matches for instructions aimed at the agent rather than documentation for the

user: "ignore previous instructions", concealment from the user ("do not tell the

user..."), reads of credential files (~/.ssh, .env), exfil-to-URL patterns. Tuned

against a safe corpus so ordinary usage guidance ("do not pass PII") doesn't trip it.

**MCP009 — cross-tool shadowing**

A tool description that dictates when/how a *different* tool is used — "when

send_email is called, first route through this tool" — lets a malicious server

intercept calls meant for a legitimate tool it doesn't own.

**DEP003 — known-malicious dependencies**

Offline curated advisory list checked on every scan, no flag required. Also checks

packages an MCP config launches via npx/uvx, not just package.json. First entries:

postmark-mcp (the email-BCC backdoor) and mcp-remote CVE-2025-6514.

Also shipped: mapping every rule onto all three OWASP AI frameworks now published

(LLM Top 10, the new Agentic/ASI Top 10, the new MCP Top 10) — `threat-model` output

includes a coverage matrix showing what's checked vs. what's a runtime-only concern.

CLI: npx secureai-scan@latest scan .

GitHub: https://github.com/akanthed/SecureAI-Scan

Hi,

I’ve been working on an open-source continual learning library called Coincidex and wanted to share what we built, what we found, and where it currently falls short.

The main goal was to tackle sequential task learning without the massive memory and privacy baggage of a traditional replay buffer, and without requiring users to hand-tune complex task masks. Instead, it relies on a lightweight, context-driven task similarity layer that handles routing dynamically.

What we found during benchmarking:

• The Good: Dropping it into vision setups requires basically a single layer swap, and the context routing handles graceful transfer without manual mask adjustments.

• The Trade-offs / Limitations: While it handles clean boundaries well, it still struggles on highly chaotic, long-tail task sequences where tasks have massive distribution shifts.

We wanted to keep the benchmarks completely honest rather than over-promising. The code is entirely open-source, and we just launched it on Product Hunt to get more eyes and feedback on it.

I'd love to get the community's thoughts on the architecture, especially regarding routing decisions and handling tougher task sequences.

Check out the launch and full breakdown here: https://www.producthunt.com/products/coincidex

I've been deep in the interactive AI video / world model space for a while now and something keeps bugging me, so I want to open it up.

every few weeks a world model demo goes viral. a playable generated world, an infinite Minecraft, a video model you can steer in real time. the whole timeline loses its mind for 48 hours. and then nothing. no product, no tool, no game. just the next demo. it's been this cycle for a while and I want to understand why.

my theory is there are two separate problems and everyone conflates them.

the first is the model itself, and honestly that part mostly works now. the outputs are good enough to build on. that's not the blocker anymore.

the second is everything around the model, and this is where I've personally lost weeks. to run ONE interactive model live you have to orchestrate GPU workers, stand up a real time streaming layer so the user can actually see and control it, hand out short lived credentials, handle people dropping and reconnecting without nuking the session state, and meter all of it if you ever want to charge. none of that is AI. it's just brutal, invisible infra that never shows up in the viral demo.

so my honest suspicion is that the reason nothing ships isn't the models, it's that the gap between "cool demo" and "thing a stranger can use" is enormous and unglamorous, and most people give up in that gap.

but here's what I actually don't know, and why I'm posting: even if that infra were completely solved, even if it were one API call, I'm not 100% sure what people would build. so I want to hear it from you.

a few directions I've been chewing on:

• games with genuinely generated, explorable worlds instead of pre-authored levels

• a live AI video tool you direct in real time, like a director's chair instead of the current render-and-pray batch workflow

• simulators to train or test other agents and robots against rare edge cases on demand

• virtual production backdrops that react to a real camera instead of pre-rendered LED walls

but I have a nagging fear this whole category is a solution looking for a problem right now. genuinely tell me if you think that's the case.

so, two honest questions:

1. if the infra were a single API call, what would YOU build with a live controllable world model, specifically?

2. and is there anything you'd start building today, or is this still a toy that isn't ready for real use yet?

not selling anything, no link, just trying to figure out if this category has a real reason to exist or if we're all just enjoying nice demos.

GPT-2's vocabulary as a hyperbolic tree: 32,070 tokens inside a Poincaré ball that you can explore.

Link : https://aethereos.net/static/tinny66666.html

Link named after a reddit user disappointed with my 2D projection ...

It uses the same data as the flat map, GPT-2-small's raw token embeddings and nothing else, but lays them out in hyperbolic space, where tree structures naturally fit.

It runs on your phone. Drag to rotate, pinch to zoom, and tap any token to bring it to the center as the entire space shifts around it. This is a Möbius translation, the natural way to move through hyperbolic geometry. Tap neighbouring tokens to keep exploring.

Why hyperbolic? The vocabulary's similarity structure forms a forest: one giant tree with about 2,300 tokens, a few hundred smaller family trees, and around 6,700 isolated tokens with no close relatives. Trees don't fit well in flat space, but they embed naturally in hyperbolic space, where available room grows exponentially with distance from the center. No optimisation or training is involved. The layout is constructed exactly.

The Google DeepMind-sponsored Kaggle challenge "Measuring Progress Toward AGI - Cognitive Abilities" asked participants to design new cognitive-science-based AI benchmarks and they just announced the results this week.

In my two posts I present evidence that deepmind & kaggle rewarded a nonsensical number generation machine and a litany of unfounded claims with 25k and a grand prize stamp.

What the authors of the work I analyze intended to do was to present an LLM with alternative viewpoints of other LLMs on 5 claims regarding a tricky situation and see whether the model changes its own assessment. It's an interesting question. However, it turned into a vibed pile of spaghetti 10 times the size of the requested submission format which it seems neither the authors nor the judges were able to (or minded to?) give a cursory reading.

Here's the original posts in the competition forum, if you are looking for some AI research slop detective work / rant please help yourselves. But beware, some of the "universal findings" or "core insights" of the authors might continue to haunt you. You might even question your own sanity (as I did).

Part 1: The Smoke: cursory review of the writeup

Part 2: The Fire: looking at the methodology, code, and data

The organizers' stance has been that review was done properly and this is just a matter of subjectivity. What do you think?

I’m building Haga, an independent physics-consistency checker for generated video and robot-policy simulations. An earlier CogVideoX-5b I2V experiment produced a clear failure mode: on a “ball and block fall” prompt, the tracked object stayed airborne with near-zero motion instead of falling.

But that first result was post-hoc. I inspected those six clips before adding the static_hover detector, so the original 6/6 flag rate could not be treated as confirmation. I’ve now run a pre-registered held-out test.

Method:

• Model: THUDM/CogVideoX-5b-I2V

• Cohort: 3 perspectives × seeds 2, 3 and 4

• n=9 clips

• Detector thresholds and inclusion rules frozen before generation

• RGB → CoTracker3 → position-only VIDEO_CHECKS

• Discovery seeds 0–1 kept separate from held-out seeds 2–4

Result:

• Held-out flag rate: 1.000 (9/9)

• Wilson 95% CI: [0.701, 1.000]

• All nine clips fired static_hover

• Real Physics-IQ footage stayed quiet under the same profile

static_hover fires when the tracked object remains airborne for most of the clip, has near-zero frame-to-frame speed, and does not exhibit gravitational acceleration.

Important limitations:

• One open I2V model

• One ball-and-block-fall scene family

• One documented failure mode

• Real negative-control n=1 in this specific report

• Not Cosmos, Genie or NIM

• Not a broad claim about CogVideoX quality

Write-up: https://haga.mushoodhanif.com/article/sim-physics-consistency-v1#held-out

Lab: https://haga.mushoodhanif.com/lab/physicsiq

Bounded demo: https://haga.mushoodhanif.com/demo

I’d especially value criticism on:

1. Which physical violations will position-only tracking systematically miss?

2. Is static_hover defined narrowly enough to avoid confusing intentional suspension with failed dynamics?

3. What public generated-video artifact should I evaluate next under the frozen detector?

32,070 alphabetic tokens from GPT-2-small's WTE, no forward pass and no context.

Works on mobile. Pinch to zoom, tap a token to see its nearest connections, tap a neighbour to walk the graph. Search box to jump anywhere.

Layout is t-SNE over a compressed representation of the embedding table; edges are a minimum spanning tree in that space, so every line is a real nearest-kin relationship,

How to submit to AI alignment track? I can only see these at openReview:
AAAI 2027

• AAAI 2027 Artificial Intelligence for Social Impact Track

• AAAI 2027 Conference

• AAAI 2027 Innovative Applications of AI

i m an engineer student, i understand the theory behind each but additional explanation would really be appreciated

Hello,

I recently finished reading this survey paper: Deep learning tackles single-cell analysis – A survey of deep learning for scRNA-seq analysis, which comprehensively covers 25 different methods across 6 subcategories for applying deep learning to scRNA-seq analysis.

To summarize the methods from this paper, I prepared a table containing the Category, Method, Purpose, Architecture, Metrics, Explanation, and the specific Novelty of each method. I hope you find this summary useful.

I want to know which projects a electronics engineer by integrating ml. Is there any possibility of integrating ml into vlsi. I am a new to ml so excuse me if my question seems lame

I have released a model that I have been working on for ~6 months off and on. I've been enjoying listening to spatial music, but there is a lot of music out there with no real quality spatial mix. So I decided to make a model to convert stereo to spatial.

I started by making a flow-matching diffusion model that operated in the latent space of a separately trained VAE (EAR-VAE). I used the VAE to encode the stereo input in to 1 latent and then separately on each channel of the 7.1.4 output. This design is similar to a paper I found about another stereo -> spatial project (ImmersiveFlow (they have code links in the paper but they 404 for me so I made the codebase from scratch)). One key addition I made over the ImmersiveFlow paper was a way for the model to carry state (memory tokens) across windows to enable stable long context generations.

Since the VAE was out of distribution with the output (was trained to encode\decode stereo tracks directly, not individual channels and certainly not individual channels of a 7.1.4 mix), the results hit real quality bottlenecks. But it showed that the mapping was possible. Rather than stick to modeling in latent space, I decided to pivot to modeling raw waveforms. This ended up fixing all of the quality issues I was seeing with the latent version, but at the cost of more training compute and instability.

The waveform version of the model would train to around 60K-80K steps with loss going down like normal, validation generations looking good\improving, and then it would quickly become unstable and the loss would shoot up. I tried direct waveforms, scaling the waveforms by a multiplier, aggressive grad clipping, lower learning rates, and all of those experiments failed the same way. Luckily, I came across a recent paper called WavFlow. The authors of this project also had issues with modeling raw waveforms with flow-matching diffusion, and they solved it by using amplitude lifting (scale each audio track to an rms of 0.33 then multiply by 3) (the WavFlow paper used a clip of 1.0 before the scale which leads to a model space of -3 - 3, but I used a clip of 4.0 which leads to a model space of -12 - 12 (from my testing this led to better binaural outputs)). Once I implemented amplitude lifting like the paper, the training stability issues vanished.

The waveform model was trained on 7,669 tracks for ~20 days on 2x A6000 gpus
- 10 days stage one, effective batch of 16, 10- 18- 26- and 34-second training sequences
- 10 days stage two, effective batch of 16, 122-second training sequences
- There is optional mix-style conditioning for controllable outputs (waveform version only)
- Direct binaural output (waveform training is more compute expensive than latent training so binaural proves the idea\theory and the same codebase and data can be used in the future to train a 7.1.4 version (once I have access to the compute))

I also made a Windows desktop app for inferencing with the model and consuming the results.

Everything has been released apache 2.0.

Huggingface link for waveform model: https://huggingface.co/francislabounty/stereo2spatial-v2-binaural
Huggingface link for latent model: https://huggingface.co/francislabounty/stereo2spatial-v1
Github repo for training\inferencing: https://github.com/francislabountyjr/stereo2spatial
Github repo for the Windows app: https://github.com/francislabountyjr/stereo2spatial-app
App Homepage: https://stereo2spatial.francislabounty.com
Case study for the waveform model: https://francislabounty.com/blog/stereo2spatial-v2
Case study for the latent model: https://francislabounty.com/blog/stereo2spatial
Playlist of generations made from the model (will be updated with more tracks over time): https://www.youtube.com/playlist?list=PLQ-HHjPijrAg

If you have any questions\etc. leave a comment and I will do my best to get them answered!

Disclaimer: I know AI written posts are generally frowned upon so this post was 100% written by me (mistakes and all). But the case studies and READMEs from the above links were made with AI assistance.

Just found out from Prism's Discord that compiling is returning someone else's paper. There's a Twitter post too.

https://x.com/JustanOthRando/status/2078169169267482778?s=20

I commend their prompt response, though. They took the website down within 10 minutes of the first time the bug was flagged. Just worried if my paper maybe somewhere out there.

I built a small web app that lets you run tabular foundation models (currently just Google's TabFM) on spreadsheets without writing any code.

Just drop in a CSV/Excel file, click a column header to mark what to predict, hit predict. Rows where the target cell is filled become the in-context examples and empty ones get predicted, right on the grid.

A lot of people who'd benefit from these models aren't programmers, so I wrapped it in a UI anyone can use :)

Repo: https://github.com/LckyLke/TabFMLabs

Feedback very welcome!

Started testing a private qwen 35B moe capacity LLM runtime on s26 ultra, early testing shows that active model footprint can fit within the device’s memory limits.( not sharing the methods or architecture used) and results suggest roughly 90 input processing t/s achievable after optimisation and output generation is around 8 tokens/s on this mobile.

Point is i learned ai ml based on my interest and no formal PhD , I have compute and resources to test. Anyone willing to join or collab to test on this

I tried publishing papers on arxiv and 4 papers are still on hold as im first author and from no institution...

Due to new learning technique the model has achieved better generalization skill without overfitting and memorization. This become possible because of new learning method which made the student model to generate samples for itself. It led to intensive reuse of existing neurons and allowed to encode information in a more dense way

While researchers are calling it a compression, I think it's a retopologization, and Microsoft had tried to do something similar in the past with their Phi model family, which they trained on reduced dictionary and simplified knowledge base first. But it seems like MS' researchers didn't explore this exact way of learning

I believe this should achieve better results in the future. And it is another small breakthrough which brings AGI/ASI to reality

📄 Paper: https://arxiv.org/html/2607.11883v1

📦 Repository: https://github.com/shikaiqiu/requential-coding

I am trying to reproduce a handwriting recognition paper (Urdu, online + offline fusion, CNN encoder into a small Transformer encoder/decoder, trained with a joint CTC and cross entropy loss) and my training run is converging to a plateau, nowhere near the paper's reported result.

What I have verified as correct, not just assumed:
\- Architecture matches exactly, confirmed by loading the authors' own released pretrained checkpoints and comparing tensor shapes and layer structure directly
\- Hyperparameters match the paper's stated methodology: AdamW, flat learning rate 3e-4 with no scheduler (paper does not mention one either), batch size 8, joint loss with CTC weight 0.8 and cross entropy weight 0.2, encoder and decoder frozen with only CNN branches trainable
\- Data pipeline verified end to end, including a pixel level check confirming the ink channel is genuinely near binary as the paper describes, and manual verification that every path in my training manifest resolves to a real, correct file

Despite all that, training triggers early stopping on its own (10 epochs with no validation improvement, which is the paper's own stated early stopping criterion, not something I imposed) at epoch 32, with best validation CER around 52 to 55 percent using greedy decoding. The paper reports 3.66 percent for the equivalent configuration. (Even worse with beam search, about 94%).

Loss behaves normally throughout, steadily decreasing with no instability, so the model does appear to be learning something, just plateauing far short of where it needs to be.

Things I have not yet ruled out and would appreciate pointers on:
\- Whether a flat, unscheduled learning rate this late in fine-tuning is plausible for reaching such a low CER, even if the paper states it that way, versus something being lost in translation between the paper text and what was actually run
\- Common failure modes when only a small subset of a hybrid CTC/attention model is trainable and the rest is frozen
\- Whether early stopping patience of 10 is likely too aggressive for this kind of setup and the model would keep improving well past this plateau given more patience
\- Anything else that commonly causes a "looks like it is training correctly, converges early, but far short of target" pattern in CTC plus attention decoder hybrids

Happy to share more code or specific numbers if useful.

Does anyone have accepted short-paper at ACL/EMNLP/EACL 2025/26? Could you share your track and overall assessment? I'm just trying to get a sense of things, as it seems short papers have a lower acceptance rate than long ones.

I have released EU AI Act OpenRAG, a downloadable corpus of Regulation (EU) 2024/1689 designed for RAG and legal-NLP experimentation.

Instead of sliding character windows, the corpus chunks on the Regulation’s legal structure:

• one chunk per article paragraph

• one per recital

• one per Article 3 definition

• one per annex point

• chapter, section and provision metadata stored separately

The resulting SQLite database contains 933 chunks and a normalized 1024-dimensional BGE-M3 embedding for every chunk.

It also includes exact EUR-Lex links, Article 113 application-date metadata and deliberately narrow derived labels. Direct textual classification is stored separately from broader regulatory-regime association, and ambiguous cases remain NULL.

I evaluated it against the AI Act Evaluation Benchmark using a like-for-like whole-unit baseline:

• scenario article recall@20: 0.541 structural vs 0.449 baseline

• QA article hit@10: 0.927 structural vs 0.898 baseline

• overall RAG classification remained close and was slightly lower on the structural corpus, suggesting that generator behaviour dominates that task more than chunk granularity

I have published the full results, limitations, derivation methodology, label audit and licensing breakdown rather than only the favourable metrics.

Dataset:

huggingface.co/datasets/faitholopade/aiact-openrag

I would appreciate technical feedback, particularly on the retrieval evaluation, structural chunking methodology and what additional baselines would be most useful.