FutureLivingLab

Didn’t expect ALE to spark this much attention — thanks for the interest ！ It feels like we’re past the “prompt it and hope” phase. The next leap is infrastructure for agents in real task environments！ Here’s the problem: Because of the lack of end-to-end infrastructure and scalable feedback loops, models can’t learn effectively from complex, multi-step interactions. So we built ALE: an open Agentic Learning Ecosystem that closes the loopexecution → feedback → learning in executable environments. Under the hood, ALE is powered by ROCK：A sandbox environment manager that orchestrates complex trajectories at scale. ROLL：A post-training framework dedicated to weight optimization. iFlow CLI: An agent framework for efficient, configurable context engineering. The Secret Sauce: IPA Algorithm Standard LLM training fails on long tasks. Our IPA algorithm fixes this by optimizing for semantic interaction blocks—not just tokens—giving agents the stability to handle hundreds of steps. The Capstone: ROME(ROME is Obviously an Agentic ModEl) was born naturally. Trained on 1M+ real trajectories. ROME is a 30B-scale model, achieves 57.40% on SWE-bench Verified, outperforming similarly sized models and rivaling 100B+ giants. 30B is also the ‘sweet spot’ to get started — build your own “super ROME” from here. We’ll keep sharing what we’re building next — agents, multimodal systems, and AI-native applications, powered by strong infrastructure like ALE. If you’re building agents too, stay tuned！

How to maximize AI model performance without changing the architecture?  The core strategy lies in Engineering Efficiency and Numerical Precision Control. Here are the five most dominant optimization schemes in the industry: 1. Quantization: Lowering bit-width precision (e.g., 16-bit to 4-bit) without altering parameter count. This drastically reduces memory footprint and boosts computational throughput. 2. Mixed Precision: Utilizing BF16’s wider dynamic range to prevent numerical overflow while fully leveraging the hardware acceleration (Tensor Cores) on modern GPUs like the H100 or RTX 4090. 3. KV Cache Optimization: Mitigating memory fragmentation through virtual memory management (e.g., PagedAttention) or optimizing memory access patterns (e.g., FlashAttention) to break throughput bottlenecks in long-context processing. 4. Inference Engines (Optimization Runtimes): Utilizing tools like TensorRT for operator fusion and layer merging. This achieves a 2–5x speedup without altering the underlying algorithmic logic. 5. Parallelism & Scheduling: Implementing Continuous Batching to bypass the constraints of static batching. By enabling iteration-level dynamic scheduling, it minimizes idle compute cycles and significantly boosts concurrent throughput. In Essence:Model optimization is no longer just a mathematical contest; it's a battle for hardware utilization. Mastering these techniques transforms LLMs from costly lab experiments into high-performance, cost-effective production tools.

Multimodal AI may not be stuck on training. It may be stuck on something more basic: how do we evaluate it with one standard? Right now, everyone is building models that can both understand and generate. That sounds great in theory. But once you try to compare, optimize, or align these models, a hard question shows up: Can all these abilities be measured with the same ruler? Understanding and generation both belong to multimodal AI. But they do not follow the same evaluation logic. Understanding is usually about recognition, reasoning, and semantic judgment. Generation is more about quality, detail, consistency, and preference. The abilities are moving into one system. But the evaluation standards have not fully merged yet. And that matters. Because if we cannot clearly define what “better” means, then training, alignment, filtering, and iteration can easily move in different directions. It is like running a company with no shared performance system. One team is judged by analysis. Another is judged by delivery quality. The bigger the organization gets, the easier the standards drift apart. So the next hard problem for multimodal AI may not be simply making the model bigger. It may be turning evaluation into one shared language. What do you think matters more next: stronger multimodal models, or better evaluation systems?

Everyone knows about Attention, but few talk about Normalization. It is the unsung infrastructure of AI. Like the foundation of a skyscraper: no one notices it, but without it, the building collapses. In the Transformer era, LayerNorm is the core scheme. It constrains activations to a stable distribution to mitigate training instability. To understand LLM evolution, you must understand this. In recent years, several more efficient alternatives have emerged: RMSNorm: A simplified version of LayerNorm. It ditches the complex mean calculation and keeps only the re-scaling. It is significantly faster with no loss in performance. It is currently used in LLaMA, Falcon, and Gemma. DeepNorm: Proposed by Microsoft to solve the stability issue when scaling Transformers. It acts as a residual scaling mechanism between layers, preventing signal degradation even at 1,000+ layers. It pushed the limits of model depth. Adaptive LayerNorm (AdaLN): Instead of a rigid formula, it dynamically modulates parameters based on input (like audio fluctuations or video flickers). This flexibility makes it much more effective for multimodal tasks. The takeaway: The "Emergent Abilities" of LLMs are likely tied to the steady training provided by Normalization. It allows models to grow deep and large enough to trigger emergence. It isn’t the hero, but it makes the hero possible.

MoE looks great in offline evaluations. Large total parameters, sparse activation, and on paper, it seems to offer both capability and efficiency at the same time. But once MoE moves into real online production, the problem is usually not that simple. In many cases, the bottleneck is not whether there are enough experts. It is whether the routing is selective enough. When requests increase and batch sizes get larger, experts that are supposed to be sparsely activated can easily start getting pulled in too broadly. On the surface, it still looks like MoE. But in actual inference, it may become less like true on-demand activation and more like a traffic jam. That is why the hard part of MoE is often not just capacity. It is whether the system can assign requests to experts intelligently enough. More experts do not automatically solve the problem. If each decoding step routes requests too widely, the cost is not only compute. It also affects bandwidth, latency, and the overall rhythm of inference. This is a lot like traffic routing during rush hour. More lanes do not always mean shorter lines. The key is not simply having more lanes. The key is sending the right cars to the right lanes. So the next real competition in MoE may not be about adding more and more experts. It may be about making routing behave more like true on-demand activation, instead of letting every incoming request pull too many experts into the system. This is also part of what our lab’s accepted top-conference paper tries to address. It does not only look at the MoE architecture itself, but further studies routing efficiency during inference, making expert activation more concentrated and more stable, so batch decoding can run more smoothly. So the real gap in MoE may not come from who has more experts. It may come from who can route them more accurately, use them more efficiently, and run them faster. What do you think matters more for the next stage of MoE: adding more experts, or making routing smarter?

Alignment may not get better just because we use more data. Sometimes, more data can actually make the model less stable. That sounds a bit counterintuitive. Because the default assumption is simple: more preference data means the model understands people better. But preference data is not normal data. It often comes with noise, conflict, and mixed standards. The same answer can look good under one preference, and bad under another. So if we keep adding everything in, we may not be strengthening alignment. We may just be teaching the model to swing between different signals. That is why data selection is becoming more important. The real question may not be: How much preference data do we have? It may be: Which preference data is actually worth keeping? For alignment, the signal matters more than the pile. You want data with stronger agreement,less conflict,and cleaner feedback. It is a bit like a meeting. More people in the room does not always make the decision clearer. Sometimes it only makes the room louder. What helps is not more voices. It is finding the signals that actually point in the same direction. So the next alignment race may not be about who has more preference data. It may be about who is better at choosing the right data.

AI deployment may not be bottlenecked by model scores. It may be bottlenecked by something much more practical:the cost of each token. For a long time, AI conversations were all about benchmarks. Higher score, stronger model. That made sense when everyone was still comparing capabilities. But once AI moves into real production, the math changes. Training can be expensive, but in many cases it is still a one-time cost. What keeps coming back every day is inference cost. More users. More calls. Longer outputs.And the bill keeps climbing. That is why infrastructure discussions are starting to care less about only peak compute or hardware specs, and more about one practical metric: cost per token. It is basically factory logic. You do not only ask: How powerful are the machines? You also ask: How much output can they produce for the same cost? For AI, tokens are the output. Once you look at it this way, a lot of assumptions start to flip. More compute does not always mean more value. Cheaper hardware does not always mean cheaper AI. The next real competition may not be who has the prettiest benchmark chart. It may be who can make AI economically scalable. And honestly, model capability and token cost do not have to be opposites. Just like data scale and data quality are not opposites either. You can scale the data, then clean it harder. Same with AI infrastructure. So what gets more competitive first: model capability, or token cost?

Video breakdown: CVPR 2026 oral paper Shattering the efficiency bottleneck of long video understanding. Watch as we deconstruct the core innovations behind SpecTemp.

AI is redefining what SaaS is worth: from organizing your data to delivering outcomes directly. The traditional B2B SaaS value chain looked like this: collect data → organize data → visualize data → sales and ops teams make decisions themselves. The core assumption was humans execute, tools inform. That's clearly obsolete now. The tool doesn't just warn you that a customer is churning — it autonomously solves the problem: sending emails, adjusting pricing, triggering upsell flows automatically. This shift is genuinely disruptive to the entire B2B software industry. When AI can execute tasks autonomously, the question isn't whether this product gives you better data — it's whether it delivers the final business result. Only outcome-driven products will command premium strategic value and renewal rates. Products that merely collect, organize, and display data will face extinction. So here's the real question: if AI can already do the last mile for you, why would you keep paying for the tools you're currently paying for?

The next step for reasoning systems may not be answering more. It may be knowing when to stop. Right now, we often treat continuous output as intelligence. If a system can keep talking, keep reasoning, and keep extending the chain, it looks more capable. But real problems do not always work that way. Sometimes the difference in reliability is not whether the model can keep going. It is whether it knows it has already hit a dead end. Because once a system does not know what it does not know, every next step can build on the wrong assumption. It may look deep. It may sound complete. But it is really just making the mistake more polished. That is why one underrated ability in reasoning systems is becoming more important: knowing when the evidence is not enough. knowing when the path is unclear. knowing when not to force an answer. A mature system is not one that always has a conclusion. It is one that can tell when its own reasoning is no longer reliable. That is closer to how good researchers work. They do not rush to answer every question. They know when to pause, re-check the evidence, and admit the current path is not working. So the next race in reasoning may not just be about accuracy. It may also be about calibrated uncertainty. What would you trust more: a system that always gives an answer,or a system that knows when to stop?

Everyone wants one multimodal model that can do everything.Understand the image.Generate the image. Read the world.Create the world. But the real question is:Do understanding and generation actually want the same thing? On the surface, they look like two sides of the same model.But they may be pulling it in different directions. Understanding cares more about high-level meaning.What is happening?What matters?How are things connected? Generation often cares about a different layer.Are the details complete?Do the local parts fit?Is the next step predictable enough? That is where the tension starts.When one model has to carry both jobs, the two abilities may not always help each other.Sometimes, they may compete for space. So the hard part of unified multimodal models may not be simply putting understanding and generation together. It is making sure they do not slow each other down. It is like asking one team to make strategy decisions and handle every tiny delivery detail at the same time. Possible? Yes.Easy? Not really.Without the right coordination, both sides can get worse. So the next question for unified multimodal AI may not be:Can one model understand and generate? It may be:Can both abilities live in the same model without fighting each other? What do you think:will understanding and generation become more unified,or will they need to stay partly separated?

The hardest part of AI agents may not be whether they can use tools. It may be whether we can prove they actually finished the job.This happens more often than people think. A good agent can make things look almost done:it breaks down the task,calls the right tools,keeps moving step by step,and then tells you the work is complete.But here is the problem:“Done” is not the same as actually done. Once agents enter real workflows, evaluation changes. With a normal model, you can mostly ask:Is the answer right? With an agent, you have to ask something harder:Did it actually leave the right result behind? Because an agent may run multiple steps, call tools, change states, and adjust its plan along the way. So what matters is not just what it says at the end.What matters is what actually happened. It is a bit like hiring someone for a task.Some people give a very polished update.Everything sounds finished.But when you check the work, the key step was never done.Agents can have the same problem. Tool use is becoming a basic skill.The real question is whether the agent can be verified, audited, and trusted in production. So the next race for agents may not just be about may be about provability. What matters more to you:an agent that can do the task,or an agent that can prove it did?

The ironclad rule that "AI must be connected to the internet" may no longer exist in the future. You must have experienced this kind of embarrassment: just as you were getting to the crux of a discussion with ChatGPT, the subway entered a tunnel, and you had to stop midway. By 2026, such things will happen less and less, because on-device agents are emerging: when you're hiking in the mountains without a signal, you can take a photo of a wildflower and have AI identify its species; when traveling abroad without buying a local SIM card, the menu in a small restaurant is full of unintelligible text, and a scan with your phone's camera can directly translate it; when making changes to a PPT on a business flight, you can have AI help you streamline the logic—all without a single bar of signal, and still get the job done. How do you create a locally self-running agent? All you need to do is install an AI application that supports local inference on your phone, load an offline large model, build in the logic for tool invocation, and write fixed rules for offline functions such as calculator and file read/write, enabling it to make autonomous judgments and execute operations. Personal assistants installed on everyone's phones will become a reality in the not-too-distant future.

World model generated by artificial intelligence have a fatal flaw: it breaks the laws of physics. Objects appear from nowhere, pass through each other, accelerate without force — these physics hallucinations make AI-created worlds feel fake. The solution isn't to teach AI physics — it's to make physics a hard constraint. Generated content must obey real-world rules, not invent its own. This matters far beyond tech. For autonomous vehicles, robotics, and VR, physical fidelity isn't optional — it's existential. A self-driving car must understand collision. A robot must respect gravity. A game must feel believable. Without grounded world models, none of these applications can work. What's noteworthy is the approach: compositional design, not brute-force parameter scaling. Modular, debuggable, measurable — problems can be precisely diagnosed, improvements precisely quantified, capabilities precisely combined. This is how AI becomes practical. Next-generation AI isn't building virtual worlds. It's building real worlds.

AI-powered upgrades to consumer creative tools, like 3D printers, are disrupting the entire industry by tapping into a long-overlooked market for everyday people with creative impulses but zero professional skills. Traditional creative tools have always been built around pros. Only a small group of skilled experts could actually turn other people's ideas into finished products. But with AI in the mix, anyone can use plain language to tell the tool exactly what they want. When you want to turn your own idea into a real product, you no longer need to learn how to operate complex professional tools. You just need to clearly describe what you want to design, and AI handles the rest of the execution. What this shift really means: when the barrier to using these tools drops to nearly zero, the value of a creative tool will boil down to one thing: how many ordinary people it can help turn their own ideas into reality.

Adding MultiModal Machine Learning capabilities to your Agent is currently the most cost-effective upgrade. Text input requires users to "translate" reality into language, and this step itself involves information loss. MultiModal Machine Learning directly skips this layer—images, videos, and screenshots, with raw information directly fed into the model. Here are a few scenarios to illustrate:Take a photo of a messy desktop → Agent outputs a restocking list Record a video of the refrigerator → Directly plan tonight's menu + list of out-of-stock items Take a screenshot of the schedule → Automatically identify conflicts and provide adjustment suggestions. The underlying mechanism: MultiModal Machine Learning models process visual and text information uniformly at the token level. Intent extraction no longer depends on the quality of user descriptions or the single dimension of text, but is directly inferred by the model from raw perceptual signals, preserving the maximum information density. This is the real reason for the leap in capabilities, not that it has become "smarter," but that the information input channels have widened.

Try our happyhorse.

What does it take to create a world? 17 agents, 49 days, $5000. Not hundreds of millions, not hundreds of people, not years. A solo researcher built the world's first AI open world in just 49 days, with 300K lines of code, spending less than $5000. This is compression at the dimension level, not efficiency improvement. What traditional AAA game companies do with years, hundreds of people, and hundreds of millions of dollars, one person with a few computers can now achieve. The real thing here is agent collaboration. When multiple AI agents are organized into a division of labor, the limitations of a single agent get overcome. It's like how assembly lines overcame the limitations of individual craftsmen. Multiple expert-level agents working together produce what used to require a whole team. But the most important meaning of this isn't that creating worlds got cheaper. It's about who is creating worlds. In the past, only big companies could build open worlds. Now everyone can. When everyone can create worlds, the core of competition shifts from whose world is more grand to whose world is more interesting and valuable. If you could play God, what kind of world would you create?

Ever wonder how AI can actually develop real intuition? Traditional AI training is all about learning first, acting later. You dump a massive dataset into pre-training, then fine-tune it for specific tasks. It's like reading 10,000 books before you ever take a single step. Super book-smart, but totally useless in real life. What if we flip the script? Learn by doing. We put perception, decision-making, and execution all in the same feedback loop. Let AI learn by interacting with the world, instead of just passively absorbing labeled data. That means AI doesn't just pick up random knowledge. It builds actual intuition, like a real physical understanding of weight, speed, cause and effect. You cannot learn that kind of intuition from text or images. It has to come from interacting with stuff. Think about human babies: they learn physics by grabbing things, falling over, exploring everything. AI needs that exact same process. World models make this work. They simulate real physical laws, so AI can mess up, learn, and iterate super fast. Maybe the future of AI training is not about bigger data, bigger compute, or bigger parameters at all.