TL;DR: AgentGarten is a virtual-world framework that keeps simulator-grade faithfulness while matching video-model realism, and it taught agents hide-and-seek tool-use strategies in a handful of rounds that took conventional RL millions of episodes. Title: AgentGarten: Code Worlds for Evolving Agents URL: Points 🎮 Couples a scene program (state, rules) with a neural renderer (visuals) through structured conditions like depth and normal maps, decoupling physics from appearance 🔬 A new technique, "Adversarial Forcing," makes history prefilling differentiable via bitwise-exact replay with block-by-block SDPA attention, where standard approaches weren't differentiable at all ⚡ Achieves real-time rendering at 480×832 and 36.5fps on a single H100 🤖 A "playbook" mechanism lets agents carry round-by-round reflections forward, accumulating knowledge with no gradient updates 🏃 In hide-and-seek, shelter-building emerged by round 4 (vs. ~25M episodes for self-play RL) and ramp use by round 10 (vs. ~100M episodes) 📈 Other environments — herding, a quarry loader — also show clear gains within just 4 rounds What's striking is how much learning efficiency you gain just by architecturally separating state dynamics from visual generation. #WorldModels# #AgentLearning#

Must-read papers of the week ▪️ Agent Lightning v1.0: Towards Harnessed Agentic RL ▪️ LEGO-RL: Harness-Native Reinforcement Learning for Coding Agents ▪️ EnvHarness: Awakening Static Worlds for Agent Learning ▪️ SPADE: Self-Play in Adaptive Synthetic Executable Environments ▪️ SkillGate: Training In-Policy Skill Selection in Long-Horizon Agents ▪️ Looped Language Models Improve Compositional Tool Calling ▪️ Graph Engineering in the Era of LLM Agents ▪️ Chain-of-Experience for Continual LLM Improvement ▪️ Cross-Model Memory Transfer via Target-Side Reader Adaptation ▪️ CLEAR: Continuous Latent Adapter Routing for Utility-Preserving LLM Safety Alignment ▪️ EXIMO: VLM Guided Exploration of VLA Policies ▪️ FreeToken: Efficient Edge-Native MoE Serving with Bandwidth-Adaptive Execution ▪️ Llama-Mobile: Efficient 2.7-Bit Quantization of VLMs ▪️ Improving the Matrix Multiplication Exponent with Modern Optimization and AlphaEvolve Here is the full list of the most interesting papers + links:

Loved this 22-minute talk on continual learning for AI agents. Must watch for anyone looking to get agents performant and into production. Credit: @FeiziSoheil at @aiDotEngineer • Agent learning can happen at three layers: the model (weights), the harness (prompts, tools, skills, code, workflows), and memory (session or persistent). • Two fundamental challenges: (1) getting feedback, meaning how do we know if the agent did well and what it should have done instead, and (2) acting on that feedback, meaning deciding which layer or component to change and how. • Feedback sources differ by stage: In development you have benchmarks with evaluators that score pass/fail. In production you only have logs, which can be judged either automatically (LLMs or code analyzing the log, which is scalable) or by human experts (low volume but critical domain knowledge). • Logs plus feedback aren't enough because they're not testable: A single log with feedback is one observation of what happened. You need to lift it into a replayable learning environment, a simulation with tools, users, and defined evaluators, so candidate fixes can be run, verified, and compared. • Three ways to optimize the agent, with tradeoffs: Model-layer updates (SFT, RL post-training like DPO/GRPO, LoRA) are expensive and need benchmarks and evaluators. Harness updates (trace-to-harness coding agents, prompt search like GEPA) are flexible but either untestable and "vibe-based" or benchmark-dependent. Memory updates (fact storage like Letta/Mem0, skill distillation) are cheapest and fastest but usually unverified. • A good learning engine makes "the smallest durable change at the right layer" of the agent. • Verifiable continual learning (VCL): Improve an agent from its own experience where every fix is proven to help and proven to break nothing that already worked. It requires an executable test (replayable failure), a measured delta (score before and after), and regression tests (prior tests still pass). • Four principles of practical VCL: Replayability (turn one-off failures into rerunnable tests), holisticness (one failure can have causes in memory, prompts, tools, workflow, or model, so route the fix to the right layer), lifelongness (fix new failures subject to no regression on past environments, with regression handled inside the optimization loop rather than post-hoc), and efficiency (the loop must run frequently and cheaply, without scaling linearly as past environments accumulate). • Three takeaways: (1) Agent continual learning isn't necessarily fine-tuning; many useful updates live in the harness and memory layers. (2) Production logs are not learning environments and must be transformed into replayable ones. (3) The frontier is regression-aware improvement: fixing new failures while verifying you don't break old ones.