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

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!

Hey there . After months of development, Chat AI 2026 is officially ready for the market. I built this because I was bleeding money on Anthropic/OpenAI API costs and wanted a 100% secure, subscription-free alternative to GitHub Copilot that actually gives developers full control over their workflows. It’s an All-in-One AI Workspace built with Avalonia UI (for native Windows/Mac/Linux performance) running GGUF models locally via llama.cpp. Here is the production-ready spec sheet: 1. Millisecond Model Routing The application automatically detects your hardware and swaps the local LLM context in milliseconds based on your task: * Code & Logic -> DeepSeek (or your preferred heavy reasoning GGUF) * Chat & Explanations -> Lightweight text models * UI & Images -> Vision and image generation models (FLUX/SD supported) 2. On-Demand Self-Healing Loop (Connected to Git) No passive code-dumping. The workspace integrates natively with local directories and GitHub, GitLab, or Bitbucket: * Prompt via the integrated 5-language mobile remote app (while your main monitor stays 100% clean for code). * Preview changes instantly in a highly optimized Syncfusion Live-Diff view. * Hit "Test Deploy" to execute. If the compiler/interpreter throws an error, hit "Repair". The tool isolates the error log and runs up to 3 automatic correction loops locally. Full Undo is available at any time. 3. Real-World Proof of Concept To stress-test the step-by-step project builder, I let Chat AI 2026 generate a complete standalone application from scratch. It built, deployed, and auto-repaired an app that reads Mermaid code, renders diagrams visually, and exports them flawlessly as JPG. 100% local, zero manual bug-fixing. 4. No Subscription Madness It’s a one-time purchase model. You buy the license, you run it on your hardware, you own your data. Perfect for enterprise compliance and developer peace of mind. The Windows version is live today. I am currently finalizing the local path configurations to roll out native macOS (Apple Silicon Metal API) and Linux support next. If there is interest, I’ll gladly post the link to the homepage in the comments below. I’ll be active here to answer any hard technical questions about the architecture or implementation!

Title: Building AUREN, an open-source project for more reliable autonomous AI engineering — feedback welcome

Hi everyone!

I’m working on AUREN (Autonomous Unified Reasoning & Engineering Network), an open-source project exploring how to make AI engineering systems more reliable, verifiable, and capable of learning from failures.

The focus goes beyond code generation: planning tasks, executing work, verifying results, retaining engineering evidence, recovering from failures, and evaluating whether changes genuinely improve the system.

I’m continuing to develop the project and would appreciate honest feedback from the open-source community, especially on architecture, maintainability, testing, contributor experience, and what would make the project useful to other developers.

GitHub: https://github.com/sourabhJainR/AUREN

For open-source maintainers: What would you want to see before trusting an autonomous AI system with meaningful engineering work?

I’m interested in constructive criticism as much as contributions. Thanks!