Open-source LLMs reach a new milestone: open weights and managed agents run in parallel

Recently, the large language model space saw a notable shift: a major AI company opened up the complete weights of its flagship model and simultaneously launched a managed agent service aimed at enterprise applications. This move signals that the LLM industry is accelerating beyond a single API-call service model toward a more open, flexible, and business-oriented landscape. For developers and enterprise users, this is not just a different way to access technology. It also forces a systematic rethink of AI application architecture and deployment strategy. This article examines the technical core, industry impact, and deployment paths behind this development, and explores the underlying technology trends.

Open weights: from black-box API calls to white-box customization

Over the past two years, mainstream LLMs have mostly been delivered through cloud API calls. The appeal is obvious: low deployment overhead and fast onboarding. But the drawbacks are becoming just as clear. Data privacy is hard to guarantee. Per-call costs depend on vendor pricing. Model behavior is difficult to customize deeply. And enterprises remain dependent on the long-term stability of the provider’s service. For industries such as finance, healthcare, and government, where data sovereignty and compliance are critical, API-only access often fails to meet core requirements.

Releasing full model weights fundamentally changes this equation. Instead of a black box accessed over the network, enterprises receive a set of digital assets they can control directly. This means:

• Stronger data security: the model can run inside a private environment, so sensitive data never leaves the local network. This removes a major data leakage risk at the source.
• Deep customization becomes possible: development teams can use domain data to perform further incremental pretraining or instruction fine-tuning on top of the open weights. A general-purpose model can be shaped into an industry expert that understands specific business terminology and logic.
• Better long-term cost structure: local deployment requires upfront compute investment, but for high-volume use cases, marginal cost is significantly lower than token-based API pricing. It also removes dependence on a cloud provider’s pricing policy.
• Greater technical autonomy: enterprises no longer face the risk of interface changes or service disruptions from the model provider. They gain real control over their AI capabilities.

Of course, open weights do not mean zero barriers. Enterprises still need solid AI engineering capabilities, including building and operating distributed inference clusters, optimizing model parallelism, and managing GPU resource scheduling. This is exactly why the managed agent service was launched at the same time: to serve enterprises at different levels of technical maturity.

Inside the model: how trillion-scale parameters support efficient inference and complex tasks

The technical parameters of the released open-weight model deserve a closer look.

1. Architecture and scale: the engineering art of MoE

The model has 2.8 trillion total parameters, placing it in the 3T class. If it used a traditional dense architecture, inference at this scale would consume enormous compute, making it unaffordable for most enterprises. The Mixture of Experts (MoE) architecture provides a far more practical solution.

The core design principle is division of labor with on-demand activation. Under MoE, the model is split into multiple specialized expert subnetworks. For each input token, the model does not activate all parameters. Instead, a routing mechanism dynamically selects the most relevant subset of experts for computation.

• 2.8 trillion total parameters: represents the model’s knowledge capacity and memory breadth. It has learned a massive range of patterns.
• 104 billion active parameters: represents the parameters actually involved in processing a single request. Although the model is highly knowledgeable, it only activates about 3.7% of its “brain” for each inference. This keeps performance high while keeping inference cost within a reasonable range. It also explains how the model can deliver trillion-parameter-level intelligence with roughly 100 billion active parameters.

2. Context window and multimodality: keys to complex business scenarios

• 1-million-token context window: the value here is large working memory. The model can process roughly the text volume of three full-length science fiction novels in a single interaction. This makes it possible to analyze an entire annual financial report, review a legal contract across chapters, or summarize multiple historical support tickets in one pass.
• Native multimodal visual understanding: the model does not simply stitch together text and images. Visual features and text features are encoded and aligned from the ground up. It can accurately parse charts, screenshots, scanned documents, and similar inputs, providing core capabilities for automated document processing, industrial visual inspection, and related use cases.

3. Training path and capability enhancement: reinforcement learning-driven iteration

It is important to note that this model was not trained from scratch. It was iterated on top of an existing base model using large-scale, cross-domain joint reinforcement learning.

• The base model already had solid language understanding and generation capabilities, similar to a person who has completed higher education.
• Cross-domain reinforcement learning is like putting that person into a practical simulation boot camp. Through interaction with the environment and thousands of rounds of trial and error, the model learns to follow complex instructions more reliably, perform multi-step reasoning, call external tools, and revise outputs based on feedback. This training approach focuses on optimizing the model’s behavioral patterns and task-solving strategies, making it more generalizable and reliable when facing unknown real-world business problems.

This iteration pattern also reveals an important strategy in LLM development: rather than blindly stacking parameters, improving a model’s upper bound and alignment through efficient training strategies has become the key path to practical usefulness.

Managed agent service: solving the last-mile problem of enterprise AI deployment

If open weights answer the question of where the model comes from, the managed agent service answers the harder question of how to actually use it.

1. The technical obstacles to agent deployment are more complex than they seem

Under a traditional development model, getting an AI agent to reliably execute complex tasks, such as automated cross-system data reconciliation, requires solving a series of underlying engineering problems:

• Context management: how to maintain, update, and compress context across a full task lifecycle, rather than simply passing text back and forth in a single conversation.
• Reliable tool calling: how to ensure that structured instructions generated by the model are correctly parsed and trigger external APIs.
• Permission and security control: how to grant the model necessary data access while preventing unauthorized operations and data leakage.
• Fault tolerance: when a task fails halfway due to network issues or API rate limits, how to preserve state and resume seamlessly.

Building this kind of harness framework usually takes a senior AI engineering team several months, and it still requires continuous maintenance and iteration after launch. This is a major obstacle to scaling AI agents.

2. Harness framework as a managed service: letting enterprises focus on business logic

The core value of the managed agent service is packaging the complex low-level harness framework into a standardized cloud service.

In a typical architecture and workflow, the enterprise only needs to define the agent’s task objectives on the platform, configure the list of business tools the agent can call, and then embed the agent into business systems through an API or visual interface. Everything else, including the underlying code execution environment, context management mechanism, tool-call orchestration, task scheduling, and interruption recovery, is handled by the managed service under cloud SLA guarantees.

The service mainly targets two typical scenarios:

• Internal enterprise system integration: it can provide 24/7 business monitoring, anomaly alert classification, and initial response. When a monitoring system detects an anomaly, the agent can automatically pull logs, identify the cause, and attempt to run predefined remediation scripts or notify the relevant personnel.
• User-facing product embedding: it can power deeply customized research assistants or intelligent customer support. Compared with traditional chatbots, a multi-agent collaboration architecture can execute a complex workflow of understanding the request, retrieving materials, analyzing and reasoning, and generating a report. This noticeably improves interaction quality and user satisfaction.

Ecosystem adaptation and deployment strategy: private deployment or cloud hosting?

For developers, the deployment ecosystem matters as much as the model itself. On the day of release, mainstream domestic AI accelerator vendors and inference frameworks announced 0-day inference adaptation for the model. This means that on certain fully domestic hardware platforms, the model works out of the box with Ready to Market capability.

Taken together, the two modes represent two philosophies of LLM application:

Dimension	On-premises private deployment (open weights)	Cloud hosting (managed agent service)
Core goal	Absolute data security, deep customization, long-term cost control	Fast launch, focus on business, reduced operations burden
Technical barrier	High (requires GPU cluster operations and inference optimization)	Low (API integration can be completed within hours)
Upfront cost	High (requires initial hardware investment)	Low (pay as you go)
Typical scenarios	R&D-driven enterprises, highly confidential core systems	Business-driven enterprises, agile development environments

For enterprise CTOs or architects, the key decision is no longer “how good is this model,” but “how do we bring this model into our existing technology stack.” If the company has an available internal GPU pool, private deployment offers high autonomy and strong marginal cost benefits. If the team prioritizes speed of business response, the managed service is a better starting option. In many large enterprises, the two modes will coexist over the long term, serving different business lines.

Conclusion: AI infrastructure as both utility and engine

The combination of an open-weight model and a managed agent service reflects a maturing LLM industry. Open weights ensure that the technical foundation remains transparent and controllable while lowering the barrier to entry. The managed service absorbs the complex application engineering, making AI capabilities as easy to plug in as water or electricity. For developers, this is a turning point. Future competitiveness will not come from simply being able to call a model. It will come from deeply understanding the model’s technical characteristics and building a real problem-solving engine on top of a managed or self-built harness framework. That is both the challenge and the starting point of new value creation.