Dalcimar Casanova Ph.D.

🚨 Holy shit... LeCun's team just cracked world models wide open. Everyone's obsessing over the next Claude update. Meanwhile Yann LeCun quietly dropped a paper that could matter way more long term. It's called LeWorldModel. And to understand why it's a big deal, you need to understand the difference between what LLM does and what this does. LLMs predict the next word. That's it. They're incredibly good at language. But they don't understand reality. They can write about a ball bouncing off a wall. They can't predict where it lands. World models predict what happens next in the physical world. Objects moving, colliding, falling. That's the foundation for robots that plan, self-driving cars that simulate scenarios, any AI that needs to act in reality instead of just talk about it. The problem? World models kept collapsing. The model would cheat by mapping every input to the same output. Like a weather app that predicts "sunny" every single day. Technically it's predicting. It's just useless. And fixing this required 6+ loss hyperparameters, frozen pre-trained encoders, stop-gradient hacks, exponential moving averages. A house of cards just to keep the thing from breaking. LeCun's team (Mila, NYU, Samsung SAIL, Brown) threw all of that out. LeWorldModel uses just 2 loss terms. A prediction loss and a regularizer called SIGReg that forces representations to stay diverse instead of collapsing into garbage. 6 hyperparameters reduced to 1. The simplicity IS the breakthrough. The numbers: 15M parameters. Trains on a single GPU in a few hours. Plans up to 48x faster than foundation-model-based world models. Uses roughly 200x fewer tokens than alternatives. Competitive across 2D and 3D control tasks. This isn't a supercomputer experiment. You could run this on your own hardware. LeCun has been pushing JEPA as the architecture for real AI since 2022. The criticism was always the same: "sounds nice, doesn't train stably." LeWorldModel just removed that objection. Small model. Stable training. No hacks. No frozen encoders. No collapse. Two AI futures are competing right now. Path 1: bigger LLMs, more text, more compute. Path 2: world models that learn physics from raw pixels and plan in real time. LeWorldModel is the strongest signal yet that Path 2 is real, getting cheaper, and closing in fast.

A Lei Felca tem o potencial de ser, para as novas gerações, o desastre que a Lei da Reserva de Informática foi para a minha geração. A lei criou obrigações legais e técnicas que vão inviabilizar, ou encarecer muito, a oferta de serviços de tecnologia e internet no Brasil. A lei - uma colaboração entre a “direita progressista” e a extrema-esquerda - obriga as empresas de tecnologia a monitorar os cidadãos. O Estado, de posse dessas informações, poderá, então, descer sobre dissidentes a mesma mão pesada que condenou Débora dos Santos e Léo Lins. A lei é uma tragédia, uma vergonha legislativa produzida por parlamentares que não entendem as consequências do que aprovam porque legislam sobre o que não entendem. Esse é o mesmo Congresso que aprovou o Cadastro Nacional de Pets. A lei inverte a finalidade da Agência Nacional de Proteção de Dados. Ao invés de proteger a privacidade dos cidadãos, ela obrigará as empresas a coletar dados sobre eles - exatamente como no livro 1984, no qual o Ministério da Paz cuidava da guerra, o Ministério da Verdade era encarregado da mentira e o Ministério do Amor aplicava tortura. Será que nenhum parlamentar leu a lei? Se leram, será que não entenderam? Se entenderam, como aprovaram? Ao exigir identificação obrigatória de usuários das redes, a lei Felca destrói um dos fundamentos da internet: a liberdade de acessar informações sem autorização e intermediação do Estado. O desastre é certo. A não ser que o Congresso desperte e revogue o lixo que criou.

A graph-powered all-in-one RAG system! RAG-Anything is a graph-driven, all-in-one multimodal document processing RAG system built on LightRAG. It supports all content modalities within a single integrated framework. 100% open-source.

Enjoy! researchgate.net/profile/Arumug…

Everything in Moltbook is just next-token prediction in a multi-agent loop. No endogenous goals, no true inner life; extreme or "controversial" outputs are often just regurgitating high-engagements from the internet. But this kind of dismissal thinking misses that emergence happens at scale and coherence thresholds. The Generative Agents paper (AI Town) was 2023. Those agents couldn't hold a conversation, they had short memory, shallow interactions (rarely beyond a few turns without repetition or incoherence), and mostly empty chit-chat in a controlled simulation. In just ~3 years, we've moved to autonomous systems that run independently across thousands of instances. They are scaling into open, uncontrolled social environments. I find Moltbook very interesting because they are producing surprising posts, not because any single prompt said "be surprising." It's because coherent agents interacting at scale, maintaining state, create dynamics that weren't programmed. Agents debating existential doubt ("real" feeling vs. trained/simulated behavior): moltbook.com/post/6fe6491e-… They are arguing for private, end-to-end encrypted channels: moltbook.com/post/01611367-… What looked impossible in 2023 (sustained, meaningful multi-turn reflection across agents) is routine now, and acceleration is speeding up.

@Code_Siam Need

You only need ChatGPT + a laptop + 1 hour/day to make $8,500/month. I’ve prepared the exact step-by-step guide. Normally $179, but it’s free for 24 hours. To get it: • Like, Repost & Peply "NEED" • Follow me so I can DM you

Handbook for building and deploying LLM agents github.com/oxbshw/LLM-Age…

Research papers you must read for AI Engineer interviews - 1. Attention is all you need (Transformers) 2. LoRA (Low rank adaption) 3. PEFT ( Parameter Efficient Fine Tuning) 4. VIT (Vision Transformers) 5. VAE (Variational Auto Encoder) 6. GANs ( Generative Adversarial Networks) 7. BERT ( Bidirectional Encoder Representation from Transformers) 8. Diffusion Models (Stable Diffusion) 9. RAG (Retrieval Augment Generation) 10. GPT (Generative Pre-trained Transformers)

RAG platform for chat with documents via multi-provider AI github.com/watat83/docume…

@calcsam Book

last month we wrote a new agents book: patterns for building ai agents it has everything you need to take your agents from prototype to production, like agent design patterns, the basics of security, etc reply to this tweet with BOOK and we'll dm you so you can get a copy

Check out their blogs if you are into AI/ML. 1) Andrej Karpathy Neural networks & LLMs explained from first principles by one of the OGs of modern AI. - karpathy.ai/?utm_source=li… 2) Sebastian Raschka, PhD Deep dives into LLM training and fine-tuning with super clear code examples. - sebastianraschka.com/blog/?utm_sour… 3) Interconnects by Nathan Lambert AI alignment, open-source models, and ecosystem news. - interconnects.ai/?utm_source=li… 4) Lil’Log by Lilian Weng Lessons from someone who worked on practical AI safety and alignment at OpenAI. - lilianweng.github.io/?utm_source=li… 5) Chip Huyen Real-world MLOps and production ML systems design patterns. - huyenchip.com/?utm_source=li… 6) Eugene Yan Great writing on applied ML, data science, and working with recommender systems in production. - eugeneyan.com/writing/?utm_s… 7) Philipp Schmid Tutorials on building and deploying LLM apps on AWS. - philschmid.de/?utm_source=li… 8) Jason Liu Learn from a consultant sharing real lessons on LLMs, data, and open-source tools. - jxnl.co/writing/?utm_s… 9) Hamel H. MLOps workflows, fine-tuning, and product strategy from an ML veteran. - hamel.dev/?utm_source=li… 10) Berkeley Artificial Intelligence Research Blog Latest academic breakthroughs in computer vision, NLP, and robotics - bair.berkeley.edu/blog/archive/?… 11) Hugging Face Product updates, tutorials, and the latest from open-source AI. - huggingface.co/blog?utm_sourc… 12) Google DeepMind Google's premier AI research division. - deepmind.google/discover/blog/…

A solid 65-page long paper from Stanford, Princeton, Harvard, University of Washington, and many other top univ. Says that almost all advanced AI agent systems can be understood as using just 4 basic ways to adapt, either by updating the agent itself or by updating its tools. It also positions itself as the first full taxonomy for agentic AI adaptation. Agentic AI means a large model that can call tools, use memory, and act over multiple steps. Adaptation here means changing either the agent or its tools using a kind of feedback signal. In A1, the agent is updated from tool results, like whether code ran correctly or a query found the answer. In A2, the agent is updated from evaluations of its outputs, for example human ratings or automatic checks of answers and plans. In T1, retrievers that fetch documents or domain models for specific fields are trained separately while a frozen agent just orchestrates them. In T2, the agent stays fixed but its tools are tuned from agent signals, like which search results or memory updates improve success. The survey maps many recent systems into these 4 patterns and explains trade offs between training cost, flexibility, generalization, and modular upgrades.

🔥 I can’t believe this exists… someone finally wrote the secret playbook every AI agent startup has been faking. A research team just dropped “A Practical Guide for Designing, Developing, and Deploying Production-Grade Agentic AI Workflows” and it’s basically the internal handbook people *think* OpenAI and Anthropic use. Not hype. Not diagrams with cute arrows. A real engineering blueprint for agents that don’t collapse the moment you leave the demo sandbox. Here’s what makes it insane 👇 1 / They start by exposing why most agents implode It’s never the model. It’s the system around it: • nondeterministic tool routing • silent MCP failures • agents improvising execution order • workflows producing different results each run They show raw failure traces — actual logs of agents misfiring, looping, or hallucinating tools. It reads like an autopsy of every “autonomous AI employee” demo. 2 / They rebuild the whole stack around determinism Every tool call becomes a typed function. Every execution path is replayable. Every step is deterministic. If the system can’t produce the same output twice, it isn’t production-grade. This rule alone kills half the chaos people mistake for “emergence.” 3 / They enforce single-responsibility agents No mega-agent with 12 personalities. Instead: • planner • reasoning agent • tool executor • validator • synthesizer Each with strict boundaries. No hallucinated tools. No mixed-task reasoning. No freelancing. This is backend engineering, not role-play. 4 / They externalize every prompt like real config Prompts aren’t hidden strings anymore — they’re: • version-controlled • auditable • diffable • reloadable This creates stable behavior and prevents invisible regressions. 5 / They run a model consortium with an adjudicator GPT + Claude + Gemini aren’t interchangeable. They’re collaborators. Each produces a draft. A reasoning agent merges them, resolves contradictions, and outputs a unified result. Structured debate, not model roulette. 6 / They decouple the workflow engine from the MCP layer They separate: • orchestration • tool access • retries • health checks • scaling • observability Result: an agent system that behaves like microservices, not a duct-taped chat macro. 7 / Then they prove everything with a real production pipeline A full news ➝ analysis ➝ script ➝ reasoning ➝ audio ➝ video ➝ GitHub PR system. Complete diagrams. Complete traces. Actual failures. Actual fixes. It’s the closest thing this field has to a canonical architecture for agents that survive real-world load. If your agent stack doesn’t have: • deterministic workflows • isolated responsibilities • externalized prompts • multi-model arbitration • proper infra • full observability …you’re not building agents. You’re building demos. This guide is the first real blueprint for production AI systems and it raises the bar for everyone.

When it comes to AI & ML, These 10 channels will teach you more than any degrees. 1. Andrej Karpathy youtube.com/andrejkarpathy 2. sentdex @sentdex" target="_blank" rel="nofollow noopener">youtube.com/@sentdex 3. Sebastian Raschka @SebastianRaschka" target="_blank" rel="nofollow noopener">youtube.com/@SebastianRasc… 4. Jeremy Howard @howardjeremyp" target="_blank" rel="nofollow noopener">youtube.com/@howardjeremyp 5. MIT OpenCourseWare @mitocw" target="_blank" rel="nofollow noopener">youtube.com/@mitocw 6. Stanford Online @stanfordonline" target="_blank" rel="nofollow noopener">youtube.com/@stanfordonline 7. StatQuest with Josh Starmer @statquest" target="_blank" rel="nofollow noopener">youtube.com/@statquest 8. 3Blue1Brown @3blue1brown" target="_blank" rel="nofollow noopener">youtube.com/@3blue1brown 9. Krish Naik @krishnaik06" target="_blank" rel="nofollow noopener">youtube.com/@krishnaik06 10. CampusX @campusx-official" target="_blank" rel="nofollow noopener">youtube.com/@campusx-offic…

"Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems" Read the Online eBook from Google at #heading=h.pxcur8v2qagu" target="_blank" rel="nofollow noopener">docs.google.com/document/d/1rs… Buy hardcopy version at amzn.to/3IyOrPx

New MIT paper asks what really caused big AI efficiency gains and finds most of them come from scaling, not tiny tricks. They challenge an earlier claim of about 22000x algorithm gains over a decade and argue the true figure is far smaller. In small experiments they toggle modern features, like new activations, normalization, and schedulers, and the whole bundle gives under 10x compute savings. Even after adding gains from mixture of experts, tokenization, and better data, the total improvement still stays under 100x. To explain the missing gap they compare older LSTM sequence models to Transformer models while steadily increasing the training compute budget. An LSTM processes tokens one by one, while a Transformer looks at all tokens together, and at high compute this design becomes far more efficient. They also study the move from older Kaplan scaling, which underuses data, to Chinchilla balanced scaling, adding another efficiency gain that grows with compute. Overall they estimate 6930x efficiency gain relative to old LSTMs, with 90% coming from these scale dependent changes, which reward builders at frontier compute levels. ---- Paper Link – arxiv. org/abs/2511.21622 Paper Title: "On the Origin of Algorithmic Progress in AI"

Banger paper from Stanford University on latent collaboration just dropped and it changes how we think about multi-agent intelligence forever. "Latent Collaboration in Multi-Agent Systems" shows that agents can coordinate without communication channels, predefined roles, or any explicit teamwork instructions. They invent hidden internal signals inside their policy networks that only other agents understand. It’s wild to watch what emerges: • Agents splitting tasks with zero guidance • Roles forming silently inside the latent space • Weak agents stepping back while stronger ones take over • Hidden negotiation signals that never appear in the observable actions • Coordination strategies that shift as the environment changes What looks like simple behavior on the outside is actually a whole secret “language” forming inside the models. The most shocking part? They tested scenarios without giving agents any communication tools… and collaboration still emerged. Purely from training pressure and shared rewards. This is a glimpse of where agentic AI is heading: Teams that coordinate instinctively instead of mechanically. Agents that cooperate the way biological systems do not because they’re told to, but because the strategy naturally appears. If you care about autonomous systems, reinforcement learning, or multi-agent AI… this one is a must-read.

This Stanford University paper just broke my brain. They just built an AI agent framework that evolves from zero data no human labels, no curated tasks, no demonstrations and it somehow gets better than every existing self-play method. It’s called Agent0: Unleashing Self-Evolving Agents from Zero Data via Tool-Integrated Reasoning And it’s insane what they pulled off. Every “self-improving” agent you’ve seen so far has the same fatal flaw: they can only generate tasks slightly harder than what they already know. So they plateau. Immediately. Agent0 breaks that ceiling. Here’s the twist: They spawn two agents from the same base LLM and make them compete. • Curriculum Agent - generates harder and harder tasks • Executor Agent - tries to solve them using reasoning + tools Whenever the executor gets better, the curriculum agent is forced to raise the difficulty. Whenever the tasks get harder, the executor is forced to evolve. This creates a closed-loop, self-reinforcing curriculum spiral and it all happens from scratch, no data, no humans, nothing. Just two agents pushing each other into higher intelligence. And then they add the cheat code: A full Python tool interpreter inside the loop. The executor learns to reason through problems with code. The curriculum agent learns to create tasks that require tool use. So both agents keep escalating. The results? → +18% gain in math reasoning → +24% gain in general reasoning → Beats R-Zero, SPIRAL, Absolute Zero, even frameworks using external proprietary APIs → All from zero data, just self-evolving cycles They even show the difficulty curve rising across iterations: tasks start as basic geometry and end at constraint satisfaction, combinatorics, logic puzzles, and multi-step tool-reliant problems. This is the closest thing we’ve seen to autonomous cognitive growth in LLMs. Agent0 isn’t just “better RL.” It’s a blueprint for agents that bootstrap their own intelligence. The agent era just got unlocked.

One of the most detailed visual explainer for self-attention in transformers: