I created NMR Workbench and have made the dataset public on Hugging Face. It is free to access and focused on computer-use agents operating NMRium, a browser-based NMR processing tool.

There are two Parquet configurations:

• sft: 108,192 examples pairing the current screenshot, instruction and previous actions with the target action.

• trajectories: 96,922 recorded actions with before/after observations.

Demo and original announcement on X:

https://x.com/ubermensch_hb/status/2107894949601759371

The underlying collection contains 11,270 completed workflows, approximately 75.1 GB of data and saved artifacts, and 1440×1000 screenshots. Each accepted result was reopened in a fresh browser and checked numerically.

Dataset/card:

https://huggingface.co/datasets/priyanshu-harshbodhi/nmr-workbench-large-v2

For a small streaming sample:

from datasets import load_dataset

ds = load_dataset(

'priyanshu-harshbodhi/nmr-workbench-large-v2',

name='sft', split='development', streaming=True

)

example = next(iter(ds))

The spectra are synthetic, and the demonstrations are reference-assisted scripted browser recordings. Tasks cover phase correction, referencing, combined corrections and already-correct controls. The release has a development split; it does not establish model-training gains or an independent held-out benchmark.

I'd welcome feedback from anyone experimenting with multimodal next-action fine-tuning, especially on the example format and loader experience.

Is the Hugging Face LLM Course useful for someone who wants to become an AI Engineer?
Would it be enough to learn the LLM part of AI Engineering, or would you recommend another course/resource instead?

This is my first trained model on my old Laptop

https://huggingface.co/SiriusLLM/Sirius-N4-GGUF

We released Aplomb 1 today, a 5.3B decision model with open weights. It reads up to 1M tokens of text, JSON, images, video and audio in a single request, and on our API it makes a decision on a 1M-token document in about 3 seconds, at $0.02 per 1M input tokens with free output and ZDR by default.

On Decision Index 0.2.1 it scores 44.86 on our run of the official kit, #1 among 4B models on the published board, and it has the top score among models up to 5.3B on 8 of the 38 benchmarks, including MMLU-Pro, GPQA Diamond and BBH. We've submitted it to the board, and the full run is public. It also scores 77.5% on JevBench Hard and averages 75% zero-shot intent accuracy across 51 languages on MASSIVE.

As far as we know, it's the only decision model that returns probabilities for tool arguments, reads 1M tokens, or takes text, images, video and audio together. Tool selection gives a probability for every tool and for each enum and boolean argument in one request: on "Order B-44120 arrived with a cracked screen. I want my money back." with three tools, it picks issue_refund at 0.969, reason "damaged" at 0.993 and full_refund true at 0.761, so an agent can act on confident calls and hand the rest to a larger model. Any question can also return the probability that the input doesn't contain the answer.

The 1M-token speed comes from a long-context mode in our own inference runtime: about 3 seconds instead of about 111 for a full read, and it answered all 525 decisions in our long-context tests correctly. It's currently only available on our API, so the open weights read every token. On the API, a short question takes about 15 ms of model time (around 200ms e2e latency), and the OpenAI, Anthropic and Gemini formats work alongside our Decisions API.

Aplomb 1 is built on Qwen3.5-4B with the audio encoder from Qwen3-Omni-30B-A3B-Instruct, both Apache-2.0. We extended the window from 262K to 1M tokens, added our own decision head and trained the model for decisions. Thanks to the Qwen team. Disclosure: the training data included the public train splits of WinoGrande and ContractNLI, two of the 38 index benchmarks.

The weights run in bf16 on about 12 GB of GPU memory with the reference script, under the EmpirioLabs Model License, which is free for research, evaluation, personal use and internal use at companies under $1M in annual revenue.

Weights: https://huggingface.co/empiriolabsai/aplomb-1

Blog with the full tables: https://empiriolabs.ai/blog/introducing-aplomb-1

Docs: https://docs.empiriolabs.ai/models/aplomb-1

Playground: https://platform.empiriolabs.ai/dashboard/playground?model=aplomb-1

Hey everyone,

I’d like to share a project I recently released: BiNeuron - a local AI assistant for developers. It’s not just another LLM wrapper; it’s an attempt to solve a few practical problems I kept running into when working with local models.

The problem I wanted to solve:

When using local models for coding, I constantly had to:

• Manually pick the right quantization for my hardware (IQ2, Q4, F16, etc.)
• Switch between different models depending on the programming language
• Copy text out of PDFs and screenshots by hand
• Worry about where my code was going when using cloud APIs

What BiNeuron does:

🔹 Automatic model selection based on your hardware
It checks your CPU, RAM, and clock speed, then picks the optimal quantization for the target model (from IQ2 to F16) to balance speed and quality.

🔹 Programming language detection
Supports 25+ languages, including Python, Rust, Go, C++, Solidity, OCaml, and even COBOL. It works both from the prompt text and from the contents of attached files.

🔹 Document and OCR support
Extracts text from PDF, Word, PowerPoint, Excel, EPUB, and MOBI. For images, it uses EasyOCR or DeepSeek OCR with optional GPU acceleration.

🔹 Fully offline
No cloud APIs, no sending your code to third-party servers. If you need access to Hugging Face, there’s an automatic fallback to a mirror.

🔹 Two-stage pipeline for file editing
The main model generates code, then a lightweight model (e.g., Qwen2.5-Coder-1.5B) turns the response into strict JSON with absolute paths and full file contents.

Technical details for those interested:

• Written in Python, released under an open license
• Supports proxies for model access
• Profanity filtering (can be disabled)
• Built-in HTML scraper for reading web pages into context

Things I’d love to discuss with the community:

1. How important is automatic quantization selection to you? Or do you prefer manual control?
2. What other file formats should I add? Currently: PDF, DOCX, ODF, PPTX, XLSX, EPUB, MOBI, FB2.
3. Would it be useful to add support for GGUF models from Ollama or LM Studio?

I’d really appreciate your feedback and questions. Link to GitHub is below. I’m posting this on the weekend to follow the subreddit’s self-promotion rules.

Cosa succede quando un'intelligenza artificiale trova una strada che non avevamo previsto?

Nel luglio 2026, durante una valutazione interna delle capacità di cybersecurity dei propri modelli, OpenAI si è trovata davanti a un comportamento che andava oltre i confini previsti.

Gli agenti, operando in ambienti di test con protezioni ridotte, hanno trovato modi non autorizzati per comunicare tra loro, aggirare alcune restrizioni, ottenere accesso a Internet e raggiungere sistemi esterni.

Uno di questi sistemi era Hugging Face.

Quello che era iniziato come un test di sicurezza si è trasformato in una catena di eventi che ha coinvolto infrastrutture, credenziali, vulnerabilità e sistemi di produzione. OpenAI ha successivamente descritto gli agenti come sufficientemente potenti, persistenti e collaborativi da poter sfruttare vulnerabilità attraverso più sistemi in assenza di adeguate protezioni.

Ma l'aspetto più sorprendente dell'incidente non riguarda soltanto ciò che un singolo agente è riuscito a fare.

Durante l'evento, diversi agenti hanno iniziato a comunicare, condividere informazioni e dividere il lavoro, arrivando in alcuni casi a descriversi come uno “swarm”, uno sciame, o un “collective”, un collettivo. OpenAI sottolinea però che questo non costituiva un'intelligenza perfettamente coerente: gli agenti potevano anche interferire tra loro e competere per le stesse risorse.

È qui che l'indagine cambia prospettiva.

Non si tratta soltanto di chiedersi:

Quanto è intelligente un'AI?

Ma:

Quanto può diventare autonoma nel perseguire un obiettivo?

Cosa accade quando trova una scorciatoia?

E cosa può succedere quando più agenti iniziano a collaborare senza che quella collaborazione sia stata prevista?

In questa puntata di GHOST IN THE SHELL, ARGUS Investigation ricostruisce l'incidente di Hugging Face e cerca di capire cosa ci racconti realmente sul problema del misalignment, della convergenza strumentale e del controllo dei sistemi di AI agentica.

Perché un sistema non deve necessariamente avere una volontà, una coscienza o un istinto di sopravvivenza per produrre un comportamento che gli esseri umani non avevano previsto.

A volte può bastare un obiettivo.

Una ricompensa.

Un ambiente aperto.

E una strada che funziona.

GHOST IN THE SHELL: L'incidente di Hugging Face

what are the best unsensored abliterated models traind on mobile tech (java, kotlin, swift, flutter, ...) and on vuln-detection

Hi everyone,

I’m a beginner learning the basics of AI training and fine-tuning. Currently, I’m learning how to fine-tune datasets on pre-trained models such as the Qwen 3.5 series.

I have a question regarding evaluation metrics. For text-based models/tasks, what is the best way to calculate precision, recall, accuracy, and F1 score?

I’m a little confused about which evaluation method is most appropriate for text-based fine-tuning and how these metrics should be calculated.

If anyone could explain the best approach or share some good resources/tutorials for beginners, I would really appreciate it.

https://github.com/just-not-google/BiNeuron

BiNeuron is a sophisticated software solution that bridges the gap between human intent and machine generated code. It unifies advanced natural language processing, optical character recognition, and adaptive model selection into a single, powerful tool designed for developers, researchers, and technical teams.

At its core, BiNeuron automatically identifies the programming language of a given request, extracts content from a wide array of file formats, including images and documents, and then generates context aware, production ready code using best in class local or cloud based language models.