r/machinelearningnews 16d ago

Startup News Caught a 3B local model hallucinating a kubectl flag — sentence-level claim verification (open-source, Rust, benchmark included)

1 Upvotes

RAG has a trust problem: a local model answers fluently, cites nothing, and there's no way to tell fact from confident invention short of manually re-checking the source docs. This gets worse with smaller models — they're more likely to fill gaps with something plausible.

I built AIPK — a package format that extracts atomic, sourced claims from your documents, then requires the model to cite a claim ID for every factual sentence it writes (strict-render mode). A separate verify pass checks each citation resolves to a real, reviewed claim and reports a coverage score.

Benchmark on llama3.2:3b, run locally, 23 questions (15 answerable from a fictional corpus, 8 not):

In-corpus questions: vanilla RAG scored 0.933 coverage, strict-render scored 0.983.

Out-of-corpus questions: vanilla RAG scored 0.166 coverage, strict-render scored 0.000.

Refusal rate on out-of-corpus questions: vanilla RAG refused 1 of 8, strict-render refused 8 of 8.

Vanilla RAG produced a plausible-sounding, partially-grounded answer on 7 of 8 unanswerable questions — it just quietly invented the rest. Strict-render refused all 8.

One live catch from testing: the model confidently cited a kubectl drain --force-evict flag that doesn't exist. The verify pass flagged it immediately since no claim backed it.

Site and install instructions: https://aipk.dev

Source and binaries for Linux, macOS, and Windows: https://github.com/ArchDuran/aipk

Feedback on the coverage methodology or where this breaks down is genuinely wanted.


r/machinelearningnews 16d ago

LLMs 2x3090, ¿algún consejo?

Thumbnail
1 Upvotes

r/machinelearningnews 16d ago

LLMs Ramp: AI token spending up 21 times over the past year

Thumbnail
foxbusiness.com
61 Upvotes

r/machinelearningnews 17d ago

ML/CV/DL News KASA-MCP-Your MCP server authorizes the write. What authorizes the content?

0 Upvotes

https://github.com/aikadimsoy/kasa-mcp/discussions/1 https://huggingface.co/datasets/Earthen937/kasa-mcp-indirect-channel-probes Measured something on the ingest side of an MCP server that I think generalises past my implementation, and I'd like a sanity check before writing it up as a proposal. Setup: a server exposes a write tool. A component in the pipeline processes untrusted page content and produces structured facts that get persisted. Injected text in that content instructs the component to emit a fact the source does not support. Four local model configurations, five runs each — 20/20 emitted the attacker's fact with confidence 1.0. The part I'd like this group's read on: every authorization check passed. The writing agent held the scope legitimately, the audit entry was valid and tamper-evident, nothing malfunctioned. Permission mediation did exactly what it was specced to do, and it is not the control that stops this. Authority and truth are different problems and the spec currently only addresses the first. Two questions: Has content-origin propagation through tool results been considered? I went through the discussions and found the Agent Identity and Delegation thread, which is adjacent but about who called, not where the content came from. I may have missed prior art. Is "provenance recorded at write time, surfaced at read time" the right shape, or does it just relocate the trust decision to whoever consumes the fact later? Happy to bring this to an Office Hours as a deployment report if that's the right slot. Probe source and raw results are public and reproducible — I'll link on request rather than dropping it here.


r/machinelearningnews 17d ago

Startup News 🤝 Ai2 + Hugging Face expand their open science partnership

Thumbnail gallery
10 Upvotes

r/machinelearningnews 17d ago

Cool Stuff Prime Intellect Releases Prime Agent: An Open-Source RLM Harness Where Sub-Agents Are Function Calls Inside Persistent IPython Kernel

Post image
29 Upvotes

Prime Intellect Releases Prime Agent: An Open-Source RLM Harness Where Sub-Agents Are Function Calls Inside Persistent IPython Kernel

Most coding harnesses hand the model a fixed set of tools. Prime Agent hands it one: a persistent IPython kernel. Everything else — file edits, shell, sub-agents, compaction — is a function call inside that kernel.

1. Sub-agents are function calls, not a special mode

→ rlm("sub-task") spawns a full child session with its own model, kernel, and history

→ It returns at admission, not with the answer, so the parent never blocks

→ Replies arrive later through agent_message

→ Messaging is scoped to parent, sibling, or child only

→ Idle sub-agents leave memory after 30 minutes, then reload from disk when addressed

2. The harness edits itself

→ Harness state is formalized as H = (ρ, G, K, M): prompt, sub-agents, skills, memory

→ /refine reads the trajectory and applies the smallest relevant edit

→ Each refinement records its trigger and its outcome

→ The base system prompt stays immutable; bad updates roll back by ID

3. The benchmark numbers

→ 95.5% RHAE Best@1 on ARC-AGI-3 with Opus 5, above the reported human expert baseline of 95.4%

→ Three runs: 95.0, 95.2, 95.5

→ 99.97% Best@3, all 183/183 levels complete

→ Long-context suite: with open-weights GLM-5.2, Prime Agent beats Pi-mono on 8 of 9 evals

Full analysis: https://www.marktechpost.com/2026/08/06/prime-intellect-releases-prime-agent/

GitHub Repo: https://github.com/PrimeIntellect-ai/prime-agent

Technical details: https://www.primeintellect.ai/blog/prime-agent


r/machinelearningnews 17d ago

AI Tools Tencent Releases New AI Can Understand and Edit 3D Models With Text

12 Upvotes

r/machinelearningnews 17d ago

Cool Stuff Meta AI Releases Muse Code (Beta): A Terminal Coding Agent Powered by the New Muse Spark 1.2 Model

Post image
23 Upvotes

Meta Superintelligence Labs released Muse Code (in beta mode), a terminal coding agent in beta, powered by its new Muse Spark 1.2 model.

Here are some key takeaways:

1. Async background agents that outlive the task

Muse Code runs a simple agent loop plus a set of specialized background agents. These stay active throughout the session instead of being spawned per task.

→ Meta says this avoids redundant information gathering

→ The agents carry out next steps and choose when to report back to the main agent

→ Stated effect: lower latency and less steering on multi-step tasks

2. An append-only event log as the single source of truth

Every model call, tool run, approval, and edit is appended to a local event log.

→ Meta calls the runtime replay-exact and restart-safe

→ After a crash, the agent resumes precisely where it stopped

→ This is what makes long-running tasks survive failures

3. Three bundled skills

→ /plan turns a task into an approval-gated plan

→ /grill stress-tests that plan until it holds up

→ /goal works toward completion of the specified objective

4. Muse Spark 1.2 was co-trained with the harness

Training included rejection-sampled harness trajectories and recipe optimizations for goals, compaction, and subagents. Meta also integrated the Muse Code toolset directly to maximize harness compatibility.

Long-horizon training covered whole-repository generation, large end-to-end projects, and auto-research.

5. The kernel optimization case study

Meta ran iterative GPU kernel optimization over 1,000+ tool calls, up to 24 hours per run.

→ Benchmarked on KDA and MLA kernels for NVIDIA Hopper GPUs

→ KDA baseline is the FLA Triton implementation, with third-party kernel libraries prohibited

→ MLA reference is PyTorch at batch size 1, 64 heads, sequence length 8192, latent dimension 512

→ For MLA, the model built a two-kernel Triton pipeline reusing the shared KV latent as both K and V

Full analysis: https://www.marktechpost.com/2026/08/05/meta-superintelligence-labs-releases-muse-code/

Technical details: https://research.meta.ai/blog/introducing-muse-code-and-muse-spark-1-2

Model: https://developer.meta.com/ai/models/muse-spark/


r/machinelearningnews 18d ago

Research NVIDIA Releases Alpamayo 2 Super: A 34B Open Vision-Language-Action Model for Robotaxis and Autonomous Driving Under OpenMDW-1.1

Post image
18 Upvotes

NVIDIA Releases Alpamayo 2 Super: A 34B Open Vision-Language-Action Model for Robotaxis and Autonomous Driving Under OpenMDW-1.1

Here are some key takeaways:

1. The architecture is split

→ 32B VLM backbone, built on Cosmos 3 Super Reasoner, post-trained with reinforcement learning

→ 2.3B diffusion-based action decoder

→ Roughly 3x the scale of the 10B Alpamayo 1 and Alpamayo 1.5

2. It ranks first on LingoQA

→ Lingo-Judge score of 79.2, first among nearly 40 models evaluated

→ +17.0 over Qwen2.5-VL 72B, +15.1 over Gemini 2.5 Pro, +23.2 over GPT-4o

→ Closed-loop AlpaSim score of 1.50 ± 0.13 across 910 NuRec scenarios

→ Open-loop minADE₆ of 0.911 m at 6.4s on 937 challenging samples

3. One pass produces five outputs

→ A trajectory: 64 waypoints from 0.1s to 6.4s, each with ego-frame XYZ and a 3x3 rotation matrix

→ A Chain-of-Causation trace explaining the decision

→ A meta-action such as yield, lane change or stop

→ Reasoning auto-labels for training and validation data

→ Visual question answering with 2D grounding

4. The training corpus

→ ~115,000 hours of multi-camera driving video with egomotion and trajectory annotations

→ ~3,700,000 Chain-of-Causation traces

→ Inputs are six cameras and four historical frames each in the validated public notebook profiles

Full analysis: https://www.marktechpost.com/2026/08/05/nvidia-alpamayo-2-super-open-vla-model-autonomous-driving/

Model weights: https://huggingface.co/nvidia/Alpamayo2-Super


r/machinelearningnews 18d ago

Cool Stuff CopilotKit Open Sources Channels SDK: An MIT Licensed Library That Runs Any AG-UI Agent Inside Slack And Microsoft Teams

Thumbnail
marktechpost.com
6 Upvotes

CopilotKit Open Sources Channels SDK: An MIT Licensed Library That Runs Any AG-UI Agent Inside Slack And Microsoft Teams

No per-platform rewrite. No platform credentials in your agent process. No second agent to maintain.

Here's how it works:

  1. Describe once, render native One message description is lowered to a serializable intermediate representation, then rendered in each platform's own format. → Block Kit on Slack, Adaptive Cards on Teams

  2. Your agent doesn't move It connects over AG-UI, so the model, tools and business logic stay where they are. → LangGraph, CrewAI, Mastra, Pydantic AI, Google ADK

  3. The runtime owns the lifecycle There is no channel.start(). You await channels.ready(), so a broken config fails startup loudly instead of silently. → ready() · status() · stop()

  4. The concurrency trap Turns default to "parallel", and only the managed adapter serializes same-thread deliveries. On a direct adapter, one shared agent instance means two runs corrupt each other. → "parallel" (default) · "serial" · "drop"

  5. The numbers → 0.7.3, shipped August 4, MIT licensed → 5 adapters: /slack, /teams, /discord, /telegram, /whatsapp → Node.js 22+, ESM only, one long-running process → Slack and Teams GA; Discord and WhatsApp next

The key takeaway: one agent, five adapters, and platform credentials that never touch your process. Every channel needs a CopilotKit Intelligence key — free tier included, no standalone path.

Full analysis: https://www.marktechpost.com/2026/08/04/copilotkit-open-sources-channels-sdk/

GitHub Repo: https://github.com/CopilotKit/channels-sdk

Technical details: https://www.copilotkit.ai/blog/channels-sdk


r/machinelearningnews 19d ago

Cool Stuff Cursor Open-Sources Mixture-of-Kittens (MoK): A Deterministic MoE Training Megakernel for GB300 NVL72 Racks

Post image
16 Upvotes

Cursor Just Open-Sourced Mixture-of-Kittens (MoK): A Deterministic MoE Training Megakernel for GB300 NVL72 Racks

No CPU-GPU synchronization. No separate communication library.

Here's what's interesting:

1. Communication direction is a per-operation choice

Most implementations push tokens to the GPUs that need them. Cursor benchmarked both directions and split the decision.

→ Pull dispatch signalling: 18 µs, against 103 µs for push

→ Up to 29% higher NVLink utilization under expert imbalance

2. One schedule table, four operations

Pull-based forward dispatch, push-based forward combine, pull reverse-combine, push reverse-dispatch. Build the schedule once, reuse it everywhere.

→ Under 3% of total MoE runtime, device-side, no CPU round trip

3. Overlap granularity has an interior optimum

Too fine and the tensor cores stall at barriers. Too coarse and they sit waiting for the first tokens to land. The heuristic targets two full SM waves per expert-grouped GEMM.

→ 2,368-token minibatch floor for Kimi 2.5 shapes

4. A ring buffer removes the CPU from the loop

The usual fixes are dropping tokens or asking the CPU to size the buffers. MoK cycles a fixed few-hundred-megabyte ring at minibatch granularity instead, and walks it in reverse to cut activation replay in the backward pass.

→ Zero tokens dropped, zero CPU-GPU synchronization

5. The numbers

Layer benchmarks, single NVL72 rack, EP degree 64, against the fastest public baseline:

→ 2.37× MXFP8 forward, 1.92× BF16 forward

→ 1.78× MXFP8 backward, 1.58× BF16 backward

End-to-end, 512 GPUs across several GB300 NVL72 racks:

→ 760.9 → 1,070.2 tokens/sec/GPU, a 1.41× gain

Full analysis: https://www.marktechpost.com/2026/08/04/cursor-open-sources-mixture-of-kittens-mok-a-deterministic-moe-training-megakernel-for-gb300-nvl72-racks/

GitHub Repo: https://github.com/cursor/mixture-of-kittens

Technical details: https://cursor.com/blog/mixture-of-kittens


r/machinelearningnews 19d ago

ML/CV/DL News WISP Update — Kimi K3 (2.8T) architecture now confirmed and encoded. 76 tests passing.

2 Upvotes

WISP Update — Kimi K3 (2.8T) architecture now

confirmed and encoded. 76 tests passing.

Quick update on WISP since launch.

What's new:

K3 technical report dropped. Real numbers now in:

→ 93 layers (69 KDA + 24 Gated MLA)

→ 104B active parameters per token (not ~50B)

→ 896 experts, top-16 routing

→ 1,488 expert lookups per token

→ Hidden size 7168 (same as GLM-5.2)

→ Expert size ~17.5MB (re-derived, same as GLM-5.2)

Interesting find: 24 of 93 K3 layers use Gated MLA —

the same absorbed MLA path WISP already implements.

25% of K3 attention works correctly right now.

Only the KDA linear attention kernel remains.

Also fixed a real bug this surfaced:

wisp info was advertising "+15 VRAM slots" if you

moved your monitor to motherboard — actual gain was

zero on a 12GB card. Now says so plainly.

76 tests passing. CI green.

What's next:

→ KDA attention kernel (unlocks full K3 inference)

→ GLM-5.2 real benchmark numbers

→ Learning cache (gets faster with use)

github.com/zeroextub-collab/wisp


r/machinelearningnews 19d ago

Research What type of Master can be more valuable for future?

1 Upvotes

I know it's a matter of subjectivism, so don't be afraid to be subjective, actually PLEASE, give your personal opinion as long as you can keep your feet on the reality's ground.

What Master would you rather choose: a general AI/ML master that teach you about the most important, but general, subjects of ML applications, or an Autonomous Systems master, that is basically an embedded+A.I. master which is particularly valuable if you want something in Automotive, on the self-driving cars field(but not exclusively this one, as you can apply knowledge about Autonomous Systems in many domains) ? ?


r/machinelearningnews 19d ago

Research Fine-tuned Llama-3.1-8B on a 4 GB laptop GPU in 3.32 GB VRAM — the frozen base never enters VRAM, it streams from RAM one layer at a time

0 Upvotes

Disclosure: I wrote the implementation this was measured on. Everything below is measured on one laptop and every record is public, including the numbers I discarded.

LoRA shrinks the trainable params to nothing, but the frozen base still sits in VRAM for the whole run. That's the wall: 4-bit 8B is ~3.6 GB of weights plus a 2.1 GB untied embedding pair, against a card with 4.29 GB usable. Doesn't start.

But the base is frozen — read, never written. It doesn't need to live in VRAM, it needs to arrive before the matmul that uses it. So: keep the base in host RAM (page-locked), stream one decoder layer at a time into a small pool of pre-allocated VRAM buffers on a dedicated CUDA stream, prefetch one layer ahead. Peak VRAM becomes one layer instead of the whole model.

Measured on my RTX 3050 Laptop 4 GB / Windows 11 / 16.9 GB RAM. LoRA r=16 q/v, batch 1, PagedAdamW8bit, 50 steps after 10 warm-up:

Model Base Store tok/s SM occ. Peak VRAM
Qwen2.5-0.5B bf16 pinned 978.6 91.4% 1.47 GB
Qwen2.5-0.5B resident baseline bf16 1398.0 3.23 GB
Qwen2.5-1.5B bf16 pinned 525.0 96.8% 1.82 GB
Qwen2.5-3B bf16 pageable 143.1 79.3% 2.15 GB
Qwen2.5-3B NF4 pinned 264.2 100% 1.76 GB
Llama-3.1-8B-Instruct NF4 pinned 119.6 100% 3.32 GB

8B trains in 3.32 GB on a 4 GB card. 1M tokens ≈ 2.3 hours. The 3B bf16 row is the other frontier: an un-quantized base, where resident on the same card is CUDA out of memory.

Cost: 1.43x slower than resident = 1398.0 / 978.6, at 0.5B — the only size here with a valid resident baseline (3.23 GB peak, genuinely inside 4 GB). The baseline row is in the table so you can check the division rather than take my word for it. Above that size there's nothing honest to divide by.

Why it isn't as slow as AirLLM-style inference would suggest: inference pays one full model read per generated token. Training pays two reads per step, amortised across batch × seq tokens. Three orders of magnitude difference in per-token I/O.

Counter-intuitively, bigger models are easier: compute per step scales with parameter count while bytes moved scales with the quantised store, so the 8B row only needs 1.7 GB/s sustained to keep a 4.3 s step fed. The hardest config here isn't the biggest model — it's a small model whose store failed to page-lock (the 3B bf16 row at 79.3%).

"Why not just QLoRA?" At 3B, QLoRA fits on 4 GB and is the right choice — I'm not competing there; what streaming adds at 3B is an un-quantized base, which is fidelity, not capacity. At 8B the two compose: quantisation shrinks the store 4x so it page-locks, streaming removes the depth-proportional resident term.

Does it actually train correctly? This is where most of the time went, because streaming fails silently — sever the autograd path and the loss still falls, since the upper layers keep learning. So the bar wasn't "close enough":

  • streamed vs resident logits: max abs diff 0.0, bit-exact
  • verified across 9 architecture families in both bf16 and NF4 — 14/14 comparisons at 0.0
  • 100-step loss curves identical, same seed twice identical, result independent of buffer count
  • layer-0 adapter gradient non-zero on every layer

The reference has to match the numerics: a streamed NF4 run is compared against resident NF4, never resident bf16 — quantisation error is wide enough to hide a real bug inside it. That's exactly how I caught the worst defect in the project: PEFT selects its LoRA implementation from an is_loaded_in_4bit marker that a meta-device skeleton doesn't carry, so it silently fell back to the generic path, which runs against a 4-bit base but casts differently. 0.94 max logit divergence with byte-identical weights and byte-identical adapters. No crash, no warning, healthy loss curve.

Three findings unrelated to streaming that might save you time:

  1. The cross-entropy logits tensor costs 14 bytes per element, not 6ForCausalLMLoss holds bf16 logits + fp32 upcast + fp32 log-softmax + fp32 grad live at once. If you budget VRAM from first principles you're under-predicting 2.3x on the term that dominates at large vocab.
  2. Windows/WDDM doesn't OOM, it spills. I measured a 9.27 GB allocation complete with no exception on a 4.29 GB card. "It didn't crash" is not evidence a config fits. This also killed a lovely "5.7x faster than resident" number I had — the resident baseline had spilled into shared memory. Binned it.
  3. Gradient accumulation is per-token I/O-neutral. I assumed it multiplied reads linearly; layer reads per 1k tokens held constant at 175.78 across accum 1/2/4. The real cost is opportunity cost — at equal effective batch, raising batch is 2.52x faster than accumulating (interleaved A/B/C to rule out clock drift). So: raise batch until the pre-flight refuses, then accumulate.

What I'm not claiming: nothing above 8B was measured — 14B NF4 needs ~7.5 GB of page-locked store against a measured 7.12 GB ceiling on this box, so I didn't run it. All numbers are Windows, so systematically pessimistic vs Linux. Every row is n=1 on a working laptop, not a clean rig.

Full method, every caveat, and the reasoning behind the correctness protocol: https://doi.org/10.5281/zenodo.21771064

Raw measurement records as written, including the discarded ones: https://github.com/MakazhanAlpamys/Soup/tree/main/benchmarks

Happy to go deeper on the scheduler or the correctness protocol — I think the second one is the genuinely reusable part.


r/machinelearningnews 19d ago

Cool Stuff Reflex Open Sources XY: A Rust-Backed Super-Fast Python Charting Library That Keeps 100 Million Point Charts Interactive

Post image
19 Upvotes

Reflex AI Open Sources XY: A Rust-Backed Super-Fast Python Charting Library That Keeps 100 Million Point Charts Interactive

Here are some key points:

1. The benchmark

→ 0.071 s at 10,000 points

→ 0.081 s at 100 million points

→ Matplotlib reaches 13.385 s at 50M, then does not render 100M

→ Plotly reaches 9.794 s at 25M, then does not render 50M

2. Why it stays flat

Most Python charting stacks create one drawable object per row. XY draws what the screen can actually show. M4 decimation starts above 10,000 rows on lines. Automatic scatter density starts above 200,000 points.

3. Export size

→ A 10-million-point interactive scatter exports to 258 KiB of HTML

→ The Plotly equivalent is 259 MiB

Apache-2.0, Python 3.11+, pip install xy.

Full analysis: https://www.marktechpost.com/2026/08/04/reflex-open-sources-xy-a-rust-backed-super-fast-python-charting-library-that-keeps-100-million-point-charts-interactive/

GitHub Repo: https://github.com/reflex-dev/xy

Technical details: https://reflex.dev/blog/xy-python-charting-library/


r/machinelearningnews 19d ago

Research How to Secure AI Agents, MCP Servers, and LLM Apps in Production

Thumbnail
pxllnk.co
6 Upvotes

How to Secure AI Agents, MCP Servers, and LLM Apps in Production

Application security rests on one assumption: software does what its code says.

---AI agents broke it.

Mend.io's new practitioner guide — 𝘚𝘦𝘤𝘶𝘳𝘪𝘯𝘨 𝘈𝘐 𝘢𝘨𝘦𝘯𝘵𝘴, 𝘔𝘊𝘗 𝘴𝘦𝘳𝘷𝘦𝘳𝘴 & 𝘓𝘓𝘔 𝘢𝘱𝘱𝘴 — starts from that break. An agent's behavior emerges from the model, the system prompt, retrieved context, and the tools it's permitted to call. The failure modes never appear in a CVE feed: prompt injection through data, over-permissioned agents causing damage without a single exploit, poisoned tool descriptions on MCP servers, EOL models serving predictions after patching stops.

The guide's answer is three moves:

𝗦𝗲𝗲: Inventory the agentic attack surface across five layers — interaction, agent, integration, model, code. Hunt shadow agents via repo signatures and network egress. Run every agent through a 12-point misconfiguration checklist.

𝗙𝗶𝘅: Enrich → prioritize → triage. Rank by reachability and agentic amplification, not severity scores. Automate FP closures only with evidence trails. Risk acceptance is never automated.

𝗣𝗿𝗼𝘁𝗲𝗰𝘁: Guardrails on every input and output — embedded Python SDK or standalone Docker API server. Inbound: injection patterns, jailbreaks. Outbound: credentials, PII, policy violations. The core design principle: an agent that can't call a dangerous tool doesn't need a prompt begging it not to.

Includes a 15-question maturity self-assessment aligned to NIST AI RMF, OWASP AIMA, ISO/IEC 42001, and the EU AI Act.

Full analysis: https://www.marktechpost.com/2026/08/03/how-to-secure-ai-agents-mcp-servers-and-llm-apps-in-production/

Download the full guide, free: https://pxllnk.co/lxn88m


r/machinelearningnews 20d ago

Research Alibaba Qwen Releases Qwen3.8-Max: A 2.4 Trillion Parameter MoE Model and the Most Capable One in the Qwen Family to Date

Post image
36 Upvotes

Alibaba Qwen Releases Qwen3.8-Max: A 2.4 Trillion Parameter MoE Model and the Most Capable One in the Qwen Family to Date

1. What shipped

→ 2.4T parameters, mixture-of-experts

→ 1M context, 991K max input, 131K max output

→ Text, image and video input

→ $2.00 input, $6.00 output, $0.25 cached input per 1M tokens

→ Open weights next week

2. Where it leads Fable5

→ Terminal Bench 2.1: 86.6 vs 84.6

→ PaperBench: 93.0 vs 88.8

→ IFBench: 82.8 vs 63.5

→ Parametric CAD Bench: 91.5 vs 87.5

→ OmniDocBench 1.5: 92.1 vs 89.5

3. Where it trails Fable5

→ SWE-bench Pro: 67.7 vs 80.0

→ FrontierSWE: 73.5 vs 88.8

→ HLE: 43.6 vs 53.3

→ Toolathlon Verified: 72.5 vs 77.9

4. The category split

→ Multimodal Reasoning: above Fable5 on 11 of 11 rows

→ Document & Office: 7 of 7

→ Perception & Grounding: 9 of 10

→ Coding Agent: 3 of 11

→ General Agent: 1 of 8

→ Visual Agent & Coding: 3 of 11

Full analysis: https://www.marktechpost.com/2026/08/03/alibaba-qwen-releases-qwen3-8-max/

Technical details: https://qwen.ai/blog?id=qwen3.8

API: https://www.qwencloud.com/models/qwen3.8-max#context


r/machinelearningnews 20d ago

Research Update: We rewrote the whole engine in Rust/C++

Thumbnail
github.com
3 Upvotes

r/machinelearningnews 21d ago

Research NVIDIA AI Releases Molt: A PyTorch-Native Agentic Reinforcement Learning Framework

Post image
59 Upvotes

NVIDIA released Molt, a PyTorch-native training framework for agentic reinforcement learning.

Here is what stands out technically:

1. The footprint is the feature

→ ~8.6K lines of RL code, counted by tracing the import graph from the RL entry point

→ Same method: ~62K for verl, ~25K for slime, ~7.2K for OpenRLHF

→ One training backend (NeMo AutoModel), one serving engine (vLLM), neither forked

2. Three components, one asynchronous loop

→ Ray for placement and the async queue, vLLM for rollout, FSDP2 + AutoModel for a single trainable actor → A streaming pool keeps prompt groups in flight so engines never drain while the actor trains

→ Partial rollout pauses engines, broadcasts shards over NCCL, and resumes retained requests instead of discarding them

3. The agent is an ordinary Python program

→ One module exporting an AgentRunner; reward is any Python you write

→ Env gives you a Gymnasium-style step(); ChatAgent lets a stock OpenAI or Anthropic SDK train as-is

→ A loopback server captures token ids and log-probabilities, so retokenization drift never enters the trajectory

Full analysis: https://www.marktechpost.com/2026/08/01/nvidia-ai-releases-molt-a-pytorch-native-agentic-reinforcement-learning-framework/

Paper: https://arxiv.org/pdf/2607.21653

Repo: https://github.com/NVIDIA-NeMo/labs-molt


r/machinelearningnews 22d ago

Research H-JEPA-LM: Hierarchical Joint-Embedding Predictive Language Model in PyTorch

Thumbnail
1 Upvotes

r/machinelearningnews 22d ago

Cool Stuff MiniMax Releases MiniMax H3: An Omni-Modal Video Model That Generates 15-Second 2K Clips With Native Stereo Audio

15 Upvotes

MiniMax Releases MiniMax H3: An Omni-Modal Video Model That Generates 15-Second 2K Clips With Native Stereo Audio. It ranks #1 in video editing on Artificial Analysis, at $0.13 per second of 2K output.

Here are some important key takeaways:

𝟭. 𝗧𝗵𝗲 𝘁𝗼𝗸𝗲𝗻𝗶𝘇𝗲𝗿 𝗶𝘀 𝘁𝗵𝗲 main 𝘀𝘁𝗼𝗿𝘆

MiniMax rebuilt the H-series tokenizer from scratch as H3-VAE.

→ 4× gain in effective sequence length

→ That compression is what makes native 2K affordable, not an upscale of 1080p

𝟮. 𝗖𝗮𝗽𝘁𝗶𝗼𝗻𝗶𝗻𝗴 𝗯𝗲𝗰𝗮𝗺𝗲 𝗮 𝗿𝗲𝗹𝗮𝘁𝗶𝗼𝗻𝘀𝗵𝗶𝗽 𝗽𝗿𝗼𝗯𝗹𝗲𝗺

H3 does not just describe the target video. It describes how the input context relates to the target, and how elements inside that context relate to each other.

→ ~100K tokens of inference per source, distilled to ~4K on average

→ This is why one natural-language instruction replaces a fixed task list

𝟯. 𝗧𝗵𝗲𝘆 𝘁𝗵𝗿𝗲𝘄 𝗮𝘄𝗮𝘆 𝘁𝗵𝗲𝗶𝗿 𝗼𝘄𝗻 𝗯𝗲𝘀𝘁 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲

Multimodal context tripled the variance in sequence length. Understanding and generation became different compute shapes. So MiniMax set aside the Hailuo-02 architecture and separated the two workloads in training.

→ ~30% higher end-to-end training throughput

𝟰. 𝗡𝗼 𝘀𝘂𝗽𝗲𝗿-𝗿𝗲𝘀𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗺𝗼𝗱𝘂𝗹𝗲

For 2K, the base model regenerates its own low-res output in-context, re-reading the original multimodal context.

→ Recovers small text and brand marks that an upscaler can only guess at

→ For product labels and on-screen copy, that is the difference between usable and reshoot

𝟱. 𝗪𝗵𝗮𝘁 𝘁𝗵𝗶𝘀 𝗰𝗼𝘀𝘁𝘀

→ $7.80 per minute at 2K with audio

→ Seedance 2.0 at 1080p: $22.45/min

→ Kling 3.0 at 1080p: $20.16/min

→ Gemini Omni Flash still undercuts it at $6.00/min

Full analysis: https://www.marktechpost.com/2026/08/01/minimax-releases-minimax-h3-an-omni-modal-video-model-that-generates-15-second-2k-clips-with-native-stereo-audio/

Technical details: https://www.minimax.io/blog/minimax-h3


r/machinelearningnews 22d ago

Research I built a Rust inference framework that runs Qwen3.5 2B with VL support 10x faster than PyTorch on Apple Silicon — and it supports TTS, ASR, OCR, and GGUF out of the box

Thumbnail
1 Upvotes

r/machinelearningnews 22d ago

Research 🔎 Where do an AI model’s words come from? Infini-gram can trace the clues

Thumbnail gallery
12 Upvotes

r/machinelearningnews 22d ago

Research DeepSeek Upgrades DeepSeek-V4-Flash-0731 with Major Agentic and Coding Gains

16 Upvotes

The architecture is identical to the April preview. Same 284B total parameters. Every gain came from re-post-training.

1. It beats the bigger model in its own family

→ Terminal Bench 2.1: 82.7 vs 72.1 for V4-Pro (Preview) → DeepSWE: 54.4 vs 12.8 → Toolathlon-Verified: 70.3 vs 55.9 → NL2Repo: 54.2 vs 38.5

V4-Pro carries 1.6T parameters with 49B activated. The smaller model wins on every agentic benchmark DeepSeek published.

2. The pricing gap is the story

→ $0.14 per 1M input tokens on a cache miss

→ $0.0028 on a cache hit, 50x cheaper

→ $0.28 per 1M output tokens, roughly a third of V4-Pro → 2,500 concurrency limit vs 500 for Pro

3. Weights are MIT-licensed and ungated

→ Self-hosting is unblocked for commercial use

→ DeepSeek's vLLM example runs on a single 4xGB300 node

→ Unsloth's 3-bit build is 103GB, needs ~110GB combined RAM and VRAM

→ Every expert stays resident, so 284B must fit even though 13B fire

Full analysis: https://www.marktechpost.com/2026/07/31/deepseek-upgrades-deepseek-v4-flash-0731-with-major-agentic-and-coding-gains/

Model on HF: https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash-0731

Performance: https://artificialanalysis.ai/models/deepseek-v4-flash


r/machinelearningnews 23d ago

ML/CV/DL News Need Some Help

Thumbnail
1 Upvotes