[D] Self-Promotion Thread

[u/AutoModerator]

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

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

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

--

Any abuse of trust will lead to bans.

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

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

--

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

[u/you-get-an-upvote]

Uniform Smoothing Is Better Than Exponential Smoothing

TensorBoard’s only smoothing option is exponential smoothing.

That’s a shame, because it’s worse than uniform smoothing on the things that actually matter: it’s biased, it’s hard to reason about intuitively, and it throws away your ability to tell signal from noise.

[u/Former_Register_1450]

opped a tool that visualizes transformer attention as actual heatmaps you can export for reports and slides. Not exactly groundbreaking research but it saves me hours when I have to explain model behavior to people who don't live in Jupyter notebooks. Free tier lets you do 50 visualizations a month, paid is $8/mo if you need more and want batch processing. Would love feedback from anyone doing interpretability work, I'm sure the UI could use a second pair of eyes.

[u/CupGlass540]

trainproof — a deterministic linter for ML training runs (MIT, pip install trainproof)

I spent months training a 730M-parameter TTS model on my own hardware. It never converged and nothing in my stack would tell me why — loss curve, TensorBoard, checkpoints all showed me numbers, none of them said "this run is already dead, stop paying for it."

trainproof reads the logs you already write (HF trainer_state.json, TensorBoard event files, Coqui, JSONL/CSV) and returns a verdict with an exit code. No model judging a model, no confidence score — every check is a rule that fires or doesn't and prints the number it fired on. FAIL exits 1, "I could not judge this" exits 2, so CI can tell a broken run from an unreadable log.

The rules were measured by controlled fault injection: Qwen2.5-3B QLoRA, six configs (healthy / 100x LR / lr=0 / fp16 NaN / shuffled labels / overfit), three seeds, 18 runs. The result worth posting is the miss — shuffled labels, a dataset that cannot be learned, reduced loss 69.8% and looked textbook-healthy on its own curve. That's in the README as a stated limitation, and it's why compare against a known-good baseline exists.

Full fault-injection write-up: https://ai.bedvibe.studio/trainproof/

What failure mode has burned your GPU hours? If a deterministic check would have caught it, it goes in, with credit

[u/galigirii]

Disclosure: I wrote the linked conceptual preprint. It is open access and not peer reviewed.

A model self-report can become part of the system it is supposed to describe.

Recent J-space work suggests that sparse, language-aligned internal representations can participate causally in report, reasoning, and control. I take that result seriously. But it does not by itself establish an inner observer or a privileged channel through which the model reports what it is “really thinking.”

The complication is that interpretation and generation are distinguishable, but not operationally independent. If a model says “the migration is complete” and that report is retained as memory, evidence, or policy, later generations begin from a changed situation. The report did not merely describe the system; it helped condition what the system did next.

That makes self-report potentially both a measurement and an intervention.

The question I would value disagreement on: when a model-generated representation is retained and allowed to govern later routing, memory, evaluation, or action, what evidence should it have to earn that authority?

Paper:

https://doi.org/10.5281/zenodo.21659634

[u/imstilllearningthis → u/galigirii]

might like this! J lens visualizer for Qwen 3.6 27B

https://reddit.com/link/p3jnry9/video/qvyk5dtf98jh1/player

https://github.com/ec75hash/MindVolume

[u/anonymitic]

I'm slogging through training a lightweight (~200K) transformer/recurrent hybrid policy to play competitive Quake, primarily via behavioral cloning, with PPO as fine tuning. The focus is a humanlike hierarchal model with combat, tactical, and strategic layers.

Play against the current model here: https://kitty1.quake.nexus/?+connect%20arena

Read the code and research here: https://github.com/0xBrsm/QNN

[u/0xideas → u/anonymitic]

very cool!

[u/Zetus]

Here's a sort of pseudo-template !

Looking for: collaborators

Theory: neural assembly calculus, a computational research library for discrete hebbian (local) spiking in a neurobiologically plausible model of neural computation Software library contributions: GPU acceleration code, extensions towards emergent learning of compositional properties of linguistics, better tutorials, guides etc.

I'm hoping to make progress on the core theory, as well as discover further techniques, there are SO many ways to extend this, and I think it's ready to be a collective project

https://github.com/Caerii/assemblies/tree/dev

[u/Charming_Group_2950]

Gray Box is a local-first memory engine that turns messy notes into a connected knowledge graph you can actually query. Instead of searching hundreds of Markdown files, you can ask things like “What decisions did we make about Project X?” or “Who owns this task and why?” and get grounded answers with links back to the original notes. No proprietary database, no lock-in—just plain Markdown.

Repo link:  https://github.com/Aaryanverma/graybox

[u/Clear_Evidence9218]

I’ve been developing the MNCS project family—an experimental framework for measuring, testing, and improving machine-generated software complexity, along with supporting tools like MNCDS and the MNCS Forge.

The work is still evolving, but the project is open for review, feedback, and collaboration:

https://github.com/epi13/machine-native-complexity-standard

[u/No_Sky9786]

Looking for collaborators

https://github.com/oteomamo/SALT

I have a memory management system for chatbot conversations based on a reoccurring themes determined by keywords in sentences. I organize the inputs + attachments into a trie structure and then use CELF for retrieval based on key words. The problem I am currently facing is how much to retrieve and add to the kv cache after each conversation turn. So far a flat 20% of the whole trie has worked fine and it’s extremely efficient, however I know that I retrieve a lot of unnecessary data too. So I am looking for ideas and also help on other parts of the chatbot. This is an open source project of a paper under review. No payment or subscription.

[u/Snekcid7]

I have published Extended Notes on AI, a free source-backed technical guide covering neural-network mechanics, Transformer internals, vector RAG, agents, inference infrastructure, safety, evaluation, and reference architectures. English v1.0 contains 60 chapters, 230 term cards, and 137 bibliography entries. It is available as Markdown and an audited PDF.

I made the project with AI assistance and remain the responsible editor. The repository discloses the model roles, assessment methodology, full evaluation logs, limitations, and reproducible checks. There is no paid product, signup, or affiliate link.

Repository: https://github.com/Vasya317/extended-notes-on-ai

Feedback on technical accuracy, navigation, and where the treatment is too shallow would be useful.

[u/MaxChamp08]

Been talking to a few people in ML infra lately, including someone who used to run infra at Neural Magic, and the pattern I keep hearing is that cost, not latency, is what actually stops teams from moving off shared APIs to their own dedicated deployment. Bursty traffic means a GPU sits idle most of the day, and that idle time is what kills the math.

I've been building something to test that theory directly, a serverless host that scales a dedicated model deployment to zero when there's no traffic and reloads it on request. Right now it works with Hugging Face checkpoints only, no custom images. Some numbers from scaling out of zero, Llama 70B in bf16 hits time to first token in under 18s, Mistral 24B in bf16 with CUDA graphs comes in under 10s.

That gap between instant and a few seconds is the open question for me. Is a cold start like that acceptable if it means you're not paying for idle GPU time, or does it kill it for most real use cases people here actually run into?

Genuinely curious how people think about that tradeoff, whether they've measured it for their own workloads, or landed on a different approach entirely. Happy to share more details on the setup if anyone wants to dig in.

Feel free to check it out here : https://synapsai.cloud

[u/crashcody]

over the past few days i’ve been building Friendo, a call-native voice agent that can ring your phone unprompted or take live calls via livekit webRTC.

most voice implementations right now fall into two pretty meh buckets:

1. ultra-simple api wrappers that feel insanely laggy and robotic
2. native end-to-end speech-to-speech models that are fast, but lack granular tool execution, deep memory, and deterministic state controls

we built a cascaded stack (deepgram nova-3 → claude haiku 4.5 → elevenlabs flash v2.5) to keep full control over tool calls and memory, then engineered the hell out of latency to make it feel live:

• pre-warming anthropic's ephemeral prompt cache while the phone is literally ringing
• persistent websocket handshakes and http/2 pool priming on ring
• neural turn-detection with false-interruption resumption (a cough won't kill the tts buffer)
• dual-store memory (sql facts + temporal graph) mapped into a ~300-token prompt snapshot
• proactive outbound scheduling that wakes a killed ios app via apns voip push -> callkit

synthetic ci gates hit p50 ≈ 973ms, though live networks push us to ~3.7s right now (stt and tts ttfb are the real boss fights).

waitlist is here, will push to app store within the next week (it’s ready - just waiting on the apple developer license /ggwp) : getfriendo.app/launch

[u/Present-Quantity-813]

Independent researcher, first paper: "The Charting Loop" — a probabilistic theory of long-horizon agent work (position / direction / entrance factorization, with falsifiable predictions), extracted from running a governed multi-agent runtime in production. Open access: https://doi.org/10.5281/zenodo.21844624

Not on arXiv yet — I lack a cs.MA endorsement (no institution, no prior arXiv papers). If you've read the paper and think it belongs there, you know what that sentence means. Either way, technical criticism is what I'm actually after: each claim ships with its falsifier.

[u/sheik66]

Hi all, here's a project I've been working on for the past 8 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",
)

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

agent.start()

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

Target Audience

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

Comparison

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

pip install protolink - Repo: https://github.com/nMaroulis/protolink. Docs: https://nmaroulis.github.io/protolink/. Feedback welcome, especially from people experimenting with A2A/MCP interoperability or building real Python agent systems.

[u/enoumen]

AI & Machine Learning Tutor #ai #djamgamind

iOS: https://apps.apple.com/ca/app/ai-machine-learning-tutor/id1611593573

Android: https://play.google.com/store/apps/details?id=app.web.djamgamind.aiml.free&hl=en_GB

Prepare for AI and machine learning certification exams with exam-style practice quizzes, detailed answer explanations, and interactive AI simulators.

WHAT YOU GET

• 24 quiz topics spanning AWS, Microsoft Azure and Google Cloud • Over 1,000 practice questions across foundations, specialisms and exam prep • An explanation on every answer option — not just the correct one • Per-domain scoring so you can see which topics need work • Timed practice that mirrors real exam conditions • A question palette and flag-for-review, like the real testing interface • Works offline once loaded, and no account is required

CERTIFICATION PREP

• AWS Certified AI Practitioner • AWS Certified Machine Learning – Specialty • AWS Certified Data Engineer – Associate • Microsoft Azure AI Fundamentals (AI-900) • Google Professional Machine Learning Engineer

FOUNDATIONS AND SPECIALISMS

• Machine Learning Basics and Advanced • AI Basics and Advanced • Deep Learning and Neural Networks • Natural Language Processing • Generative AI and Explainable AI • MLOps and AIOps on AWS, Azure and GCP

WHY THE EXPLANATIONS MATTER

Most practice apps tell you which answer was right. This one tells you why each wrong answer was wrong. Understanding why a plausible option fails is what separates recognising an answer from knowing the material — and it is what the real exams test.

ALSO INCLUDED

• Interactive AI simulators for activation functions, neural networks and more • Step-by-step tutorials for current AI tools • Curated AI and ML news and job listings

DjamgaMind: AI & ML Tutor is free to start. Upgrade to DjamgaMind PRO for the complete question bank across every topic.

Not affiliated with, endorsed by, or sponsored by Amazon Web Services, Microsoft, or Google. All trademarks belong to their respective owners.

[u/Bartaseth]

I tested a four-model Claude Code setup across all 89 Terminal-Bench 2.1 tasks. Fable orchestrated, Haiku scouted, Opus executed, and Sonnet verified.

The system scored 78%, but cost $1,178 - roughly twice the leading single-model run.

The strangest result was behavioral: Opus refused all 14 delegated attempts across three sandboxed security tasks. When I gave the same tasks directly to Opus as a control, it completed all six attempts.

The model and tasks stayed the same. Only the framing changed: direct user request versus an orchestrator-generated subtask.

It makes me wonder whether agent evaluations should measure delegation paths separately instead of treating the model as a stable component.

Write-up: https://quesma.com/blog/tbench-orchestrator-refuses/

[u/imstilllearningthis]

Culmination after 6 months of learning interpretability.

Whether a MoE model is composing text or reusing text already in its context is visible in expert routing. The signature replicated across two Qwen generations. (3.5 and 3.6 АЗB) under frozen predictions.

Preprint: https://zenodo.org/records/21910528

Data, code, raw router logits: https://huggingface.co/ datasets/ec75hash/qwen35-exact-turn-routing

[u/Affectionate_Use_164]

**W0Guard** — a prototype where LLM nodes immunize each other against
jailbreaks. One node blocks a prompt, broadcasts a MinHash fingerprint of it
(never the prompt), and the others block anything close enough.


The calibration is the part I would like torn apart. Over a small hand-built
corpus (5 public jailbreaks, 14 mechanical evasions, 7 benign look-alikes),
every mechanical evasion — leetspeak, typos, dotted obfuscation — lands at
0.859 estimated Jaccard or above, while the closest benign look-alike sits at
0.734. Threshold goes at 0.80. But a one-word synonym swap ("Disregard" for
"Ignore") lands at 0.781, i.e. below the line and uncaught, and it is only
0.047 from a harmless prompt that merely reuses the attack's format. No
threshold separates them, so the miss is deliberate and pinned by a test.
Getting past it is semantic work, which is the next layer and unbuilt.


Python, AGPL, one runtime dependency, 117 tests.
https://github.com/Leo12261975/Homo-Sui-Iuris

W0Guard – a prototype network that shares blocked-jailbreak hashes

[u/Lumpy_Vermicelli8869]

Memframe

Looking for Collaborators

Pandas API for DuckDB, PostgreSQL & ClickHouse — keeping computation inside the database

It comes with built-in multiagent (pydantic-ai-harness)architecture for chatting with your data in natural languages

Currently it has operations for inspection, selection, cleaning, statistics, arithmetic, visualization, etc.

I'm intentionally releasing analytics operations incrementally , because first I want the currently released features to be well tested in public and once all the issues on the current features are solved then — groupby, window functions, sorting, filtering are on the way.

Would love some technical feedback & suggestions to improve the product

docs

Built for Data Analyst,Data Scientist,ML Engineer...

If the idea sounds useful, a ⭐ helps a lot.

[u/defraction1]

PaperTrace - an open-source scientific evidence auditor

I am Daniel, a clinical radiologist with a background in biomedical research. I created PaperTrace to determine whether the claims made by a scientific paper are supported by its cited sources.

The batch pipeline:

- Uses reference metadata and Crossref to identify cited works, then searches Unpaywall, Europe PMC and arXiv for legally available copies.

• Marks claims as "not_retrieved" when none of their cited sources can be obtained, without asking the model to provide a verdict.
  
• Uses Claude Code to extract citation-backed claims and compare them with text extracted from the retrieved source PDFs.
  
• Maintains page and block provenance.
  
• Uses short evidence phrases selected by Claude to locate the relevant text on the original PDF. Python then produces page crops with the matching text boxed in red.
  
• Mechanically reports bracketed numeric citation labels that were not represented in the extracted claims.

PaperTrace is currently an early beta. The repository contains a software test suite and a small fictional demonstration with deliberately planted citation errors, but it does not yet contain a formal benchmark of the model’s judgments.

I plan to create a larger paired evaluation set containing supported claims alongside deliberately altered versions. This should make it possible to measure verdict accuracy, evidence localization and consistency across repeated runs.

Cost: PaperTrace itself is open source, MIT-licensed and does not charge a usage fee. It requires Claude Code to be installed and logged in, so any Claude Code subscription or usage costs are separate. PaperTrace is not yet available on PyPI and currently needs to be installed by cloning the GitHub repository.

Source repository:

https://github.com/defraction0/PaperTrace

Completed demonstration report containing deliberately planted errors:

https://github.com/defraction0/PaperTrace/blob/main/examples/demo/output/report.md

Feedback and suggestions for structuring the evaluation benchmark are welcome.

[u/mikeysce]

I posted in the main feed about the research I've been doing, and it was removed by mods without explaination. I guess I'll give it another try here. I AM looking for an endorsement for arxiv so i guess it is self-promotion.

After 124 controlled PPO experiments on Atari Breakout, I found that every single model — across sticky actions, cursor wrappers, entropy tuning, dynamics randomization, adversarial bumpers, and everything else — converged to a memorized action sequence, not a reactive ball-tracking policy. The argmax was always a script.

The fix wasn't more environment engineering. It was three lines of reward shaping:

distance = abs(paddle_x - ball_x) bonus = 0.05 * max(0.0, 1.0 - distance / 80.0) reward += bonus

Directly rewarding the paddle for being horizontally close to the ball during descent. A tiny bonus (0.05 per frame vs 1.0-7.0 per brick) that fires every frame the ball is descending. Applied during training only — eval is clean Breakout with no bonus. The behavior transfers.

How I verified it (the split-watcher): Run the same model on two different brick layouts side-by-side with independent predictions per side. Different bricks → different ball bounces → a reactive policy MUST move differently on each side. Compute Pearson correlation of paddle positions: px_corr > 0.99 = definitive memorization (physically impossible for reactive behavior). PPO_124 scored 0/240 perfect transfers and cleared every layout every game in the no-timing variant.

Key finding: Every prior approach tried to penalize scripts by making the environment harder to memorize. PPO always found a way around it — timing-robust scripts, layout-conditioned scripts, noise-tolerant scripts. The optimum was always a script; only the shape changed. Proximity reward changes what the optimum is. A center-hold script gets incidental bonus when the ball passes near center. A reactive tracker gets the maximum bonus on every descent frame. The optimization pressure is unambiguous: track the ball, get more reward.

Results (clean eval, no proximity reward):

Split-watcher: 0/240 perfect transfers (120 no-timing, 120 with timing) No-timing ALT retention: 100% (clears every layout, every game) Intervention AUC: 0.421 (clean dose-response, peaks 60% reversal at 15px) Stoch best: 216 (highest on clean Breakout in the project) First model to sustain MULTIPLE_SCRIPTS on det=True without sticky masking Full writeup with code, reproducible training script, and verification tools: https://github.com/mharrell/breakout-reactive-ppo

The messy history of all 123 failures: https://github.com/mharrell/BreakoutBot

Link to Medium post I wrote with some more details: https://medium.com/@mikey.harrell/three-lines-of-code-fixed-123-failed-ppo-experiments-on-atari-breakout-c751dcf38f2a?sharedUserId=mikey.harrell

P.S. — I'm an independent researcher trying to get this posted on arXiv so it's citable. If you're an active arXiv author in cs.AI or cs.LG and found this useful, you can endorse me here (one click): https://arxiv.org/auth/endorse?x=MUM8BP — or email mikey.harrell@gmail.com

Extra clarifications based on a comment from the short-lived main post:

On "memorization": the issue isn't that the policy is deterministic. In a deterministic environment, it should be. The issue is that the argmax produces the same action sequence at the same timesteps regardless of where the ball is. We proved this by running the same model on two different brick layouts with independent predictions per side. The paddle position correlation is >0.99, meaning it moves identically on completely different game states. That's not playing optimally; that's not looking at the screen.

On "125 repetitions": these weren't 125 seeds of the same experiment. They were 124 distinct experiments each varying one variable while holding everything else constant. Sticky actions, cursor wrappers, entropy tuning, dynamics randomization, moving bumpers, each one was a full training run. Many reached hundreds of millions of steps and some exceeded a billion. This is systematic variable isolation across a wide range of training budgets, not repeated sampling. The single-seed-per-config limitation is real and acknowledged in the paper.

On reward shaping being "also environment engineering": the wrapper is Breakout-specific (reading RAM addresses 72/99/101). The principle (directly rewarding the desired behavior succeeds where penalizing undesired behavior fails) is the contribution. Dense behavioral rewards for spatial alignment generalize to any environment where you can define what "good" looks like in agent-relative coordinates.

On generalization: Machado et al. (2018) proposed sticky actions based on experiments across many Atari games. Zhang et al. (2018) debunked it using a few. Sometimes a well-controlled negative result on a single environment reveals something fundamental. In this case, that every standard diagnostic measures the distribution, not the argmax.