Hey all,

I've been working on this for a while and finally shipped it today, so figured I'd share here since this sub actually gets the problem.

The thing that's always bugged me about coding agents: you give them a task, they take one pass at it, and then they stop whether it actually works or not. You're still the one testing it, finding what's broken, and re-prompting. The agent did the "coding" part but you're still doing the "engineering" part.

So I built Keel Code around what I'm calling loop engineering instead of a single model taking one shot, it runs a team of frontier models in a loop that plans, builds, tests, and critiques its own output, and keeps going until the goal is actually met. Not one-shot. Not "here's my attempt, good luck."

The core command is /ascend you give it a goal, it puts together a plan, executes, checks its own work, and iterates until that goal is hit. You're not babysitting it every few minutes.

Install:
bun i -g @keelcode-ai/keelcode

It's using top-tier frontier models for free for a limited time while we're fresh out of launch, so this is the cheapest it'll ever be to kick the tires.

Site: keelcode.ai

Not here to oversell it genuinely want feedback, especially on where the loop breaks down or gets stuck, since that's the hard part of this whole approach. Happy to answer anything about how it works under the hood.

Like everyone else, I saw 2.8 trillion parameters and immediately rolled my eyes a little.

Then I started reading and reading and.... yes, you guessed it: reading.

A few hours later I realized I wasn't thinking about the parameter count anymore.

I was actually thinking about MXFP4, 16-of-896 expert routing, million-token contexts, cache architecture, and all the boring systems problems that somehow let a model this size exist in the real world. Kimi K3 is a 2.8T-parameter MoE model with 16 active experts per token and a 1M-token context window, which is where the engineering starts getting interesting.

The thing that surprised me a lot is how much of the conversation seems to focus on the weights themselves. The more I looked into it, the more I felt the harder problem is serving. Everyone asks whether they can run a model like this. I'm increasingly interested in whether they can run it efficiently.

I ended up going down a rabbit hole on sparse MoEs, batch sizes, cache economics, and Kimi Delta Attention. Somewhere along the way the headline stopped being "2.8T parameters" and became "how did they make this remotely affordable?"

So I wrote a Substack post about it, not just about benchamarks or whether it s more or less good than claude or chagtp.

It's more about the engineering trade-offs hiding underneath the announcement and why I think those are the details that will matter long after everyone forgets the parameter count.

I'm final-year student and i ahve to build my final-year project. I don't want to make another AI chatbot, scam detection, or other overused project. I want something unique that combines Machine Learning with other technologies and solves a real-world problem. Any ideas, research papers, GitHub repos, or tech stack suggestions would be greatly appreciated!

I wanted to share my open-source project, Servent-AI. I built this framework with accessibility in mind—aiming to help physically challenged or motor-impaired individuals operate their laptops, write code, and build digital careers hands-free.



Features:

-  Real-time hand gesture tracking (MediaPipe) for mouse cursor, clicking, and page scrolling.

-  Voice control (Whisper STT) to speak complex commands.

-  Aria Planner (Gemma 4 E4B via LM Studio) that compiles commands into multi-step JSON action sequences.

-  VISTA Verification (Moondream via Ollama) that takes screenshots to visually check if a step succeeded before proceeding.

-  100% local, offline, and private.



Check out the code and flow here: https://github.com/Anikesh0415/Servent-AI



Would love to hear your feedback, thoughts on optimizing the local loop, and suggestions for more accessibility features!

We've all been there: you build a beautiful 40-layer model, hit .forward(), and PyTorch responds with a shape mismatch error that reads like a ransom note. Three hours later you find out you transposed something in layer 12.

So I built mlnode — you design your architecture as a graph (either by hand in JSON, or by literally drawing it in the companion editor), and it validates every tensor shape before it lets you build anything. If your ResNet block doesn't add up, it tells you exactly where, not "somewhere, good luck."

No exec(), no eval(), no cursed metaprogramming — just a clean pipeline: JSON → Parser → Validator → Executor → real nn.Module you can train, save, export to ONNX, whatever you'd normally do.

Why you might care:

🧑‍🎓 Just started learning DL? You get to focus on "what connects to what" instead of memorizing tensor arithmetic and staring at stack traces. I reproduced the full Transformer from Attention Is All You Need as one graph — 45M params, trains fine — and you can literally see it as a diagram instead of 200 lines of __init__.

🏗️ Building serious stuff? Weight sharing, multi-output nodes, reusable blocks, HuggingFace layers — it's not a toy, it compiles to a normal PyTorch module with nothing hidden.

Would love feedback, roasts, feature requests, or "this already exists and it's called X" comments — all welcome.

• GitHub: https://github.com/Nasser-Obeid/mlnode
• Visual editor: https://github.com/Nasser-Obeid/mlnode-editor
• pip install mlnode

When will ECCV oral/spotlight decisions be announced? Also, what scores usually have a chance at CVPR/ICCV?

i decided to build a LLM model but.... what do you think ?

MLIR sits under Triton, XLA, Mojo, and a growing list of AI accelerators, but most explanations stop at the slogan level. I tried to write the version that shows the machine running: one linear layer (matmul + fused bias/ReLU) lowered by hand from high-level tensor IR down to genuine sm_90 PTX, with a CPU JIT in the middle that prints the actual result. Every code block was executed on LLVM/MLIR 20.1.2 and the commands are reproducible.

The second half is the ecosystem and economics: why the recent $3.9B Qualcomm/Modular deal is really about the compiler layer, and what it means that this layer is becoming shared infrastructure.

Interested in this community's take on the counter-narrative I raise: if LLMs get good at writing kernels directly, does a shared IR layer matter more (verification, a structured search space) or less?

https://open.substack.com/pub/softwarefrontier/p/exploring-how-mlir-works-the-compiler?r=3c7w5a&utm_campaign=post-expanded-share&utm_medium=web

Hi Everyone, I am currently a 3rd year student pursuing BTech in CSE specialization in AIML . I want a reputed comapny to work for like big tech MANGOS,FAANG,MAANG etc.But for now i am confused that either i should i go for SWE roles by doing DSA and development but i have a interest in AIML roles. Please guide me how to get a strong role as a fresher in these companies i am also doing DSA from past 3 months .

Hi guys! I'm Nai, and I would really like to share this learning journey of mine with you all.

A few months ago, I got the interest to understand machine learning, I didn't know where exactly to start, but I just did the simplest thing, which is asking. I just searched on youtube "how to make a neural network", that was the farthest thing I knew about machine learning back then. I found the youtube tutorial series "Neural Networks from Scratch in Python" by sentdex.
I was genuinely blown away over how simple it turned to be. I just wondered if I could go a bit deeper, so, I started a C++ project, I tried my best to replicate every piece of math a neural network would need to run in a structured style, with classes, functions and everything. despite some concepts being still ambiguous for me, I kept searching, I found some other youtube videos that cover things like backpropagation deeper so I can understand it better.

Over time, I started taking a hold of it, running a couple of successful experiments, even if slow, they were functional, and I understood them.

After that, I turned it into a library (NeurologicalLibrary) that can be called from Python with Pybind11, I used tkinter to make a simple bounce ball environment just to test the library, and it worked! Just making a neural network that can get variable position of a ball and rectangle then predict where to go, despite simple, made me feel really proud.

That however, was just the below zero beginning, here is the project repo called "NAISENT_workspace" that is basically my entire learning journey work until I finally made my first ever Language Model!

https://github.com/Nai-built/NAISENT_workspace

The repository is under the Apache 2.0 License
Here is a copy of the README file:

this project is made with:
 - DotNet WinForms (C#)
 - Pybind11 (Python <-> C++23)
 - CMake (C++23)
 - CUDA (C++17)


Powershell commands to build the 3 libraries:
cd NeurologicalLibrary/bridge; cmake -S . -B build -A x64; cmake --build build --config Release -j; cd ../..
cd OptimizedNeurologicalLibrary; cmake -S . -B build -A x64; cmake --build build --config Release -j; cd ..
cd CudaNeurologicalLibrary; cmake -S . -B build -A x64; cmake --build build --config Release -j; cd ..


Run showcases:
py SHOWCASES/BASIC_SHAPE_RECOGNITION_CPU.py
py SHOWCASES/BETA_NAISENT_BALL_SEEKER_CPU.py
py SHOWCASES/LSTM_MATH_TEST_CPU.py
py SHOWCASES/NAISENT_ELM_CPU.py
py SHOWCASES/NAISENT_LM_CUDA.py
py SHOWCASES/NAISENT_SLM_CUDA.py
py SHOWCASES/SHAPE_RECOGNITION_CPU.py


Make sure that your terminal's path is set exactly to NAISENT_workspace


The core idea of this project was to learn and understand Machine Learning by building it from scratch
So I've built 3 different libraries in 3 seperate stages:
 - NeurologicalLibrary (NL)
    . The absolute beginning for me
    . I've learned in it how Dense Layers work and how to chain them to make Deep Neural Networks
    . How Convolutional Layers and pools work
    . How Recursive Layers (specifically LSTMs) work
    . And also Activation Functions
    . I've also tipped toes into Graph Layers but couldn't run a successful experiment, so I removed it
    . This library was the first time I made an image recognintion model, and also one that can play a simple bounce ball game
    . Was also the first time I made an optimizer like Adam for training
    . Save/load system for the model .json files


 - OptimizedNeurologicalLibrary (ONL)
    . Here things started to get a bit more serious
    . I've gotten way deeper into how C++ works and how we can optimize its performance
    . I've made faster Dense Layers
    . Faster Convolutional Layers
    . And faster LSTMs
    . Merged Activation Functions into the layers' own activation/gradient functions
    . After that, I got into Transformers (similar concept to Graph Layers, but this time it was successful!)
    . I optimized the training loop for image recognition
    . I made a simple experimental language model that can that it's "NAISENT" with the Transformer system I've made


 - CudaNeurologicalLibrary (CNL)
    . My most precious one so far
    . For the first time, I've got into Cuda kernels!
    . I've learned how Cuda interacts with data through the CPU, Memory and GPU
    . I've learned how to optimize it using shared memory
    . For this one, I went right ahead to build a language model system
    . First, I made Dense Layer Cuda kernels
    . Then I went into Norm Layers (RMS)
    . SCC (Sine/Cosine Cycle) positional embedding kernels
    . Multi-head Masked Self Attention kernels (split into multiple optimized Cuda files)
    . The ability to place sub chains to assemble the transformer architecture properly
    . Adam optimizer in Cuda Kernels
    . And obviously, Activation Functions (Cuda kernels)
    . First time adding the Residual mechanic as a visible variable in the Python side
    . Almost all of these were made in ONL already, but it wasn't with Cuda to use the GPU and it was juggled up together awkwardly. I'm much more proud of this one
    . Was when I made a proper tokenizer system in Python


The libraries are made in C++
and they're used by the Python side via Pybind11
I made the shape recognition and bounce ball environments in C# with WinForms
CUDA to use the GPU in the library CNL

We're presenting this at ACM Multimedia 2026. Short version of what it does:

Most controllable image-animation methods estimate optical flow relative to the FIRST frame (Lagrangian guidance). As the animation runs longer, those displacements grow, the flow estimate degrades, and you get drift, smearing, and identity collapse over long horizons.

We instead supervise with adjacent-frame (Eulerian) motion fields, so every training signal is a short hop that stays inside the reliable range of flow estimators — which bounds the per-step supervisory error regardless of sequence length. For newly revealed (dis-occluded) regions, a forward–backward cycle check masks out pixels where the flow isn't geometrically consistent, so the model is never supervised on bad correspondences.

On 100-frame generation we get FVD 76.18 (vs 79.20 for the strongest baseline), a 94.4% user-study win rate on portrait animation, and ~2.7× faster training since adjacent-frame flow is computed in one batched pass.

Project page (videos + side-by-side comparisons): https://nguyentthong.github.io/eulerian/

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

Happy to answer questions — I'm one of the authors.

Over the past few years, the Al industry has invested hundreds of billions of dollars, yet hallucinations remain one of its biggest unsolved problems. Models are dramatically better at coding, reasoning, and using tools, but they can still confidently invent facts or misinterpret information that's directly available to them.
Is this just an engineering problem that will eventually be solved with better training, verification, and tooling?
Or is hallucination a fundamental limitation of autoregressive language models, meaning we'll eventually need a different architecture for truly reliable AGI?
I'm curious what people here think. Are we on the right path, or are we approaching the limits of the current paradigm?

🧠 
**Why is this game so much harder for a computer than Chess or Go?**


Chess and Go are games of 
**perfect information**
 — both players see the whole board. Hugely
complex, but nothing is hidden. The tougher frontier for AI is 
**imperfect information**
, where
you 
*can't*
 see what your opponent has and must reason under uncertainty — like Poker: you weigh
what they might be holding (and what they think 
*you*
 hold), and you bluff.


**That's Tactico.**
 Each player commands 40 hidden-rank pieces. You see 
*where*
 the enemy is — but
not 
*what*
; a piece reveals itself only when it fights. Capture their flag before they capture
yours. With every rank hidden, each move is memory, deduction and bluff, and the possible enemy
setups are astronomical — which is exactly what makes it so hard.


For this project I trained a neural net to play it: 
**imitation learning**
 on tens of thousands
of human games, then 
**self-play reinforcement learning**
 over millions of games — converging
toward a 
**Nash equilibrium**
, a strategy no opponent can exploit. It plays shockingly well.


**So… can you beat it?**
 Most people can't. 👀


▶️ 
**Browser**
 — free, no signup: https://tactico-4fhpquk6aq-uc.a.run.app/
📱 
**Android early beta**
 — the enhanced, best-supported version (play a friend offline, even in
airplane mode): join https://groups.google.com/g/tactico-testers/about → then become a tester:
https://play.google.com/apps/testing/com.tactico.app


Tell me how many moves you last 😄

Challenge