U2-Flash translated the layout into a seating area, workspace, and furniture arrangement. It then refined the Blender scene—addressing failed Boolean operations, flipped normals, and poorly lit areas through a cycle of rendering, inspection, and code changes.

From a structured 2D layout to a furnished 3D interior. 🏠 U2-Flash wrote scripts to build and render this LOFT scene in Blender—bringing spatial reasoning, code, and tool use together. Here’s the result—and the workflow behind it. 👇 #Blender #AICoding

What if the Moon held an entire city? 🌕🚀 For this U2-Flash × Blender project, we imagined a lunar space station with two faces: a cratered surface outside, and a world of buildings, forests, lakes, and domes within. The camera approaches the station, passes through its entrance, explores the interior, then pulls back to reveal Earth beyond it. Bringing that sequence together meant coordinating geometry, materials, lighting, camera paths, and animation keyframes through Python-driven Blender workflows. The challenge was spatial consistency: connecting the outer shell, entrance, passageways, and interior landscape into a scene the camera could travel through. This 32-second showcase explores how U2-Flash can help translate a complex creative brief into a structured 3D modeling and animation workflow. Watch the journey—from lunar surface to hidden world. What should we build next? #Blender #AICoding

199 requests succeeded. One returned HTTP 500. U2-Flash tracked down why. 🔍 In this vLLM debugging demo, concurrent requests using bad_words triggered an intermittent “Already borrowed” error. Working through OpenCode, U2-Flash followed the execution path—from HTTP serving through async processing to the Rust tokenizer backend—and identified shared tokenizer state as the cause. The repair loop: → Reproduce the failure → Trace the shared-state conflict → Isolate the tokenizer used for bad_words → Add regression tests and rerun the workload The demo’s before-and-after results: ✅ Regression tests: 2 failed, 2 passed → all 4 passed ✅ H100 replay, 200 requests at concurrency 50: 199/200 → 200/200 successful From a runtime failure to a targeted patch—and evidence that it works under the tested conditions. Watch the debugging walkthrough below. #AICoding #AIAgents

One prompt. A 3D escape-room prototype. 🔑 We asked U2 Flash to build a first-person browser game set in a study, with hidden items, interactive puzzles, and a key to find. The walkthrough shows: 🎮 First-person exploration 📦 Item pickup and inventory 🧩 An item-combination interface 🔍 Discoverable clues, including a number puzzle From a natural-language game brief to an interactive 3D scene—bringing code, spatial layout, UI, and gameplay interactions together. Watch the walkthrough below. What should we ask U2 Flash to build next? #AICoding #GameDev

From understanding a task to working through it. ⚡ U2 Flash brings reasoning, coding, and tool use into multi-step agent workflows: 🛠️ Generate and refine code. 🔍 Analyze complex problems and plan next steps. 🔗 Use tools to execute tasks and check results. 📚 Work with extensive code, documents, and task history. Powered by 266B parameters, with a 1M-token context window and up to 128K output tokens. Built for complex engineering tasks and real-world workflows. Explore U2 Flash 👇 maas.unisound.com/ #AIAgents #AICoding #LLM

More context. More room to build. ⚡ U2 Flash now supports a 1M-token context window—bringing more code, documents, and task history into your coding and agent workflows. Built for complex tasks: 🧠 266B-scale model 📚 1M-token context window ✍️ Up to 128K output tokens 🛠️ Reasoning, coding, and multi-step agent execution Ready to try it? U2 Flash API calls are FREE for new and existing users through October 31, 2026, with no token quota during the promotion. Platform rate limits apply. Start building 👇 maas.unisound.com/ #U2Flash #API #LLM #AIAgents #AICoding

Research agents need room for sources, task history, and verification. U2 Flash now offers a 1M-token context window. What research workflow would you put it to the test on? API calls are free through Oct 31: maas.unisound.com/

Self-Maintaining Training: From Model to Participant U2-Flash is not just a model being trained. It also takes an active role in the training system itself. During training, U2-Flash can inspect training machines, detect and diagnose failures, apply fixes and restart affected processes. It participates across the training lifecycle, from data preparation and task scheduling to failure detection and recovery. By integrating the model into these operations, the system reduces the average recovery time from training failures to around one-third of that required with manual intervention, while reducing reliance on manual operations. In other words, U2-Flash is no longer simply being trained. It becomes an active participant in its own training process. This capability is part of a broader self-evolving training loop. Asynchronous Agent RL continuously generates new experience for training. MOPD turns that experience into denser learning signals, while Adaptive Task Generation adjusts the difficulty and diversity of training tasks as the model evolves. Self-maintaining operations help keep this entire process running reliably. Together, these mechanisms create a continuous cycle in which U2-Flash can learn from experience, adapt to new challenges, and help maintain the training environment that supports its own development. U2-Flash is not simply a smaller version of U2. It is designed to further develop reasoning, agentic, and complex-task capabilities at higher intelligence density. From being trained to taking part in its own training. #U2Flash #LLMTraining #AgenticAI #SelfImprovingAI #AIInfrastructure

Adaptive Training: Evolving with the Model As a model improves, a fixed training set can quickly become too easy to provide useful learning signals. U2-Flash addresses this with Adaptive Task Generation, dynamically adjusting task difficulty based on the model’s performance on the current task set. The system keeps more tasks near the model’s capability boundary — problems it cannot solve yet, but is close to solving. As performance improves, the difficulty distribution of new tasks shifts accordingly, helping maintain effective learning signals and diverse exploration throughout training. This adaptive process is supported by an infrastructure designed to evolve with the model. The Harness is continuously refined as stronger model capabilities reveal new execution boundaries, creating a feedback loop between the model and its task environment. Memory operations, including selective forgetting, key-state snapshots and semantic refinement, help manage active context across long-running tasks and preserve the information most relevant to subsequent reasoning. At the training layer, the TITO Rollout gateway helps maintain the fidelity of training trajectories, while end-to-end FP8 optimization improves computational efficiency. Together, they provide a stable foundation for training mechanisms such as Asynchronous Agent RL and MOPD. The result is a training system where task difficulty, execution infrastructure and model capability evolve together, allowing U2-Flash to keep learning as its capabilities advance rather than being limited by a static training environment. #U2Flash #AdaptiveTraining #LLMTraining #TrainingInfrastructure #SelfImprovingAI

MOPD: Bringing Multiple Expert Capabilities into One Model Training a model for one capability can sometimes come at the expense of another. For example, optimizing specifically for mathematical reasoning may improve performance in that domain while affecting capabilities such as open-ended writing. U2-Flash addresses this challenge with MOPD, designed to bring specialized capabilities together within a single model. Specialized teacher models are first trained with RL for domains including math, coding, Agent tasks and instruction following, and their capabilities are then distilled into a unified student model. Instead of relying on trajectories generated by the teachers, the student generates its own trajectories during training, helping reduce the distribution gap between training and inference. The teachers then score the student’s output token by token, providing denser and more fine-grained learning signals than relying primarily on final task rewards. This allows capabilities from different specialized models to be transferred more efficiently while reducing interference across domains. Compared with training from scratch using RL alone, MOPD reduces the number of training steps required to reach the same capability level by approximately 55%. This enables U2-Flash to combine diverse capabilities within the same model through more efficient distillation and training signals, rather than simply increasing model size. #U2Flash #MOPD #KnowledgeDistillation #LLMTraining #ReinforcementLearning

Asynchronous Agent RL Agent training often involves long rollouts with multiple rounds of tool use, making data collection slow and resource-intensive. U2-Flash addresses this with an asynchronous Agent RL architecture, where multiple rollouts run in parallel to collect training trajectories without blocking policy updates. Policy optimization is based on GRPO, which compares trajectories in the same group to estimate their relative advantages, eliminating the need for a separate value model. This encourages the model to explore different approaches to the same task rather than relying on a single solution path. Agent tasks also tend to have sparse rewards, making it difficult to determine which decisions actually contribute to success or failure. To improve long-horizon credit assignment, U2-Flash uses key-action attribution to trace outcome signals back through the decision path and assign them to the actions that matter most. Compared with synchronous training, this asynchronous architecture produces approximately 60% more effective training trajectories per unit time, allowing exploration experience to be incorporated into training more efficiently. #U2Flash #ReinforcementLearning #GRPO #AgentTraining #AIResearch

Self-Evolving Training Loop U2-Flash is trained through a continuous self-evolving loop designed to identify capability gaps and turn them into useful training signals. For a given task, stronger and weaker models generate separate trajectories. A supervisor compares them to identify the critical decisions that lead to success or failure, then uses these differences to generate targeted guidance and reasoning traces. The weaker model then resamples and filters higher-quality trajectories for further training. Once improved, the model becomes the foundation for the next iteration. This creates a recurring cycle of identifying weaknesses, generating training data, training and evaluation, allowing the system to continuously refine its capabilities with less reliance on large-scale human annotation. Through this process, we have constructed a high-quality SWE task set of nearly 100K tasks across major programming languages. This data loop provides the foundation, while Asynchronous Agent RL, MOPD and Adaptive Task Generation help efficiently turn these evolving training signals into stronger model capabilities. #U2Flash #LLM #ReinforcementLearning #AgentRL #LLMTraining

Hybrid Attention Architecture U2-Flash combines standard Softmax Attention with Gated Linear Attention, alternating between the two at a fixed ratio to balance precise global attention with efficient long-context processing. Softmax Attention provides accurate access to information across long contexts, making it useful for retrieving and connecting details across documents and conversation turns. However, its computational and memory costs increase significantly as context length grows. Gated Linear Attention complements this by compressing KV states into a fixed-size recurrent representation, reducing memory pressure when processing long sequences. By combining the two mechanisms, U2-Flash can use global attention where precise retrieval matters while relying on linear attention for more efficient long-range interactions. This hybrid architecture is an important foundation for U2-Flash’s support for a 512K context window and up to 128K output length, enabling demanding long-context workloads such as large codebase analysis, long-document understanding, cross-file refactoring, multi-turn conversations, long-running Agent tasks, and enterprise knowledge retrieval. Precise when it matters. Efficient at scale. #U2Flash #MoE #LLM #ModelArchitecture #EfficientAI

Sparse MoE Architecture U2-Flash is built on a Sparse Mixture-of-Experts (MoE) architecture, with approximately 266B total parameters while activating only ~10B parameters per inference, less than 4% of the total. The key idea behind Sparse MoE is selective activation. Instead of using the entire model for every input, a routing mechanism dynamically directs each token to a small subset of expert modules. This allows U2-Flash to maintain a large overall parameter capacity while concentrating computation on only part of the model at a time. Different experts can develop different capability strengths during training, while the router dynamically selects which experts to activate based on the input. In this sense, Sparse MoE can be understood as specialized capacity with dynamic routing. With this architecture, U2-Flash supports a broad range of tasks, including coding, agentic execution, mathematical reasoning, instruction following and office tasks within a unified model. Different inputs can activate different combinations of experts rather than requiring all 266B parameters to participate in every inference. The distinction is important: 266B = total model capacity ~10B = parameters active per inference <4% = parameter activation ratio This is the core of U2-Flash’s Sparse MoE architecture: large model capacity with sparse computation at inference time. #U2Flash #MoE #LLM #ModelArchitecture #EfficientAI

Multi-Agent Collaboration U2-Flash can automatically organize multiple Agents to work together on complex tasks, assigning different roles for coordination, execution and verification based on what the task requires. For complex problems, a lead Agent can split the task into multiple paths and have different Agents explore them in parallel. Their outputs are then evaluated, with useful results selected and merged back into the shared context. Across longer workflows, one Agent can also pass key context and intermediate states to the next, allowing the next Agent to continue the task without losing important progress along the way. As a result, U2-Flash can divide work, explore multiple paths and coordinate handoffs across Agents to keep complex tasks moving forward. #U2Flash #MultiAgent #AIAgents #AgenticAI #AgenticWorkflows

U2-Flash API is free from Sep 30th to Oct 31st, 2026 (UTC)!🎉 For a limited time, all logged-in users can access U2-Flash for free, without usage caps. Built for coding, agentic workflows, complex reasoning and tool use, U2-Flash is designed to handle complex tasks while keeping inference fast and efficient. Performance highlights: 🔹 DeepSWE v1.1: 64.6 🔹 SWE-Bench Pro: 61.6 🔹 TerminalBench 3.0: 24.3 Powered by a Sparse MoE architecture, U2-Flash has 266B total parameters while activating approximately 10B per inference, combining strong capabilities with efficient compute. Stronger capabilities. Faster responses. Lower costs. Start building with U2-Flash and bring your ideas to life. 🚀 Try U2-Flash now: maas.unisound.com/ #U2Flash #LLM #AIAgents #Coding #AIModels

Research Synthesis U2-Flash can synthesize information across multiple research papers and academic fields while maintaining context and consistency over long inputs. Given a collection of papers on an emerging technology, U2-Flash traces technical developments over time, compares different approaches and identifies conflicting terminology across sources and disciplines. Rather than analyzing each paper in isolation, it connects findings across different papers to build a coherent view of how the field has evolved. As a result, U2-Flash can turn fragmented research into structured analysis, making complex technical landscapes easier to understand and compare. #U2Flash #ResearchAI #LongContext #LLM #AIResearch