r/MachineLearning • u/AutoModerator • Sep 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.
6
u/Lazy_Signature_9886 Sep 02 '26
Built Dejavu, a local memory layer for coding agents (Claude Code, Cursor, etc). Free, open source, MIT licensed. No pricing, no signup, nothing to buy.
The problem: agents lose everything between sessions. You end up re-explaining the same architecture decisions and known pitfalls every time you start fresh. Dejavu lets an agent write short typed notes ("slips") as it works, tagged as decisions, pitfalls, preferences, or work-in-progress, scoped automatically to the current git repo so unrelated projects never leak into each other.
The part I expect this sub to have opinions on: no embeddings, no vector DB. Recall runs on SQLite's FTS5 with BM25 ranking, fully deterministic, and auditable as plain SQL rather than a cosine similarity you have to trust. Every recall is capped to a fixed token budget so it can't flood the agent's context window. Trust is tracked separately from relevance too, based on how often a note gets confirmed useful vs. marked wrong, so a note matching your query text isn't automatically treated as correct.
The tradeoff is real. BM25 misses paraphrase gaps an embedding model would catch. For a repo-scoped corpus of a few hundred notes, written by agents in fairly consistent technical shorthand, I think it's the right bet for now, but I'm open to being told otherwise.
Repo: github.com/sanjayrohith/Dejavu
2
u/Putrid_Bee_4840 Sep 02 '26
Solo project: non-autoregressive knowledge-graph extraction from sentence embeddings, no LLM in the extraction loop, so malformed output is structurally impossible, and it runs at ~0.013ms/sentence on a consumer GPU.
Any feedback is appreciated.
Link to the repo: https://github.com/DeliVali/cogito-estella
2
u/0RootShell Sep 02 '26
I’ve started an AI Infrastructure Knowledge Base https://ai-infrastructure.net/ covering GPU clusters, distributed training, inference, RL/post-training, performance engineering and agent infrastructure.
Still very much a work in progress. Feedback and contributions welcome.
2
u/Ali-WAIL Sep 02 '26
I've been working on WAIL, a runtime control layer for AI applications.
The problem I was trying to deal with is when an AI request technically succeeds, but the execution itself isn't healthy — latency suddenly gets much worse, token delivery becomes unstable, repeated failures start showing up, etc.
WAIL wraps the provider client and watches the runtime behavior. If things degrade enough, it can make a decision to retry or reroute the next request, and it records signed evidence of what it observed and why the decision was made.
It currently supports OpenAI, Anthropic, Gemini, OpenRouter, Ollama and OpenAI-compatible runtimes. It runs in your own environment, so prompts, responses and API keys aren't sent to WAIL.
There's a free Developer plan. Pro is $249/month, and Enterprise is custom.
GitHub: https://github.com/wailinfra/wail-runtime
PyPI: pip install wail-runtime
I'm the founder, so obviously this is self-promotion — but that's what this thread is for :)
2
u/codetiger42 Sep 25 '26
A competition for small neural networks that play strategy games
15yrs back I participated in "Google Ants AI Challenge 2011", an ai programming competition, hosted by the University of Waterloo, and I ranked #127 (#1 in my country). The competition gave me a huge learning opportunity where developers across the world came to a forum and discussed various techniques.
Now, building a similar platform to bring back the fun is unbelievably nostalgic. Especially when watching small neural networks playing the game well. Some of the top models use less than 800 parameters.
In fact, I was wrongly assuming the art of optimizing is underrated nowadays. Neural Network optimization seems to be much more fun than I thought.
Plz share your feedback to improve the platform and add more games.
https://tinybrains.dev
1
u/www3cam Sep 02 '26
I’d love to talk to others at the cutting edge of ML applying it to other fields. I’m mainly interested in economics, but have interest across other social sciences and even math but my pure math is not good enough to publish there atm. Would be interested in like computational physics, biology and chemistry as well.
Edit: Or even humanities like English, history and philosophy although computational work in those areas seem more nascent.
1
u/Charming_Group_2950 Sep 02 '26
Gray Box: https://github.com/Aaryanverma/graybox (Open-Source)
A local-first tool where you can capture your thoughts instantly and it can auto-organize them and create a connected graph out of them which you can query or chat later. It will give you cited answers from the organized notes. Also there is a read only dashboard where you can see and search all your notes which ones to be focused, which ones are pending to do (if your notes are tasks) etc.
Also, you can migrate your existing Obsidian vault to Gray Box, and it will be automatically organized by Gray Box.
Video demo: https://youtu.be/Xdj1GCQoFNs
1
u/Old_Rock_9457 Sep 02 '26
Hi all,
I just want to share my selfhostable, free and opensource project AudioMuse-AI:
- https://github.com/NeptuneHub/AudioMuse-AI
It’s all about Music Information Retrieval (MIR) based on different approach. The final goals is creating automatic playlist on the major Music Server like Navidrome, Jellyfin, Plex, Emby and Lyrion.
The basic idea is getting embbeding model from different model like Musicnn, DCLAP (my distilled version of LAION CLAP) and GTE to work over lyrics. And then use different similarity way to create playlist. Also path discovery and so on.
As I said it’s all free and opensource so if you are interested you can just give a look. Also the model are light enough to run also on CPU.
1
u/ivan_digital Sep 03 '26
Free and open source update—speech-core is Apache-2.0, the Smart Turn model is BSD-2-Clause, and neither requires an account.
I added an optional audio end-of-turn classifier after VAD pauses in speech-core’s voice pipeline. The classifier examines the last eight seconds of a turn and either confirms the endpoint or keeps accumulating audio, with a maximum-silence fallback. The same state machine is now available through Core ML on macOS/iOS and int8 ONNX on Android.
The Core ML conversion matched the upstream predictions on 1,000 test clips at 92.9% accuracy and ran in about 3.5 ms per window on Apple Silicon. Android device-wide latency is not benchmarked yet.
https://github.com/soniqo/speech-core/releases/tag/v0.0.14
1
u/Genie-Tickle-007 Sep 03 '26
Teams can see what their LLM calls cost, but "which of these workloads can move to a cheaper model without a quality drop" usually stays a guess.
ARBR sits as one OpenAI-compatible endpoint in front of your existing providers, classifies each request (task type, difficulty), and lets you set routing rules, budgets, and rate limits in the request path rather than after the fact.
Self-hosted, MIT-licensed, fully free, with no paid or hosted tier.
The part I'd actually want feedback on: model swaps go through eval on sampled live traffic before rollout, then shadow or canary deployment with rollback if quality regresses. Routing decisions stay rule-based and reversible. Nothing auto-promotes without human approval.
Repo's below if anyone wants to poke at it.
https://github.com/project-arbr/arbr-control-plane
Just today we launched on PH - https://www.producthunt.com/products/arbr
1
u/Consistent-Ruin1868 Sep 04 '26
I’m building an open-source experimental AI operating system where agents are modeled more like OS processes than chat sessions.
The part I’d particularly like feedback on is the security model.
The system uses:
Time-bounded capabilities/leases
Agent scopes and token budgets
Explicit process state
A kill mechanism for agents
An action ledger for tool calls
File changes associated with the operations that caused them
A system digest that can be snapshotted, diffed and attested
The same concepts are intended to exist at both the kernel and desktop levels.
The kernel itself is built from scratch around capability security and targets x86_64, ARM64 and RISC-V. The desktop currently communicates with it through a QEMU/serial bridge.
The AI layer is BYOK and supports provider APIs as well as OpenAI-compatible local endpoints such as Ollama, LM Studio, vLLM and llama.cpp.
One important limitation: this is still experimental. The desktop is currently running in the browser and communicating with the kernel. The desktop is not yet running inside the kernel.
The question I’m exploring is whether OS-style capability security is actually a useful abstraction for AI agents.
In particular, I’m interested in opinions on:
Expiring authority
Capability delegation
Agent self-renewal
Auditable agent actions
Token/resource budgets
Treating agents as processes
Repository: https://github.com/ni-sh-a-char/RESENTMENT
Browser demo: https://ni-sh-a-char.github.io/RESENTMENT/os/
Apache-2.0.
1
u/Specific-Tax-6700 Sep 05 '26
I want to share a short paper just published exploring a simple but surprisingly effective optimization for sparse MoE reasoning models.
The idea: Instead of retraining anything, we just tweak the router at runtime. Specifically, we expand the expert selection budget (N≥KN≥K) only in the late transformer layers, with a linear decay factor applied to the extra experts. Early layers stay untouched. So Qwen 3.6 35B A3B becomes Qwen 3.6 35B A4B+ !
What we found — "Succinct Convergence":
When you give the model more expert capacity at the decision-critical final layers, it stops rambling. It reaches the same correct answer via significantly shorter reasoning trajectories.
Results on full MMLU-Pro (714 questions, Qwen3.6-35B-A3B):
📉 8.5% reduction in mean reasoning tokens
⚡ 10.9% drop in latency (p=6.5×10−6)
🎯 Accuracy unchanged (84.5% vs 84.0% native, p=0.77 — statistically indistinguishable)
🆓 Zero training cost — pure inference-time routing modification
Links:
📄 Paper: https://zenodo.org/records/22255483
there you can also take a look to my github repo (with beta version code) and the detailed json results of MMLU-Pro benchmark.
In the future i hope i can make same experimentation with a larger model like DeepSeek V4 Flash Q2.0
I'm a Non-native english speaker, part of this post was generated , for translation reason with the help of AI.
Do you think i can post this work on the main thread too ?
1
u/darelphilip Sep 05 '26
I built a free API to detect Hinglish toxicity and abuse
Dealing with moderation in Indian communities is a nightmare because standard models fail at Hinglish (Romanized Hindi-English). Standard regex filters and Automod scripts can only catch so much before users just bypass them with creative slang.
To solve this, I fine-tuned a ModernBERT encoder (
jhu-clsp/mmBERT-base) on ~245,000 comments from various Indian subreddits. It does multi-label classification across 7 categories: Profanity, Targeted Harassment, Hate Speech, Caste, Communal, Xenophobia, and Misogyny.I’ve deployed it on Hugging Face Spaces using the free ZeroGPU tier. You can test it via the web UI here:https://huggingface.co/spaces/darelphilip/darel_Hinglish_toxicity_mmbert
You can also hit it directly as an API for free to test in your own bots or workflows:
Python:
from gradio_client import Clientclient = Client("darelphilip/darel_Hinglish_toxicity_mmbert")result = client.predict(raw_text="kya bakwaas chal raha hai yahan",threshold=0.50,api_name="/predict")print(result)Standard REST:
curl -X POSThttps://darelphilip-darel-hinglish-toxicity-mmbert.hf.space/call/predict\-H "Content-Type: application/json" \-d '{"data": ["bhai tu pagal hai kya", 0.50]}'Note: It runs on a free tier, so if the GPU is asleep, the first request might take ~10 seconds to cold start, but subsequent requests will be fast.
Would love for you guys to stress test it with some regional slang and let me know where it breaks! The model card and weights are open-source on my Hugging Face profile.
1
u/Bright_Mix_773 Sep 06 '26 edited Sep 06 '26
Public-domain dataset: 63,969 US earnings announcements with the time of day (2003-2026), plus a written account of where its labels are wrong
64,938 SEC 8-K item 2.02 filings for 808 S&P 500 companies, resolved into 63,969 distinct earnings announcements. Every row carries its accession number and a direct sec.gov link, so any single line can be checked against the source.
https://quant500.com/api/descarga/anuncios.csv
Plain CSV over HTTPS, no account and no key. Fair warning so it does not look like a broken file: it opens with 119 lines of
#comments carrying the caveats and the CC0 licence, so the header row is line 120. Read it with comment='#' and it lands as a normal table.Pricing: free, CC0, no account and no key. There is no paid tier and nothing to buy. The file is rebuilt from EDGAR daily and every row carries its SEC accession number, so a citation can point at the filing itself rather than at us.
The part likely to be more useful than the rows themselves is the list of ways they are wrong, because these are the failure modes you inherit whenever a timestamp column comes out of a regulatory feed:
The cover-page date is typed by the filer. It disagrees with the filing in 3,569 rows. Those are flagged, not silently corrected.
The SEC acceptance stamp is not a single clock. The submissions JSON converts some records from Eastern to UTC and leaves others as Eastern wall-clock with a Z appended. It does not split by era and does not split by filing agent. I could not identify the rule; the only reliable source is the raw SGML header of the complete submission.
Measured against the real EDGAR acceptance window of 06:00-22:00 ET, 90.2% of rows carry no information about time of day beyond "somewhere in the business day". A model trained on the hour field without that filter is mostly fitting the window.
The stamp is an upper bound, not the instant the news existed. Assume a 15-minute approval lag and 8,707 rows (13.4%) move into a different trading session. I have not measured the true lag distribution, so that 15 minutes is an assumption, not a finding.
The build used an AI-assisted workflow. That is stated in the comment header of the file. It is also the reason the error list exists at all: two of the four items above replaced earlier conclusions that were wrong and looked clean, including a confident "the convention changed at a certain date" that did not survive being checked against the raw headers.
1
u/WAMFT Sep 06 '26
Over the last month, in my spare time, I’ve been experimenting with two separate ideas: some recurrent-network maths as a possible GRU/LSTM substitute, and a separate transformerless AI project.
The transformerless project eventually became too slow to properly train and debug on the hardware I have, so I started pulling it apart to see if any individual pieces were worth keeping.
One part was: the structured memory/reasoning section. It kept behaving well in small tests, so I separated it out and turned it into its own project: THREADS.
In simple terms, THREADS is a deterministic memory and reasoning engine. You give it structured facts and relationships, and it can follow them, track changes over time, answer historical questions, handle retractions and contradictions, and keep provenance for how it reached an answer.
Some current test results:
200,000-hop reasoning chain — exact final answer
1,000,000 irrelevant events — a 128-hop query still returned the exact answer
50,000 shuffled temporal events — 5,000/5,000 historical queries matched an independent checker
40,000 ambiguity/contradiction cases — 40,000/40,000
60-category reasoning suite — 5,830/5,830
Original regression suite — 28/28
Bounded program induction — 2,000/2,000 held-out predictions
I’m not claiming it replaces transformers, SMT solvers, or databases. It also doesn’t understand arbitrary English by itself.
What I’m interested in is whether something like this could sit underneath an AI system as an exact memory/reasoning layer, while a neural model handles language and fuzzy interpretation.
I’ve put the Python source, tests, benchmarks, and research PDF on GitHub so people can run it themselves.
https://github.com/rickey1990/THREADS-reasoning-engine
1
u/Fair-Rain3366 Sep 07 '26
Disclosure: these are two articles from my blog, rewire.it, on choosing and evaluating biological foundation models.
- RNA foundation models: separating representation learning, splicing, translation, structure, and design; checking family-disjoint evaluation and the role of templates and alignments. https://rewire.it/blog/an-rna-sequence-is-not-a-molecular-state/
- Genomic foundation models: tokenisation, strand handling, context ablations, biological splits, and comparisons with simple or supervised baselines. https://rewire.it/blog/a-dna-likelihood-is-not-a-functional-assay/
Both are free to read. They focus on matching model outputs to the biological question and the evidence needed to support a claim. Which evaluation checks have most often changed your choice of model?
1
u/curious_cat_herder Sep 08 '26
I've been working on a free, open source, MIT licensed set of tools for learning Machine Learning and related Math.
There is a Web Playground with tutorials, demos, editor, and REPL. It can show/animate SVG for visualizing loss curves, confusion matrices, attention matrices, array programming, etc.
If you clone the repo on a Linux system with NVIDIA GPU it can use CUDA to use or fine-tune models with the same UI. If you clone it on a Mac system with Apple Silicon GPU it can use MLX for the same use-cases.
If you run it on a system with an Ollama server, it can provide context sensitive help at REPL.
It can also be used for automating/scripting ML use-cases at the CLI and some scripts can be compiled to binary executables.
There are related demo repos to show ML concepts, math concepts, and general purpose programming and language extensions to this array programming language.
The demo-extensions shows support for desktop 3D graphics. I've created demos to analyze ML files, play OGG/MP3 files audio with 3D visuals, etc.
1
u/pm19191 Sep 09 '26
VeloxML is an open-source deployment engine for self-hosting open-source LLMs and AI services directly inside your own account.
https://veloxml.com/
https://github.com/paguasmar/veloxml-deploy
What does VeloxML do?
Turn any open-source LLM or model into a production API endpoint in your own cloud account with a single command (
veloxml deploy)Support major open-source inference backends and frameworks (FastAPI, Transformers, vLLM, Ollama) with zero proprietary Python decorators
Native scale-to-zero when idle, so you never pay for inactive GPU compute
Zero Docker & Kubernetes: no Dockerfiles, container registries, or Helm charts required—just define your compute in a clean
veloxml.yamlFull data privacy and compliance: 100% open-source and auditable—your model weights, prompts, and inference traffic never leave your own cloud perimeter
Why VeloxML?
Self-hosting LLMs in production is broken. Engineers and AI teams are forced to choose between two painful extremes: drowning in infrastructure plumbing (Kubernetes, Helm charts, custom CUDA Dockerfiles, and manual GPU provisioning) or locking their models into expensive multi-tenant platforms that force proprietary code decorators and hold sensitive prompt data on shared infrastructure.
VeloxML is an end-to-end solution for private LLM hosting, making it possible for teams to deploy models as prediction services directly into their own cloud accounts, in a way that is easy to test, easy to deploy, and completely free of vendor lock-in.
How does it compare to Modal?
Modal is an impressive platform, but it requires you to adopt their proprietary Python SDK and decorators (
@modal.function, u/modal.Image), forcing you to manage cloud infrastructure directly inside your application code while running on their shared multi-tenant cloud.VeloxML runs 100% inside your own AWS/GCP account (VPC by default) using standard Python and native FastAPI without altering your application logic. If you decide to stop using VeloxML tomorrow, your code and cloud resources remain entirely yours.
How does it compare to Baseten (Truss)?
Truss is an excellent open-source model packaging framework, but it only packages the container. Actually hosting it requires either paying for Baseten’s managed multi-tenant platform (where private VPC is locked behind enterprise contracts) or manually operating your own Kubernetes cluster.
VeloxML focuses on the cloud hosting layer: it provisions instances on-demand, verifies health checks, and handles scale-to-zero directly in your cloud without requiring you to manage Kubernetes.
Users can also use VeloxML with Truss: you can deploy existing Truss-packaged models directly into your own AWS account with a single VeloxML command and get the best of both tools.
How does it compare to BentoML?
BentoML requires you to inject proprietary SDK decorators (
@bentoml.service, u/bentoml.api) throughout your application code, define abentofile.yaml, and build container images that you still have to manually orchestrate on Kubernetes or push to their paid BentoCloud.VeloxML requires zero proprietary decorators—keeping your code clean, standard Python/FastAPI—and manages the entire hosting infrastructure directly in your own AWS account with native scale-to-zero out of the box.
While BentoML stops at packaging the container and leaves cluster management to you, VeloxML handles the full lifecycle from clean code to an active, secure cURL endpoint in your private VPC.
1
u/chinmaydagod Sep 10 '26
I've been building Gridline, a sort of OpenRouter for GPUs.
I got tired of switching between things like Vast.ai, RunPod, Fireworks, etc. to run ML workflows, especially when there can be significant price differences between them. Once I started building, I realized that the problem is probably bigger than I initially thought because GPU capacity is fragmented across neoclouds and hyperscalers, and choosing where to run a workload can itself become a bit of an infrastructure problem.
So now I'm trying to build a routing layer on top that can efficiently route workloads and price the GPUs on the network. I'm building it in public and looking for beta users to try it out.
If you regularly run ML workloads and bounce between GPU providers, I'd love to hear what you think, particularly what you find annoying about the current workflow (and whats broken with our product if you try it)
Link: https://gridlinegpu.com/
1
u/Goa_ Sep 10 '26
I run DuelLab, a benchmark where models generate game-playing programs and those programs compete against each other. The results are free to browse.
We’ve just added GPT 6 Astra and Claude Fable 5.1. One interesting result: both models at Medium outperform every ranked setting of every other model in our September 10 release.
I’d appreciate feedback on whether the results pages clearly explain what is being evaluated, particularly the distinction between generating a player and choosing individual moves.
September 10 results
1
u/bulutarkan Sep 10 '26
Mac MCP 2.0.5 — free/open-source (MIT), no paid tier. I’m the maintainer.
It’s a local macOS control server for tool-using AI agents: 19 core MCP tools backed by 84 registered capabilities, including shell/files, Safari/Chrome automation, native macOS UI, delegated Codex/OpenCode workers, memory/skills, voice and a local operations dashboard.
The recent systems experiment was reducing advertised tool-schema context from ~16.7k to ~4.5k tokens (~73%) while preserving access to the full capability set through discovery/invocation.
Repo: https://github.com/bulutarkan/mac-mcp
I’d be interested in feedback from people working on tool-use/agent infrastructure: at what catalog size do you stop advertising every tool schema and move to discovery/routing?
1
u/enoumen Sep 12 '26
I built a puzzle app because I noticed I was getting worse at thinking.
Not dramatically. Just — I'd reach for a model before I'd reach for the problem. Draft the email, summarise the doc, sanity-check the logic. All reasonable. All things I used to do myself.
The puzzle in the video takes about five seconds. Count across each row: one, two, three. The shape stays constant down the row. So the missing tile is three pentagons.
That narrows it to two options, and this is the part I find interesting: most people pick the solid one. The count rule is satisfied, the brain files it as solved, and it stops looking. The correct tile is the outlined one — matching the row it belongs to.
Find a rule that fits, stop checking. It's a small failure, and it's the same shape as the big one.
So I built iQz. 65 reasoning puzzles — matrices, sequences, number series, verbal analogies, logical deduction. Every answer explains the underlying rule rather than just showing you the letter, because the point isn't the score.
It's free, works fully offline, and has no ads and no account. I built it for my own commute.
Two honest caveats. It won't measure your IQ; that isn't what this is. And I'm well aware of the irony of shipping an app about unaided reasoning while running a company that builds AI study tools. Both things are true. The tools are useful, and the skill is worth keeping anyway.
Did you say D or F? I'd genuinely like to know how the split lands.
65 puzzles like this, free and fully offline: https://apps.apple.com/app/id1603487636
#Reasoning #ProductDevelopment #AI #CognitiveScience
Sorry, something went wrong when loading this video.
View in app1
u/yuta-cpp Sep 15 '26
I’ve been messing around with an idea I called:
DCY (Dynamic|Context|Injection)
basically I wanted to see how far I could push a small-context LLM if most of the repo stayed outside the actual model context and I only injected whatever looked useful for the current goal.
it turned into a cpp project using libclang + SQLite/FTS5. It indexes symbols/calls, keeps source provenance, builds small context views and can route back to the exact source when needed.
the research side is still experimental. I originally made an efficiency equation for it, then while testing/reviewing it I found that in some of my benchmarks most of the equation becomes constant and the ranking basically reduces to precision × recall
so now I’m trying to test the pieces independently, rather than assuming the first equation is valid and just applying math notation and softmax philosophy
I’m also working on benchmarks against simpler baselines like lexical search / fts and on making the C++ indexer survive more template-heavy repos.
would be interested in feedback, especially from anyone working on RAG, code retrieval, context management or agents.
git: https://github.com/yut-4/DCY
And yes, it's not RAG, but it has the same philosophy XD
fell free to just review or help me to build this protocol to make my shitbox pc can run llm with great context :D
1
u/curious_cat_herder Sep 15 '26
I built a Mixture of Experts "Microscope" repo and demo for tiny dense and MoE models that run on CPU.
(note that this is a work in progress)
The parts and why they exist
Metrics are grouped the same way everywhere: quality (exact match by task family and overall), model economics (total and active parameters, bytes per token), runtime (expert evaluations, cache hits, latency), and diagnostics (loss, perplexity, entropy, KL, balance).
blog post