dave

interesting new work from Alibaba and WHU (Agentic Memory). most agent memory systems now are basically hardcoded infra, vector db + hand-written rules for when to store/delete/summarize. the model never gets to touch any of it. they made memory ops into actions. add, delete, update, retrieve, summarize, filter, same as calling a tool. then RL trains the whole thing end to end. the neat part is the model discovers on its own that it should proactively clean up its context when things get noisy. nobody wrote a "if tokens > 4k then summarize" rule. And it just emerged from the reward signal. makes you wonder how many other parts of the RAG pipeline are secretly just learnable actions we've been hand-coding for no good reason. arxiv.org/abs/2601.01885

here’s the blog post I wrote on environments davidokpare.com/blog/rl-101-q-…

first steps in rl (top-bottom approach) > read @jsuarez guide on rl > wrote a simple environment (basic python class) > built a q-learning agent > wrote a two parts blog post on what I learned

@toriste1 @Odenigbo511 @ebukagaus @OkeyMeta @GroqInc @real_okechukwu @Jeffreypaul_ Not exactly — I get your point tho, only that it’s worded wrongly. We based our work from existing research and added our flavors to it (every good research starts and takes inspiration from past research)

@DavidOkpare @Odenigbo511 @ebukagaus @OkeyMeta @GroqInc @real_okechukwu @Jeffreypaul_ Ya, you trained a model but from a foundation model, which is my point. But nonetheless you guys did a great job.

"Imagine a 17-year-old boy built an LLM @OkeyMeta from scratch" Meanwhile it is a llama3 model from @GroqInc inference via API Y'all are giving a platform and publicity to a FRAUDULENT PERSON and using age sentiment as a waiver @real_okechukwu you can not deceive everyone

Happy to know you took the time to read the paper :) yes the model is part of GPT-J family, we never stated we invented a new architecture. Similarly to almost every SoTA model out today being based on an MoE architecture, or the like of Mistral, Gemma, Qwen all based on Llama’s architecture

@toriste1 @Jeffreypaul_ @DavidOkpare @Odenigbo511 @ebukagaus @OkeyMeta @GroqInc @real_okechukwu I NEVER EVER said they fine tuned a model. I literally suggested they trained a model from scratch. However, it was based on the GPT-J architecture. Meaning the model was pre-trained on GPT-J and SabiYarn was not on an entirely new architecture.

@toriste1 @Odenigbo511 @ebukagaus @OkeyMeta @GroqInc @real_okechukwu @Jeffreypaul_ Here’s the paper too aclanthology.org/2025.africanlp…

@toriste1 @Odenigbo511 @ebukagaus @OkeyMeta @GroqInc @real_okechukwu @Jeffreypaul_ Wrong, we pretrained and fine-tuned the model (I’m part of the team) but thanks for the compliment :)

@Odenigbo511 @ebukagaus @OkeyMeta @GroqInc @real_okechukwu @Jeffreypaul_ trains from scratch (just like other major labs) huggingface.co/BeardedMonster…

@ebukagaus @OkeyMeta @GroqInc @real_okechukwu Everyone in AI knows no one builds AI from scratch, i don’t know what you’re expecting to gain by dunking on a 17 year old on the path to greatness.

New post 🎉 Going back to my roots on writing about the inner workings of things, a breakdown of key-value databases and how you might make one from scratch: nan.fyi/database

Readers responded with both surprise and agreement last week when I wrote that the single biggest predictor of how rapidly a team makes progress building an AI agent lay in their ability to drive a disciplined process for evals (measuring the system’s performance) and error analysis (identifying the causes of errors). It’s tempting to shortcut these processes and to quickly attempt fixes to mistakes rather than slowing down to identify the root causes. But evals and error analysis can lead to much faster progress. In this first of a two-part letter, I’ll share some best practices for finding and addressing issues in agentic systems. Even though error analysis has long been an important part of building supervised learning systems, it is still underappreciated compared to, say, using the latest and buzziest tools. Identifying the root causes of particular kinds of errors might seem “boring,” but it pays off! If you are not yet persuaded that error analysis is important, permit me to point out: - To master a composition on a musical instrument, you don’t only play the same piece from start to end. Instead, you identify where you’re stumbling and practice those parts more. - To be healthy, you don’t just build your diet around the latest nutrition fads. You also ask your doctor about your bloodwork to see if anything is amiss. (I did this last month and am happy to report I’m in good health! 😃) - To improve your sports team’s performance, you don’t just practice trick shots. Instead, you review game films to spot gaps and then address them. To improve your agentic AI system, don’t just stack up the latest buzzy techniques that just went viral on social media (though I find it fun to experiment with buzzy AI techniques as much as the next person!). Instead, use error analysis to figure out where it’s falling short, and focus on that. Before analyzing errors, we first have to decide what is an error. So the first step is to put in evals. I’ll focus on that for the remainder of this letter and discuss error analysis next week. If you are using supervised learning to train a binary classifier, the number of ways the algorithm could make a mistake is limited. It could output 0 instead of 1, or vice versa. There is also a handful of standard metrics like accuracy, precision, recall, F1, ROC, etc. that apply to many problems. So as long as you know the test distribution, evals are relatively straightforward, and much of the work of error analysis lies in identifying what types of input an algorithm fails on, which also leads to data-centric AI techniques for acquiring more data to augment the algorithm in areas where it’s weak. With generative AI, a lot of intuitions from evals and error analysis of supervised learning carry over — history doesn’t repeat itself, but it rhymes — and developers who are already familiar with machine learning and deep learning often adapt to generative AI faster than people who are starting from scratch. But one new challenge is that the space of outputs is much richer, so there are many more ways an algorithm’s output might be wrong. Take the example of automated processing of financial invoices where we use an agentic workflow to populate a financial database with information from received invoices. Will the algorithm incorrectly extract the invoice due date? Or the final amount? Or mistake the payer address for the biller address? Or get the financial currency wrong? Or make the wrong API call so the verification process fails? Because the output space is much larger, the number of failure modes is also much larger. Rather than defining an error metric ahead of time, it is therefore typically more effective to first quickly build a prototype, then manually examine a handful of agent outputs to see where it performs well and where it stumbles. This allows you to focus on building datasets and error metrics — sometimes objective metrics implemented in code, and sometimes subjective metrics using LLM-as-judge — to check the system’s performance in the dimensions you are most concerned about. In supervised learning, we sometimes tune the error metric to better reflect what humans care about. With agentic workflows, I find tuning evals to be even more iterative, with more frequent tweaks to the evals to capture the wider range of things that can go wrong. I discuss this and other best practices in detail in Module 4 of the Agentic AI course on deeplearning.ai that we announced last week. After building evals, you now have a measurement of your system’s performance, which provides a foundation for trying different modifications to your agent, as you can now measure what makes a difference. The next step is then to perform error analysis to pinpoint what changes to focus your development efforts on. I’ll discuss this further next week. [Original text: deeplearning.ai/the-batch/issu… ]

Copy-pasting PyTorch code is fast — using an AI coding model is even faster — but both skip the learning. That's why I asked my students to write by hand ✍️. 🔽 Download: byhand.ai/pytorch After the exercise, my students can understand what every line really does and connect it to the math. You can too!

Bad take, OpenAI just validated the market. There will always need to be products that support other models / ecosystems.

LoRA in reinforcement learning (RL) can match full-finetuning performance when done right! 💡 A new @thinkymachines post shows how using 10x larger learning rates, applying LoRA on all layers & more, LoRA at rank=1 even works. We're excited to have collaborated on this blog!

It's delightful how easy it is to deploy working prompt injection attacks via LinkedIn

Many people think LLMs are non-deterministic. This is often not true! You just need 3 lines of code to make your LLM deterministic LLMs (as any PyTorch model) are non-deterministic only when they include certain operations or when using multiple GPUs Try the code yourself

quality slop

I just realized that I have been building out a “demo project” with Kubernetes and load balancers even after squeezing out 10k request/secs from it

@aigeek__ @jobergum yeah, that was the initial pushback but then people started suggesting skipping evals altogether, instead of pushing for DIY evals

@jobergum @DavidOkpare i think, it is more of a revolt against the tools than the fact that people New’s to start looking at their data more closely to get better results.

The upside of the eval wars is that it triggered creation of a lot of high alpha content

tl;dr: don’t outsource evals. log your traces and QA them yourself. evals aren’t a sham, they’re necessary but best done diy.