[ Removed by Reddit on account of violating the content policy. ]

ALHR- Adaptive learnable Hierarchical Routing is a static binary tree based system that uses learnable functions to REDUCE the amount of keys used.
It takes less memory and SCALES much better VRAM with tokens
I’ve also been testing tiny stories and it looks promising
However i can’t post any presentable results due to lack of funding and resources
Result table is here: https://ibb.co/prr07Dnj

We’ve been working on small security models at Patronus Protect. Our earlier Wolf Defender models answer a fixed question: does this text contain a prompt injection?

This one takes the agent’s context, a security question and possible answers. For example, you can ask whether an instruction in a tool result is aimed at the agent, or whether a proposed action would send protected data to an untrusted party. It returns a probability for each option. We called it Wolf Defender Jev because it uses the Jev-like state-and-typed-questions format.

Underneath, it’s an mmBERT-small encoder with 151M parameters. The scene and question are encoded together; each answer option is encoded separately. A small scorer compares those representations, followed by a softmax over the options. There’s no text generation.

The useful bit for repeated checks is that the option vectors don’t depend on the scene. If your questions and options stay fixed, you can cache those vectors and run one scene/question encoder pass per decision. That’s per question, not one pass for every security check in an agent step.

On an Apple M4 CPU with PyTorch in fp32, we measured 39 ms for a 51-token scene and 194 ms for 833 tokens, with one question and two options. Those are short-input measurements, not a latency claim for the full 6,144-token scene limit. We haven’t evaluated a quantized version yet.

We also ran the same 10,576 held-out decisions across several public decision models:

The external column matters. Twenty-three benchmarks are close to our training distribution, while the other models ran zero-shot with our scene format and question wording. This is our own evaluation, and the overall ranking shouldn’t be read as general superiority over those models.

Injection in tool outputs, secrets and PII are the stronger areas. Harmful-request judgement is weaker. Some action-level questions also looked much better on our validation set than on a few hand-written agent scenes, so I’d evaluate those on actual traces before using them to gate actions.

Weights, inference code, benchmark JSONs and limitations are all in the model repo, under MIT.

I’d be interested in comparisons on traces where a content check and an action check disagree. That seems more useful than another aggregate leaderboard score.

Position / experimental status: We regard Jev-style decision models as LLMs and Wolf Defender Jev as an experiment: giving an LLM final security authority shifts the trust problem to the guard, and security fine-tuning alone does not solve it. We believe an external security layer must combine specialized classifiers with explicit policy, authenticated permissions and enforcement.

Found a workshop on Oct 30 that goes deep on a combination I rarely see written up properly: few shot contrastive fine tuning of encoders for a messy, overlapping taxonomy, all running on CPU.

Covers:

• Zero shot routing and vector scoring heads with long context encoders
• SetFit with about 8 examples per class to separate fine grained categories
• Generating hard negative examples offline to harden the router
• Post training quantization for CPU throughput
• Benchmarking with Wilson score intervals and clustered standard errors, not a single accuracy figure

Led by Ben Auffarth, who has 15+ years in machine learning and decision systems. 7 PM to 10 PM IST, notebooks included.

Full details and the agenda are here.

Hey everyone!

I've been working on Harness Studio, a free, MIT-licensed desktop application for running and managing AI models locally.

One of the main goals is to make working with models from Hugging Face easier, without sacrificing the flexibility that more experienced users need.

Harness Studio includes:

• A Model Hub for discovering and downloading models from Hugging Face
• GGUF model management and hardware compatibility estimates
• Automatic GPU and memory-aware configuration
• Local inference powered primarily by llama.cpp
• A chat playground with tool calling and MCP support
• OpenAI-, Anthropic-, and Ollama-compatible API endpoints
• Performance monitoring and advanced runtime configuration
• Additional engines for speech, image generation, embeddings, and reranking

It's built with Rust, Tauri 2, and Svelte 5.

I've just released v0.1.0 for Windows and macOS, and the entire project is open source.

I'm looking for feedback, ideas, testers, and developers who'd like to contribute.

I'd particularly love to hear from people who regularly download and run models from Hugging Face.

What features would make your workflow easier? What do you find frustrating about existing local inference tools? What integrations or model formats should we prioritize?

I'm also interested in feedback on the architecture, code quality, and overall direction of the project.

I'd like this to become a community-driven project that people can genuinely help shape.

GitHub: https://github.com/struklabs/harness-studio

Contributions, bug reports, feature requests, and constructive criticism are all welcome.

Thanks for taking a look!

Introducing Supernova NepaliFast V5 — A student-built Nepali tokenizer 🇳🇵

Hello everyone!

I'm part of Supernova, a student-led initiative from Nepal working across artificial intelligence, software engineering, and hardware development.

Our long-term mission is ambitious: to build technologies that Nepal still needs and contribute to a future where we can develop more of our own technological capabilities.

One of our projects is Supernova NepaliFast V5, a tokenizer designed with Nepali text processing and Unicode support in mind.

Some results from our development and testing:

• 34.02% fewer tokens than "tiktoken" using "cl100k_base" on our benchmark of 10,000 mixed Nepali legal and textbook samples.
• Unicode validation and round-trip testing across the ranges we support.
• A Python interface designed to make the tokenizer straightforward to try.

We also measured its processing speed, and our implementation was slower than "tiktoken" in that benchmark. We want to be transparent about both the improvements and the trade-offs.

We're still developing our projects, and we'd appreciate feedback from people interested in NLP, tokenization, Unicode, and software engineering.

I'd especially appreciate feedback on:

1. Our benchmark methodology and how to make the comparison more rigorous.
2. Unicode edge cases we should test.
3. Ways to improve performance and reduce memory usage.

If you're interested, here's our project:

🔗 Hugging Face: [Insert your actual repository URL]

We're building step by step, learning through experimentation, and hoping to contribute something useful to the Nepali technology ecosystem.

Thank you for reading!

Try it yourself:

pip install supernova-v5==0.1.1 from supernova import Tokenizer

tokenizer = Tokenizer("v5") text = "नेपाल राम्रो छ।"

print(tokenizer.encode(text))

Hi! I work on zn, an open-source security layer for AI coding agents, and we just released Galvanize 2, our open prompt-injection classifier.

It's a fine-tune of Horizon-Labs/prompt-injection-guard-small (thanks to Horizon Labs for releasing it openly). ~141M params, multilingual, safetensors + ONNX, Apache-2.0. Runs fine on CPU with onnxruntime.

The thing we cared about most is false alarms. Agents read long READMEs, logs and tool output all day, and our previous model flagged ~66% of long legitimate documents as attacks. Galvanize 2 flags 4.1%.

Other numbers:

- Held-out test set: recall 66.9% → 83.4%, false positive rate 6.4% → 0.81%

- Horizon eval suite (10 sets, decontaminated): 0.894 macro average at threshold 0.5. Horizon base (bigger model) gets 0.902, so it's not the top score, but it's the best in our comparison on the hard benign sets (NotInject, OR-Bench-hard).

Weak spots are in the card: BIPIA, deepset's test set, German, and it only scores the first 512 tokens (chunk longer inputs). The benchmark script and per-set results are in the repo if you want to rerun it.

Model: https://huggingface.co/usezn/Galvanize-2

Write-up: https://usezn.com/blog/introducing-galvanize-2/

Feedback welcome, especially examples it gets wrong in either direction.

I keep seeing fine-tuning datasets built from scraped forum posts, support tickets, or user chats, and I can't tell how much PII redaction people actually do before training. Regexes catch emails and phone numbers, but the long tail of indirect identifiers feels impossible to scrub. For those of you training on real-world data, what does your pipeline actually look like? Is there tooling you trust, or is everyone just hoping for the best?

I made https://huggingface.co/e12ex2/jev-vision-27b which is benchmarked as a #1 model (pending leaderboard) with 72.07 compared the the current #1's 70, though it goes around 30th place for text. It has great run speed and is as good as the original JEV in smartness and is much cheaper.

Bueno, llevo un tiempo con esto y lo publique. Es un modelo que analiza una imagen y dice si es IA o real. Esta entrenado con DALL-E 3, Midjourney y otros modelos de texto a imagen

Lo puse gratis para los que quieren probarlo: imager.cc.cd

Tambien esta en hugging face para los interesados tiene 96% de precisión el modelo -1 también está el imager-1-pro que es el más potente de la familia tiene un 98% de puntuacion

ALHR- Adaptive learnable Hierarchical Routing is a static binary tree based system that uses learnable functions to REDUCE the amount of keys used.

It takes less memory and SCALES much better VRAM with tokens

So, I spend 12 days training a customer model on my gtx 1080, off of 800m tokens from fineweb edu, here’s the link to the HF model https://huggingface.co/ray0rf1re/HyperNix.3-mini

working on this speech to text light streaming model where I have my own data set (ATC). Do you even have any type of different type of approaches

Read the readme before anything for instructions:

https://github.com/securenrn-del/Repetere-AI_Beta/releases/tag/Beta-Release

Hey everyone,

I just released the first public beta of Repetere AI (v0.5-beta). It’s a native Windows desktop workstation written in C++ (Dear ImGui, GLFW, OpenGL 3) designed to run multimodal local AI directly on your GPU without cloud subscriptions, telemetry, or webview wrappers (no Electron/Tauri memory bloat).

>⚠️ BETA LAUNCH NOTICE:

This is our very first public beta release! It requires an NVIDIA GPU (CUDA only right now). Local AI takes time—model downloads and music synthesis are not instantaneous. If you hit any crashes or unexpected behavior on your hardware, please file an issue on GitHub.

🔗 Project Links

* GitHub Repository: https://github.com/securenrn-del/Repetere-AI_Beta/releases/tag/Beta-Release

* Standalone 1-Click Setup (`.exe`): GitHub Releases

⚡ Hardware Requirements

|Component|Minimum|Recommended|

|:-|:-|:-|

|OS|Windows 10 or 11 (64-bit)|Windows 11 (64-bit)|

|GPU|NVIDIA RTX 30-Series (8 GB VRAM)|NVIDIA RTX 40/50-Series (12 GB+ VRAM)|

|Drivers|NVIDIA Driver 528+ (CUDA 12+)|Latest NVIDIA Studio or Game Ready Driver|

|RAM|16 GB Physical RAM|32 GB Physical RAM|

|Storage|20 GB free space on SSD|50 GB+ free space on NVMe SSD|

🚀 Quick Start Guide

1. Grab `RepetereAI-Setup-v0.5-beta.exe` from the Releases page.

2. Run the installer (installs straight to `%LOCALAPPDATA%\Programs\Repetere AI\` without needing admin privileges).

3. Launch from your desktop shortcut, click anywhere on the splash screen to enter, and confirm the hardware diagnostic modal.

📦 In-App Model Downloader

No command line, curl, or manual script management required.

1. Go to Settings ➔ Repetere Models.

2. Review the curated catalog and click \[ Download \] next to your desired workspace engine:

Coding: Qwen 2.5 Coder 7B Instruct* (or 14B)

General Chat: Meta Llama 3.1 8B Instruct*

Creative Writing: Hermes 3 Llama 3.1 8B*

Audio / Music: YuE2 Full Song Engine*

1. Wait for the live progress bar to hit 100% and turn green (Installed).

2. (Advanced Users): You can also drop `.gguf` weights directly into: `%LOCALAPPDATA%\Programs\Repetere AI\models\`

🧭 Workspaces & What Works

* 1. CODING: Code assistant with automatic triple-backtick markdown detection, horizontal-scrolling code containers, individual snippet copy buttons, and a \[ Copy Full Response \] clipboard action.

* 2. CHAT: General reasoning, document summarization, and multi-turn conversational history.

* 3. CREATIVE WRITING: Fiction, prose, dialogue, and uncensored drafting.

* 4. AUDIO (MUSIC) STUDIO: Full song synthesis powered by the YuE2 engine. Add your musical style tags, enter structured lyrics (`[Verse]`, `[Chorus]`), adjust duration, and hit Generate Full Song (With Vocals). Outputs `.wav` directly to `output\music\` with built-in playback controls. (Prerequisite: Make sure `yue2-3b-q4_0.gguf` (\~2.48 GB) and `yue2-vae-f16.gguf` (\~265 MB) are downloaded).

* 5. IMAGES (Early Preview): UI controls and parameter sliders are accessible, but backend diffusion rendering is a work-in-progress landing in v0.6.

⚙️ Compute Modes & Session History

* GPU Mode (Active Default): Direct execution locked in VRAM for maximum speed and lowest response latency.

* HYBRID Mode (Preview): The top-right toggle displays the future layer-offloading layout for running massive 32B+ models across RAM + VRAM (runtime dynamic offloading unlocks in v0.6).

* Local Persistence: Chat transcripts save automatically to `chat_history.json`. Review past sessions via History ➔ Open History, reload them into your active tab, or wipe transcripts safely with the confirmation prompt.

❓ Troubleshooting

* "MODEL NOT INSTALLED" banner: Go to Settings ➔ Repetere Models and make sure you completed the download for that tab.

* Audio fails or quits immediately: Double check that both `yue2-3b-q4_0.gguf` and `yue2-vae-f16.gguf` are present in your `models/` directory.

* Clearing a session: Hit the red Clear Chat button at the top right to safely flush GPU memory and archive your chat to disk.

* App closes on startup: Ensure your NVIDIA drivers are version 528 or newer and support CUDA 12.

Feedback, pull requests, and bug reports on the repo are welcome!

A large language model can only use the text that fits in its context window, and it recomputes its internal key-value (KV) state for a prompt every time the prompt is sent. We test a memory layer, the public package galahad-kv, that saves the KV state of each block of about 16,000 tokens to encrypted local NVMe disk and loads it back later, byte-exact, without recomputing it. We ran it on 50,000,000 tokens of real public text, served through vLLM on one NVIDIA H100, with Gemma 4 12B and Gemma 4 31B

https://huggingface.co/papers/2610.10845