Macaron-V1 – MindLab's Post-training Multi-capability Model System

1. What is Macaron-V1

Macaron-V1 is a post-training multi-capability model system introduced by MindLab, built upon the GLM 5.2 base model. It employs LoRA fine-tuning on approximately 0.5% of core parameters through reinforcement learning and features the proprietary Mixture-of-LoRA (MoL) architecture. Four independent experts—Chat, Agent, Coding, and UI—are mounted onto the system, with the Router activating them on demand, completely eliminating capability interference. The system offers the flagship version Venti (748B) and a lightweight version Tall (35B), covering dialogue, agent systems, coding, and interactive UI generation. Real-world testing shows a generation speed of 320 characters per second, and with LongStraw technology, the context length is extended up to 2M, providing a new paradigm for multi-capability integration and efficient inference.

Image source: Official article
Image source: official article

Technical positioning and domain: Belongs to the field of natural language processing and multi-capability AI systems, focusing on the post-training stage for multi-expert capability integration. It achieves isolation and collaboration of multiple capabilities—such as dialogue, agent systems, coding, and UI generation—through parameter-efficient fine-tuning. It is positioned as a high-performance model system for enterprise-level complex tasks, differing from traditional end-to-end full-parameter training methods.

Development background: Developed by the MindLab team, based on the GLM 5.2 and Qwen 3.6 base models. The team addressed the "pressing one葫芦 and floating another瓢" capability interference issue in traditional multi-capability joint training by proposing the MoL architecture, aiming to achieve flexible capability expansion with extremely low training costs. To support reinforcement learning training at the trillion-parameter scale, the team also built its own distributed training platform, MinT.

Core value: Solves the central pain point in multi-capability model training where performance trade-offs are inevitable. Through the LoRA expert isolation mechanism, new capabilities can be added by simply mounting new LoRA modules, without the need to retrain the entire model, significantly reducing expansion costs. Additionally, LongStraw long-context technology and reward functions driven by real-world environments ensure the model's efficiency and stability in handling ultra-long documents and multi-turn complex conversations.

Technical features: Key innovations include the MoL multi-expert isolation architecture, LongStraw long-context extension (2M), the MinT distributed training platform (only Adapter is transmitted), and the self-built dynamic evaluation benchmark (Macaron ChatBench and LivingBench). The system emphasizes reward signals derived from real product environments, enabling the model to continuously evolve within a sandbox simulating real-world noise and dynamic user interactions.

2. Key Features

• MoL Fine-tuning Architecture: Freezes all base model weights and only trains approximately 0.5% of core parameters. Optimization is isolated and non-interfering through four independent LoRA experts (Chat, Agent, Coding, UI). New capabilities can be added by simply mounting another LoRA, without the need for retraining, greatly enhancing scalability and flexibility. This fundamentally resolves performance conflicts that arise when multiple capabilities are trained together.

• Dual Model Variants: The flagship version, Venti (748B, based on GLM 5.2, with native 1M context extended to 2M), is designed for high-computation scenarios, offering the strongest inference and execution capabilities. The lightweight version, Tall (35B, based on Qwen 3.6, optimized for local deployment), is suitable for individual developers and edge devices, addressing diverse deployment needs from the cloud to local environments.

• UI4A General-Purpose Generative UI Architecture: Supports rendering interactive views, enabling the model to generate interactive user interfaces directly from natural language descriptions. This is ideal for rapid frontend prototyping and visual expression, granting the model native UI generation capabilities without requiring additional frontend toolchains.

• REPL Harness Persistent Python Environment: The model can write its own tools and elevate them to global tools, performing code debugging and algorithm development in a persistent Python execution environment. This design creates a closed loop for programming tasks, allowing the model to dynamically generate, test, and register tools, achieving true autonomous programming.

• MinT Custom Training Platform: The core design transmits only the Adapter rather than full weights, naturally aligning with the MoL architecture. It supports management of millions of Adapter entries and end-to-end reinforcement learning training for models with trillions of parameters. This platform significantly reduces communication bandwidth and storage pressure in distributed training.

• LongStraw Long Context Extension: Shared prompt words are reused in a resident state, avoiding the overhead of repeated calculations for long sequences. The context window is expanded from 1M to 2M. This ensures efficient and stable performance when handling ultra-long documents and multi-turn complex conversations, significantly reducing resource consumption and latency in long-context inference.

• Self-Constructed Dynamic Evaluation Benchmark: Macaron ChatBench evaluates the model's alignment with truthfulness in long-context scenarios and its task completion capabilities. LivingBench tests the model's continuous understanding, information verification, and task re-planning abilities in a sandbox environment with dynamic noise, dynamic environments, and dynamic users, ensuring the model continues to evolve during real-world interactions.

• Exceptional Generation Speed: API testing shows a generation speed of 320 words per second, completing a 10,975-word long text in 34.3 seconds, far surpassing mainstream models. The model maintains stable output after the first token response, making it ideal for latency-sensitive production environments such as real-time conversations and online code generation.

3. How to Use

1. Environment Requirements and Prerequisites: Ensure that the network environment can access the Macaron gateway (link to be updated after official release). The environment must be 3.8+ and have the requests library installed. Since the service is currently in internal testing, you must apply for access rights in advance with MindLab and obtain an API key.

2. Obtaining an API Key: Visit the official MindLab page or contact the team to submit an internal testing application. Once approved, you will receive a dedicated API key. The key must be passed with each request via the HTTP header (e.g., Authorization: Bearer <key>).

3. Calling the Core API: Use a POST request to (link to be updated after official release)

   import requests
   headers = {"Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json"}
   payload = {
       "model": "macaron-venti",
       "router": "coding",
       "messages": [{"role": "user", "content": "Write a Python quicksort function"}],
       "max_tokens": 2048,
       "temperature": 0.7
   }
   response = requests.post("（链接待官方发布后更新）", json=payload, headers=headers)
   

4. Key Configuration Notes: You can use the router parameter to forcibly specify an expert module; if not specified, the system will automatically route the request. For processing long documents, it is recommended to set max_tokens to a larger value (e.g., 8192) and leverage the LongStraw feature to handle ultra-long inputs. The Venti version supports a 2M context, but the actual usable length is limited by API configuration.

5. Notes and Best Practices: During the internal testing phase, the API may have call frequency limits. It is recommended to reasonably control concurrency. For UI generation tasks, when using the UI4A mode, clearly describe the interface layout and interaction logic in the prompt. The REPL Harness feature requires enabling the tools parameter, allowing the model to automatically generate and execute Python code. It is advised to first test on the Tall version before migrating to the Venti production environment.

4. Pros and Cons Analysis

5. Comparative Analysis with Similar Tools

Selection Recommendations: For teams requiring isolated capabilities and the ability to expand new features at extremely low cost, Macaron V1's MoL architecture offers a unique advantage. Its UI4A and REPL Harness features are irreplaceable in interactive UI generation and autonomous programming scenarios, making it suitable for specific domains such as front-end development and automation workflows. If the project demands a mature ecosystem, broad community support, and multilingual stability, GPT-4o or Claude 3.5 Sonnet remain reliable choices, although they are less flexible than Macaron in terms of capability expansion and long context handling.

For enterprise-level tasks requiring ultra-long context processing (such as legal document analysis or research summary generation), Macaron V1's 2M context window and 320 characters/second generation speed make it a strong contender. The lightweight version, Tall, offers a high-cost-performance ratio for local deployment and edge computing, making it ideal for individual developers and small to medium-sized teams. If budget and computational resources are limited, the Tall version should be prioritized for prototype validation, with migration to Venti based on specific requirements.

6. Editor's Summary

Macaron-V1 demonstrates a clear and differentiated approach to technological innovation. Its MoL architecture pushes parameter efficiency in post-training to new heights, achieving isolated optimization across four capabilities using just 0.5% of core parameters, fundamentally avoiding performance conflicts that arise during joint training of multiple capabilities. This design not only reduces training costs but also makes capability expansion as flexible as "installing plugins," providing a new paradigm for model iteration. The LongStraw long-context technology extends the window to 2M through state reuse while maintaining low resource consumption, offering practical value in scenarios involving long document processing. The self-built dynamic evaluation benchmarks (ChatBench and LivingBench) emphasize reward signals driven by real-world environments, making model optimization more aligned with actual applications rather than static metrics.

In terms of practical value, Macaron-V1 achieves or exceeds mainstream levels in generation speed, context length, and native UI/tool capabilities. The flagship version, Venti, is suitable for enterprise-level scenarios with strict performance requirements, while the lightweight version, Tall, lowers the barrier for local deployment. However, the main shortcomings at the current closed beta stage are access restrictions and an immature ecosystem. Developers must rely on official APIs, and community resources are limited. The target audience includes AI application developers requiring flexible combinations of multiple capabilities, researchers pursuing ultra-long context processing, and frontend teams aiming to quickly generate interactive UIs. As MindLab gradually opens its APIs and improves documentation, Macaron-V1 is expected to occupy an important position in the field of post-training multi-capability models, and its MoL architecture may also be adopted by more systems.

7. Application Scenarios

• Enterprise-level Complex Task Processing: The Venti version is designed for advanced scenarios, offering stable and reliable inference and execution capabilities. It is suitable for tasks requiring long context and high-quality outputs, such as financial report generation, legal document analysis, and scientific literature summarization, with a 2M context window capable of handling hundreds of pages of documents in one go.

• Intelligent Agent Development: Supports tool calling, task planning, and dynamic environment interaction. The Agent expert module is specifically designed for automated workflows, combined with the REPL Harness, allowing the model to autonomously write tools and register them as global capabilities, achieving a closed-loop from planning to execution. This is ideal for customer service systems, automated operations, and similar scenarios.

• Code Generation and Engineering: The Coding expert covers code generation, debugging, algorithm development, and SWE (Software Engineering) tasks. With a TerminalBench 2.1 score of 87.6, it demonstrates strong capabilities in terminal commands and software engineering tasks. Developers can use the REPL Harness for interactive programming, and the model can dynamically execute and correct code.

• Interactive UI Auto-generation: Through the UI4A architecture, users only need to describe their UI requirements, and the model can render an interactive view. This is suitable for rapid front-end prototyping, data visualization dashboard generation, and low-code application development, significantly shortening the UI development cycle.

• Lightweight Local Deployment: The Tall version (35B) is optimized based on Qwen 3.6 and supports running on consumer-grade GPUs. It is suitable for individual developers to conduct experiments, learning, or build small-scale applications. It can also be deployed on edge devices to enable offline inference and lightweight agent functionalities.

8. FAQ

Q: What is the difference between Macaron-V1's MoL architecture and traditional MoE (Mixture-of-Experts)?
A: Traditional MoE divides the network into multiple experts during pre-training and dynamically selects them via a gating network. However, these experts share some parameters, which can still lead to interference. MoL (Mixture-of-LoRA), on the other hand, freezes the base model during post-training and only trains independent LoRA adapters. Each expert is completely isolated and does not share parameters, fully avoiding capability interference. Additionally, expert switching in MoL is controlled by an explicit Router Tool rather than an implicit gate, making routing decisions more transparent.

Q: How can I apply for the internal testing API?
A: Macaron-V1 is currently in the internal testing phase, and applications must be submitted through official MindLab channels. You can access the Macaron gateway (link to be updated once officially released).

Q: How to choose between the Venti and Tall versions?
A: Venti (748B) is based on GLM 5.2 and offers the strongest performance with a 2M context window, suitable for enterprise-level high-computation scenarios, but requires deployment on multiple high-end GPUs. Tall (35B) is based on Qwen 3.6 and is optimized for local deployment, capable of running on consumer-grade GPUs, making it ideal for individual developers and edge devices. It is recommended to start with the Tall version for prototyping and then migrate to Venti based on specific needs.

Q: Which programming languages does Macaron-V1 support?
A: The Coding expert module is deeply optimized for Python, with the REPL Harness providing a persistent Python environment. Through the tool calling mechanism, the model can also generate code in other languages (such as JavaScript and C++), but the debugging and execution environments must be configured separately.

Q: How does LongStraw technology achieve a 2M context window?
A: The core mechanism of LongStraw is to reuse shared prompts in a resident state, avoiding the overhead caused by redundant KV cache calculations in long sequences. By reusing states, the model only needs to compute the newly added parts when processing ultra-long inputs, significantly reducing inference latency and memory usage, thereby extending the native 1M context window to 2M.

9. Project Links

• API Gateway (Internal Testing Entry): https://mintcn.macaron.xin