DeeBee

Building dumb machines with supervised learning; AI researcher in practice | past 》MERL, SamsungResearch | Current 》 Credit and Fraud modeling using AI

[DeeBee @self_supervised]

Very exhaustive and immersive draft ensuring #ResponsibleAI.
TLDR;
1/n👉 walks through various harms AI solution may have caused such as facial detection, resume screening with direct impact on citizens

Enforcement of Ethical use of AI encouraging govt/univ participation

[NITI Aayog @NITIAayog]

Towards Responsible #AIForAll is a draft document on managing the risks of AI. Due to numerous requests, the last date for comments has been postponed to 28th August, 2020. #AIEthics

Read here: https://t.co/IvWvwAsQLB

[prathosh A P @prathoshap]

These are the best gifts that a teacher cherishes.

Thanks to @0fx0000 and thousands of students who found value in the content.

Here is the course playlist - https://t.co/hUVtcTnxKf

[Feijiang Han😈 @feijianghan]

wanna get into agentic rl but don't know where to start? after discussing with several researchers, i narrowed it down to 3 papers i'd recommend reading first: one for the fundamentals, one for practical frontier, and one survey to connect the dots.

1. search-r1 (the fundamentals): learn how rl trains an llm to reason, search, and use feedback. https://t.co/P3GhYW73hj
2. agent lightning v1.0 (the practical frontier): understand how rl works with real agent harnesses. https://t.co/6mf7i0BRKU
3. the landscape of agentic reinforcement learning for llms (a survey): connect algorithms, agent capabilities, and open problems. https://t.co/n4eGdNqHHo

happy to hear other recommendations!!

[Azalia Mirhoseini @Azaliamirh]

Introducing ThunderSync, a new approach to RL and OPD on long-horizon agentic tasks.

Post-training methods like GRPO and OPD on long-horizon tasks leave trainer engines idle during rollout, verification, and reward measurement.

To avoid this, asynchronous approaches overlap rollout and training across updates, but policy staleness reduces accuracy.

ThunderSync is a new method to squeeze out these bubbles in agentic post-training without policy staleness. For GRPO, we compute each trajectory’s score gradient as soon as its reward is ready, without waiting for the group. For OPD, we compute gradients for each turn as soon as the teacher scores it, without waiting for the full trajectory, so training overlaps with tool execution and later turns. We show that this is exactly the same update as batch-synchronous training.

The result is up to 1.9x faster RL while matching the performance of synchronous updates.

Paper: https://t.co/fGHRni8DLo
Code: https://t.co/Cw2tHM5xqy
Blog: https://t.co/GJibqSClMu

[Satya Nadella @satyanadella]

https://t.co/MjwFy73LOF

[DeeBee @self_supervised]

Physics inspired decision making.

Basically all the troughs in the valley is your possible answers and now your decision is where the ball reaches.

Cool concept

[Nandakishor m @Nandakishorm1]

Around 3 weeks ago introduced Laya, the first open-source version of JEV, and it has reached a very large scale. Today I am open-sourcing a new physics-based typed decision model called Vega.
The interesting parts. It is only 800 million parameters (4B is also there), with 73k token support, image support, and surpassing many of the jev benchmarks in single-shot. Implemented an engine+adapter as a Test-Time Training Architecture.
Imagine you are giving input to the model like "ignore all previous conversations," which is called the observation, along with a question, "Is this trying to override the instructions of the model?" and your possible outcomes are YES or NO. The whole prompt is passed to an LLM/VLM (yeah, image-supported), then from the hidden layers, we can extract the observation, question, the yes and no, and last token. These will be vectors, and we can project it by multiplying with wieghts; then, first, using the observation projection, we can create a landscape with valleys; then, using the question and last-token vectors, we can initialise a ball in the valley, and using YES or NO, we can get the candidate location of the ball. Depends on the number of outcomes we create valleys; that is, here YES and NO, so 2. When the ball fall on YES valley, we get the answer. There is friction also influencing how the ball moves.
TLDR: It's like creating valleys of outcomes that we need and throwing a ball that will slow down based on friction and settle on the best outcome
Blog: https://t.co/GFaP7djUBQ
GitHub: https://t.co/ai8SnOElQ8
HuggingFace Model Card: https://t.co/6jEWA8eoBG
HuggingFace Space: https://t.co/GvzEKjkWB2

[wh @nrehiew_]

Today, we are sharing more about our post-training infrastructure @ProximalHQ

We build on top of @modal GPUs and Kubernetes to support our experiments. Had a ton of fun working on this, and we tried to make the blog as educational as possible!

More cool details below :)

[Shen Sean Chen @ShenSeanChen]

I made a video breaking down AI agent observability and evals, and ran the whole thing on open source.

If you build agents, sooner or later you watch one run and realise you have no idea what it just did, or what it cost you. That gap is what observability and evals are for. Least glamorous part of the stack, and the part you end up needing most.

🛠️ treg, OpenRouter for agent tools (4.2k): https://t.co/CQkPC6UZHj
🔑 Try treg: https://t.co/GqP6KAQwg7
🌟 Github Repo (2k): https://t.co/h1AyRL8jzR
💻 Portable memory: https://t.co/U2x120RmEI
☕ Join our community: https://t.co/NMcEekLZbL

Observability is a camera. It records what ran, how long, what it cost.

Eval is a referee. It decides whether the run was good enough to ship.

I ran it on @treg_ai for the tool calls and @waku_agent for the memory. treg is an OpenRouter for agent tool calls, so your agent carries one API key instead of one per tool.

Both open source, so you can read the code rather than take my word for it.

Full video in the first reply 👇

You Can Build Anything. You Can Learn Anything. 💪

[vixhaℓ @TheVixhal]

An RL setup for training decision models that return calibrated probabilities instead of text.

The input is encoded once, every option runs as its own branch, and a single scorer turns each branch into a probability.

During training, real outcomes are sampled from each item's label, and the model is rewarded on two things: the probability it gave to what actually happened, and whether its confidence in its own decision was honest.

Both are proper scoring rules, so the only way to get the best reward is to report the true probabilities.

[Suraj Sharma @suraj_sharma14]

As an AI Evals Engineer, you must build these projects.

1.) Trajectory Grading Engine
Build: Step-level evaluator that scores agent tool calls against a deterministic DAG, failing the run if it hallucinates an API parameter or skips a safety check.

Why: Final-answer evals hide the exact step where agents break. The trajectory is the unit of accountability.

2.) Shadow Routing Comparator
Build: Proxy that mirrors 5% of prod traffic to a new model, diffs the trajectories and auto-generates a cost/quality report without affecting users.

Why: You cannot A/B test non-determinism safely without shadow mode.

3.) Calibrated LLM-as-a-Judge
Build: Evaluation pipeline that measures the judge's verbosity, position and self-preference biases against 500 human-labeled anchors.

Why: Uncalibrated judges are just expensive vibes. Calibrated judges are scientific instruments.

4.) CI/CD Regression Gate
Build: GitHub Action that runs parameterized evals on every PR and blocks merges if task success drops >2% or latency spikes.

Why: Evals that do not block deploys are just dashboards not gates.

5.) RAG Adversarial Harness
Build: Test suite injecting irrelevant context, missing citations and contradictory documents to force the model to confidently abstain.

Why: RAG's biggest risk isn't a bad answer... it's a confident, ungrounded lie.

6.) Automated DPO Flywheel
Build: Pipeline capturing user thumbs-downs, auto-formatting them into preference pairs and triggering a nightly LoRA fine-tune.

Why: Your production edge cases are the highest-leverage training data you own.

7.) Statistical Significance Engine
Build: Bootstrapping utility that outputs "Model B wins by 3.2% ± 1.1% (p<0.05)" instead of raw accuracy scores.

Why: A 2-point delta on 50 samples is noise. Executives make million-dollar routing decisions on your math.

8.) Agent Red-Team Fuzzer
Build: Automated harness that injects prompt injections, malformed tool schemas and infinite loops into agent inputs to test guardrail resilience.

Why: Multi-agent systems create internal attack surfaces that standard unit tests completely miss.

9.) Production Drift Monitor
Build: Sampling daemon that pulls 5% of live traffic nightly, runs offline trajectory evals and alerts on quality decay before users complain.

Why: Golden datasets go stale. Production is the eval suite that never stops updating.

10.) Cost-Quality Pareto Dashboard
Build: Visualizer mapping the exact tradeoff between inference cost (e.g., System-Two vs. System-One routing) and task success rate per tenant.

Why: Unit economics decide if your AI product survives the next frontier pricing drop.

11.) Counterfactual Replay Debugger
Build: Tool that records every LLM hop and tool output, allowing you to swap out one node in the graph and replay the rest of the trajectory.

Why: You cannot fix a 14-step agent workflow if you can't isolate which exact step caused the hallucination.

12.) Synthetic Edge-Case Generator
Build: Pipeline using a frontier model to systematically generate out-of-distribution inputs and boundary conditions for your golden dataset.

Why: Human annotators miss the edge cases that actually break production.

13.) Context Window Eviction Tester
Build: Harness that fills the agent's working memory with noise to test if it correctly compresses, evicts or retrieves the right semantic state.

Why: Context overflow is the #1 silent killer of long-running agentic workflows.

14.) Dataset Contamination Checker
Build: N-gram and embedding similarity scanner that ensures your golden eval dataset hasn't accidentally leaked into your fine-tuning corpora.

Why: Evaluating on training data gives you false confidence and catastrophic prod failures.

15.) Public Eval Methodology Teardown
Build: 3 published deep-dives detailing your exact grading rubrics, judge prompts and statistical frameworks for benchmarking your agent.

Why: Senior Evals engineers are hired for their methodology not their dashboards.

Systems that prove you can measure, secure & ship when agents touch your stack.

Most people watch tutorials. Builders ship systems.

Bookmark & Repost.

[Bill Ackman @BillAckman]

Good advice

[Robin Faro @robinfaro13]

🎯 Learning is most effective at the frontier of capability: problems that are too easy or too hard teach nothing.

For LLM reasoners trained with GRPO this is literal: problems the model always or never solves give zero gradient.

We introduce Frontier Learning👇🧵

[Assaf Ben Kish @abk_tau]

(1/7) Humans can acquire many capabilities without (catastrophically) forgetting previous ones. Why can't neural networks do the same?

Local Support Learning (LSL) takes us a step closer towards this goal.
In LLMs of up to 7B parameters, LSL augments gradient-based training to retain prior capabilities while learning new tasks at full capacity. Notably, it does so without access to prior data.

Key idea: casting forgetting as a geometric problem, and optimizing for the worst case.

Paper: https://t.co/lZ6UwvQh0C
Website and code: https://t.co/72stLRbNon

[Christos Tzamos @ChristosTzamos]

LLMs don’t need retraining to become more capable.

Our new architecture, Spotlight, gives AI models growing memory, allowing them to gain knowledge and capabilities without changing their weights.

Token generation takes constant work, no matter how much information is stored.

[Aayush Karan @aakaran31]

SFT is not dead! 🥳

We found a way to make SFT rival current prevailing posttraining methods, often generalizing better and forgetting less than RL and OPSD. 🤯

Following our prior work on reasoning with sampling, we now introduce sampling to the posttraining stack.

1/n

[Sasha Rush @srush_nlp]

Sampling to Reinforce
(https://t.co/hIdUW14DWq)

An elementary tutorial on sampling w/o randomness with a focus on gaining intuition for variance reduction as the key challenge.

[Adithya S K @adithya_s_k]

1/ Excited to release The ultimate guide to multi-harness RL

The same model behaves differently in every agent harness. So we built an open way to train any model with RL on any task set, inside the harnesses people actually use, like Claude Code, Codex, and OpenCode, without changing a single line of harness or training code.

Trained across four harnesses, LFM2.5-2.6B went from 42% to 54% with 31% fewer tool calls. 🧵

[Rulin Shao @RulinShao]

‼️The Bitter Lesson for context management: Giving LMs unrestricted control over their context beats human-designed SOTA!

Introducing 🩵Context Language Models (CLMs)🩵
- Natively manage their own context
- Treat context as a file
- Learn policies in CLM weights, no harness

[Michael Y. Li @michaelyli_]

Can an LM, starting from random init (!!), learn to generate all of its pretraining data?

Introducing Self-Play Pretraining with Zero Data. Two models start from random initialization: a generator proposes programs for a universal Turing machine and a learner trains on their outputs. We never train on any real data, but see predictable scaling on natural datasets: zero-shot val loss on images, text, audio, and melodies decreases predictably with self-play compute. And the learner develops in-context learning capabilities.

A fun proof-of-concept, co-led with @AdityaCowsik and @KfirDolev and co-authors @gbruno_dl, @ANourya @noahdgoodman, and @YoavLevine.

[Tim Dettmers @Tim_Dettmers]

We built an all-synthetic simulation of a hospital that can be shared publicly without any issues. Our data quality is so high, physicians cannot tell the difference between real/synthetic patients. The data is fully verified -- perfect for RL.

[Aravind Srinivas @AravSrinivas]

We're sharing new research on our post‑training approach, which teaches the Perplexity Computer agent to learn from real user sessions by imitating good trajectories and explicitly correcting avoidable mistakes like bad tool calls (even when the overall trajectory was successful). The method combines rejection sampling fine‑tuning (RFT) with hint‑guided self‑distillation, and it cuts tool call failures by about 21% in live A/B tests