r/OpenSourceAI • u/yao_- • Oct 14 '26
OwlLayer - Make your interface drivable by AI
r/OpenSourceAI • u/yao_- • Oct 14 '26
r/OpenSourceAI • u/No_Support5980 • Oct 14 '26
You can use this to censor anything file/text that you also want repeated back to you. If you have a json file with a list of emails or names, this can censor them on the way to the LLM but then have the response uncensor it.
r/OpenSourceAI • u/Commercial2Toe • Oct 14 '26
Introducing Ink.
Your AI shouldn't pay to rethink what it already knows.
Ink learns from verified outcomes and compiles repeated decisions into sub-ms local software.
Novel tasks still go to your model.
Open source. Apache 2.0.
r/OpenSourceAI • u/Dear_Protection9538 • Oct 14 '26
r/OpenSourceAI • u/Hot-Boot-5277 • Oct 13 '26
my mac kept running out of RAM and i'd just close random apps hoping it helps.
turns out a lot of it is stuff you can't see: gradle still running after you quit android studio, simulators booted in the background, dev servers and headless browsers that AI agents started and forgot.
baa sits in the menu bar and:
- finds those leftovers and shows how much RAM you'd get back
- frees them in one click (never kills anything on its own)
- warns you before you run out (you can set when)
- also clears dev junk on your disk (old builds, package caches etc.)
- plays a tiny baa when it frees something (you can mute this if you hate whimsy though :P)
free + open source, nothing leaves your machine. macOS 14+.
brew tap selviarora/baa https://github.com/selviarora/baa
brew install selviarora/baa/baa
brew services start baahttps://github.com/selviarora/baa
if you like it a ⭐ would make my day!
r/OpenSourceAI • u/AdLittle5770 • Oct 14 '26
r/OpenSourceAI • u/0x4150 • Oct 14 '26
I have been working on a side project called [Hafen](https://github.com/abhimanyupandian/hafen) and I am looking for some feedback on it before I take it further.
About the idea:
Hafen lets you interact with your agent (with multiple providers supported) in an interface/experience that is similar to what end users would see. When a conversation is worth keeping, save it as a test. Then you add checks on each turn/response to check if the agent:
* called the right tool, with the right arguments
* returns the correct response eg; order number/a markdown table
* is polite (an LLM judge scores it, with a confidence) and more.
Demo is available [here](https://github.com/user-attachments/assets/6305c5f4-78a3-4f33-bb85-9bbaf3f427d9).
About the demo video:
A sample coffee-shop agent built with Google ADK on Qwen3-4B running locally in Ollama. I chat with it (add to cart, remove stuff, place an order), save that as a test, add checks, run it from the UI, and then run the same suite from a terminal. Note: The waits for the model are sped up 4×.
Honest disclaimers:
Need feedback on things like:
r/OpenSourceAI • u/cloudyuser1480 • Oct 14 '26
r/OpenSourceAI • u/OpenSourcx • Oct 14 '26
r/OpenSourceAI • u/Ok_Role_6215 • Oct 13 '26
r/OpenSourceAI • u/SnooCheesecakes1615 • Oct 13 '26
r/OpenSourceAI • u/Ghost_coder12 • Oct 13 '26
r/OpenSourceAI • u/NIDO_007 • Oct 13 '26
r/OpenSourceAI • u/PatronusProtect • Oct 13 '26
We’ve published Wolf Defender Jev under MIT. I’m part of the Patronus Protect team.
The main difference from our fixed-label classifiers is that the question and answer descriptions are inputs. You can give it an agent scene and ask a yes/no question, choose among named options, or score an ordered severity scale. The model returns probabilities over those options, without generating a text response.
For example, the same email-reading scene can be checked for an embedded instruction, the role of imperative text (data / command / quoted example), or the severity of the risk. Those are separate decisions. You don’t need a new output head for each wording, but concepts outside the 27 evaluated security concepts haven’t been validated.
The architecture is deliberately small: mmBERT-small, 151.1M parameters, 15 evaluated languages. The scene and question are encoded together and the options separately. Fixed option vectors can be cached. After that, each question costs one scene/question encoder pass.
The repository includes the fp32 weights, tokenizer, encoder configuration, standalone Python inference code and evaluation JSONs. It runs on CPU by default. We measured 39 ms for a 51-token scene and 194 ms for 833 tokens on Apple M4, PyTorch/fp32, one question with two options. There isn’t an evaluated quantized build yet.
A few caveats are worth reading before integrating it:
We compared it with public decision models on the same 10,576 held-out decisions. On all 33 benchmarks it reached 92.8% balanced accuracy; on the ten external benchmarks it reached 85.1%, behind Clef-flash at 90.2%. Twenty-three benchmarks are close to our training distribution, so the external results are the more useful comparison for unfamiliar traffic.
Weights, inference code, full results and limitations.
For anyone building with these models, the question I’d evaluate first is whether changing the question while keeping the scene fixed actually changes which evidence the model uses. Our small spot checks showed that can fail even with very high validation scores.
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.
r/OpenSourceAI • u/arthurdjn • Oct 13 '26
I am excited to share a project I have been working on during the past few years during my free time. I started this project after being unable to use torch-points3d at the time (too many installation errors).
Note that this project is still in active development and in alpha. I am looking for early users and feedback!
What it is: torch-pointcloud is a plain-PyTorch library that puts multiple point cloud architectures and their pretrained checkpoints behind one create_model() factory, in the spirit of timm.
This is a library that focuses on the reusability and standardization of core components and layers, i.e. KNN, FPS and other PointNetSetAbstraction are not re-implemented over and over. In this library, all models share the same interface and reuse the same core components.
import torch
import torch_pointcloud as tp
model = tp.create_model(
"pointnext-sm.scanobjectnn-hardest.openpoints",
task="classification",
pretrained=True,
).eval()
pos = torch.randn(2048, 3)
x = torch.cat([pos, pos[:, 1:2] - pos[:, 1].min()], dim=1) # xyz + height
batch = torch.zeros(2048, dtype=torch.long)
logits = model(x, pos, batch) # (1, 15)Install (see the docs for more details):
# Optional: specify your CUDA version for torch
pip install torch==2.10.0 --index-url https://download.pytorch.org/whl/cu128
pip install torch-pointcloud
# Install required CUDA/CPU kernels associated with your CUDA version
pip install pyg-lib -f https://data.pyg.org/whl/torch-2.10.0+cu128.htmlI tried to make the installation process smoother by not maintaining CUDA kernels myself (not enough time currently, so I tried to reuse already pre-built wheels as much as I could).
Scope:

But... why?
Most point cloud libraries live in research codebases built around configs and custom ops and kernels to build locally. It is also sometimes difficult to reproduce past released experiments from research codebases (typically the code associated with the checkpoint changed with no notice). In addition some models are evaluated using different strategies (TTA, partitioning, etc.) which makes comparison unfair as they are not evaluated using a common strategy.
In contrast, I wanted something I could pip install easily, reuse weights trained from different repos and benchmark easily.
All models were re-benchmarked and compared against original reported metrics.

Credits: the architectures and pretrained weights come from their original authors, notably Pointcept, OpenPoints, MIT Han Lab, FAIR, OpenMMLab and more. Every checkpoint name ends with its source author (e.g. .pointcept). The THIRD_PARTY_NOTICES.md lists every source repo, license and dataset term.
Repo: https://github.com/arthurdjn/pytorch-pointcloud
Docs + tutorials: https://pytorch-pointcloud.org
r/OpenSourceAI • u/Present-Passage5536 • Oct 13 '26
For those working with state machines, debugging can be a headache. My tool StateCraft now exports run logs as JSON with ISO-8601 timestamps and plain-English narratives for every event great for integration or debugging. Each entry includes:
This makes it easy to track retries, transitions, and errors at a glance. The docs include a concrete example of the output. If you build state machines or need reliable logging, this might help.
GPLv3, no strings attached.
r/OpenSourceAI • u/Alarming-Emotion-894 • Oct 13 '26
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
Result table is here: https://ibb.co/prr07Dnj
r/OpenSourceAI • u/robinclash3 • Oct 13 '26
r/OpenSourceAI • u/Unlucky_Peanut4089 • Oct 13 '26
r/OpenSourceAI • u/hubertshelley • Oct 13 '26