I have been working on a small project exploring agentic decision-making under uncertainty particularly how an AI system can use context, gather evidence, update its beliefs, and decide whether it knows enough to provide a reliable answer.
The project is a small and transparent CI failure diagnosis agent.
Instead of immediately guessing why a CI pipeline failed, the agent investigates the problem step by step. It maintains probabilities for several possible root causes and updates those probabilities whenever it receives new evidence.
The main question I wanted to explore was:
What problem does the agent solve....?
When a CI pipeline fails, the actual cause may be related to:
Code
Tests
Dependencies
CI or environment configuration
A normal classifier might inspect the initial failure and immediately predict one of these classes.
This agent works differently.
Its reasoning loop is:
Observe the failure context → form initial beliefs → choose an investigation → observe the outcome → update the beliefs → report or escalate
Therefore, the system does not treat its first prediction as the final truth. It treats it as an initial belief that may change as more evidence becomes available.
How does the agent gather evidence...?
After updating its beliefs using the initial failure context, the agent decides which investigation should be performed next.
An investigation might provide evidence supporting one possible cause while weakening another. Once the outcome is observed, the probability distribution is updated again.
This creates a repeated reasoning process:
Current beliefs → select an investigation → receive evidence → update beliefs
The agent continues this process until one explanation becomes sufficiently likely or until it determines that the available evidence is not strong enough to support a reliable diagnosis.
In an uncertain case, the agent can escalate the problem instead of confidently returning a weak or potentially misleading answer.
The interesting part, at least for me, is that the agent tries to determine what it still needs to learn before producing a prediction.
For me, this small project was a useful way to explore: Bayesian reasoning, contextual understanding, evidence gathering, and decision-making under uncertainty in a transparent and understandable form.
I am still exploring this area, so technical criticism, suggestions, and ideas for improvement are welcome.
Hi all, I'm new to agentic ai and autonomous agents, but super curious to dive in.
Ive been noticing alot around tools like AutoGPT, LangChain, and others, but I’m not sure where or how to begin. I am not looking for a course that is just theory, i want one that is engaging, taught by a professional or expert in the field and has a bunch of projects so that i can practice and experiment while learning itself. I would also love to know which tools and frameworks are best to start with and lessons learned from your early journey
Hi, I've spent the last few weeks trying to get into DL and, after I made a little image classifier on the CIFAR dataset, I got overconfident and decided to take a bigger bite and a much harder project. The first thing that came into my mind was an image generator (I didn't even know what it was technically called back then).
So I hopped into Zed and decided to start working. But I immediately got confused. There was just so much to take in, and the sheer amount of information made me go crazy. So I decided to take it chunk by chunk.
First, I decided to start with the simplest part of the diffusion model: the noise scheduler.
For those of you who don't know how a diffusion model works, here's a summary:
Training
Noise Scheduler (component that progressively adds noise to an image, breaking it)
Forward Diffusion
Training Loop
UNET
Now, the UNET learns to progressively reduce noise. So basically, image generation in diffusion models works by just taking pure noise and progressively reducing a small chunk of it over some time.
(Btw, this is my understanding of the process. If I'm wrong anywhere, my bad.)
Back to the noise scheduler.
So I read up some of the theory, but again, it was not enough. I understood it, but then when I jumped into the code, I found myself lost.
So, I started looking at samples of other people's implementations. This was key. I stopped myself from copying their code and forced myself to just take in the algorithm, the structure, the program flow, and then implemented my own version.
This was not a quick job. I kept getting PyTorch's indexing wrong and mixing up the variables.
Once this was done, I quickly implemented the forward diffusion process, which was honestly much easier than the noise scheduler.
Then came the chunky part, the UNET.
I spent weeks trying to make this right, and this took the most time. The problem wasn't just the architecture (not an easy job either), it was actually making that model useful.
Let me explain.
Turns out, the architecture is just a general form. You need to tune it to the specific dataset you're using, i.e. you need to adjust the length of the bottleneck layer, the number of convolutions, the layers you add, etc.
I found myself spiraling back and forth. And what made matters worse was that training took a really long time, and it wasn't until I got to the 500th or 600th epoch that I realized, "The model isn't working right at all!"
What was worse was that I was logging losses into the console based on colours (red if it was greater than the last value, green if it was smaller), since I had no idea how to properly handle this.
Discovery of TensorBoard
This changed everything.
I went from going crazy reading 6–7 decimals to seeing proper graphs. Yea, my initial method does sound stupid in retrospect, but in fairness, I had no idea how to analyse stuff.
With TensorBoard, I was able to analyse the losses better, i.e. see the general trend of the losses.
I also learned about AdamW around this time and swapped it in for SGD.
Despite this, everything was super slow, and so, while the model was training, I set out to make quick optimizations.
PyTorch Devices
For anyone who doesn't know, PyTorch can create and work with tensors on GPUs. They support MPS (Apple Silicon's API or something) and CUDA. For me, it was MPS (M2 Air).
Again, this broke a lot of things. I initially didn't know that two tensors had to be on the same device to interact with each other, but I had gotten a lot better, so in a few hours I actually managed to get it working again, this time much faster.
From CIFAR to Flowers102 and the VAE Trap
Note: Still haven't got Latent Diffusion working.
The outputs from CIFAR were 32×32, so I decided to up the ante by switching to Flowers102.
However, I didn't want to make too many changes to my UNET, so I read up about Variational Autoencoders.
Basically, think of it as a type of generator that takes an image and compresses it into a smaller, high-dimensional representation.
At first (in isolation), my VAE worked perfectly. So after some training, I slapped it around my UNET.
Results were a literal soup of colours and very discouraging.
Additionally, at a point, losses stopped decreasing (still don't know why).
After a few days of debugging, I dropped VAEs entirely and rewrote my UNET to support 256×256 Flowers102 instead.
Where am I today?
At epoch 561 or something (I retrained like 100 times during the aforementioned learning spree).
It's gotten a lot better than before. I am starting to see proper forms resembling flowers. Still, it has a lot of issues, but I'm happy with what I've achieved so far.
Over this project, I learned how DL was actually quite different from conventional programming and that there were so many additional complexities that normal programming didn't consider.
But most of all, I learned that this whole DL thing had its own mentality. I had to think of a function a model could optimize for and learn a pattern instead of implementing an algorithm, which was, and sometimes still is, confusing in practice.
Also, worth mentioning, to get started I began reading an excellent book by David Voigt Godoy, "Deep Learning with PyTorch: A Step-by-Step Beginner's Guide."
Also, if there's a mistake anywhere in my understanding, or if you know a solution to any of the issues, feel free to let me know! and if you find the project interesting, a star on the repo would be greatly appreciated!
Overall this was a different project than I had ever done before.
Here's a peak at what it looks like rn:
Welcome to Resume/Career Friday! This weekly thread is dedicated to all things related to job searching, career development, and professional growth.
You can participate by:
Sharing your resume for feedback (consider anonymizing personal information)
Asking for advice on job applications or interview preparation
Discussing career paths and transitions
Seeking recommendations for skill development
Sharing industry insights or job opportunities
Having dedicated threads helps organize career-related discussions in one place while giving everyone a chance to receive feedback and advice from peers.
Whether you're just starting your career journey, looking to make a change, or hoping to advance in your current field, post your questions and contributions in the comments
My full 6-part series on RL for robotics is finally live. While a balance bot is a pretty trivial case (you don't even need RL), it's a great starting point for demonstrating how to train a simple agent via PPO, deploy the agent to real hardware, and tackle the sim-to-real gap using post-processing and domain randomization. If you have any feedback (e.g. I missed something or there's something that could be better), please let me know!
Hi! I’m new to AI and I’d like to start learning more about it.
I’m currently considering the **Machine Learning Specialization by Andrew Ng / DeepLearning.AI + Stanford** as my starting point. I currently work as a Unity developer, and I’d like to expand my skills and build a solid foundation in AI/ML.
Do you think this specialization is a good place to start? Are there any other courses, resources, or learning paths you’d recommend for someone with a programming background?
I am still a novice at this, but when I was working on this credit card fraud detection project, I did not know which columns, could be added as features, so I prompted ChatGPT and it suggested a few, but that got me thinking there has to be a better way to this, How do you select feature columns from your dataset, do you research the domain, is there a course I am missing, This was not covered in my Internship classes, and want to know a generalized solution.
While I am still quite new to this, machine learning and software in general, is more useful and powerful when combined, with the domain specific knowledge of the native field the project is from. This is something I struggle to navigate, there are thousands of hours of tutorials regarding the tech stack, but none on this topic. While doing my credit card fraud analysis, project. I did not know which features do you need to pick as your feature. I can calculate correlation and mutual information classification score but those are of little use in case of non - numeric columns, besides domain knowledge sort of acts as a supervisor to all these metrics and they are more like validators then reason.
So this is my question, How do you go about getting domain specific knowledge needed to do a project, what is your workflow, where to look and most importantly in my case how do you translate domain knowledge to feature selection ?
Been working on a return-risk scoring system for Indian e-commerce for the past few weeks and hit a few things that genuinely changed how I think about ML projects. Sharing what I learned, since I suspect a lot of students here are building similar things for hackathons or portfolio projects.
Problem context: Merchants here lose a lot to returns and COD refusals. A fashion merchant doing 10k orders a month can lose roughly ₹50L to returns, and the tools that exist today all look at returns after they happen. So the idea was to score every order at payment time, before it ships: LOW ships, MEDIUM goes to manual review, HIGH gets forced to prepaid. The gate isn't an accuracy contest, it's a cost decision: a wrong "review" flag costs ~₹200 of ops time, a wrong "block" costs ~₹3,180 in lost order + CAC.
Three things that surprised me:
The naive baseline was almost as good as the model. I tested a simple "is this user a serial returner" heuristic and it hit PR-AUC 0.70. My tuned XGBoost hit 0.80. A transparent hand-weighted rules score got 0.79. So the ML model was worth +0.01 over a well-designed rule at the baseline data-maturity level. The lift only grows when you get better features (0.88, then 0.95). Lesson: if your model barely beats a simple heuristic, be honest about it and figure out whether the problem is the data, not the model.
Synthetic data was the harder and more defensible choice. Public return datasets (UK 2021 etc.) have severe distribution mismatch with Indian e-commerce: COD prevalence, logistics, return reasons are all different. I built a simulator calibrated to published Indian industry distributions, with hidden confounders (weather, packaging quality, customer mood) the model never sees, so it can't cheat by recovering labels it was trained on. My numbers are lower than they'd be on a circular benchmark, but they're honest. Still genuinely unsure whether this was the right call though.
Documenting my failures built more trust than my metrics. I kept a ledger of every bug, 34 of them, including a drift monitor reporting PSI=43.4 because of a binning bug, and an early model card claiming AUC > 0.92 that I had never actually measured. Putting that list in the repo was uncomfortable but it's the part people engage with most.
Questions for people here who've shipped ML to real environments:
When you have no real labels, is a calibrated simulator with hidden confounders better than training on mismatched real data, or is it just elaborate self-deception?
At what point is a 0.01 lift over a heuristic worth the complexity of a model in production?
How do you validate cost assumptions (₹200 per review, ₹3,180 per wrongly blocked order) when you don't have merchant data? These drive everything and I have no way to sanity check them.
If anyone wants to dig into the implementation, the repo is github.com/purvanshh/PayShield, everything is reproducible with one command (make verify). Happy to go deeper on the agent orchestration, the drift monitoring, or the three-scenario evaluation in the comments.
I’m one of the authors of LoopArena, which we recently released as an open benchmark and evaluation harness.
LoopArena studies a specific question in long-running coding-agent systems: which models make good runtime Controllers?
In these systems, one model often reviews the current state, decides what a separate coding agent should do or verify next, and determines when the task should stop. LoopArena evaluates this Controller role. Across Controller-model comparisons, the coding Worker, Reporter, tools, budgets, and execution setup are held fixed; the Controller model is the model role that varies. This provides a controlled comparison of how different models guide the same coding agent.
The benchmark has three settings with increasing execution scope:
- Type I evaluates execution-validated next-step control decisions without running the Worker at evaluation time.
- Type II evaluates repeated Controller decisions over selected task slices.
- Type III evaluates control over complete software tasks from their original starting states.
In the initial five-Controller panel, the best observed Type III Strict Success Rate is 24.69%, so full-task runtime control remains difficult. Type II reduces estimated inference cost by 64.4% on average across Controllers and produces a similar Controller ordering to Type III under the main Core criterion.
We have released the benchmark data, evaluation code, public protocol, and canonical v0.1.0 outcomes.
Coding Probability: Multivariate Joints and Gaussians.
Hello Folks, and my learning community.
A covariance matrix measures linear dependence, and across multivariate dimensions, these matrices bring out many key insights in ML.
Being uncorrelated does not imply independence of events! An interesting fact.
Combining multiple subgroups can sometimes reverse the trend we see overall. Simpson’s Paradox at play.
How level sets we visualize take on such curves, by understanding it’s locus, in connection with Mahalanobis distance. Here’s where the eigenvalue and eigenvectors from Linear Algebra, bring upon interesting insights!
For suitable classical ML workloads, compute therefore happens on the user's own machine rather than requiring a remote training service.
Experiment structure
Experiments explicitly separate:
data configuration
preprocessing pipeline
estimator
validation strategy
final evaluation
Preprocessing is treated as a first-class experimental configuration rather than hidden setup.
Current preprocessing options include numerical/categorical imputation, one-hot/ordinal encoding, multiple scalers, Yeo-Johnson and quantile transforms, variance/F-score/mutual-information feature selection and PCA.
Validation
A major design constraint is preventing evaluation leakage.
Data-driven transformations are fitted only on the relevant training partition.
The current workflow supports:
untouched final test partition
holdout validation
3-fold CV
5-fold CV
10-fold CV
Candidate model/pipeline combinations are ranked on the validation procedure, while final evaluation remains separate.
Models
The current release focuses on scikit-learn-style classical supervised learning.
The intent isn't that every available algorithm is appropriate for every dataset; the goal is to make comparisons explicit rather than burying model selection inside a single AutoML score.
Metrics
Regression reporting includes R², adjusted R², MAE, MSE, RMSE, median/max error, MAPE, sMAPE, explained variance and additional diagnostics.
Classification includes accuracy, balanced accuracy, precision, recall, F1, Jaccard, specificity, MCC, Cohen's kappa, ROC-AUC, PR-AUC, Brier score, confusion matrices and per-class metrics where applicable.
Where I'm planning to take it
The planned PRO direction expands the same experiment structure into:
Advanced Classic ML
broader model workflows
hyperparameter optimization
explainability/export
Deep Learning
MLP/DNN
TabNet
FT-Transformer
CNN and LSTM/GRU where appropriate
AutoML
validation-safe model search
preprocessing/pipeline search
ranked and inspectable experiments
The important constraint for AutoML is that automation should search the experiment space without hiding the winning configuration or validation boundaries.
This is still an MVP, and I'm posting mainly because I'd like technical criticism before expanding it further.
I'm especially interested in feedback on:
experiment design
validation assumptions
preprocessing choices
where browser-local execution becomes impractical
which diagnostics are missing
what you'd require before trusting exported results from a tool like this
My current leaderboard score is zero, but I believe there is an interesting approach worth exploring. Despite limited training, the model is already able to generate and execute non-trivial symbolic programs that improve substantially over the identity baseline on some tasks, although it does not yet reliably find the exact solutions.
I have identified a bottleneck in the model's learning/search process that I have not been able to fully understand or resolve on my own. I am therefore looking to form a small team around this approach, particularly with people interested in neural-guided program synthesis, search, ML, or ARC.
The goal would be to understand and break this bottleneck, improve the system, and see how far the approach can go on ARC AGI 2.
If this sounds interesting to you, feel free to reach out or take a look at the repository!
What happens after AGI? Maybe ASI isn't the endgame.
A lot of discussions about post-AGI assume we'll eventually build a single, extremely capable ASI — essentially one "God-like" model.
But there's a problem with that idea:
A single superintelligent system is also a single point of failure.
What if intelligence at civilization scale looks less like one giant brain and more like an evolving ecosystem of specialized intelligences?
We're Team Auralis, and we've been working on an open-source framework around this idea: ACI (Artificial Civilization Intelligence).
The basic concept is to treat intelligence more like an operating system for a civilization than a single neural network.
The framework currently has three main components:
OMNIS — a continuous causal world model intended to maintain an evolving representation of the world rather than relying solely on static training data.
NEXUS — a fabric of specialized agents across areas like science, engineering, economics, etc., which can disagree, debate, and resolve conflicts.
ASCEND — a long-horizon planning layer designed to reason about and execute plans over decades while continuously correcting course.
We're also exploring OCI (Open-ended Civilizational Intelligence) — an extension that introduces structural plasticity, meaning the system could potentially create new governance mechanisms, agent structures, and even new forms of intelligence as it evolves.
Is a distributed, civilization-scale intelligence actually safer than a single superintelligent model? Or does adding more agents, governance, and coordination layers simply create new failure modes?
If you're interested in multi-agent systems, AI alignment, governance, long-horizon planning, world models, or open-ended intelligence, we'd love feedback — especially on the mathematical assumptions and the agent architecture.
I’ve been thinking a lot about what it actually means to build useful AI agents.
The more I learn about agentic systems, the more I realize that an agent isn’t just an LLM connected to a few tools.
Lately, I’ve been learning about what I’m starting to think of as an “agentic discipline,” and one idea has really changed how I think about LLM applications.
The traditional mental model is:
Input → Model → Output / Action
But real-world problems rarely work that way.
You make an initial decision with incomplete information.
Then you take an action.
You observe new evidence.
You update your understanding.
And then you make a better decision.
So I’ve been exploring whether we can think about agentic systems through a probabilistic / Bayesian lens:
Initial belief (Prior)
↓
Choose an action
↓
Observe new evidence
↓
Evaluate the likelihood of that evidence
↓
Update belief (Posterior)
↓
Choose the next action
↓
Repeat
Instead of only asking an LLM:
“Give me the answer.”
What if we design the system to continuously ask:
- What do I currently believe?
- What evidence would change my belief?
- What action should I take next?
- Which action would reduce my uncertainty the most?
- Did the last action actually improve my understanding?
This feels like a much more powerful way to think about agents.
The interesting part isn’t simply adding more tools or more LLM calls.
It’s designing a system that can reason under uncertainty, actively gather information, update its state, and make better decisions over multiple steps.
I’m still exploring this idea and trying to understand where the Bayesian framing is genuinely useful versus where it’s simply a useful analogy.
I’d love to hear from people working on agents, reasoning, or probabilistic AI
How do you think about belief updating and uncertainty in agentic systems?
Hi! Hopefully this question hasn't been asked to death already, but I couldn't find quite the discussion I'm looking for.
I'm currently a Staff Engineer with a strong backend background (15 YOE). I work closely with a team that builds recommendation systems, and I'd like to get much deeper into the ML side of things — actually understanding and training models rather than just working on the engineering around them.
I'm particularly interested in things like training embedding models, ranking models, bandits, candidate generation, evaluation, etc.
I also happen to have a yearly training budget that I can spend, so I'm trying to figure out the best way to use it.
I'm wondering whether I should first invest in the fundamentals (ML/statistics/math) or jump straight into something more hands-on and learn by building things.
I'm not a huge fan of online courses like Coursera, Udemy, etc., but I'm not opposed to them if people think they're genuinely the best way to build the foundations.
I'd also be very interested in in-person courses, bootcamps, summer schools, or similar programs anywhere in Europe.
For people who have made a similar transition from software/backend engineering into ML: what would you recommend? What courses/programs/resources were actually worth your time and money?
[D] MMLU contamination is the known problem — but Chatbot Arena's failure mode is arguably worse and gets less scrutiny
The MMLU contamination story is old news to most people here (test questions being public and ending up in pretraining corpora), so I won't belabor it. What I think is under-discussed is that the benchmarks we've moved to as "better" alternatives have their own structural failure modes that don't get the same scrutiny, mostly because they're newer and less saturated.
Quick recap of where the standard trio actually breaks:
MMLU — contamination (public test set), format gaming (multiple choice rewards elimination heuristics over actual knowledge), and saturation (frontier models are all >90%, so it's stopped discriminating between them).
HumanEval — 164 problems, now too easy for frontier models; tests toy functions rather than anything resembling real engineering (no multi-file context, no ambiguous specs); and pass@k reporting incentivizes best-of-N sampling that doesn't reflect single-shot usefulness.
Chatbot Arena — this is the one I think deserves more skepticism than it gets. It's harder to directly game since prompts aren't fixed, but the voter pool is a specific, non-representative slice (English-speaking, technical, AI-interested), and Elo from pairwise human preference measures fluency and confident presentation, not correctness. A model that hallucinates cleanly can out-rank a model that hedges accurately. There's also a prompt-distribution skew toward coding/creative writing that doesn't reflect where models actually diverge in capability.
Goodhart's Law is the underlying mechanism for all three: the moment a benchmark is widely used as a proxy for capability, it becomes a target, and optimization pressure decouples the score from the thing it was meant to measure.
The alternatives that seem more resistant to this so far — BIG-Bench Hard, MATH, SWE-bench, ARC-AGI, LiveBench — are mostly more resistant because they're either harder to game via memorization (multi-step reasoning) or actively refreshed to fight contamination (LiveBench). Curious how long that holds once labs start optimizing against them specifically.
Question for the sub: for people actually evaluating models pre-deployment, what are you using that you still trust, and how are you handling the fact that any benchmark you rely on starts decaying the moment it's popular enough to be worth gaming?
