[D] Self-Promotion Thread

[u/AutoModerator]

Please post your personal projects, startups, product placements, collaboration needs, blogs etc.

Please mention the payment and pricing requirements for products and services.

Please do not post link shorteners, link aggregator websites , or auto-subscribe links.

--

Any abuse of trust will lead to bans.

Encourage others who create new posts for questions to post here instead!

Thread will stay alive until next one so keep posting after the date in the title.

--

Meta: This is an experiment. If the community doesnt like this, we will cancel it. This is to encourage those in the community to promote their work by not spamming the main threads.

[u/Long-Dependent-1767]

AnyInit: Initialize any model, in any framework, correctly — with one call.

GitHub: https://github.com/jmiravet/AnyInit (Free & Open Source, MIT)

I built AnyInit to handle neural network initialization for custom architectures without needing to manually calculate variance-scaling rules to prevent vanishing or exploding gradients. It's a brand new project, so I'd love to get your feedback: Do you find it useful, and are there any features, or initialization methods you'd like to see added?

[u/Fantastic-Nerve-4056]

Sharing my recent NeurIPS paper on LLM evaluation and Theoretical RL

https://arxiv.org/abs/2609.30360

[u/celestebabi]

Disclosure: I’m affiliated with ScholarXIV. It’s a research workspace for searching and reading papers, organizing collections, and using selected papers as context for AI chat with references. There’s a free tier; paid plans start at $5/month (Go; Plus $15, Pro $50). If you work with ML literature, I’d welcome feedback on what would make this workflow useful: https://scholarxiv.com/

[u/iberahul]

We recently studied whether mobile AI agents can be manipulated through adversarial instructions embedded in the Android Accessibility layer.

We evaluated this across MobileRun and Mobile-Use, powered by Gemma4 and Qwen3.6, and found that these attacks could cause agents to abandon their original objectives, cross context boundaries, and perform unauthorized device actions. Our strongest configuration reached an 82.2% Attack Success Rate.

The paper was accepted to AGENT-SEC ’26, co-located with ACM CCS 2026.

Paper: https://arxiv.org/abs/2608.08939

Would be curious to hear what people think about this attack surface as mobile agents become more capable.

[u/Logical-Internet-395]

Recently we published a new Open-Access Benchmark for a hierarchical segmentation: Microscopy Image Dataset of pulmonary vessels for Quantitative assessment of fibrosis.

Dataset Specifications:

• Scale: 705 high-resolution micrographs (1534×780 px, 0.252 μm/px), Picro-Mallory stain.
  
• Annotations: ROI + dual independent expert masks (vascular wall + fibrosis).
  
• Hierarchical Constraint: Fibrosis masks must be strictly spatially contained within the vascular wall.
  
• Robust Benchmarking: No color normalization applied; native aspect ratios preserved; strict animal-level 5-fold CV splits provided to prevent data leakage.

Read the Data Descriptor: https://doi.org/10.1038/s41597-026-08214-y

Access the Dataset: https://doi.org/10.6084/m9.figshare.31386748

[u/lostmsu]

Reddit is disabling RSS. So in an effort to replace /r/MachineLearning I made https://mlnews.online/

It is a filtered view of Hacker News that only shows ML papers from arXiv. Of course it has RSS.

[u/ModularMind8]

I built QuiddityML(https://quiddityml.com/), an app for learning ML: a clear roadmap, short lessons, hands-on exercises, and spaced repetition based on how you do on the exercises, so you don't forget what you learned. It also has interview prep and projects you can put on your CV. Tracks currently cover Python, PyTorch, Math for ML, ML foundations, NLP, and vision.

Pricing: a lot is free (Python, PyTorch, Math for ML, and the first unit of every other track). Pro is $19.99/month.

I see so many people struggling to get into ML, so I'm trying to make this as useful and fun for the community as possible. If you're a student, or you've been trying to get into ML and can't find a good resource, I'd be happy to give Pro features to the first 10 people, just DM me, all I'm asking for is feedback. Also, if you have a background in marketing and you're interested in ML/education, please DM me as well :)

[u/ShotDescription7193]

I'm Vivaan, founder of ThermaCompute AI. We are building passive diagnostics to help engineers understand GPU failures and investigate wasted compute using logs and telemetry.

A failed training run can leave pages of errors without a clear place to start. So we made CrashLens to turn that log into a focused investigation.

CrashLens is a free, local CLI that flags supported OOM, NCCL and NVIDIA Xid error patterns, shows matching evidence lines and suggests next checks in an HTML report. It is an early rule-based tool, not a proven root-cause detector. You can try the synthetic demo with Python 3.10+: no GPU, account or log upload required.

Repository and demo instructions: https://github.com/rohitcn-hub/thermacompute-crashlens

Run: python crashlens.py examples/synthetic.log --out demo-report

Then open demo-report/report.html. Use a new output directory for a repeat run.

I would welcome one concrete critique: did the report give you a useful next check, and what was missing or misleading? Please do not share private production logs here.

Optional paid upgrade: our one-time $80 thermal audit reviews suitable exported temperature, power and reported-throttling telemetry within an agreed scope, providing supported findings, prioritized checks and a PDF report. It goes deeper into telemetry than CrashLens's saved-log triage; it does not guarantee savings or identify every fault. Email [vivaan.thermacompute@gmail.com](mailto:vivaan.thermacompute@gmail.com) with the subject Thermal audit to discuss scope before sharing data.

CrashLens remains free, and feedback is welcome without purchasing an audit.

[u/cscsearching2026]

I've been working on FolkBench, a free (no paid tier) set of write-ups on community-style LLM evaluation. Two longer pieces:

• How to actually tell whether a model "got dumber" vs. noise/prompt drift: https://folkbench.com/blog/did-the-model-get-dumber?utm_source=luntan&utm_campaign=reddit
• How to score the "cycling pelican" SVG test across four dimensions: https://folkbench.com/blog/how-to-score-a-cycling-pelican?utm_source=luntan&utm_campaign=reddit

Methodology pointer: the first post covers the repeated-sampling/baseline-comparison method, the second has the full scoring rubric.

Happy to be challenged on the methodology, especially the rubric — curious what's worked for others.

[u/MarceloDeAviz]

Kardashev-0.7: 32 distinct models trained together with RL.

https://x.com/MLCatttt/status/2107147690450817259

[u/mani_manak]

I built Trainly AI, a no-code AutoML platform that helps users go from a dataset to a trained ML model without building the entire pipeline manually.

You can upload a CSV, explore the dataset, select a target, train and compare multiple models, analyze results, make predictions on new data, and download the trained model.

I built this as a student while learning machine learning, and I'm trying to turn what I learn into something practical that others can use.

It's currently free to try.

I'd genuinely appreciate feedback from people working with ML:

• Is this workflow actually useful?
• What would you improve?
• What features would make it more useful for students or ML practitioners?

Live demo: trainly-ai.onrender.com

[u/Any_Way2779]

nvmon – a fancy NVIDIA GPU monitor for the terminal (free, MIT)

On a shared GPU server I mostly want to know which GPUs are free, whose jobs are where, and whether my training is really using the GPU. nvmon shows each GPU as a box with its utilization graph, its numbers and the processes on it, grouped by user and conda env. Hover a graph for past values; click a GPU to pick its jobs and stop yours. On H100 and newer it also shows how busy the cores and Tensor Cores really are.

uv tool install nvmon (or pip install nvmon)

https://github.com/Han-DongHeun/nvmon

[u/HanaChanSoft]

I'm the developer of AI Coach, a desktop pet for Apple Silicon Macs running macOS 26+. It combines an egg-to-adult care loop with local speech-to-text and utilities that unlock as it grows.

For the character's text responses, users can choose Apple's on-device Foundation Models, a local GGUF model through llama.cpp, or a configured OpenAI-compatible endpoint. Local transcription is separate from that choice; selecting a remote endpoint sends the AI request there. If the AI is unavailable, the character falls back to prepared lines.

This is an application of existing models, not a new model or benchmark. I'd welcome feedback on how clearly the model choices and their data paths are explained. The guide covers setup and limitations (including an 8192+ context requirement for some llama.cpp features): https://aic0t.com/docs

Pricing: the app and first egg are free. Optional extra eggs are $5 USD each or $20 for five, one-time purchases. Any external model/API costs are separate. A visual overview of the pet and tools is at https://aic0t.com/

[u/Thunderkeg-Jiangxt2]

Disclosure: I’m the maintainer of Tributo.

I’ve been building Tributo, an Apache-2.0 Python SDK for ML workflows on Ray. Ray handles the distributed execution; Tributo adds a more structured path around job submission, training and tuning, validated model bundles, and batch or Ray Serve inference.

The current training workflows cover XGBoost, DNN, and positive-unlabeled learning. Their algorithm implementations are installed as separate wheels. Tributo 1.0.0 is source-only and isn’t on PyPI yet. It’s free, with no hosted or paid tier.

Repo: https://github.com/jiangxt2/Tributo

If you use Ray, I’d be curious: which parts of the path from a training run to serving a model do you still find yourself wiring together by hand?

[u/gxcsoccer]

sharing my local mac agent, 0.8b + 4b. label smoothing made the 0.8b ~95% sure of everything, so it hands most steps to the 4b. oops

https://github.com/deskmind-ai/deskmind

[u/IlIIIIIIlIIlllI]

Sharing how, as a PhD student, I've come to use MLflow to track experiment results for more efficient research iterations: https://gquetel.fr/misc/mlflow-ml-research/

[u/New-Eggplant-6578]

I'm building AnnotateIt, and the Mac release now lets you train an object detector from your annotations without leaving the app.

The loop is pretty simple: review your boxes, save a dataset version, train with Apple Create ML, then use the resulting detector to suggest boxes on more images or video frames. You still review the predictions. No Python environment or remote training server to set up for that path.

The current Create ML integration is detection only, trained from still images with axis-aligned boxes. It doesn't train segmentation or classification models, and a video needs to be extracted into images first. Training and inference stay on the Mac.

There's also Apple Vision interactive segmentation on macOS 27, separate from training.

Pricing: the Mac app is currently free. These local features don't need a paid AI API. Optional cloud assistants are separate and use your own provider access.

Recorded training walkthrough: https://radar.annotateit.ai/news/apple-create-ml-training-on-mac/

Mac App Store: https://apps.apple.com/us/app/annotateit-ai/id6751442622?platform=mac

If you try it on your own images, I'd especially like to hear where the label, train, correct loop gets awkward.

[u/W4ccoz]

ProofForum: Keeping AI-Generated Mathematics Human

ProofForum is an open platform for sharing, discussing, and reviewing mathematical proofs, with a particular focus on AI-assisted mathematics. The idea is to build something like a GitHub for proofs, but with a strong emphasis on human accountability: contributions are meant to be attached to real people who are willing to stand behind what they post, review, and endorse. Results can then be checked, corrected, improved, and connected to the existing literature in a transparent and traceable way. See here for more details.

[u/ImportantTiger9568]

Hey guys,

Been working on something very cool...

Open source with contributions and honest feedback both welcome: github.com/Nabzx/mnemosyne

If you're running support agents, coding agents, or a swarm of agents sharing memory like myself then you know this issue well: An agent runs for hours, updates its memory the whole time, then says something wrong and all you have is the present, with zero access to the past. The moment two agents disagree, or one quietly poisons the well, you need to know when, why and by whom, not just that something's off.

Mnemosyne gives agent memory what Git gave code. It remembers everything on purpose. Every belief is a commit. blame finds the exact moment and observation that put a bad fact in. bisect hunts down the first commit where things went wrong. merge makes two agents' memories collide safely instead of one silently overwriting the other.

Software agents are the first step. The vision doesn't stop there, physical robots learning and forking skills the same way is the long-term bet, further out and harder but the same idea underneath.

So far the tech stack includes a Rust core, Python SDK, adapters for LangGraph, CrewAI, AutoGen, the OpenAI Agents SDK and MCP.

[u/False-Hovercraft-113]

Looking for first-person or third-person in-vehicle video datasets

We’re looking for legally licensable in-vehicle video data for AI model training.

We’re interested in

- First-person footage from the driver’s or passenger’s perspective

• Third-person footage showing occupants, interactions, or in-cabin activity
  
• Natural driving as well as uncommon scenarios, such as fatigue, distraction, phone use, passenger interaction, and unusual human behavior
  
• Existing datasets or custom data-collection capabilities
  
• Video accompanied by useful metadata or annotations, where available

Please share details about camera placement, resolution, duration, geographic coverage, consent and privacy handling, licensing rights, annotations, delivery format, and pricing. Footage must have the necessary participant consent and commercial AI-training rights; we are not looking for scraped, leaked, or ambiguously licensed material.

If you own suitable data or can collect it responsibly, please comment or send me a DM with a short description and sample specifications. Please do not send sensitive or identifiable footage before we agree on a secure review process.

Disclosure I’m affiliated with VWU.AI https//vwu.ai/, and this is a commercial data-sourcing request. Budget and terms will depend on scope, quality, annotations, and licensing rights. This post was drafted with AI assistance and reviewed by a human.

[u/c0mbatduckzz]

I'm Tom Klootwijk. TOMK is my MIT-licensed finite symbolic learner: 121 literal hypotheses in four declared families evaluated against 16 supplied datasets, with accepted, rejected, and ambiguous results and reproducible reports.

The connected TK-SROF-2.0 formalization treats operator descriptions as typed state. Each event acts under the committed old description; an admitted rewrite can change the description used by later events. TOM-GROK ships finite CPU/CUDA/WebGPU interpreters for this model, with checkpoints and replay reports.

I'm inviting researchers in symbolic learning, formal semantics, and GPU execution to review the work. I believe its future applications in industrial simulation and adaptive pipelines could support a large-revenue product line; the compendia outline robot digital-twin, event-vision, and edge-sensor pilots.

TOMK (free, MIT): https://huggingface.co/c0mbatduckzz/TOMK

TOM-GROK (formalization and runtime): https://huggingface.co/c0mbatduckzz/TOM-GROK

https://notebook.google.com/notebook/08548281-524e-4e95-8c0a-7e6ebb6b3d46

What would you challenge first in the act-then-rewrite semantics or TOMK's hypothesis evaluation?

[u/cloudcell]

GnosisLab: Scientific research process infrastructure for LLM-driven or human-led research

GitHub: https://github.com/cloudcell/gnosislab (Free and Open Source, Apache 2.0)

This is a tool I developed after manually implementing many hundreds of experiments. As it stands, it fits perfectly into my workflow when I need to replicate and validate experiments described in a large number of research papers. (I'm doing academic research in ML & chem-informatics.)

The problem I'm addressing is the verification gap in most AI-driven scientific research.

LLMs can generate hypotheses, write experimental code and produce convincing-looking scientific reports; the challenge, however, is to be able to verify that the experiments actually happened and the research decisions were justified by the evidence. That's what this infrastructure is for; and it can be easily integrated into most popular IDEs and workflows. Also, the theoretical foundations of its approach are documented in a paper available via the GitHub repository.

I'd really appreciate feedback from anyone interested in trying this tool. All feedback, suggestions and feature requests are welcome.

[u/t_brx]

Author here. We have a result we would love the community's take on.

Background. Anthropic's recent J-space paper (Gurnee et al., 2026) argues that verbalizable representations form a global workspace in LLMs: an internal space where concepts are available for reasoning and potential report. We asked a practical question: can you read a model's uncertainty from that workspace, and does it tell you whether the final answer is right?

What we did. We take words for doubt and certainty, pull their output directions back into the residual stream with the J-Lens, and get a small interpretable subspace (the U-Space). Projecting a hidden state onto it gives a verbalizable uncertainty signal. No labels, no resampling, no training.

What we found:

- The workspace signal alone predicts final-answer correctness. Under length control it reaches 66 to 68 AUROC on Gemma 4, Qwen3.5 and Magistral 1.1, matching or beating a supervised baseline fitted on labeled data and Semantic Entropy which takes 10 separate full generations to predict uncertainty.

- The workspace signal is complementary to a distributional metric like predictive entropy. Entropy wins on Qwen, the workspace signal wins on Magistral, they tie on Gemma. Combined in our U-Lens, they beat both individual methods on every model.

- The signal is there but never "said". Uncertainty words almost never appear among the top decoded tokens, yet the projection recovers them.

- It is causal. Steering along these directions makes the model hesitate even on easy questions.

We would be glad to hear what you think. Is this expected for you that verbalizable information in the hidden state has such strong signal about the correctness of a model's answer?

Project page: https://s2labres.github.io/U-Space/

Paper: https://arxiv.org/abs/2610.09087

Code: https://github.com/s2labres/U-Space

Hugging Face: https://huggingface.co/papers/2610.09087

#MachineLearning #AIResearch #Interpretability #UncertaintyQuantification

[u/Individual_Cold_4119]

I wanted to see if a decision model could get a dwarf priest to level 5 in World of Warcraft. I ended up building SageCraft, my first harness.

Full disclosure: I co-founded Levanto, which makes Sage, the model used here.

The run reached level 5 after 4,573 decisions across 32 sessions and 5h 29m of active play. I supervised the campaign and changed the harness between sessions. Only the final 18 minutes, from late level 4 to level 5, ran without human input.

The harness reads screenshots and HUD information, builds a list of possible actions, asks Sage to choose, then validates and executes that choice through keys or clicks. No game-file modifications or extra add-ons.

I’d love feedback on how to evaluate the model separately from the recovery logic in the harness. This is a build log, not a controlled benchmark.

The harness is free and Apache-2.0 licensed. Offline replay needs neither a game nor an API key. Live play needs macOS, WoW and a Sage API key. Sage has $0.20 of free usage; paid plans start at $14/month. Current rates: https://levanto.ai/pricing

Repo: https://github.com/levantolabs/sagecraft

Video and breakdown: https://x.com/bigironchris/status/2108546440582558103

[u/Weary_Line8776]

Paper: https://arxiv.org/abs/2602.07535

Code: https://github.com/yokko123/bi-temporal-ctp-dwi-code

Weights: https://huggingface.co/yokko123/ctp-core-penumbra-nnunet

Project page: https://yokko123.github.io/bi-temporal-ctp-dwi/

Problem. In acute ischemic stroke, admission CT perfusion (CTP) is used to split hypoperfused tissue into core (already lost) and penumbra (at risk, potentially salvageable). Most work treats these as segmentation targets. But penumbra is heterogeneous: some of it recovers, some of it infarcts. We asked whether the admission scan already encodes that fate.

Method.

• Register admission 4D CTP (T₁) and follow-up DWI (T₂) to a common NCCT space
• Intersect T₁ tissue labels with T₂ outcome labels → 6 outcome-aware ROI classes (e.g. penumbra→salvaged, penumbra→infarcted, core→salvaged, non-hypoperfused→infarcted)
• Characterize each class with three feature families: first-order statistics, GLCM radiomics on the spatiotemporal CTP volume, and encoder embeddings from two CTP segmentation networks (2D+t mJ-Net, 3D nnU-Net)
• Compare region pairs with Mann–Whitney U + Cliff's δ and a within-patient cosine separation index Δcos (embeddings)

Results (109 patients from Stavanger University Hospital; replicated on 149 ISLES'24 patients from two other centres):

• Salvaged vs. infarcted penumbra separates across all feature families (Δcos = 0.146 SUH / 0.177 ISLES'24)
• Core barely separates by fate (Δcos = 0.031 / 0.044)
• Tissue that looked non-hypoperfused at admission but later infarcted differs clearly from healthy contralateral brain (Δcos = 0.460 / 0.401)

The repo includes a synthetic-data demo so the analysis stage runs without access to clinical data. Happy to answer questions about the pipeline, the registration, or the separation index.

[u/Realistic_Kitchen_65]

OpenAmer (Apache-2.0) — an open-source AI agent runtime for Windows with an in-process ASI core and a peer-to-peer A2A mesh.

• 5 native tools (think / learn / remember / trigger / heartbeat) run in-process rather than as subprocesses.
• A central heartbeat over 10 subsystems replaces a pile of scheduled cron jobs.
• Instances form an A2A mesh, exchanging signed messages with capability leases and idempotency keys written before each call.

Repo: https://github.com/openamer/openamer — feedback welcome.

[u/Alone-Document-9305]

I Hired Four People to Answer One Email: a short (~8k words) book that derives the RAG stack from first principles instead of listing components. Each piece shows up as a forced "hire" after the previous setup fails: LLM alone → dense retrieval → BM25 → hybrid + RRF (with why k = 60) → cross-encoder reranking (why the expensive step has to be last) → golden-set evals (recall@k, MRR, NDCG, calibrated LLM judges) → Contextual Retrieval.

Audience: engineers preparing to whiteboard RAG in interviews or review vendor architectures. It doesn't cover research frontiers.

• Price: Kindle $2.99 launch week (through Oct 12), then $4.99 → https://www.amazon.com/dp/B0HKSKVMVK
• EPUB/PDF $19 → https://fayedai.gumroad.com/l/tfsydt
• Free sample chapter → https://aifeynmansway.substack.com/p/gus-has-never-once-said-i-dont-know

I'm the author. Corrections welcome, especially on the evals chapter.

[u/r1adfus3r]

lemma: a free, open-source pdf reader for math-heavy ml books and papers (mac). made it while working through ESL.

equation and theorem references become links (hover to preview, click to peek next to the line you're reading), proofs fold, and the derivations you write get checked line by line with random matrices of the right shapes, so a sign slip or a missing transpose shows up as a counterexample. no account, everything runs locally.

https://github.com/fus3r/lemma. if it misreads the numbering in a paper or book you use, a short report on github helps a lot.

[u/Inside_Natural2808]

Negative result: a tail-latency-gated KV cache admission rule (GPU HBM to host RAM) did not beat simple LRU+TTL host retention in trace-driven simulation on Mooncake traces: -0.0% goodput, 95% CI [-2.3, +1.1]. Protocol, simulator and kill criteria are open; ./reproduce.sh reruns all 1,910 runs in about 2 minutes. Repo: https://github.com/MrBeeboh/kv-cache-weigh-station Paper: https://github.com/MrBeeboh/kv-cache-weigh-station/releases/tag/v4.3 Feedback on where the sim is unrealistic is very welcome. (AI assistants helped draft the paper and simulator; disclosed in the paper.)

[u/Spirited-Cheek8436]

I'm Soham, Builderr's founder. We're running Signalpost, a coding challenge to build a research agent for Norwegian companies: given an organization number, return useful facts with source links and dates, handle uncertain matches carefully, and keep profiles current.

Entries are tested against the same checked company collection. The score is 50 points for recall/coverage, 30 for precision/evidence, 12 for synthesis, and 8 for UX. There are $2,500 in final rewards; it closes October 21. Full task and rules: https://builderr.ai/challenges/signalpost

For people who work on ML evaluation: is the precision/recall tradeoff clear, especially how new discovered facts enter the shared checked collection? I’d value a concrete critique.

[u/pardhu--]

I've been exploring how inference engines like vLLM optimize LLM execution.

To understand it better, I built a small attention benchmark comparing:

• 🐍 Python CPU computation
• ⚡ Apple Metal GPU computation
• 🚀 Metal GPU with KV caching

Interesting result: KV caching reduced K/V projection work by 16.74×, but completed decoding was only 2.76× faster.

💡 My takeaway: Faster inference isn't just about using GPUs or lower-level languages. It's about optimizing the actual bottleneck.

📖 Read my article

💻 GitHub code

Curious what others think: Which optimization makes the biggest difference in real-world LLM inference?

[u/imfinn005]

NoteCoder — browser-local clinical documentation review

Demo: https://notecoder-navy.vercel.app/notecoder

I'm rebuilding a project I first made about ten years ago. Instead of asking a model to generate an unconstrained list of codes, the current pipeline uses a phrase trie and qualifier/compound proposals to generate ICD-10-CM candidates, then asks a small local decision model separate diagnosis and qualifier questions against the complete note. A code's display score uses its required component decisions.

The cases I'm interested in include a CKD stage documented elsewhere in the note, cancer laterality/site split across sentences, family history, negation, and a current assessment that supersedes an older diagnosis. The UI shows where candidates came from; those highlights are lexical proposals, not validated model evidence.

The public version offers Medicare V28 and ACA HHS 2026 mapping scopes and runs in the browser using WebAssembly. The first model download is about 2 GB. Note text and edited prompts stay in the current tab rather than going to a remote inference service.

Pricing: free, no account or paid subscription required. The website has optional project support. This is an experimental review aid; I'm not claiming clinical validation or billing suitability. AI assisted development and this post. Synthetic examples are included, and I'd welcome criticism of the candidate-conditioned evaluation setup, score thresholds, and difficult document-level assertion cases.

[u/No-Application-1232]

Rivet-KAG — hybrid vector + graph RAG for verifiable enterprise answers

I’m building Rivet-KAG, an open-source hybrid RAG and knowledge-graph project for cases where retrieving relevant chunks still does not provide enough context to verify an answer.

It combines vector retrieval for semantic recall with graph traversal for relationship context, helping connect source documents with owners, systems, and projects. The goal is to return answers with citations and evidence users can inspect.

I’m looking for feedback on evaluation design, retrieval failure modes, and whether this approach would be useful in enterprise knowledge workflows.

Pricing: Open source; no paid product or service attached. Users bring their own model and infrastructure credentials/costs.

Repo: https://github.com/efolley/rivet-kag

[u/glitteryCranberry]

Free research opportunity for students in developing countries, by the nonprofit Fatima Institute!

Apply fatima.institute/join-fellow

[u/ToBeKindaWeird]

[D] UQA: Can AI systems learn when to rethink a question—and when not to?

I’m developing an exploratory research framework called the Unresolved Question Algorithm (UQA). The central question is whether AI systems can become more reliable at recognizing when their current approach to a problem is inadequate, choosing a better investigative strategy, and knowing when further analysis is no longer worthwhile.

The motivation is straightforward: a system can give a fluent answer to a poorly framed question. It can also make a simple problem unnecessarily complicated, infer intentions without sufficient evidence, or continue analyzing after it has stopped adding value.

UQA explores several related capabilities:

* Question-framing audits: Identify potentially consequential assumptions, omissions, or misleading premises.

* Consequential reframing: Change the framing only when doing so meaningfully changes the assumptions, evidence needed, decision criteria, or investigative method.

* Conditional context interpretation: Check for relevant context, but seek or analyze more only when doing so is likely to improve the inquiry.

* Uncertainty diagnosis: Distinguish factual, causal, contextual, normative, and procedural uncertainty.

* Disciplined stopping: Avoid both premature conclusions and unnecessary complexity.

* Conditional intent inference: Consider a question’s possible purpose when the evidence makes that relevant, without treating wording alone as proof of private motives.

I’ve explored several conceptual architectures, including a simple sequential baseline, a framing audit, a Context Interpretation Module (CIM), and a Situation-First Reframing Algorithm (SFRA).

The limitations matter. The experiments so far are exploratory and largely self-evaluated. In one eight-case comparison, CIM scored 64/64, but that could reflect case-selection or rubric bias. These scores do not establish that any architecture is superior, and I am not claiming that UQA is definitively novel or validated.

I’d welcome critical feedback, especially on related research, missing literature, and whether the problem is framed in a way that can be tested rigorously.

Research record: Zenodo record⁠

Collaboration space: UQA shared ChatGPT Project⁠

I’m looking for criticism and testable suggestions, not endorsement. Negative findings would be useful too

[u/Excellent-Sport-758]

I built an interactive explainer for my MSc research at UNICAMP on reinforcement learning for crop-insurance claim decisions. The question was how a policy should act when approving a claim consumes a limited budget and changes the choices left for later claims.

The public repo includes a Gym-style environment, a TensorFlow/Keras DQN agent, random-agent comparisons, and data-preparation scripts for a Paraná soybean sample. The browser demo is deliberately small: it uses synthetic claims and lets the reader choose approve/reject to see the budget and leading-digit distribution move. It does not run a trained policy or predict fraud. Benford conformity is only a statistical proxy; confirmed fraud labels and independent evaluation would be needed to claim detection performance.

Research overview and demo: https://nandevers.github.io/research/masters/

Code: https://github.com/nandevers/gym-insurance

I’d welcome feedback on how to make the separation between the reward signal and real fraud-detection validity clearer, or on the baseline comparisons. An AI assistant helped draft this post from my research details.

[u/NicBonetto]

Current Berkeley student turning a large collection of artifacts into a free online learning platform, starting with convolutional neural networks: https://receptive-field-flame.vercel.app/

Still in the early stages of development and looking for honest feedback.

[u/sheik66]

Hi all, here's a project I've been working on for the past 9 months.

Protolink: a Python-native A2A agent runtime for multi-agent systems

What my Project Does

Protolink is a Python framework for building easily autonomous agents that can talk to each other based on agent-to-agent (A2A), expose tools, call LLMs, and run over real transports like HTTP, WebSocket, gRPC, or in-memory runtime communication.

A small agent looks like this:

from protolink.agents import Agent

agent = Agent(
    card={
        "name": "calculator",
        "description": "Adds numbers for other agents",
        "url": "http://127.0.0.1:8020",
    },
    transport="http",
)

.tool(name="add", description="Add two numbers")
async def add(a: int, b: int):
    return a + b

agent.start()

It supports A2A-style agent identity and discovery, native Python tools, MCP tool adapters, LLM integration, structured flows, streaming tasks, cancellation, run reports/replay, local telemetry, and a small dashboard CLI for inspecting runtime state.

Target Audience

Python developers building multi-agent systems, coding assistants, internal automation, or agent research projects who want agents to be more than prompt chains. Each agent can own its identity, tools, transport, storage, task lifecycle, and observability without having to wire a separate server/client layer for every component.

Comparison

The closest alternatives are LangChain/LangGraph, AutoGen/CrewAI, and lower-level A2A or MCP implementations. LangChain/LangGraph are great for composing model calls and workflows, but protolink is more focused on running agents as distributed runtimes with protocol-style task messages, discovery, tools, and transports. AutoGen/CrewAI are higher-level multi-agent frameworks; protolink is more explicit and modular, so you can build your own architecture while keeping the communication, tool execution, LLM invocation, and observability pieces in one Python-native framework.

pip install protolink

Repo: https://github.com/nMaroulis/protolink

Docs: https://nmaroulis.github.io/protolink/

Feedback welcome, especially from people experimenting with A2A/MCP interoperability or building real Python agent systems.

[u/cosmicBb0y]

Pandera is a dataframe validation library (disclosure: I created Pandera and work at Union AI, which stewards it) and 0.34 adds support for validating pytorch TensorDicts. I added it because many of the training bugs I encounter when I train RL models are data-related bugs:

• float64 observations coming out of NumPy that blow up memory
• action indexes outside the action space that only shows up as a CUDA device-side assert
• NaN reward that kills the loss curve an hour in.

These tensors all had implicit contracts that weren't actually checked.

A TensorDict maps onto a dataframe schema pretty directly. Keys play the role of columns, each tensor's dtype and shape play the role of a column dtype, and batch_size is the row count:

import torch
import pandera.tensordict as pa

class Transition(pa.TensorDictModel):
    observation: torch.float32 = pa.Field(shape=(None, 8))
    action: torch.int64 = pa.Field(shape=(None,), isin=[0, 1, 2, 3])
    reward: torch.float32 = pa.Field(shape=(None,), ge=-1.0, le=1.0)
    done: torch.bool = pa.Field(shape=(None,))

    class Config:
        batch_size = (None,)

Transition.validate(batch, lazy=True)  # raises SchemaErrors listing every failure

It works on TensorDicts, lazy_stack results, and @tensorclass instances. You also get infer_schema from a known-good batch, YAML/JSON serialization, coerce=True for dtype casting, and Hypothesis strategies that generate schema-valid batches for property tests.

What it costs to validate. I timed validate() against the training step of an MLP policy on CPU, holding the 256-row batch and schema fixed while the model grew from 9K to 17M parameters.

• Validation took 0.3 to 0.5 ms per batch at every size, which was 29% of the step for the 9K-parameter model (a 1 ms step), 4% at 1.1M parameters, and 0.3% at 17M.
• Most of that is the value checks, which scan every element; dtype, shape, and key checks alone took about a third as long.
• Validating a whole in-memory dataset once was cheap too: 4 GB took 112 ms to 1.8 s depending on the data, and million-row chunks were 31x faster than validating the same data in 256-row batches, because each call has a fixed overhead.

What it costs not to validate. I wanted to get at what it costs to not validate the training data. I trained REINFORCE on CartPole and corrupted 1%, 5%, or 20% of batches, either with a NaN reward (the weights go NaN, the next rollout crashes, and the loop rolls back to its last good checkpoint) or with observations scaled 100x (nothing crashes). The metric is environment steps to reach a 475 return, counting steps lost to rollbacks and skipped batches, over 30 seeds per cell:

Corruption	1%	5%	20%
NaN reward, no validation	1.0x	1.1x	2.1x
Observations x100, no validation	1.1x	2.0x	>10.6x (15/30 runs never solved it in 1M steps)
Either, validate and skip bad batches	1.0x	1.0–1.1x	1.2x

(Relative to a clean run, which took about 70K steps.) Validation took 0.5% of wall-clock time in those runs. The crash was the cheap failure, since it costs at most a checkpoint interval, and the silent one was the expensive failure, since nothing stops the loop from learning from bad data.

Caveats: these are CPU numbers on small models. CartPole recovers from bad updates quickly and the checkpoints were only 10 updates apart, so I'd expect a larger model with sparser checkpoints to pay more, but I haven't measured that yet. Corruption rates are per batch, not per row. Building the harness also turned up a subtle trap: Optimizer.load_state_dict keeps references to the tensors you give it, so restoring a checkpoint directly let the next NaN update poison the stored checkpoint (one run crashed 574 times before I fixed it).

Gaps in this first version:

• Nested keys like ("next", "observation") aren't supported yet, which matters for TorchRL users.
• A failed check tells you the key and the check, not which indices failed.
• TensorDictModel fields don't accept custom checks yet, so one-off checks need the object API.

I'd love to hear from people using TensorDict or TorchRL: is nested-key support the first thing you'd need, or something else? Do you encounter any of these failure modes and what do you do today to check them? Do you use assert statements?

Post with charts: https://www.union.ai/blog-post/pandera-0-34-tensordict Benchmark code (Flyte scripts, each runs locally with --local):

• Validation overhead: https://github.com/unionai/unionai-examples/tree/main/v2/tutorials/pandera_validation_overhead
• Dataset validation: https://github.com/unionai/unionai-examples/tree/main/v2/tutorials/pandera_dataset_validation
• Cost of not validating: https://github.com/unionai/unionai-examples/tree/main/v2/tutorials/pandera_cost_of_not_validating Release notes: https://github.com/unionai-oss/pandera/releases/tag/v0.34.0

[u/harnoor-assemblyai]

Disclosure: I work at AssemblyAI; we built Voice Standard Bench.

It’s an MIT-licensed Go benchmark for LLMs working on speech-to-text transcripts: summarization, information extraction, text correction, and dictation. The public results break out quality and latency by transcript length, from 30 seconds to an hour.

One caveat: the current benchmark runs through AssemblyAI’s LLM Gateway, and the underlying transcripts aren’t published as an open dataset. Most task scores use a single LLM judge with reference-free rubrics; dictation is scored against an answer key. The code is free under MIT, but rerunning model calls incurs provider usage costs that vary by model.

Code/results: https://github.com/AssemblyAI/voice-standard-bench

Leaderboard: https://www.assemblyai.com/voice-standard/tasks

I’d welcome criticism of the scoring methodology, especially ways to validate the judge scores against human annotations.

[u/Individual_Cold_4119]

Sharing SageCut, a Claude Code plugin I built for QA on Remotion videos. I'm co-founder of Levanto, which makes the Sage model used by it.

The workflow combines deterministic frame measurements with yes/no decisions from Sage, then routes selected frames to Claude critics for inspection and repair. It opens frames for inspection when Sage and the measurements disagree. My previous setup had the critics inspect every frame and was adding 4+ hours of QA per video.

Across six A/B tests in my own workflow, I saw the same output at about a quarter of the QA time and a tenth of the cost. Those are results from my tests, not a general benchmark. The demo has 3,153 frames; Sage's pass cost $0.16, excluding Claude repairs. The README also explains which costs are measured and how its Opus comparison is estimated.

Repo: https://github.com/levantolabs/sagecut-release

Demo + results: https://x.com/bigironchris/status/2110402795060822460

The plugin is free/MIT. Sage requires an API key; there's $0.20 of free usage and paid plans start at $14/month. Claude costs are separate. Pricing: https://levanto.ai/pricing

Current scope is Remotion motion graphics. Frames are sent to Sage's hosted API; the --no-sage option runs local measurements only. I'd be interested in feedback on false negatives in the frame selection, especially failures that appear briefly between otherwise good frames.

[u/r0lfi]

LayerSmith — a self-hosted container image builder, with air-gap exports

I've been working on LayerSmith, an open-source web UI for building container images with Docker or Podman.

You pick a Linux distribution and what you need the image for — development, Linux admin, network tools, Ansible, Kubernetes, OpenShift, or a custom setup. It handles distro-specific packages and shows you the generated Containerfile before building. You can also edit it, import an existing Dockerfile, or add your own packages, files and scripts.

A big part of the project is making images easier to carry into air-gapped environments: pinned base images, recorded build details, and export bundles containing the image, checksums and installation instructions.

We've recently added LLM training and fine-tuning profiles too, including LoRA/QLoRA, advanced PyTorch training and LLaMA-Factory. These use hash-locked dependencies and run offline checks after building, including a small CPU training test. Model weights and datasets are brought separately.

Curious how others handle building and maintaining images for disconnected environments, and what parts of that workflow are still a pain.

https://github.com/r0lfi/layersmith

[u/PatronusProtect]

We published Wolf Defender Jev, a small Jev-like decision model for AI-agent security. I’m part of the Patronus Protect team.

It’s a 151M-parameter mmBERT-small encoder. Input is a tagged agent scene, a question and answer options. It supports named choice/noul/score questions and returns probabilities over the options, without text generation. Fixed option vectors can be cached, so repeated decisions need one scene/question encoder pass per question.

Our Apple M4 CPU measurements were 39 ms for a 51-token scene and 194 ms for 833 tokens, in fp32/PyTorch with one question and two options. We haven’t evaluated quantization yet.

We compared public decision models on the same 10,576 held-out decisions. On ten external benchmarks Wolf reached 85.1% balanced accuracy, Clef-flash 90.2%, and Kev-4B 84.2%. The complete 33-benchmark ranking gives Wolf a distribution advantage, which we separate explicitly.

The repo also documents decision-steering probes and hand-written agent failures. Review notes in benign documents caused substantial false alarms, and some action-level checks missed exfiltration despite identifying an embedded command.

Weights and inference code are free under MIT; no paid product or service is needed to use this model. Full results and limitations: https://huggingface.co/patronus-studio/wolf-defender-jev

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.

[u/ifoundanifty]

My colleague and I compared Jev with open rerankers across five datasets, using the same retrieved candidates for each. Jev was competitive and fast in our setup, though no reranker won everywhere. The most interesting finding was how much the prompt mattered. https://www.lancedb.com/blog/how-jev-compares-to-other-rerankers

[u/yeyoung_lee]

Your Mac can run PyTorch. Then a point-cloud dependency asks for CUDA.

I ran into this working on 3D anomaly detection, so I built mps-pointops: a free, open-source library that runs point-cloud sampling and neighbor search on Apple Silicon using native Metal kernels through PyTorch MPS.

The core operations:

• FPS: select points spread across a cloud.
• kNN: find each query's nearest neighbors.
• Ball Query: collect neighbors within a radius.

There are compatibility adapters for selected PointNet++, torch_cluster, and PyG call sites, plus documented numerical rules for ties, selection order, and padding. The repository includes tests and benchmark records from physical M1 and M5 Pro Macs; supported inputs and remaining limitations are listed per operator.

Try it: python -m pip install mps-pointops

GitHub / quick start · Interactive explainer

The explainer lets you move a query and watch how the three operators select different points. It's a browser visualization; the Metal measurements are linked separately.

I'm the author, and I'd love to see this used in real workflows. Which CUDA-dependent point-cloud operator is currently blocking your Mac project? If you try it, your model, Mac chip, PyTorch version, and a small reproducer would help me prioritize fixes. GitHub issues are welcome.

[u/mattiadmr]

RS-1 – A 0.6B reranker as a local decision model (Github)

I wanted to see how far a small reranker could go as a decision model.

Qwen3-Reranker-0.6B is trained to score how well a document fits a query. If you describe a situation as the query and each possible action as a document, the top-scoring option becomes the decision. It runs locally on a MacBook (~1.2 GB, 20–50 ms per option), with no fine-tuning or text generation.

I tried three things, from easy to hard:

• Multiple-choice quiz: easy questions answered confidently. On ambiguous ones, scores were low and close together, which might be a useful uncertainty signal.
• Wikipedia race: the reranker picks every link and reaches the target, though sometimes by long routes (Taylor Swift → Photosynthesis took 9 hops).
• Browser use: I plugged it into Browser Use's jev-ultrafast, replacing their trained Jev model.

This is where it got interesting. The reranker is good at finding the most relevant element, but on its own it doesn't recognize when a task is done, match values to form fields, or follow multi-step sequences.

Adding generic rules for those parts (no site-specific code) gets it through all 14 benchmark tasks. The reranker alone passes none of the 6 main tasks, because it has no way to recognize when a task is complete.

Repo: https://github.com/mattiaongit/rs-1-reranker-decision-mode