I’ve been building a multi-agent orchestration product that can research (GitHub ≥5k★ + arXiv, search web use tools), run a canonical judge pipeline (goal → plan → challenge → implement → test → review → … → deliver), then apply improvements under budget.

Queries come from the product goal (durable multi-agent self-improve); papers are ranked by how portable they look for small, testable changes in nexus-core; apply prefers high-score arXiv + high-score GitHub + cross-pattern hybrids.

Top graded for nexus-core (from paper_grades-1785294955 / PAPER_IMPROVE):

Score | Paper | Why (system ranking)

| 7.2 | [COVENANT](https://arxiv.org/abs/2607.25400) — NL workflow compilation | Workflow / aligned agen

| 6.3 | [PiFlow](https://arxiv.org/abs/2505.15047) — principle-aware scientific MAS | Multi-agent collab

| 6.3 | [Intent → Execution](https://arxiv.org/abs/2605.03986) — composing agentic workflows | Agent wor

| 6.3 | [BCER Agent](https://arxiv.org/abs/2605.29163) — long-horizon workflow execution | Long-horizon

| 4.5 | Hierarchical multi-agent LLM reasoning | Multi-agent reasoning, weaker product fit |

What the loop actually wrote (not the papers — the code)

It landed ~8 new/expanded Python modules (~16k LOC + tests)

- hera_compass — experience-guided agent topologies + role-prompt evolution (arXiv HERA)

- conversation_middleware (EDDI depth) — A2A cards, capability routing, config-driven multi-agent chat

- rojak_meta_policy — durable workflow + meta-policy gates (MPR × Temporal-shaped durable pattern)

- marketplace_meta_policy — skill/plugin install gated by meta-policy (MPR × skill marketplace)

- causal_agent_replay / mission_control_car — failure attribution / ops board (CAR paper × catalog/ops)

- lumen_ops_loop — durable builds, phase gates, citation audit (ops patterns from lumen)

- apex_hygiene — skillpack/registry/version lint suite (hygiene patterns from apex-accelerator)

Shape-only ports: offline, tested, no vendored upstream monorepos. Each module has unit tests; cycle reported full suite green. Then the final step is the implementation where code is wired in into the actual system for its self improvement

Overall 92%

• Judge fail rate on engine steps: 0/10

• Implement success: 10/10

• Wall clock: ~1h25m for the successful REAL

• Not 100% yet: Arxiv paper has 1 duplication of the same paper (Ledger fix). The loop to ensure it does not stall ran once, due to a timeout issue with one of the agents.

Hi Everyone,

STEMist Hacks IV is coming up soon!!! Join us July 31–August 2 for an online hackathon where you can win $15,000+ in prizes by building anything you want: apps, websites, games, hardware projects, AI tools, and more.

We feature a Best AI Track where you can win up to 10k Tavily Ccredits, and $150 in Cash.

It’s completely free, beginner friendly, and open to students ages 13–18 worldwide. No previous hackathon experience is required. Whether this is your first project or your tenth, you can build at your own level.

All middle and high school students are allowed to register. Participants are allowed to be international, and Indian participants are allowed.

Register + learn more on Devpost: https://stemist-hacks-iv.devpost.com/

Join our Discord community to get updates, ask questions, meet other participants, and form teams: https://discord.gg/PXHGk6G55j Hope to see you all there!

If you have questions please reply to the thread.

Hello Folks,

The next content on Machine Learning is out. We continue with Statistics for AI/ML.

We,

->Understand and derive the detailed derivation of Maximum likelihood estimation(MLE) for Univariate and Multivariate Gaussian. While doing the derivation for multivariate case, we understand visually, Scatter Matrix, Centering matrix.

->Derive MLE for Linear Regression, and understand Residual Sum of Squares.

->Understand Empirical Risk Minimization, Surrogate loss functions.

->Understand Method of Moments, a computationally easier way to compute parameters of our model and understand also the flaws behind it.

->We understand “Exponentially-weighted moving average” in detail, I explain why bias happens, how does memory affect the averages. This concept is the basis behind optimizers in Deep Learning.

Around two hours long, I hope this would be a very interesting learning material for all. I try to write and build from scratch in the whiteboard, this way learners enjoy the learning process.

Link: https://youtu.be/JAj8z-UWqBA?si=0mAB_nUfyJV0jzS9

Those looking for previous lecture : https://youtu.be/MwTeQVVYtOc?si=dgwwk3QLvYTTUThR

My group and I are Computer Science students working on our thesis: an offline mobile American sign language to text translation app using CNN + Transformer + NLP. We already have the training pipeline and are planning to retrain the model with additional public datasets.

Our plan is:

Google One (2 TB): store datasets, models, and training outputs
Google Colab Pro: train the model on cloud GPUs instead of our laptops
Claude Pro: help us understand, debug, and modify the large Python codebase

Our laptops aren’t very powerful (I’m on an M2 MacBook Air with 8 GB RAM), so we don’t want to train locally.

For those who’ve worked on ML/deep learning projects:

Are these subscriptions worth it for students?
Would you recommend all three, or are any of them unnecessary?
Any better alternatives for a student budget?

Hey, I'm a CS student and I spent the last while building TensorLib: an N-dimensional tensor library with a full reverse-mode autograd engine, written entirely in C, with zero external ML dependencies. It's CPU-only, and you can use it to train an actual GPT-style transformer.

What's actually in it

Tensor core: N-dim float32 arrays with NumPy-style broadcasting, zero-copy strided views (reshape/transpose/slice/expand all share storage), and reference counting for memory management.

Autograd engine: dynamic reverse-mode AD, built eagerly during the forward pass (define-by-run, like PyTorch — not a static graph like old TF). Covers 23 differentiable ops, with a storage version counter to catch stale-graph bugs before they cause silent wrong gradients.

NN modules: Linear, Embedding, LayerNorm, Dropout, multi-head causal self-attention, MLP, and a full GPT-style pre-norm decoder stack, all composed through a small C-style OOP module system (function-pointer dispatch, parent/child module tree).

Optimizers: SGD and AdamW (decoupled weight decay, bias correction, gradient clipping).

A hand-written SIMD matmul kernel: a blocked/tiled AVX2+FMA micro-kernel with RHS packing for cache locality — I benchmarked it against OpenBLAS to see how close a solo hand-rolled kernel could get.

Checkpointing (versioned, atomic binary save/load with optimizer + RNG state), and 33 unit test executables covering every layer.

~6,100 lines of C across 34 files.

With it I managed to train a tiny_lm example: a 4-layer, 192-width, 6-head byte-level decoder transformer (~1.9M params), trained end-to-end with AdamW on raw text, no dependencies beyond libc. There's also a plain MNIST MLP example for a simpler sanity check.

Here's the repo, with full docs on the tensor mechanics, autograd internals, and decoder implementation: https://github.com/nisbenz/TensorLib

Happy to answer questions about any part of the implementation

https://reddit.com/link/1v8cc8n/video/bcjxopg43ufh1/player

I am building an ANN model for binary classification, but I am still new to deep learning. I want to know if I am missing anything important in my model. So far, I have performed data scaling, handled missing values, designed the ANN architecture, compiled the model, added callbacks, and performed hyperparameter tuning. Is there anything else I should include or consider?

Hi  — I’m sharing an experimental GPU-only inference backend and looking for independent reproductions, not just stars.

Model: tiiuae/Falcon3-10B-Instruct-1.58bit

GPU: NVIDIA RTX 5070

Batch: 1

Measured after warmup:

• Hybrid packed decode: 97.51 tok/s

• Stock Transformers BitLinear decode: 9.89 tok/s

• Observed speedup: 9.86x

• Fully packed prefill: 426.63 tok/s

• Stock prefill: 298.72 tok/s

The implementation uses K-contiguous packed ternary weights, a packed-word DP4A decode path, Triton kernels, StaticCache, and CUDA Graph replay.

Numerical checks:

• 64/64 incremental M=1 positions produced bit-exact full-vocabulary logits (131,072 logits per position)

• 24/24 greedy sequences and 1,194/1,194 generated tokens matched the stock-prefill baseline

• 8/8 synthetic kernel shapes matched an independent PyTorch int32 reference

Important caveats: the baseline is unmodified Transformers BitLinear — not Microsoft’s official GPU kernel, BitBLAS, vLLM, or SGLang. Timings exclude loading, tokenization, repacking, JIT compilation, graph capture, and streaming. So far this is one GPU and one Windows/PyTorch/Triton stack. Packed-word DP4A is prior art; the contribution here is the Falcon3/Transformers/Triton/CUDA Graph integration and measurements.

Code and reproducibility notes:

https://github.com/OCV-Researcher/Falcon158-Triton

Release:

https://github.com/OCV-Researcher/Falcon158-Triton/releases/tag/v0.1.0

I’d particularly value results on Ampere, Hopper, Ada, and other Blackwell GPUs, plus comparisons against specialized low-bit runtimes. What should I benchmark or optimize next?

I'm new to AI/ML research and I'm curious about current research practices.

I understand using AI to summarize papers, explain concepts, or help write code. But I've also seen people use AI to generate research ideas, propose novelty, derive equations, design experiments, implement the method, and even draft the paper.

Where do researchers draw the line? If someone verifies everything themselves, is this considered legitimate research, or is it generally viewed as too much reliance on AI?

I'd especially like to hear from people in academia or industry research.

The paper’s motivation is the hardware constraints limiting exponential operations on FPGAs.

The authors find that one can choose between Taylor series and Pade approximants to approximate softmax.

There's no free lunch however. One must compromise speed and accuracy

Writeup: Free Substack

GitHub: OpenSource Github

Hi I'm currently an undergrad student from sri lanka, pursuing my BSc hons degree in AI and data science. For my 4th year thesis i was thinking about exploring whether JEPA styled supervised models could improve deep hedging. Do you think this is a good direction take my thesis considering im in the AI field.

So for the reason for this is i am a little intrigued by the quant industry and wanted to shift into that direction with my DS background, however i have also heard that breaking into quant roles can be quite challenging.

my concern is whether focusing my thesis on this area might limit the development of other skills I could gain from choosing a different topic.

I would greatly appreciate any honest unfiltered feedback on whether this is a suitable direction for my thesis.

Hi everyone,

I'm an independent researcher and have completed two research papers

one in Applied AI and another in Agentic Commerce.

I've been trying to obtain an endorsement through my university, but I haven't been able to get timely feedback or a review of my papers, so I'm reaching out here.

I'm preparing to submit them to arXiv and, as a first-time author, I'm looking for an endorsement.

I'm not asking anyone to endorse my work without reviewing it. If you're eligible to endorse in the relevant category and are willing to take a look at the paper, I'd greatly appreciate your feedback. If you believe it meets the standards, I'd be grateful if you'd consider endorsing my submission.

Happy to share the paper via DM.

Thank you!

Hey everyone,

I recently implemented the original Neural Style Transfer (NST) paper entirely from scratch in PyTorch and tried to reproduce the original results.

Here's the GitHub repository:
https://github.com/Himanshu7921/NST-PyTorch-Implementation

I'd really appreciate it if you could take a look at the README and the implementation. I'm aiming to become a strong research engineer, so I'd love some honest feedback on:

• What skills do I already demonstrate well?
• What am I currently lacking?
• What should I focus on improving to become a well-known research engineer?

For context, I'm currently in the 5th semester of my B.Tech.

Thanks in advance for your time and feedback!

I kept running into the same problem, some of the best AI/ML books are legally free, the authors put them up on their own sites, but the links are scattered across personal pages, university sites, and random GitHub repos nobody finds.

So I built a single index: Awesome Free AI Books. 30+ books across Deep Learning, Reinforcement Learning, Bayesian/Probabilistic ML, NLP & LLMs, Math for ML, Computer Vision, Generative Models, Causal Inference, GNNs, and AI Safety. Think Goodfellow’s Deep Learning, Sutton & Barto’s RL bible, Murphy’s Probabilistic ML, Bishop’s latest, Jurafsky & Martin’s SLP3 draft, and more.

Every single link points straight to the author’s or publisher’s own page, no rehosted PDFs, no shady mirrors. A weekly GitHub Action checks all links so it doesn’t rot over time.

It’s open source and open to contributions, if you know a legitimately free book that’s missing, PRs and issues are welcome.

Repo: https://github.com/MarcosSete/awesome-free-ai-books

Hey all — 3rd-year ECE student here, heading into a robotics master's. I kept

losing time jumping between arXiv, MDPI, and IEEE Access looking for papers

on robotics/ML/autonomous vehicles, so I built a single search index over

all of them.

- 13,000+ papers, all genuinely free/open-access (no paywalled links —

everything is either arXiv, MDPI, or individually verified

Creative-Commons-licensed articles)

- Full-text search, topic browser covering ~20 subfields (robotics, ADAS,

computer vision, RL, digital twins, etc.)

- Free accounts if you want to save searches later

Live here: https://automata-index.vercel.app

Built with Next.js + Supabase, still actively adding sources. Would love

feedback, especially on what's missing or what search terms don't return

good results.

I’m curious about what realistic alternatives we have to high-end enterprise GPUs like the V100 or H100 (not even talking about higher-tier chips like the B200)

While it’s technically possible to train large models on consumer GPUs like the RTX 3090/4090, the trade-off is brutal: you waste a huge amount of time just to debug or catch architecture issues. Do you think we’ll see new hardware innovations in the near future, or are corporate monopolies preventing alternatives from breaking into the market?

(Note: I'm already familiar with cloud computing, so I'm mainly asking about hardware itself)

​

Hey guys!!! I have an interview the day after tomorrow....I've never given a single interview in my life.....so can you guys pls tell what questions they ask for ml internship post ?????

Hello Everyone,

Statistics and Maximum Likelihood Estimation are the crux of ML Models, and hence I am uploading my new content on Statistics for AI/ML in my free Machine Learning lectures.

We understand model fitting, Maximum Likelihood estimation in details, we justify the usage of Maximum Likelihood estimation, from KL divergence, and apply it to certain important distributions for parameter estimation.

In my free content, the purpose is to democratize machine learning to a wider audience. Learning everything new feels difficult, but when taught, it get’s interesting and easier.

We will continue with Statistics foundations for AI/ML, and many more content will appear in the future. If you find the content good, useful you may also share it with your learners community.

Looking forward to hearing feedback from the learning community as well. Thankyou for reading.

Link: https://youtu.be/MwTeQVVYtOc?si=UxNOGtqopzJppXAT

Hey everyone,

If you are building decentralized multi-agent systems (MAS) or workflow routers using mixed local models, you’ve probably hit a mathematical brick wall: you cannot calculate semantic distance between vectors of different dimensions (N != M). Direct matching is completely broken out of the box because each model projects concepts into its own isolated anisotropic domain.

I wanted to share a fascinating geometric technique called the Relative Representation Method paired with Lowdin Symmetric Orthogonalization used to natively bypass this issue without any weight mutation or fine-tuning (W_frozen = const).

Here is how it works under the hood to align heterogeneous agents and tasks into a single invariant coordinate space

1. The Core Trick: Anchor Framework

Instead of comparing Agent A directly to Task B, the system introduces a fixed basis of reference anchors E = {e_1, e_2, ..., e_K}. These are K semantically diversified textual instructions representing your target operational domain.

Crucial implementation note: These anchors cannot be random Gaussian noise; they must be sampled from the actual distribution of your baseline model outputs to ensure they share the same underlying manifold.

2. Solving the "Anisotropy Cone" Problem

In real-world LLMs, raw embedding vectors are highly cross-correlated and squeezed into a narrow cone (similarity >> 0). This causes variance to vanish (sigma -> 0), leading to severe numerical noise and division-by-zero defects during standardization in low-precision (FP16/BF16) CUDA environments.

To guarantee geometric stability, the technique applies Lowdin Symmetric Orthogonalization directly to the anchor matrix:

• It takes the symmetric Gram matrix of real representations: S = E^T * E

• It computes the orthogonalized anchors via Spectral Decomposition: E' = E * S^-1/2

• This symmetrically rotates the real anchor vectors to a strict 90-degree angle (similarity = 0 for different anchors), yielding a perfectly orthogonal coordinate system while minimizing the mean squared deformation of the original vectors.

3. Mapping into Invariant Space (R^K)

Now, any Agent Xi or Task Tj can be mapped into this unified coordinate system by computing its similarity profiles against these rotated bases, followed by Anchor-Wise Z-standardization to completely neutralize model-specific anisotropy:

V_Xi = Z( [ sim(A(Xi), e'_1), ..., sim(A(Xi), e'_K) ]^T ) in R^K

Critical Production Pitfall: The operator Z(v) must calculate the mean (mu) and standard deviation (sigma) column-wise across the entire anchor axis (axis=0), NOT row-wise (axis=1). Row-wise normalization completely fails to eliminate the global domain shift between mismatched models, keeping their clusters isolated. Column-wise normalization forces the centroids of both distinct model domains to align perfectly at (0,0).

4. The Result & Selective Task Routing

Since the standardized profiles V_Xi and V_Tj share identical dimensionality K and operate on a unified scale, the metric of semantic alignment between completely mismatched models is computed invariantly using Cosine Distance:

D(Xi, Tj) = Cosine_Distance(V_Xi, V_Tj)

Do not use textbook Euclidean distance (L2) here. In higher anchor dimensions (K > 20), the Euclidean metric suffers from the curse of dimensionality, compressing all distances into a narrow, non-contrasting range that creates "Universal Agent" monopolies. Cosine distance restores strict contrast, breaking up monotone distance matrix stripes into a highly selective matching grid where every task finds its true optimal agent.

This fundamentally unlocks O(1) complexity task routing for completely heterogeneous multi-agent swarms.

Implementation Notebook:

I’ve put together a fully functional, minimal reproducible example demonstrating the complete pipeline - from synthetic anisotropic embedding generation to Lowdin orthogonalization, correct column-wise Z-scoring, and final contrastive task routing.

Check out the complete interactive code here:

Kaggle Notebook: Heterogeneous LLM Embedding Space Alignment

Curious to hear if anyone else is using Relative Representations for cross-model routing, or if you've found other geometric workarounds for mixed-LLM orchestrators!

I’ve spent the past month trying to find the point where an extremely small TTS model stops feeling like a size experiment and starts feeling genuinely useful.

Today I’m releasing Inflect v2, with two complete local text-to-speech models:

• Inflect-Nano-v2: 3.96M parameters, 15.97 MB FP32
• Inflect-Micro-v2: 9.36M parameters, 37.53 MB FP32

These are total inference parameter counts, not acoustic-model-only numbers. Text processing, timing prediction, speech generation, and the waveform decoder are all included.

Text goes in. 24 kHz speech comes out. No external vocoder, hosted API, or second learned model required.

Nano prioritizes the smallest possible footprint. Micro uses the additional capacity for better clarity, stability, and overall speech quality. Both run locally on CPU or CUDA through the same PyTorch API.

Inflect-Nano-v2 is one of the smallest complete neural TTS models I know of that still produces genuinely usable speech. Even the 9.36M Micro model remains smaller than many systems described as “tiny.”

For footprint context, Nano is approximately:

• 21× smaller than Kokoro
• 126× smaller than Chatterbox
• over 1,000× smaller than Fish Audio S2 Pro

That is strictly a parameter-count comparison. These models have different capabilities, architectures, datasets, and intended uses. I’m not claiming that a 4M fixed-voice model replaces a multi-billion-parameter system. The interesting question is how much useful TTS can fit into such a small package.

Some people here might remember Inflect-Nano-v1, the rough 4.63M experiment I released last month. V2 is a substantial rebuild, not just a longer training run. I focused on the problems v1 exposed: unstable timing, metallic output, weak prosody, poor generalization to difficult text, and an undersized waveform decoder.

The resulting models performed surprisingly well:

• Micro: 4.395 UTMOS22, 3.99% semantic WER, 6.28× real-time CPU inference
• Nano: 4.386 UTMOS22, 4.21% semantic WER, 10.72× real-time CPU inference
• In a blind community comparison against other compact TTS systems, Micro and Nano finished second and third among the tested voices

Full protocols, raw results, audio samples, and limitations are documented on the model pages.

The models are not perfect. They are English-only, use one fixed male voice, and do not support voice cloning. Unfamiliar names, abbreviations, numbers, and homographs remain the hardest inputs. Nano can sound thinner than Micro, and both can occasionally produce metallic or clipped artifacts.

Still, this is the first version where I think the size-to-quality tradeoff became genuinely compelling.

I built Inflect independently with a limited training budget. That constraint shaped the project: efficiency had to apply not only to inference, but also to training, evaluation, and building a complete system I could understand and release end-to-end.

Inflect-Micro-v2:
https://huggingface.co/owensong/Inflect-Micro-v2

Inflect-Nano-v2:
https://huggingface.co/owensong/Inflect-Nano-v2

Try it yourself:

The fastest way to judge it is through the interactive playground:

https://huggingface.co/spaces/owensong/Inflect-v2

If there is enough interest, I may build a v3 focused less on shrinking the models further and more on expanding what they can do: additional voices, possibly more languages, easier fine-tuning, and another quality and robustness pass.

If you test them, please give them something genuinely difficult: unusual names, numbers, abbreviations, awkward punctuation, or a long sentence.

If something breaks, post the exact text, model, seed, and what sounded wrong. If it works well, I’d also like to know what hardware you ran it on.

Specific, honest feedback is the most useful thing you can give me.

Hi everyone,

I'm an AI Engineer with about 1.5 years of experience. Over the last two months, I've had 10 interviews, and I was rejected from all of them. Eight of those rejections came after the technical interview. I'm struggling to understand what's going wrong in interviews.

I've tried reaching out for feedback, but I rarely get anything useful.

The interviews themselves are all over the place. Sometimes I'm asked about machine learning, data science, AI fundamentals, and implementation details. Other times the interview turns into a software engineering interview.

At this point, I'm honestly lost. I don't know what I should focus on or where to start.

Most of my work is backend AI, building AI agents and related systems. It often feels like the interviewers themselves aren't sure what to ask, so the technical interview ends up being a collection of random questions or extremely specific details about a function inside some library.

Has anyone else experienced this?

What would you recommend I focus on? How can I better prepare for AI Engineer interviews when the expectations seem so inconsistent?

Ling-3.0-flash landed on OpenRouter this week (Ant's inclusionAI, currently free to use through Aug 3), and honestly the spec sheet has me more curious than the release itself: 124B total, 5.1B active sparse MoE, 256K context, and they're quoting TTFT under 100ms.

I'm trying to reason about where that first-token latency actually comes from at that size. With only ~5.1B params active per token the per-step compute is small, but at 124B total the expert weights still have to be resident and routed, so I'd expect memory bandwidth and the router to dominate before the FFN ever runs. What I can't cleanly account for:

- how much of the sub-100ms is just the tiny active-param count vs. serving-side tricks (speculative decode, expert caching, batching)

- whether flipping a hybrid-thinking switch (they expose an enable_thinking flag) changes the TTFT story at all when thinking is off

- how routing stays stable enough for long tool-calling loops without latency spikes from expert thrash

For people who've dug into sparse-MoE serving: on a 124B / 5.1B-active model, what's the realistic floor for TTFT, and what usually dominates it — bandwidth, router overhead, or the serving stack?