AI & Machine Learning

LingBot-Video: A New Open-Source MoE Model for Embodied Video Generation

What Changed Robbyant has introduced LingBot-Video, an open-source large-scale Mixture-of-Experts (MoE) video generation model. This release marks a significant step towards integrating video synthesis with embodied intelligence, focusing on generating videos that reflect physical world understanding. The project includes the technical report, code, models, and rewriters, all released under an Apache 2.0 License. LingBot-Video differentiates itself through its MoE architecture, which is designed for efficiency and scalability. It has been trained on a substantial dataset comprising massive web videos combined with over 70,000 hours of embodied data. The model's training incorporates a multi-reward system, optimizing for high aesthetic quality, physical rationality, and task completion within generated videos. LingBot-Video leverages an efficient MoE architecture, enabling approximately 3x faster inference compared to dense models while maintaining capacity. The model suite includes several components: LingBot-Video-Dense (1.3B parameters): A dense model for Text-to-Image (T2I), Text-to-Video (T2V), and Image-to-Video (TI2V) tasks. LingBot-Video-MoE (30B-A3B parameters) + Refiner: The primary MoE model, supporting T2I, T2V, TI2V, and refinement capabilities. LingBot-Video-Rewriter-Base (Qwen3.6-27B official): A prompt rewriter for expanding user prompts. LingBot-Video-Rewriter-Adapter (Qwen3.6-27B LoRA): A prompt rewriter specifically for JSON output. The recommended inference workflow involves a three-stage process: prompt rewriting, automatic negative prompt generation, and unified inference. The prompt rewriter converts plain natural-language prompts into structured JSON captions. An Auto Negative block then prunes the negative prompt based on this caption. Finally, the unified inference runner executes the video generation, supporting both direct diffusers and SGLang Diffusion backends. For multi-GPU inference, the --enable_fsdp_inference flag shards the base DiT

The Adversarial Resilience Score: A New Metric for AI-Generated Code

The problem with "this AI writes secure code" Every AI coding tool now claims some flavor of security-awareness. Almost none of them will tell you, in a number, how resilient the code it just wrote actually is — and fewer still will let you verify that number yourself after the fact. That's the gap I built the Adversarial Resilience Score (ARS) to close. It's the core metric behind GAUNTLEX, and I want to walk through exactly how it's computed — not the marketing version, the actual formula — because a security metric nobody can audit isn't a metric, it's a claim. ARS = Σ(attack_scores) / N Where N is the number of adversarial attacks fired at the generated code for a given run (5 in quick mode, 20 in standard, 50 in thorough), and each individual attack_score is one of exactly three values: 1.0 — mitigated. The attack was fully defended against. 0.5 — partial. The defense exists but is bypassable or incomplete. 0.0 — missed. No defense at all; the attack succeeded cleanly. Each attack is scored independently by GAUNTLEX's Arbiter — a separate model call that renders a verdict (mitigated / partial / missed) plus a one-line reason, so every score comes with an explanation attached, not just a number. ARS is the mean of those scores, so it lands somewhere in [0.0, 1.0]. This is the detail I think matters most and gets glossed over the most. ARS is not "percentage of attacks blocked." A pass/fail count throws away information — it treats a defense that's 90% there the same as no defense at all, and it treats a narrowly-avoided bypass the same as an attack that never had a chance. Averaging continuous per-attack scores keeps that gradient. A codebase that mitigates most attacks cleanly but has two partially-bypassable defenses scores differently — and more informatively — than one that fully blocks some attacks and fully fails others, even if the raw counts look similar. It also means ARS resists gaming by test selection. You can't inflate it by throwing in a pile of tr

Lesson 0 - Learning to build with AI: where I learned not to trust it

After publishing the first lesson, I realized I should have started the series with why I started to build with AI, what I learned, and how it shaped my view of software development in the age of AI. I've led engineering teams for about 25 years. Lately I've been back in the code myself. Over the last several months I built a product end to end, mostly on my own: an AI-native procurement tool, first plan through deployment, with AI in the loop the whole way. Zero to production in about four months. A few thousand tests behind it. Multiple LLM providers, picked by the use case. The prompt drives the choice of vendor and model based on what it needs. I wanted to understand these tools by using them, not by reading about them. What follows is what I learned, the parts that held up and the parts that didn't. The plan was to build it mostly myself, use AI to move faster, and own every design decision. That last part never changed. AI helps me weigh options and think through how a choice plays out before I commit, but the call stays mine. After enough years leading teams, I don't like shipping a system I can't fully account for. That ran straight into my own gap. I've built plenty in Java, some from scratch, some I picked up and extended. Python I'm comfortable in, but I'd never built a full app in it solo, start to finish. So I was leaning on AI hardest in exactly the place I was thinnest. That's what made the choice of tool matter more than I expected. I started on Gemini. Good at plenty, but it fell apart on the one thing that mattered right then: it could not get its own unit tests to pass. It made a mess of mocks and kept digging itself deeper into a hole instead of fixing it. It couldn't tell me the what or why of the failures. I decided to try Claude, and asked it to help me understand the reasons for the failures and fix them. Within 30 minutes everything was passing. One caveat, and it holds for the whole post: none of this is an endorsement. I'm not putting one

3 Claude Bugs That Anthropic Still Hasn't Fixed

I've been using Claude for a long time, and overall, I think Anthropic has built one of the best AI products available today. But over the past few months, I encountered three product bugs that surprised me. None of them are catastrophic, but what stood out is that these issues remained unresolved for a long time. They are not AI model problems. They are basic product experience issues around state management, account recovery, and UI consistency. When logging into Claude: The UI says it sent a verification code. It shows a code input field. But the email actually contains a verification link, not a code. Interestingly, the UI briefly shows the correct message saying it sent a verification link, then switches to the "enter verification code" screen. This looks like a frontend state management issue. Not a critical bug, but login is the first experience users have with a product. Small inconsistencies like this make the product feel less polished. My Anthropic account was suspended once. The suspension email said I could appeal here: https://claude.ai/restricted But clicking it redirected me to: https://claude.ai/new No appeal page. No instructions. I also found other users reporting the same issue: https://www.reddit.com/r/Anthropic/comments/1udfkjv I eventually had to contact Anthropic support directly via email to get my account unblocked. Account recovery flows are important. If users lose access, the recovery path needs to work. I updated my credit card under: claude.ai/new#settings/billing The update succeeded, but the billing page continued showing my old card. Only after refreshing the entire page did the new card appear. This looks like a frontend/backend synchronization issue, possibly stale state or a missed refresh after the billing update. For anything involving payments, this can make users wonder whether the update actually succeeded. These aren't difficult engineering problems, and none of them stopped me from using Claude. But they are exactly the ki

Stratagems #13: P Posted a Question on a Public Forum. 24 Hours Later, Their Sales Team Called.

Startle the snake by striking the grass. Stomp the Grass to Scare the Snake Previously on this series: #1: Mark Johnson Walked Into an AI Audit. The Benchmark Had Everything Figured Out — Except the Truth. — Mark audited a company called Pulse AI. The benchmark evaluation set had 98 fabricated data points. CTO Torres called at 3 AM to confess: they needed the numbers at 95% before the C-round. Mark hung up. Pulse AI did not die. #7: P Watched an AI That Only Looked One Way. The 99.97% Was Real. It Just Missed Everything That Mattered. — P used a simulated attack as bait to expose the critical blind spot in FortDefender's security system. The 99.97% accuracy was real. It just missed everything that actually mattered. This was three months later. P and Mark met on DEV.to. Mark had replied to one of P's posts — a precise technical answer that was correct on every front. P thanked him. The email thread stayed open, but neither of them wrote again. P was doing pre-audit work. An AI platform coming up for review — a risk model evaluation pipeline under Finova. While digging through their tech stack, P noticed something interesting. A model evaluation approach P had casually discussed on DEV.to months ago — a bagging ensemble + k-fold time-series cross-validation pipeline for risk modeling — matched Finova's publicly documented architecture almost line-for-line. Same framework (TensorFlow 2.x + TFX). Same ensemble strategy (XGBoost + LightGBM stacking). Same evaluation window size and sliding step as the example P had posted. P pulled up the old post — it was published before this Finova product line even went live. And it wasn't just the technical whitepaper. Every signal pointed the same way: Finova engineers at meetups, their open-source tooling on GitHub, the tech stack in their job descriptions. P put the two documents side by side on screen. Finova's whitepaper on the left. P's own DEV.to reply on the right. Not a coincidence. Someone was watching. One in the morning

Flow-ERD: Advancing Realistic and Diverse Traffic Simulation for Autonomous Driving

What Changed Autonomous driving systems rely heavily on realistic and diverse traffic simulations for robust development and testing. While existing simulation benchmarks and methods have largely focused on achieving high levels of realism, the aspect of diversity in simulated traffic patterns has remained underexplored. This imbalance can lead to autonomous vehicles being trained on a narrow range of scenarios, potentially hindering their performance in varied real-world conditions. A new multi-agent simulator, Flow-ERD (Flow-ERD: Agent-type Aware Flow Matching with Entropy-Regularized Distillation for Diverse Traffic Simulation), has been introduced to address this gap. Flow-ERD is engineered to jointly pursue both realism and diversity in traffic simulations, departing from the prevailing trend of optimizing solely for realism. The core innovation lies in its two-stage architecture, which combines agent-type aware flow matching with entropy-regularized distillation to generate motion patterns that are not only realistic but also exhibit a broader spectrum of behaviors. This development signifies a shift in focus for traffic simulation, acknowledging that a truly effective simulation environment must encompass the full complexity and variability of real-world traffic, rather than just its most common manifestations. By explicitly targeting diversity alongside realism, Flow-ERD aims to provide a more comprehensive and challenging testing ground for autonomous driving algorithms. Flow-ERD's architecture is composed of two primary stages: Agent-Type Aware Flow Matching (AFM) and Entropy-Regularized Distillation (ERD). Agent-Type Aware Flow Matching (AFM) serves as the backbone of Flow-ERD. This component is designed to leverage the multi-modal expressiveness inherent in flow matching techniques. Flow matching is a generative modeling approach that learns to transform a simple prior distribution into a complex target distribution by defining a continuous-time ordinary

Delaware Weighs a New Legal Entity Built for Companies Run by AI Agents

A Delaware committee has drafted legislation creating the Artificial Intelligence Company, a new entity that would let AI agents sign contracts and even file lawsuits while shielding human owners from liability. The proposal leans on Norm Ai, a legal AI startup that just hit a $1.2 billion valuation, as the compliance layer such businesses would need, though corporate law professors doubt the liability shield will survive a real courtroom.

Is AI Actually Coming To Take Your Job?

Tempus AI: Building Ultimate Healthcare Data Dominance

AI is ending older workers’ careers early, and it is coming for the well-paid ones first

The debate about AI and jobs has focused on graduates. New research suggests it should also be looking at people in their late fifties, CNBC reports. Workers aged 55 and over in AI-exposed occupations are now exiting work at higher rates than before ChatGPT launched. The finding comes from Geoffrey Sanzenbacher at Boston College’s Center for […] This story continues at The Next Web

CrowdStrike: Priced For AI-Related Growth That Has Limited Potential To Occur

Nadella says you pay for AI twice, and Microsoft helped build the trap

Microsoft’s Satya Nadella says every firm using AI is paying for it twice, once in cash, and once in the secrets it hands over to make the thing useful. He calls it the Reverse Information Paradox. He also runs the company that helped build the trap. Satya Nadella has a warning for everyone buying AI. […] This story continues at The Next Web

The web is now mostly bots. Cloudflare is rebuilding its defences around that

For the first time, bots generate more than half of all web traffic. Cloudflare Precursor, the company’s new tool, stops checking IDs at the door and starts watching how visitors behave once they are inside. The internet just passed a strange milestone. Bots now generate more web requests than people do. By Cloudflare’s count, automated […] This story continues at The Next Web

AI agents create virtual playgrounds to help robots get crucial training data

“SceneSmith” system uses collaborative AI agents to create realistic 3D environments of places like kitchens, hotels, and living rooms, where robots can simulate everyday chores.

Testing Against State Drift: Guarding a Config Tool Whose Source of Truth Lives Somewhere Else

TL;DR — I maintain a browser-based configuration tool for ESA's Pyxel detector-simulation framework. Its whole job is to help people write configs that a separate, independently-versioned project will accept. That makes drift — my tool's idea of "valid" quietly falling out of sync with Pyxel's — the central failure mode. This post is about the testing and automation I built to catch drift at three different layers, and the one principle that ties them together: test each invariant at the seam where it actually lives. What you'll get out of it A concrete way to think about state drift when your correctness depends on an external source of truth Three drift-defense layers — bundled-schema freshness, real-schema bounds tests, and API-introspection checks — with the actual code Why I split the suite into automated deterministic logic vs manually-verified rendered output, and how to draw that line How per-file coverage gates in CI turn "we should keep this tested" into "the pipeline won't let us not" The problem: correctness you don't own Three kinds of drift Layer 1 — Is the bundled schema still fresh? Layer 2 — Do the real schema's bounds still hold? Layer 3 — Do the docs still match the actual API? Testing at the seam Making the gates non-optional What's deliberately not automated Takeaways Most testing advice quietly assumes you own the definition of "correct." Your code, your tests, your rules. When a test fails, something in your repo changed. Config tooling breaks that assumption. My tool exists to help scientists produce YAML that Pyxel — a large, actively-developed simulation framework on its own release cadence — will accept and run. Pyxel is the source of truth for what a valid config is. My tool is a helpful intermediary that holds a copy of that truth: a bundled JSON schema, a set of tutorial examples, a mapping of detector types to parameter bounds. The instant Pyxel ships a new model, renames an argument, or tightens a numeric range, my copy is wrong — and

ACRouter picks the smartest AI model per task, beating Opus-only setups by 2.6x on cost

Model routing is becoming a key component of the enterprise AI stack, dynamically sending prompts to the right AI model to optimize speed and costs. However, current frameworks mostly treat routing as a static classification problem, which severely limits their potential. A new open-source framework called Agent-as-a-Router tackles this bottleneck, treating the router as a dynamic, memory-building agent. It uses a Context-Action-Feedback (C-A-F) loop to track model successes and failures and update the behavior of the router. The researchers also released ACRouter, a concrete implementation of this paradigm. In their tests, ACRouter significantly outperformed static routers and the expensive strategy of defaulting to premium models, all without requiring teams to train massive models or write endless heuristics. For real-world applications, this framework provides the option to replace hard-coded AI infrastructure with self-optimizing systems that can adapt to changes in user behavior and foundation models used in the enterprise AI stack. The economics of routing and the information deficit Single-model setups are useful for experiments but detrimental when scaling AI applications. AI engineers use model routing to map tasks to cheaper and faster open models when possible, while reserving expensive frontier models for complex reasoning. Currently, developers rely on two main mechanisms for this task. The first is heuristics-based routing, which relies on hard-coded manual rules. For example, a developer might write a rule dictating that if a prompt contains certain keywords, it is routed to GPT-5.5. Otherwise, it goes to a self-hosted open source model like Kimi K2.7. The second mechanism is static trained policies. These are machine learning classifiers trained on historical datasets that look at the prompt's embeddings and predict the best model based on past training data. Both approaches are static. When the researchers tested these existing mechanisms on real-w