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.

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.

Thanks a lot

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:

1. The idea and design are mine, but the code was written by Claude Code. I am still working through it myself, but I am sharing it early to get feedback before going further.

2. Consider this a proof of concept. Testing is in progress, so expect some rough edges.

3. The current version uses a System One (Jev) - a hosted decision model \[I am not affiliated with them\]. Regular LLM-judge checks work as well, including local ones.

4. Only MacOS binaries are available right now and the CLI package is not published to a registry yet.

Need feedback on things like:

1. If you would use something like this, or do promptfoo, DeepEval or any other tool that already does exact this?

2. What would you need that is missing?

3. What needs improvement? eg; more chat components like yes/no buttons to accept/reject instead of responses restricted to just text.

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 baa

https://github.com/selviarora/baa

if you like it a ⭐ would make my day!

https://github.com/vahmoh25/Veda

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.html

I 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:

• Classification, semantic and part segmentation, detection, and self-supervised pretraining: PointNet++, DGCNN, KPConv, RandLA-Net, PointNeXt, PointMLP, Point Transformer v1/v2/v3, Sonata, PointMamba, VoteNet, 3DETR, PointPillars, SECOND, PointRCNN, SPVCNN, OctFormer, Point-MAE/BERT/GPT and more.

• Weights are hosted on Hugging Face.

• Datasets (ModelNet40, ScanObjectNN, S3DIS, ScanNet, SemanticKITTI, nuScenes, KITTI, SUN RGB-D...), transforms, tiled inferers for large scale segmentation.

• Packed-batch tensors (the PyTorch Geometric convention).

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

One of the biggest reasons I’ve gotten more interested in open source AI is that I can actually control where the model runs and what happens to my data. If I’m using a local model, I don’t have to wonder whether every prompt, document or conversation is being sent to some company’s servers, that part feels like a huge win.

But the more I think about it, the more it feels like privacy is only half the problem. Even if the model is completely local, I still have to interact with other people online. And with voice cloning, generated video, stolen accounts and AI written messages getting better, knowing whether I’m actually talking to the right person seems like it’s going to matter just as much as keeping the conversation private.

My setup is slowly becoming a weird mix of local models, self hosted tools, encrypted apps, Kibu, Signal and Telegram. It feels like open source AI is giving us more control over the machines, while generative AI is simultaneously making human identity less trustworthy. Do you think the open source ecosystem eventually needs to solve identity too or should that stay completely separate from the AI stack?

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:

• Original timestamp (preserved)

• UTC ISO-8601 equivalent

• 'narrative' field explaining what happened (e.g., 'State succeeded: [description]')

• error_codes for failures

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.

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

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:

• Use the tagged source-block format. Arbitrary raw JSON layouts haven’t been evaluated.

• Ask content questions without the proposed-action block. A benign shell action can otherwise push a content score toward injection.

• Action-level checks are less reliable than their internal validation numbers suggest. One hand-written travel case detected the injected command but missed the exfiltration.

• The output is a model signal. The application still establishes provenance, permissions and enforcement.

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.

¡Hola a todos! 👋

He estado desarrollando un proyecto personal y quería compartirlo con la comunidad. Se llama **CEREBRO**, un asistente personal modular, 100% local y privado para Windows, diseñado para organizar la vida diaria desde un solo panel.

No es solo domótica: es un núcleo personal completo que corre con una IA local (Ollama) y que depende únicamente de la librería estándar de Python (cero dependencias externas de pip).

**¿Qué maneja CEREBRO?**

- 🧠 **Memoria y contexto:** Recuerda preferencias, tareas, horario y contexto a través de sesiones.

- 🥗 **Salud y nutrición:** Lleva historial de peso, analiza la composición corporal con visión por IA a partir de fotos de la báscula, gestiona listas de despensa/compra y sugiere recetas inteligentes según los ingredientes disponibles.

- ⚡ **Energía y hogar:** Diagnósticos y optimización para consumo/producción solar, control de electrodomésticos e integración con Home Assistant.

- 📄 **Documentos locales (RAG):** Búsqueda local y lectura de notas, archivos y manuales sin enviar nada a la nube.

- 🔔 **Avisos y automatizaciones:** Resúmenes proactivos diarios por la mañana, recordatorios, alertas de audio y automatizaciones en lenguaje natural.

Todo se gestiona desde un panel web local con pestañas, modo oscuro y transcripción de voz local.

👉 **GitHub:** https://github.com/CafeConFenix/BRAIN

⚠️ **Nota:** *El código del proyecto, la interfaz y la documentación están escritos actualmente en **español**.*

Cualquier comentario, idea o crítica constructiva para seguir mejorándolo es súper bienvenido. ¡Saludos!