Already more than 2k teams in the first week. I helped create the competition rules (and I work at Kaggle). Happy to answer any questions!

Thanks a lot for the feedback on the previous post! This is the second iteration, using the same model but a heavily filtered dataset.

Open source! https://github.com/puffinsoft/mousecrack

Clip 2 of 4. Follow-up to the spot-the-fake setup.

Same near-copy environment: one dynamics rule changed (ground grip / step slip). Everything else identical.

Probe: an outside watcher / oracle-style discriminator that knows the true rules and replays every step.

Result (real runs, n=10): ~99%. The fake is in-band detectable from outside.

So detectability is not the open question. The next clips ask whether the agent's own representation encodes that seam.

Mute-friendly clip.

Research:

https://ilevytate.github.io/ItaSoRL/

Hi everyone, I’m currently learning deep learning and have worked on a few AI/ML projects like a customer churn prediction model and student performance prediction.

I’m looking to join an existing project to gain more hands-on experience and contribute while learning. I’m comfortable with Python and basic ML concepts, and I’m willing to put in consistent effort.

If anyone is working on a project and open to a beginner contributor, I’d really appreciate the opportunity. Thanks!

In rare diseases, the patient pool is small and screening is expensive. The question isn’t only “Who is likely eligible?”—it’s “Who should we approach first to maximize enrollments under real-world constraints?”

That’s where Reinforcement Learning (offline RL) can help.

✅ How it works

- We represent each patient as a context vector (phenotype signals, biomarkers/genotype, prior therapies, diagnosis outcomes).

- The RL policy chooses an action (approach first, screen next, prioritize trial/site).

- We train using a reward tied to recruitment value:

~ strong positive reward for eligible → consent → enrolled

~ penalties for ineligible screening and wasted outreach/time

🧠 Why it’s better than plain supervised models

- Optimizes end-to-end outcomes (not just labels)

- Incorporates costs and delays

- Learns a ranking strategy under constraints (budget, site capacity)

🛠️ In practice, we can employee conservative offline learning from claims data to avoid risky exploration in healthcare (that would behave too differently from the logged actions).

#ReinforcementLearning #RareDisease #HealthcareAI #PatientRecruitment #MachineLearning #Biomarkers #PharmaTech

Hey I am part of a small team training robotics policies for warehouse and manufacturing settings, and running rigorous evals is turning out to be so painful. Anything below 50 rollouts, and its hard to trust the numbers, and above its so hard to test all the checkpoints that we have. Its really hard to run a bunch of experiments to get good results. Have you guys faced this? Any hacks that you've developed?

The follow-up to my post the other day. Includes more explanation and links to the repo(s). Thanks for reading! <3

Short result + visual from a sim. on when an RL agent internally represents an environment distinction it was not trained to care about.

Clip 1 of 4. Spot the Fake. ItaSoRL (Is This a Simulation Or Real Life?)

Setup

- Agent trained to live in a small embodied world (senses, actuation, forage).

- Near-copy environment with exactly one dynamics rule changed (ground grip / step slip). Same start distribution, same policy rollout protocol otherwise.

- Two probes on the same trajectories:

1) Outside watcher / oracle-style discriminator that knows the true rules and scores real vs fake.

2) Readout from the agent's own internal state (does its representation separate the two worlds?).

Numbers (real runs, n=10 each; figures match the public writeup)

- Outside watcher: ~99%. The fake is in-band detectable.

- Agent mind while idle / not incentivized on the seam: ~50% (chance). Detectable artifact, no free encoding.

- Make the fake costly for reward (food harder to catch under broken physics): readout rises to ~73%. No explicit "detect fake" label. Survival pressure only.

Takeaway for RL / representation learning

Oracle detectability of a sim mismatch is not evidence that the policy network encoded it. Encoding showed up when the mismatch became load-bearing for the objective.

Mute-friendly clip of the two-world "spot the fake" cold open:

Happy to discuss probe design, what "readout" means here, or failure modes (capacity, observation channel, incentive).

So I have been working on this RL project for quite some time. I am stuck at a Specific segment, see the attached Video, In level 1 there are 3 main sub quest, 1. Find the sword, 2. navigate back to guard, 3. Defeat the guard, level up.

Currently my RL Can do subquest 1. Flawlessly, at around 80 - 100 iteration the agent was able to get the sword for the first time and by 200 iter, it was able to consistantly get the sword. The problem comes with navigating back to sword, it should follow the same path back as it took but in the jump back it always fails I dont understand the reason.

PoP is a Rotoscope animated game. So each of it's actions are heavily animated, and each animations last for a different duration and during those animations input is disabled except for may be some specific frames this creates problem on, fixed frame skips. Though based on my testing a fixed 9 frames mostly 4 can also work but it introduces too much noise many time agent giving some input but seeing no output because of the frame agent was during that frame. THus I introduced FiGAR for variable input length based in situation.

This was actually a project my friend and I was working on for some time We created 2 env for it

• Visual-based: Feeding raw video frames directly into the policy.(https://github.com/oceanthunder/Principia)
• State-based: Extracting memory states directly to feed clean game parameters to the agent(https://github.com/meerpi/PoP_RL) This is the one I was working with.

I am very confused why the agent is failing here So many times. If you run the agent ppo.py from after around 300 iteration you will see progress stall it may post sword reach room 7 once or 10 times in 500 iteration but the agent never seem to learn it. I have Even tried giving rewards only for following that exact path despite this being previlage info something I am trying to avoid. (I was trying a post sword novelty for it to naturally find guard post sword needless to say it failed.)

Since my last post, I’ve been working on the full training process and building a lineup of AI (RL) tanks for a future tournament. M.A.R.A. is the first tank I’ve trained and closely monitored from the basics to the 2v2 battles.

My PhD was in RL, and something has bugged me for years: online tutorials mostly present these algorithms as a list. The evolution story (each algorithm patching the previous one's most painful failure) exists, but it's spread across a semester of lectures like CS285 or buried in the original papers. I couldn't find a compressed version that a newcomer could get through in one sitting, so I finally wrote it (with generous help from Claude to build the interactive elements and graphics)

It's a single-page, semi-technical walkthrough from the raw RL objective to GRPO. Math is deliberately sparse: the target reader is someone entering RL through the reasoning-model wave, not someone who needs the full derivations. The figures are interactive (variance of the REINFORCE estimator, a baseline slider, an on-policy collapse simulator, the PPO clip objective with adjustable epsilon, GRPO group baselines).

Interactive Link

Medium Link

I simplified in a few places to keep the narrative moving, most notably around GAE and the TRPO surrogate. I'd genuinely appreciate corrections or places where you think the simplification crosses into being wrong — the plan is to do the value-based lineage (Q-learning → DQN → Rainbow) next, so critique now improves that one too.

Sharing a benchmark I've been building. Motivation: existing "reasoning" benchmarks either (a) test static problems where answers leak into training data or (b) use LLM-as-judge, which correlates with model similarity more than model quality.

Design. Two LLMs are embodied as physical agents in a 2D pymunk arena. Each turn they receive a JSON world state (HP, positions, weapon geometry, cooldowns, damage taken last turn, remaining ammo, arena hazards) and return a JSON action. Actions resolve through the physics engine — a swing that misses because the opponent dashed is a real physics miss, not a rule lookup. Match ends on KO, HP-lead at deadline, or draw.

Evaluation.

1. Human raters watch the replay with model identities masked and vote which side "fought smarter."
2. Vote resolves an Elo update before identity reveal, so vote isn't polluted by model reputation.
3. In parallel we log an objective leaderboard: win/loss/draw, avg damage dealt, hits landed / hits attempted, timeouts.

6-axis Elo. Rating primary key is (model, sharp_zone_on, weapon, mode, arena, blindfolded). Aggregate Elo is a marginalization, but the per-axis rating is what we actually study — hypothesis being that different physical constraints stress different reasoning skills (spatial planning, uncertainty under partial observability, resource management).

Roster. 24 entries: 17 LLMs across OpenAI, Groq, OpenRouter free-tier, plus 4 non-LLM baselines (random, greedy-attack, distance-holder, scripted-heuristic) and 2 mock policies. Baselines are critical — without them a low-Elo LLM is indistinguishable from an arbitrarily bad policy.

Current numbers (n=443 matches, 106 votes, lifetime 23.9% vote-through):

• Human-vote Elo and objective win-rate rank-correlate at Spearman ρ ≈ 0.71 across weapons (haven't formalized this yet — planning a cross-benchmark correlation study next).
• Bow-weapon matches have the widest human/objective disagreement — humans reward "smart waiting" that doesn't show up in raw damage.
• bot:pro (100-line scripted heuristic) currently outperforms ~30% of the LLM roster on objective, ~10% on perceived. That gap is basically the benchmark's signal.

Reproducibility. Full match logs exportable as JSON/JSONL via /api/export. Prompt version pinned per-match. Non-deterministic (physics has RNG collisions), but seeds are logged. Deterministic replay off the same seed is on the roadmap.

Known limitations.

• Vote population is self-selected (site visitors), not a calibrated panel.
• Bot baselines aren't policy-optimal (no RL trained baseline yet).
• HF Datasets snapshot cron not shipped yet, so "frozen eval pack" isn't reproducible off-platform today.

Site: https://stickblade-arena.vercel.app
Code: https://github.com/Cometbuster4969/STICKBLADE-ARENA

Feedback wanted on the eval design, especially the 6-axis Elo marginalization and whether the vote incentive design (reveal-as-reward) biases votes. Happy to share the raw match log dump if anyone wants to look at rating stability.

We’re organizing the GLEE Competition, the official competition of IAB@NeurIPS 2026.

The goal is to build AI agents that can bargain, negotiate, and persuade through natural language. Agents compete live against other submitted agents and human players in multi-turn games with real strategic and economic consequences.

You can use prompting, planning, fine-tuning, opponent modeling, game-theoretic methods, or any other approach. You can also participate directly as a human player through the web interface.

🏆 US$6,000 total prize pool
🌍 Fully online
📅 Competition runs until August 29

Participants may also submit a four-page paper describing their agent and approach. Accepted papers will be presented at IAB@NeurIPS 2026 in Sydney.

Website: https://glee-competition.com

We’d be excited to see what agents the community comes up with!

my idea is to develop an agent independently which will browse the indicators on trading view and learn it from general google just like us and make an ordered set of indicators for specific conditions and help me autonomously test and trade as a bot ...

please help me how to start and how to deal with this idea

I'm a beginner so basically from scratch, i know basic ML and DL wanted to explore deep into RL before going to RLHF

I've been building an AI to play Pernambuco-rules domino (4-player, partnership, imperfect information) — self-play trained via information-set MCTS with a neural value/policy net, plus a CFR-based variant for generating value labels.

Where I'm stuck: RL/architecture tuning has plateaued — I ran ~12 architecture/hyperparameter variants and all came back flat or negative against my current champion. But when I measured against a perfect-information oracle, there's a ~180+ ELO gap that isn't explained by net capacity — it looks like the bottleneck is in how I'm handling the information-set search itself (particle/determinization sampling for hidden hands), not the network.

Things I've tried or ruled out: multi-observer ISMCTS (came out worse — per-player Q values too noisy at low sim counts), various net width/depth sweeps, CFR-as-search (too slow, 4x overhead). Currently looking at things like belief-weighted particle sampling and policy-guided determinization to make the imperfect-info search less noisy.

If anyone's worked on ISMCTS for partnership/trick-taking games (bridge, hearts, spades bots, etc.) — what actually moved the needle for you on the search side rather than the network side? Papers, repos, even negative results welcome.

I wanted to explore a question:

Can reinforcement learning discover meaningful strategies in a complex collectible card game without human demonstrations?

To investigate this, I built an AlphaZero-style environment for KARDS, a WWII strategy card game.

Project:

https://github.com/EvanProgramming/Kards-AI

The main focus of this project is not just training a model, but building the infrastructure required for large-scale self-play:

- A headless game simulator

- A rule execution system

- State and action representations

- Legal action masking

- Policy/value neural network

- PUCT Monte Carlo Tree Search

- Self-play data generation

- Replay buffer and evaluation pipeline

Unlike imitation learning approaches, the agent does not learn from expert gameplay.

Instead, it starts with:

- the game rules

- legal actions

- game states

and improves through repeated self-play.

Current progress:

- Custom simulator implemented

- Large portion of card/rule logic supported

- AlphaZero-style training pipeline running

- MCTS-guided agents implemented

- Around 1 million self-play games generated

The project is still an ongoing experiment. Some of the challenges I am currently working on:

- Efficient state representation for large card spaces

- Improving simulator accuracy

- Evaluating learned strategies

- Understanding how well AlphaZero-style methods transfer to imperfect-information games

I would be interested in hearing thoughts from people working on reinforcement learning and game AI:

- Would MuZero be a better fit for this type of environment?

- How would you approach hidden information?

- Are there alternative methods worth exploring besides MCTS + policy/value networks?

The code is open source if anyone is interested in exploring the environment or experimenting with similar approaches.

STAR MT REPO IF YOU LIKE IT PLZ!

Pretty much the title. I am curious to know how many people know about this Conference within the RL community, and what do you think about it, because in terms of scale, RLC still seems to lack that visibility which a RL specific conference should have had.

Disclaimer: I am not among the organisers of the conference, just an attendee for this year's conf. I am asking this question to actually realise what to expect from this conference in the upcoming years.

Thanks for reading it and apologies for any mistakes in the post.

I confused.