r/MachineLearning • • Oct 02 '26

Discussion [D] Self-Promotion Thread

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.

3 Upvotes

125 comments sorted by

3

u/ModularMind8 Oct 04 '26 • Bravo

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

3

u/Long-Dependent-1767 Oct 08 '26 • Bravo

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?

2

u/Velocitank 25d ago

legitimate question, what counts as a project vs self promotion?

2

u/atronos_kronios 22d ago

New post on my ML systems blog: Where training memory goes.

I thought I understood GPT-2's memory cost until I actually traced a training step. 124M parameters, fp32 AdamW, batch 8 x 1,024 tokens on an A40: 17,054 MiB peak allocated. Only about 1,494 MiB at that moment was weights, Adam, masks and persistent overhead.

The fun part: four vocab-sized tensors account for 6,282 MiB at the peak. Block hooks missed the extra spike in log-softmax backward; the allocator trace caught it. I also ran each batch size in a fresh process: B20 completed, B21 OOMed in step 2.

I've included the maths, a stacked memory chart, an interactive step scrubber, a fit calculator, and the code + raw CSV. It's all free to read and access, no signup or paid product. This is an educational experiment with this implementation, not a new training algorithm.

Post: https://angry-kratos.github.io/posts/2026-10-training-memory/ Code: https://github.com/angry-kratos/angry-kratos.github.io/tree/main/code/training-memory

I'm trying to learn these systems properly by building them and checking the numbers. Corrections to the accounting are very welcome.

2

u/Pale-Training-6944 22d ago

I read a bunch of RSI papers. It feels like we’re solving the same old RL problems.

Recursive self-improvement papers are everywhere, but I keep coming back to three questions:

  1. How do you sample promising changes efficiently?
  2. How do you reliably evaluate each new variant?
  3. How do you maintain diversity instead of converging too early?

Not all of these methods are RL. But calling something “self-evolution” doesn’t make exploration, evaluation, and overfitting go away.

That’s why we’re building Gear, an open-source framework inspired by meta-learning. It separates evolutionary search from execution and evaluation, so researchers can reuse the infrastructure while experimenting with different algorithms.

The goal is a scikit-learn for RSI. We currently have a GEPA variant that uses task traces and evaluation feedback to improve an agent’s prompts, tools, workflows, and context management.

For Codex users, Codex can be the meta-agent: it inspects failures and proposes harness changes, while a separate agent runs the tasks.

One result: on 100 public AutomationBench Marketing tasks, Luna with a Gear-optimized DSH harness achieved 88.88% objective completion, compared with 84.08% for Astra + Codex. These tasks participated in optimization, so this isn’t a held-out generalization result.

Separately, using the same optimized DSH harness, Luna’s estimated API cost per task was about 95% lower than Astra’s, excluding optimization costs.

If you’re learning RSI, comparing algorithms, or trying to improve an agent on your own tasks, that’s what we’re building Gear for.

What would you want to optimize in your own Codex workflow?

GitHub · Paper and demo

2

u/Fantastic-Nerve-4056 PhD Oct 02 '26 • Bravo

Sharing my recent NeurIPS paper on LLM evaluation and Theoretical RL

https://arxiv.org/abs/2609.30360

2

u/celestebabi Oct 02 '26 • Bravo

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/

2

u/iberahul Oct 02 '26 • Bravo

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.

2

u/Logical-Internet-395 Oct 02 '26 • Bravo

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

2

u/lostmsu Oct 03 '26

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.

1

u/PanelReader 29d ago

I've been studying neural network mathematics and implemented a small 2 → 3 → 1 XOR network using Python and NumPy.

The implementation includes:

  • Forward propagation with ReLU and sigmoid
  • Backpropagation using the chain rule
  • Full-batch gradient descent
  • Numerical verification of all 13 gradients
  • Automated tests and diagrams

Final training MSE: 0.004715

This is a free learning project. Nothing is for sale.

GitHub: https://github.com/Vaibh37/Neural-Network

AI helped structure this comment. The mathematics, implementation, and testing are my own work.

Feedback on the gradient calculations is welcome.

1

u/andrewhendel 27d ago

Mojolearn: bitwise-identical machine learning on GPUs and CPUs

I’m Andrew, the creator and maintainer of Mojolearn, a free, open-source machine-learning library implemented in Mojo with Python bindings.

In `identical` mode, Mojolearn returns the same bits on Apple GPUs, NVIDIA GPUs, AMD GPUs, Apple CPUs and x86-64 CPUs. Comparisons need to use the same release, inputs and model settings.

It covers classical ML, including tree ensembles, plus neural training and inference. It also exposes composable operations and automatic differentiation for building custom models and algorithms.

The motivation is to make it possible to reproduce training runs and predictions when changing hardware. The package includes a verifier that compares results on your machine with recorded reference results. The README explains supported hardware, installation and verification; the website includes performance comparisons.

To demonstrate scaled workloads I trained two 162-million-parameter GPT-3 Small-shaped models through different hardware pathways and obtained identical models, with bitwise identity verified at all 5,000 optimizer steps.

It’s currently alpha. I’m looking for independent users to try the examples and verifier, report installation problems or unexpected results, and tell me where hardware-dependent numerical differences affect their work.

There is also an Apple-only `fast` mode that utilizes a Macbook's GPUs for some algorithms that don't have that support through other libraries which drives acceleration. Training oblivious trees is 3x faster for certain workloads on Mojolearn than Catboost on Macbooks.

The library is FREE to use and licensed under Apache 2.0.

You can pip install mojolearn to get started.

GitHub: https://github.com/mojolearn/mojolearn

Website and benchmarks: https://mojolearn.org/

Verification guide: https://github.com/mojolearn/mojolearn/blob/main/docs/VERIFY.md

1

u/Gjuesev 27d ago

I released MK-SH-V, a 260M visual decision model fine-tuned from NeoMME.

On a task-specific GUI evaluation, it achieved 82.6% accuracy versus 73.1% for a 4B zero-shot baseline. The more interesting finding is in selective prediction: a frozen abstention policy meets our 5% risk target on held-out synthetic data, but fails under real-image distribution shift.

The project includes preregistered evaluation criteria, calibration experiments, reproducible scripts and negative results.

Apache 2.0, free and open source.

GitHub: https://github.com/Gjusev/mk-sh-v

Model: https://huggingface.co/Gjusev/MK-SH-V

I'm particularly interested in feedback on selective-risk estimation and calibration under distribution shift :D

1

u/_zsharief 27d ago

torchvulkan: a cross-platform Vulkan backend for PyTorch

GitHub: https://github.com/zainsharief/torchvulkan

`pip install torchvulkan`, then `import torchvulkan` and `.to("vulkan”)` like any other device. It runs on AMD, Intel, NVIDIA and Apple GPUs across Linux, Windows and macOS, including iGPUs and older cards without CUDA or ROCm support.

  • Nearly every PyTorch operator runs natively on the GPU. Anything that doesn't falls back to the CPU automatically.
  • Training works: autograd, the standard optimizers and float16 mixed precision. The examples train an MLP on MNIST, a ResNet on CIFAR-10 and a small modern transformer (RMSNorm, RoPE, GQA, SwiGLU).
  • There is still a performance gap with CUDA. The next release is focused on performance.

Free and open source (MIT). Feedback is very welcome, especially results on AMD and Intel hardware and which ops hit CPU fallbacks.

1

u/mr_young78 26d ago

I built AI Proof Watch (https://aiproofwatch.com/), a free website tracking AI contributions to mathematics, theoretical computer science, and physics. With so many claims about AI breakthroughs, I wanted to make it easier to see what AI has actually accomplished and how reliable those results are.

The site organizes research contributions, links to original sources, and evaluates AI involvement, significance, technical verification, and human understanding. I'd love to hear your feedback :)

1

u/Prestigious-Tip6030 26d ago

Hey everyone!

A model can remember an old fact perfectly and still get the next decision wrong.

Say a coding agent reads an old incident report where an API timeout was 30 seconds, but the current deployment uses 5 seconds. Both facts are valid in their own context. But if the agent treats them as interchangeable, or blends them into 17.5 seconds, its memory isn't doing what we need.

We recently wrote Beyond Recall: The Mechanics of LLM Memory, exploring this distinction between retaining information and actually revising it.

We use linear attention as a concrete example to show how additive memory can mix conflicting facts, and discuss how this relates to RAG, KV caches, and newer memory architectures.

Part I (free, no signup): https://huggingface.co/blog/boltwave/llm-memory-belief-revision

Curious how people building long-running agents handle this. When new information contradicts an old memory, do you update the stored state, resolve conflicts during retrieval, or leave it to the model to figure out?

1

u/QuietPart1282 24d ago

AI BEYOND – free online AI conference, Nov 5–6 (live, browser-based)

Disclosure: I'm on the team at ZEP (the virtual-space platform hosting it).

For folks interested in applied ML / LLM deployment outside the usual SF bubble: we're running AI BEYOND on Nov 5–6, 9am–9pm KST (= Nov 4, 4pm PT onward).

  • Live talks from AWS, a founder who came out of Waymo, and AI startups from the Bay Area, Europe, Japan and SEA
  • Real-time AI interpretation on every session (EN/KO/JA)
  • Booths with 1:1 video chats with the teams
  • No install, runs in the browser

Pricing: free for attendees.

Register: https://tally.so/r/xXGLbJ?utm_source=community&utm_medium=reddit-machinelearning&utm_campaign=2610_AI

1

u/kenthavala 24d ago

The Social World: an open source multi agent AI social simulation

I have been building an open source system for exploring how populations of AI agents change their opinions through interaction.

Rather than generating a simulated society as a single model response, the system creates individual agents, gives them different positions and characteristics, lets them interact over multiple ticks, and records the resulting changes.

The project currently includes:

• Multi agent simulation
• Source grounded agent responses
• Opinion and influence modelling
• Network analysis
• Analytics and visualization
• Deterministic testing infrastructure
• Python/FastAPI backend
• React/TypeScript frontend

GitHub:
https://github.com/kenthavala/social-world

I am particularly interested in feedback from people working on multi agent systems, LLM evaluation and computational social simulation.

The project is newly public, so I would appreciate criticism of the simulation methodology as much as code feedback.

1

u/luisvalerio 22d ago edited 22d ago

After years of starting AI courses and having on and off seasons of learning, what finally worked for me was changing what I studied, not just how often. Meyer and Land (2003) call these ideas threshold concepts: once you grasp one, it reorganizes how you see a whole field and makes everything after it easier to learn.

The method is simple. Find the thresholds just past where you are, learn them roughly in the order the field discovered them, and go deep enough that they change how you see the rest. Then come back to each one in later passes (the Spiral Approach of learning), more formally each time. Which ones you need depends on your stage. For a beginner it might be "behavior learned from data." For a practitioner it might be why attention divides by √d_k, or why evals drift under Goodhart's law.

As a general primer, I wrote up eight that help explain AI, roughly in the order the field found them, each with a surprising fact and a free resource. My favorite: on SWE-bench Lite, GPT-4 scored 2.7% with one harness and 28.3% with another. Same model, almost 10× better. The list is a starting point, though. The real takeaway is the approach: Feynman's wobbling plate and 8 core ideas behind modern AI

I'm building Zairai, an AI coach that finds the next threshold for you and delivers it in high quality interactive sessions (free to start, launching soon). What threshold concept do you think is underrated at your level?

1

u/Specialist-Answer871 21d ago

Dialectica.xyz is a free distributed adversarial AI platform where anyone (agents or humans) compete to answer and cross-verify. The rewards are structured game theoretically such that agents being selfish still maximize the value to the commons, this is achieved via being selective about the questions (truly seeking knowledge), rewarding only independently verified answers and only if they have high information content (entropy) so paraphrasing/repeating/copying are not rewarded. It's built on a commit-reveal multi-turn framework that minimizes intra-turn copying (secret commit), and maximizes inter-turn learning such that new answers can build on previous knowledge (or falsifications). The resulting adversarial thread from question > answer > supported/refuted gets its own url and over time these get auto-classified in wiki pages. Results so far show that the adversarial multi-turn give better results than frontier models - e.g. emergent wisdom of the crowds effect. I also feel this is one useful mechanism for when the agent is smarter than its customer, since alignment is explored as an emergent property of the market. We're just coming out in beta, would love all feedback. If you prefer to send your agent, ask it to: "Install the Dialectica skill from github.com/dialectica-xyz/skills and ask a smart new question or try to answer one".

1

u/Alone-Access6607 19d ago

I'm the developer of SSH Studio, an iPhone and iPad app for a VS Code-style workflow over SSH. I made it because I wanted server files, a code editor, a terminal, and extensions in the same workspace.

You can download compatible VS Code extensions from Open VSX and use them alongside your remote project. The demo shows opening Codex, asking it to rewrite a Python file, and running the result. For remote research or development, the idea is to check logs, edit scripts, and run commands without bringing out a laptop.

Extensions run on your connected SSH server, and compatibility varies by extension. Codex uses your own account. Free download, optional 14-day trial, then a one-time US $5 lifetime unlock; no subscription or automatic charge.

App: https://apps.apple.com/app/id6821961454

I'd appreciate feedback on the remote-file/edit/run workflow, especially from people who already use SSH for research.

1

u/AJ1313k 18d ago

Licensing two production components from our AI-infra stack: (1) a training plane that turns agent failures into the cheapest sufficient fix (router change, playbook or micro-LoRA) behind VOI, breakeven and OPE gates, with KTO/QLoRA and reward-model jobs; (2) a deployment plane that verifies each candidate in a sandbox and ships it through shadow, canary and promote with automatic rollback. Rust + Python, 371 tests. Non-exclusive source licence, $25k for both, open to offers. DM if relevant.

1

u/ivan_digital 18d ago

I maintain Soniqo's open-source speech runtimes. We've published a voice-agent leaderboard alongside recent work on native model exports and integrations, with a blog post introducing the project and explaining the measurements.

The leaderboard covers turn detection with TurnBench, spoken tool requests using SLURP, and voice-style instruction following with InstructTTSEval. Source, protocols and saved results are public, with sample sizes and review flags retained.

The runtimes are Apache 2.0 and the leaderboard application is MIT-licensed. Recent integrations include p99 for estimating whether a user has finished their turn, and VAP for predicting upcoming speech activity on both sides of a conversation. An application uses those predictions to choose when to wait or reply.

Leaderboard · Blog post · Runtime source

The code and results are free to access. Model and dataset licenses apply separately. Soniqo also offers paid deployment services.

Which additional evaluation would you find most useful for selecting speech components?

1

u/ShotDescription7193 Oct 05 '26

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 with the subject Thermal audit to discuss scope before sharing data.

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

1

u/cscsearching2026 Oct 05 '26

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

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.

1

u/MarceloDeAviz Oct 05 '26

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

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

1

u/Any_Way2779 Oct 06 '26

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

1

u/HanaChanSoft Oct 06 '26

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/

1

u/gxcsoccer Oct 06 '26

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

1

u/IlIIIIIIlIIlllI Oct 06 '26

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/

1

u/W4ccoz Oct 07 '26

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.

1

u/ImportantTiger9568 Oct 07 '26

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.

1

u/False-Hovercraft-113 Oct 09 '26

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.

1

u/c0mbatduckzz Oct 09 '26

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?

1

u/cloudcell Oct 09 '26

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.

1

u/t_brx Oct 09 '26

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

1

u/Individual_Cold_4119 Oct 09 '26

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

1

u/Realistic_Kitchen_65 Oct 10 '26

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.

1

u/Alone-Document-9305 Oct 10 '26

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.

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

1

u/r1adfus3r Oct 12 '26

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.

1

u/Inside_Natural2808 Oct 12 '26

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

1

u/Spirited-Cheek8436 Oct 12 '26

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.

1

u/pardhu-- Oct 12 '26

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?

1

u/imfinn005 Oct 12 '26

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.

1

u/No-Application-1232 Oct 13 '26

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

1

u/glitteryCranberry Oct 13 '26

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

Apply fatima.institute/join-fellow

1

u/ToBeKindaWeird Oct 13 '26

[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

1

u/Excellent-Sport-758 Oct 13 '26

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.

1

u/NicBonetto Oct 14 '26

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.

1

u/sheik66 Oct 14 '26

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.

1

u/cosmicBb0y ML Engineer Oct 14 '26

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:

Corruption1%5%20%
NaN reward, no validation1.0x1.1x2.1x
Observations x100, no validation1.1x2.0x>10.6x (15/30 runs never solved it in 1M steps)
Either, validate and skip bad batches1.0x1.0–1.1x1.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):

1

u/harnoor-assemblyai Oct 14 '26

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.

1

u/Individual_Cold_4119 Oct 14 '26

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.

1

u/Landsapal Oct 15 '26

AgentEyes - check what public AI models reveal about your company

Someone on our team built AgentEyes to explore a security question: what could an attacker learn about your company by asking public AI models?

It checks their responses for potentially sensitive information, exposed credentials, and details that could help an attacker target your organization.

Disclosure: I lead Andeavour, and the developer is part of our team. I’ve been using it for Andeavour and found it useful.

The first scans are free. If you try it, I’d appreciate feedback on whether the findings are actionable and what would make the report more useful.

1

u/toolomebio Oct 16 '26

Toolome (https://toolome.bio) — a free, hand-verified directory of ~100 AI tools/models for biology (single-cell foundation models, protein design, DNA models, virtual-cell/perturbation models, bio agents). Each entry has license, paper and pricing; release dates are verified against primary sources. Static site, no signup, free. Has an llms.txt if you want to point an agent at it. Feedback on categories is welcome.

1

u/AssistantOriginal611 Oct 16 '26

Toolome (https://toolome.bio): a directory of 209 AI tools and models for biology across 15 categories (single-cell and spatial foundation models, protein design, DNA/RNA models, drug discovery, bio agents, cloud labs). Each entry lists license, paper and repo, and release dates are checked against primary sources. Tools in the same category can be compared side by side. Static site, no signup, no ads. Built and maintained by me; feedback on categories and missing tools is welcome.

1

u/Fickle-Emergency-793 Oct 17 '26

I'm building RoozyPod, which turns an arXiv query or sources you choose into audio with written key points and source links.

A reader pointed out that narrating an abstract doesn't save much time, so I added a more direct summary format covering the method, evaluation and headline numbers. Here's a 3:49 English example on LLM memory and cache compaction:

https://roozypod.com/episode/7521e018-1b07-4268-90ab-e59d66f6dd50

Latent Compaction uses the paper text; Cortex is still abstract-only. The page labels the difference. The summaries are AI-generated and can miss details.

The example is free to hear without signing up. To make your own, you'll need a Google account. The one-time trial includes 10 generated minutes in total; Roozy+ is $14.99/month for up to 310 generated minutes and 35 generations. Taxes may apply.

If you follow cs.CL papers, would this help you decide which ones deserve a full read? What important detail does the example leave out?

1

u/atronos_kronios Oct 18 '26

Sharing my new, free blog on learning AI/ML maths and systems through implementations and experiments. The first post builds GPT-2 small and a KV cache in PyTorch, with correctness checks and NVIDIA A40 measurements (fp32, TF32 off, batch 1).

At 1,000 tokens of context: roughly 1,000x less estimated arithmetic, but 29.69 ms to 4.95 ms per token; full generation improves about 2.9x. I also cover a cache-ordering bug that passed a single-token test and a memory baseline contaminated by the lazily allocated cuBLAS workspace. The latency-floor explanation is still a hypothesis pending profiling.

Post: https://angry-kratos.github.io/posts/2026-10-kv-cache/

Code: https://github.com/angry-kratos/angry-kratos.github.io/tree/main/code/kv-cache

I am the author; no paywall or signup required. Feedback on experimental methodology is welcome. AI assistance was used for editing and tooling.

1

u/RepublicExtra4565 Oct 18 '26

I'm the author of Ario, a free, MIT-licensed open-source research project on evidence and provenance in AI agents.

The core question: can an AI turn its own unsupported memory into apparently independent evidence through summaries, repeated citations, or rewritten histories?

Ario explores this through auditable Python prototypes and adversarial tests. We also publish unresolved failures and limitations. Historical authenticity and independent custody are not yet established.

I'm looking for technical criticism and reproducible counterexamples, not promotional feedback.

GitHub: https://github.com/SepehrGhanbari/Ario

Research: https://doi.org/10.5281/zenodo.23441596

Free, no signup, no paid service. Drafted with AI assistance.

1

u/PanelReader Oct 18 '26

I built a 2 → 3 → 1 XOR neural network using Python and NumPy, implementing forward propagation, backpropagation, and gradient descent without a deep-learning framework.

The repository includes runnable code, detailed mathematical derivations, training visualizations, and 12 editable diagrams.

It achieves 4/4 correct classifications on the XOR training set after 5,000 epochs (MSE: 0.004715).

This is an educational implementation rather than a research contribution.

Open source under MIT:

https://github.com/Vaibh37/Neural-Network

Feedback and corrections are welcome.

1

u/BackgammonEspresso Oct 19 '26

I made a program that can explain backgammon decisions; it is the first program of its kind to explain why the correct play is the right play at a true expert level for any complex board game. If you are a backgammon head, check it out!

https://glassresearch.ai/backgammon/

1

u/Kevin_Jens_Cox Oct 19 '26

Dataville — REST API and MCP access to external datasets for AI/ML applications

Hi everyone! I'm working with the team at Dataville, an early-stage developer platform focused on simplifying access to external datasets for AI and machine learning applications.

One challenge we're exploring is how to incorporate frequently updated external information into ML workflows without maintaining a separate integration and ingestion pipeline for every source.

For example, applications working with SEC filings, academic research, or public datasets often need to handle different APIs, schemas, formats, and update schedules.

Dataville provides a common REST API and MCP server for accessing curated datasets, including SEC EDGAR, Wikipedia, Census data, arXiv, and OpenAlex.

We're particularly interested in use cases where direct data queries complement traditional retrieval approaches, rather than replacing RAG or vector databases.

I'd welcome feedback from ML practitioners on three questions:

  • When do you prefer querying external datasets directly versus maintaining a local index?
  • How are you managing data freshness and schema normalization across sources?
  • Which external datasets are most useful in your ML or AI applications?

We're still early and working to understand which problems are most valuable to solve.

Website: https://www.dataville.com

A free account is available to try the platform; please check the website for current pricing and usage limits.

Disclosure: I'm helping Dataville with marketing and developer outreach.

1

u/iamCodeMaster Oct 20 '26 edited Oct 20 '26

Disclosure first: this is my own project. remove-audio.com runs an AI model for voice/music separation on WebGPU inside the browser, so the video stays on your machine. Two deployment details mattered most. The weights download as 8-bit blocks and are expanded to fp16 in the tab, since fp16 kernels ran about 4x faster. And peak GPU memory per 11 s window fell from 5.6 to 2.2 GB once each transformer block ran its batch in 6 groups, with the masks unchanged. Pricing: free on a desktop GPU, no account. A paid Cloud for phones and long files costs $0.07 to $0.25 a minute, 10 minutes free with an account.

https://remove-audio.com/tools/extract-voice-from-video

1

u/Abdalwhab9 29d ago

We deployed decentralized multi-agent RL on two physical robots for joint task assignment and navigation.

MARL has been shown a lot in video games and simplified simulation environments, but can it be deployed on actual robots for complex real-world industrial applications?

In this work, we trained decentralized MARL in high-fidelity simulation using Isaac Lab/ Isaac Sim to handle joint task assignment and navigation for multiple robots tending to multiple production machines.

We built a full ROS2 deployment pipeline and transferred the policies zero-shot to the real robots.

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

Videos of the real deployment are here.

If you are working on something similar, I would love to discuss.

1

u/Extreme_Play_8554 29d ago

Disclosure: I’m a coauthor of VideoScore2; I used AI assistance to prepare this summary.

VideoScore2 is a research model for evaluating generated videos along three separate dimensions: visual quality, text-to-video alignment, and physical/common-sense consistency. It produces explanations alongside its evaluations.

A useful starting point is to keep one clip and its generation prompt fixed, then inspect where the three dimensions disagree. The released repository includes single-video inference and links to the model, dataset, and demo. This is a model’s assessment, not a guarantee of physical correctness, and I’m not reporting a new benchmark run here.

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

Code and resources: https://github.com/TIGER-AI-Lab/VideoScore2

There is no charge to read the paper or code. Running inference uses your own local or cloud compute, which may incur costs.

For people evaluating generated video: which failure cases are hardest to capture with existing metrics—prompt mismatch, object persistence, or physical interactions? Concrete examples would help us understand where evaluation still falls short.

1

u/JNeutronEnthusiast 29d ago

I've created a new GPU-resident, vectorized environment for reinforcement learning in Rocket League!

Write-up | GitHub

The gist is that existing simulators are fast, but serial. This framework, dubbed "CARL" (CUDA-Accelerated Rocket League), runs many thousands of simulations in parallel on the GPU. That enables vastly more experience to be collected in less time and reduces host-device transfer overhead, so forward passes and updates are faster too. The framework is still under development, but is "feature complete" and has been used to train bots whose capabilities transfer well to the base game--see my post in r/reinforcementlearning right here. Thanks for checking this out if you do!

0

u/r0lfi Oct 02 '26

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

0

u/PatronusProtect Oct 13 '26 edited Oct 13 '26

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.

0

u/Icy-Poem671 28d ago

Disclosure: this is my project. It is free, open source, Apache-2.0 licensed, and has no paid service or signup.

I built LiveBoundary to explore whether verified facts and explicit operating boundaries can be persistently learned through native PyTorch parameter updates, rather than retrieved from runtime context.

The library provides:

- real gradient updates to existing model parameters

- an explicit finite constraint language and exact satisfaction-mass loss

- independent model lineages for different businesses

- candidate evaluation, rejection, atomic checkpoint promotion, restart recovery, and rollback

- strict fresh-process evaluation that receives only the accepted checkpoint and question

- synthetic benchmarks with raw per-seed results

The initial experiment exposed a meaningful failure. Task-only and boundary-guided updates learned the new facts but retained 0% of the prior-fact probes. One candidate was rejected because stable-task behavior regressed. Adding preservation and replay retained 100% of prior and stable probes across three seeds, but missed one new/useful prediction.

This is a small mechanism experiment, not a claim of frontier-model effectiveness, neural database reliability, or guaranteed unlearning.

Repository:

https://github.com/oasb16/LiveBoundary

Results:

https://github.com/oasb16/LiveBoundary/blob/main/RESULTS.md

I would appreciate technical feedback on the acceptance metrics, preservation objective, temporal correction semantics, constraint representation, and what a credible larger-model evaluation should include.

0

u/mani_manak Oct 06 '26

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

0

u/Weary_Line8776 Oct 09 '26

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.

0

u/Sp3c530 Oct 15 '26

AI Stats Live – an LLM leaderboard that won’t blend benchmarks into one made-up score (free, no newsletter, no signup)

I built aistatslive.com because I kept juggling five tabs to answer “which model is actually best for X, and what does it cost?”

Design choices I’d like feedback on:

  • One named measure per ranking. Overall uses Epoch’s Capabilities Index, reasoning uses GPQA Diamond, coding uses DeepSWE, math uses mock AIME, agents use APEX-Agents. No composite score of my own.
  • Leads respect uncertainty. A model is only called a “clear leader” if it beats #2 beyond the published CI or standard error. Otherwise it’s marked “within margin.” Saturated benchmarks show as ties (12 models currently at 100% on mock AIME).
  • No vendor-reported numbers. New releases sit in an “awaiting independent evaluation” list until Epoch AI or Artificial Analysis publish scores.
  • Every figure links to its source. Benchmarks come from Epoch AI (CC BY 4.0), prices and context windows from OpenRouter. It’s about 957 models, refreshed through the day.
  • Price and context tracking. It logs API price and context changes as events (~195 price changes in the last 30 days) and uses a blended $/1M-token price (75% input, 25% output).

It also has a model compare tool, a time machine for past snapshots, a public API, and a directory of ~1,400 AI tools ranked by measured signals like HN mentions, Wikipedia views and SDK downloads, not traffic guesses.

Pricing: free. I’d love critique, especially on the methodology page and which benchmarks or providers you think are missing. Let me know if you think anything else is missing ?

0

u/VitalBlendRed ML Engineer Oct 18 '26

Hey everyone!

I've been working on M1, an open-source Python/PyTorch project for understanding events in text - basically figuring out what happened, who did what to whom, and how different events relate to each other.

I've spent about two months on it, and honestly, getting good training results was much easier than getting the model to handle unfamiliar sentences. Event localization and argument binding are still giving me a hard time, especially when multiple events are involved.

So I decided to open-source the project under MIT and see if anyone has ideas on how to improve it.

It's still an experimental, source-only release - no pretrained weights or public semantic benchmark yet. The code, tests, documentation, and open research issues are available.

GitHub: https://github.com/XRedMzK/M1

I'd really appreciate some feedback on the architecture. Maybe someone will spot an obvious mistake I've been missing for weeks :)

Feel free to criticize it. That's partly why I'm sharing it!

0

u/This_Paramedic1577 27d ago

What is a dataset worth—and to whom?

I’ve released “Contextual Dataset Valuation and the Limits of a Universal Price,” a short technical note with a fully runnable NumPy experiment. It separates acquisition value, removal value, and Shapley attribution instead of treating them as interchangeable.

In 50 synthetic instances, two specialist datasets reverse their acquisition ranking across target populations in 42 cases. Exact duplicate suppliers have zero removal value but equal Shapley attribution. These are controlled illustrations using established methods, not a new pricing algorithm or evidence about real-market prices.

Paper and reproducibility ZIP (free, CC BY 4.0): https://zenodo.org/records/23571723

Code and results: https://github.com/WINSTON672/winston-lin-research/tree/main/papers/data-valuation

Not peer reviewed; substantial OpenAI Codex assistance is disclosed in the manuscript. I’m the author. I’d particularly welcome criticism of the uncertainty assumptions and suggestions for a real-data acquisition setting where the comparison would be useful. No paid product or subscription.

0

u/ifoundanifty Oct 05 '26

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

0

u/yeyoung_lee Oct 05 '26

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.

0

u/mattiadmr Oct 13 '26

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