3-Trillion-Parameter Open-Source MoE: Architecture and Deployment Practices
This article examines a newly open-sourced, natively multimodal Mixture-of-Experts (MoE) model with roughly 2.8 trillion parameters, released together with its technical report and the infrastructure used to train it. It explains why trillion-scale parameters do not translate linearly into compute cost, walks through three key architectural designs (hybrid attention, attention residuals, and sparse MoE optimization), covers the natively trained visual encoder and the open training infrastructure (MoonEP, FlashKDA, AgentEnv), and offers a practical framework for evaluating and deploying such a model across capability, efficiency, stability, and cost—alongside concrete deployment guidance and risk-governance advice.
1. Introduction: Open-Source LLMs Enter the 3-Trillion-Parameter Era
In July 2026, an open-source team fully released a natively multimodal MoE (Mixture-of-Experts) large model—including its weights, technical report, and the infrastructure components used to train it. According to the official disclosure, the model has roughly 2.8 trillion parameters, placing it in the 3-trillion-parameter range and making it one of the largest open-source models known to date. Its public materials state that it can now stand alongside some leading closed-source models on tasks such as long-chain-of-thought coding, ultra-long-context agent collaboration, and complex reasoning.
Zooming out, over the past year or two the upper bounds of open-source models—both in parameter count and capability—have been reset almost every quarter. What makes this release stand out is two things:
- A step-change in scale: moving from hundreds of billions to trillions of parameters changes the engineering problem qualitatively.
- Thorough openness: the team released not just weights but also the technical report and training infrastructure, giving the outside world a first chance to “open up” the complete path of a trillion-scale model from training to inference.
Parameter count, however, is an outcome—not capability itself. Rather than dwelling on “how many trillions,” it is more useful to ask three engineering questions:
- What capability gains does a 3-trillion-parameter model bring, and at what cost?
- What key designs in architecture and infrastructure support a model at this scale?
- How should ordinary developers and enterprises evaluate and adopt it?
The rest of this article addresses these three questions in turn.
2. Trillion Parameters Is Not Trillion FLOPs: Three Basic “Accounts” to Settle First
2.1 The capability account: capacity comes from total parameters, cost comes from activated parameters
A large model’s “intelligence” can be roughly split into two kinds of resources:
- Compute: determines how “deep” the model can think at each step.
- Parameter capacity: determines how much knowledge and how many patterns the model can “remember.”
In a dense model, the two are bound to the same set of parameters: all parameters participate in every forward pass, so doubling parameters usually means doubling compute too. MoE decouples them:
- Total parameter count sets the upper bound of the model’s knowledge capacity.
- The expert parameters actually activated for each token determine the compute cost.
Take a sparse MoE with roughly 2.8 trillion total parameters that activates only a tiny fraction of them per token: activated parameters account for only one or two percent of the total. That means the compute to train or run one token is roughly comparable to a dense model that is one or two orders of magnitude smaller, while the model can hold a knowledge capacity several orders of magnitude larger. This is precisely why “parameter scale” and “inference cost” are no longer linearly linked—and the premise for trillion-scale models to be practically useful.
That said, capacity is not the same as capability, and the two should not be conflated:
- High-quality data and training recipes. More capacity only raises the ceiling. If data quality and data mixture can’t keep up, the extra parameters just become “capacity you can’t use.”
- Inference-side cost still exists. Inference cost depends on activated parameters but is also affected by the attention mechanism, context length, concurrency, and batching strategy—it is not as simple as “total parameters divided by activation ratio.”
2.2 The VRAM account: if the weights don’t fit, more compute won’t help
Compute looks at “activated parameters,” but VRAM looks at “total parameters,” because during inference all expert weights must stay resident in VRAM or memory. This mismatch is the most common trap when deploying sparse large models.
To be clear, the numbers below are order-of-magnitude estimates based on general rules of thumb, not official figures for any specific model. Actual results depend on architecture configuration, parallelism strategy, quantization, and framework implementation.
Using the rule of thumb VRAM (GB) ≈ parameters (billions) × bytes per parameter:
- Under FP16 or BF16, each parameter takes 2 bytes, so 2.8 trillion parameters alone come to nearly 5.6 TB of weights;
- Under FP8, each parameter takes 1 byte, so the weights are about 2.8 TB;
- After INT4 quantization, the weights are about 1.4 TB.
None of these include KV cache, activation tensors, communication buffers, or runtime overhead. Even with the most aggressive quantization, you still need dozens of high-bandwidth accelerators in the 80 GB class, spanning multiple servers to form an inference cluster, plus sensible tensor and expert parallelism to get the model running.
This also explains why the “deployability” of a trillion-scale open-source model depends heavily on how well inference partners and framework communities support it: whether the weights can be stably loaded, sharded, and run in parallel on mainstream hardware and frameworks often matters more than benchmark scores in determining whether a model escapes the lab.
2.3 The context account: long-sequence cost comes from attention
Tasks like agent collaboration and repository-level code understanding require a model to “take in” hundreds of thousands or even over a million tokens at once. Traditional multi-head attention has compute that grows with the square of the sequence length, and it needs to cache Key/Value (KV) for every token, so VRAM usage grows linearly with context length. For a 1-million-token context, a conventional estimate puts the KV cache alone in the hundreds of GB range, making it the main bottleneck for long-context scenarios.
This is the core reason trillion-scale models are turning to hybrid attention architectures.
3. Architecture Evolution: Three Key Designs
From the public information, the architecture of this trillion-scale MoE can be summarized at three levels: a hybrid attention mechanism, residual-structure optimization for deep networks, and sparse-MoE optimization for very large parameter counts. The first two address the “long context” problem from 2.3, while the last addresses the “decoupling capacity from compute” problem from 2.1.
3.1 Hybrid attention: balancing long-sequence efficiency and precise retrieval
The model’s hybrid attention adopts a KDA mechanism, designed specifically for ultra-long sequences. By name, KDA belongs to the family of Gated Delta Attention methods, and its design philosophy is in line with the linear-attention research that has gained momentum in recent years:
- Compressed state instead of history cache: it maintains a set of fixed-size state matrices, rewriting the state on each incoming token according to a “write—forget—update” rule, rather than storing all historical K/V. Compute complexity drops from quadratic in sequence length to linear.
- Gating for dynamic forgetting: the model learns “what to remember and what to forget,” easing the information bottleneck of a fixed-size state.
- Delta updates to reduce interference: it updates the state using the difference between old and new values rather than the new value itself, reducing how much new information overwrites or dilutes existing memory.
But linear attention is not a panacea. By compressing a long history into a fixed capacity, it inevitably loses fine-grained information. So long-context models generally use hybrid stacking: linear attention layers handle most of the long-range modeling, with a small number of standard attention layers inserted periodically to do precise retrieval on key segments.
A practical way to measure the quality of a hybrid structure is a “positional retrieval test”:
- Build several sets of “context—question—ground-truth answer” samples.
- Place the evidence containing the answer at positions such as the beginning, 1/4, 1/2, 3/4, and end of the document.
- Measure the model’s recall accuracy at each position.
If the same model is markedly more accurate at the beginning and end than in the middle, that often signals uneven preservation of long-range information; being accurate only at the beginning and end while failing almost entirely in the middle may indicate that the linear layers are carrying too much of the load. In practice, you should push the test length all the way up to the context limit the business actually needs, because many degradations only surface at extreme lengths.
3.2 Residual structure optimization: turning “depth” into real capability
Attention Residuals is another key design in this architecture. The residual connection in a standard Transformer is a fixed-proportion addition, where each layer’s output is added directly onto the main path. The idea behind Attention Residuals is to let each layer use attention weights to “select” how to fuse the outputs of different branches or layers.
Intuitively:
- After stacking many layers in a deep network, shallow-layer signals are easily diluted or drowned out during backpropagation;
- Aggregating information from different depths with dynamic weights that depend on the input makes the gradient path smoother and deep representations more controllable.
This matters to the model in two main ways:
- Better training stability, so it is less prone to gradient explosions or loss spikes under large learning rates and long training runs;
- Deep parameters are more “usable,” avoiding the situation where stacked layers become mere formality.
Illustrative comparison (showing only structural differences, not any specific implementation):
# Standard residual: fixed additionhidden = hidden + attn(layer_norm(hidden))# Attention residual (illustrative): use the current representation as query,# compute weights over multiple branch outputs, then fuse them by weightingweights = softmax(score(current, branch_outputs))hidden = sum(w * out for w, out in zip(weights, branch_outputs))
In trillion-parameter, long-cycle training, the payoff from such improvements is amplified: a single training run consumes enormous compute, and the cost of stability problems that cause “training interruptions and rollback-and-rerun” is extremely high.
3.3 Sparse MoE optimization: fine-grained experts and routing efficiency
In MoE models, an “expert” is essentially a feed-forward network. A router scores each token and selects the few highest-scoring experts to compute. The difficulty of a trillion-parameter MoE lies not in “piling up experts” but in three things: capacity large enough, routing accurate enough, and communication cheap enough.
(1) Capacity: fine-grained expert partitioning
According to the public information, this model uses a combination of 896 experts with only 16 activated at a time—an activation ratio under 2%. A more common industry practice is hundreds of experts with single-digit activations; this configuration partitions experts more finely:
- Each expert has smaller capacity and a more specific role;
- Total parameter count can be scaled up substantially while keeping activated parameters under control;
- Summing the outputs of multiple experts yields stronger compositional expressiveness.
The cost is a larger routing decision space. Going from 64 to 896 experts, the router must choose among nearly a thousand candidates, which raises the bar considerably for training stability, load balancing, and communication efficiency.
(2) Stability: a stable latent-space mixing framework
The public information mentions that the MoE part of this model combines a Stable LatentMoE framework, improving compute efficiency while keeping the huge parameter count. The common idea behind this kind of “latent-space” MoE is: instead of doing full computation over all parameters of each expert, tokens are first mapped into a low-dimensional latent space, routing and expert computation happen in that latent space, and the results are mapped back to the original space. This way, each expert participates in computation with fewer parameters, and the communication volume is smaller too.
“Stability” usually comes from a set of engineering techniques:
- A suitable expert initialization scheme;
- Shared experts that carry general-purpose capability;
- Load-balancing constraints, such as auxiliary loss or auxiliary-loss-free bias correction;
- Gradient clipping and monitoring of parameter update norms.
(3) Routing: load balancing and communication efficiency
Load imbalance is an old problem in MoE: a few popular experts get selected by large numbers of tokens and become overloaded, while less popular experts are under-trained. Common countermeasures fall into three types:
- Auxiliary loss: directly penalize unevenness in the routing distribution;
- Capacity factor and dropping strategy: set an upper capacity limit per expert; tokens over the limit are dropped or fall back to a shared expert;
- Bias correction: dynamically adjust routing scores at inference time based on real-time load, achieving auxiliary-loss-free balancing.
For communication, when 896 experts are spread across different devices, each routing step generates a large amount of cross-device data exchange. Two common industry approaches are:
- Grouped routing: do a coarse filter at the node or device-group level first, then refine within the group, reducing cross-node traffic;
- Overlapping communication with computation: hide data exchange inside the time spent on expert computation.
The illustrative code below shows a routing decision with a load-balancing penalty:
import mathdef route_tokens(token_repr, experts, top_k=16, num_experts=896,alpha=0.01, balance_loss_coef=0.01):"""Illustrative MoE routing: scoring, Top-K selection, normalization,and load-balancing penalty.This only expresses the compute flow and contains no real model interface."""# 1. Router scoring: similarity between the token representation and each expert's routing vectorscores = [sum(a * b for a, b in zip(token_repr, e["route_vec"]))for e in experts]# 2. Normalization (a noise term can be added to encourage exploration and ease early routing collapse)probs = softmax(scores)# 3. Top-K selection: activate only 16 of 896 expertsselected = sorted(range(num_experts), key=lambda i: probs[i],reverse=True)[:top_k]# 4. Weight normalization: gate weights sum to 1 to keep the output scale stableweights = {i: probs[i] / sum(probs[j] for j in selected)for i in selected}# 5. Load-balancing penalty: the more concentrated the routing distribution, the larger the penaltyfreq = [1.0 / num_experts] * num_expertsfor i in selected:freq[i] += 1.0 / len(token_repr)balance_loss = alpha * num_experts * sum(f * p for f, p in zip(freq, probs))return weights, balance_lossdef softmax(values, temperature=1.0):exps = [math.exp(v / temperature) for v in values]total = sum(exps)return [e / total for e in exps]
It’s worth emphasizing that routing in a real system also involves mechanisms such as grouping, bias correction, and capacity limits, and is far more complex than the illustrative code. But understanding this basic flow helps identify bottlenecks during deployment—for example, whether a particular set of experts is overloaded, or whether cross-device communication has become a hotspot.
3.4 Working together: an overall improvement in scaling efficiency
The official data show that these innovations improved the model’s overall scaling efficiency by roughly 2.5× over the previous generation. It’s important to understand what “scaling efficiency” means precisely: it measures how fast model capability grows with scale for a given resource investment, not raw inference speed or response latency.
The three designs have a clear division of labor:
- Hybrid attention lowers long-sequence cost;
- Attention residuals ensure deep stacking is effective;
- Sparse MoE expands knowledge capacity.
Working together, they let “making parameters bigger” and “using the model well” reach a good balance for the first time within the same model family. For developers, the direct significance of this improvement is: for a comparable compute budget, the model reaches a higher capability ceiling.
4. Native Multimodality: Joint Training of a Visual Encoder and Language Objectives
Compared with the previous generation, this model’s visual encoder (MoonViT-V2) is trained entirely from scratch, relying only on subsequent token prediction. It can adjust the encoder’s representations directly according to the language-modeling objective, and it stays stable throughout training.
This sentence hides the essential difference between native multimodality and the traditional “stitched-together” approach.
The stitched-together route: first pretrain a visual encoder separately, e.g., via self-supervised contrastive learning, then attach a projection layer and a frozen vision tower, and fine-tune the language model on image-text data. The advantages are simplicity and maturity; the drawback is that the objective of the visual representation is not aligned with the language-modeling objective, so on tasks like fine-grained text recognition, chart understanding, and spatial-relation reasoning, the model tends to “see but not say correctly.”
The native multimodal route:
- Train the visual encoder from random initialization;
- Use “predicting the next token” as the sole training objective, so the visual representation directly serves language generation;
- Details that are hard to lose on the visual side can be compensated for by the context and reasoning capability on the language side.
“Trained from scratch and stable throughout” is not easy, for three reasons:
- The visual encoder has many layers and high resolution, so both its parameter count and compute are significant;
- If the language-side signal is unstable early in training, gradients can easily hit the visual side and cause representation collapse;
- There are many visual tokens, so long image-text sequences substantially lengthen the training sequence.
Stability usually relies on engineering techniques such as learning-rate grouping, progressive resolution scheduling, and modality data-mix control. The practical significance for developers is that scenarios such as document parsing, chart interpretation, screen understanding, and visual agents may get more coherent visual understanding—not just “describe the picture.”
5. Training Infrastructure: More Than Just Weights Are Open
This time the team also open-sourced key infrastructure technologies used in training. According to the public information, these mainly include three areas:
- Expert parallelism framework (MoonEP): addresses routing and communication when hundreds or thousands of experts are spread across different devices; it is the core foundation for training and inference of a trillion-scale MoE.
- Efficient attention kernels (FlashKDA): provide a high-throughput, low-VRAM implementation at the compute level for hybrid linear attention, making ultra-long-sequence training feasible in both time and memory.
- Agent training environment (AgentEnv): provides an interactive, verifiable, concurrent training environment for agent tasks; it is key to improving capabilities like long-chain-of-thought coding and agent collaboration.
Opening “model—technical report—infrastructure” together means far more than “giving out a few extra documents”:
- Reproducibility: research institutions can reproduce key experiments against the technical report and verify whether the conclusions hold.
- Improvability: developers can build on the same set of parallelism and kernel implementations to do secondary optimization, such as hardware-specific adaptation, communication-scheduling improvements, and kernel fusion.
- Portability: these infrastructure methods are decoupled from the specific model and can be borrowed for training other MoE models or other modalities.
For industry, opening infrastructure is also an important way to lower the barrier to large-model innovation: newcomers don’t have to solve the hard problem of large-scale parallel training from scratch and can focus their energy on data, scenarios, and product innovation.
6. How Developers Should Evaluate: Beyond Benchmarks
Faced with a trillion-scale open-source model, the most common mistake developers make is “only looking at leaderboards and skipping validation.” It’s recommended to build an evaluation system across four dimensions.
6.1 Capability evaluation: from “answering” to “getting work done”
- Long-chain-of-thought coding: don’t just look at single-file function completion; also look at repository-level understanding, cross-file modification, multi-step refactoring, and bug fixing, with executable test cases in place and test pass rate as the main metric.
- Ultra-long-context agent collaboration: simulate multiple agents dividing and collaborating on long documents, long dialogues, and multi-tool calls, and observe task completion rate, information-transfer loss, and the speed at which errors accumulate.
- Complex reasoning: use math, logic, and multi-hop QA tasks, and check whether the final answer and the intermediate reasoning are consistent.
6.2 Efficiency evaluation: separate latency from throughput
- Prefill (time to first token): determines “how long the user waits,” which is especially critical for long-input scenarios.
- Decode (generation throughput): determines the unit cost for long outputs and batch concurrency.
There is often a gap between a model’s claimed “support for ultra-long context” and its actual throughput. The VRAM and bandwidth pressure from long context can markedly slow down decoding, and this must be measured.
6.3 Stability evaluation: reproducible means reliable
Fix the random seed and decoding parameters, run the same input multiple times, and observe whether the output is stable; then change batch size, concurrency, and quantization precision, and check whether the results drift noticeably. For enterprise applications, unstable output means online behavior is hard to predict.
6.4 Cost evaluation: do the math on the whole bill for your business load
def estimate_monthly_cost(avg_input_tokens, avg_output_tokens,daily_requests, card_throughput_per_sec,card_hourly_cost, utilization=0.5):"""Coarse-grained cost estimation (illustrative; no real product or billing interface):estimate monthly compute cost from business load, per-card throughput,and resource utilization."""tokens_per_request = avg_input_tokens + avg_output_tokensseconds_per_card_day = 86400 * utilizationcards_needed = (daily_requests * tokens_per_request) \/ (card_throughput_per_sec * seconds_per_card_day)return cards_needed, cards_needed * card_hourly_cost * 24 * 30# Example assumptions (not any real product data):# 100,000 requests/day, input 8000 tokens, output 500 tokens,# measured per-card throughput 3000 tokens/s, resource utilization 50%.cards, cost = estimate_monthly_cost(avg_input_tokens=8000, avg_output_tokens=500,daily_requests=100_000, card_throughput_per_sec=3000,card_hourly_cost=10, utilization=0.5)print(f"Estimated equivalent accelerators needed: {cards:.1f}, estimated monthly compute cost: {cost:,.0f}")
The above is only a method for order-of-magnitude estimation. Actual cost is also affected by factors such as parallelism efficiency, VRAM capacity, network bandwidth, and redundancy for disaster recovery, so it should be based on measured data after stress testing.
7. Deployment Practices: Getting a Trillion-Parameter Model Running
7.1 VRAM estimation: figure out resource requirements first
def estimate_vram_gb(num_params_b, bits_per_param=8,kv_cache_bytes=0, overhead_ratio=1.15):"""Order-of-magnitude VRAM estimation (for demonstration):VRAM(GB) ≈ parameters(B) × bytes per parameter / 1024^3 × overhead ratio + KV cacheBytes per parameter: BF16≈2, FP8≈1, INT4≈0.5 (all theoretical lower bounds, excluding quantization metadata)"""bytes_per_param = bits_per_param / 8weight_gb = num_params_b * bytes_per_param * (1000 ** 3) / (1024 ** 3)return (weight_gb * overhead_ratio + kv_cache_bytes) / (1024 ** 3)# Demonstrate order of magnitude with about 2800B (i.e., about 2.8 trillion) parametersfor bits, name in [(16, "BF16"), (8, "FP8"), (4, "INT4")]:vram = estimate_vram_gb(2800, bits)print(f"{name} resident weight VRAM: about {vram:.0f} GB")
Rough estimates for BF16, FP8, and INT4 put the resident VRAM for a trillion-scale model’s weights at about 5700 GB, 2900 GB, and 1500 GB respectively; adding the KV cache and runtime overhead, hosting it typically requires dozens of high-end accelerators working together.
Note: this function is only for order-of-magnitude demonstration and does not use any real model configuration or interface.
7.2 Inference: the special challenges of long context and MoE
Long-context inference:
- Paged KV cache management: borrowing the idea of virtual memory from operating systems, manage the KV cache in blocks and allocate on demand, reducing fragmentation and waste and increasing concurrency capacity.
- Prefix reuse: reuse the KV cache of fixed prefixes such as system prompts and knowledge-base documents, significantly reducing the overhead of repeated prefill—especially beneficial for long-document QA.
- Chunked prefill: split the prefill of a long input into small chunks and mix them into scheduling with decode requests, avoiding a long request monopolizing compute and slowing down all online requests.
MoE inference:
- Expert parallelism and node topology: try to place experts that are frequently co-activated within the same node or communication domain, reducing cross-node traffic.
- Overlapping communication with computation: pipeline routing dispatch, expert computation, and result reduction as much as possible.
- Routing load monitoring: watch the expert load distribution to catch individual expert overloads that cause tail latency.
Multimodal inference: high-resolution images generate large numbers of visual tokens, dramatically lengthening the input sequence. Control the number of visual tokens through sensible image tiling and resolution strategies, to avoid the context being “crowded out” by images.
7.3 Enterprise adoption: three typical scenarios
- Dedicated knowledge bases: combine retrieval-augmented generation (RAG) with long-context capability to build enterprise knowledge-QA systems. Long context is good for reading an entire set of policies, contracts, or technical documents in one pass; but ultra-long context is costly and attention tends to scatter, so a hybrid “retrieve first, then read the long document” strategy is usually more cost-effective.
- Agent clusters: in scenarios like coding assistance, test generation, and ops diagnostics, split tasks among multiple long-context-capable agents that collaborate.
- On-premises deployment and secondary development: deploy on your own infrastructure and fine-tune or continue pretraining with domain data, meeting requirements such as keeping data within your boundary and deep domain-knowledge adaptation.
7.4 Cloud hosting and risk governance
Cloud hosting: If an enterprise hosts this kind of workload on a cloud platform such as Baidu AI Cloud, it can typically design the architecture around the following general capabilities:
- Use a container platform to elastically orchestrate inference services;
- Use object storage to hold model weights and training data;
- Use a logging service to collect call logs;
- Use monitoring and alerting to track latency and error rates;
- Use a private network to isolate management traffic and enforce network boundaries for inference services.
It should be noted that this article offers design ideas only from a general architecture perspective and does not touch on the support scope, compatibility, or service capabilities of any specific product. For actual selection, refer to the official documentation and service descriptions.
Risk controls:
- License compliance: carefully read the model license and clarify terms for commercial use, redistribution, and derivative training.
- Output-quality guardrails: set up sensitive-content filtering, fact-checking, and human-review mechanisms at the business layer.
- Version management: record weight versions, quantization schemes, and inference parameters to ensure problems are traceable and reproducible.
8. Risks and Boundaries: A Rational View of the “Largest Open-Source Model”
- Scale is not quality: a large parameter count doesn’t mean the model is strong at every task; domain adaptation still needs to be driven by data and evaluation.
- High resource barrier: both training and inference need large-scale, high-bandwidth compute; small and medium teams are better off using it on demand through cloud services rather than building their own clusters.
- Long-context cost can’t be ignored: the longer the context, the greater the prefill compute and KV cache overhead, so weigh the payoff against the actual task.
- Limited agent reliability: errors accumulate across multi-step tasks, so critical business flows need human review and rollback mechanisms.
- The ecosystem is still maturing: hardware adaptation, framework support, and quantization schemes are all still evolving, so verify compatibility thoroughly before deployment.
9. Conclusion: From “Watching Parameters” to “Watching Usability”
The arrival of a trillion-parameter open-source model marks the formal entry of open-source LLMs into the 3-trillion-parameter era and brings frontier-level model capability to the open-source community. But for developers and enterprises, what matters more than remembering this number is understanding the engineering logic behind it:
- Parameter scale sets the ceiling of model capability; architecture and infrastructure determine whether that ceiling can be realized stably and efficiently;
- Hybrid attention, residual optimization, and sparse MoE work together to unify “scale” and “usability” well for the first time;
- Native multimodality aligns visual representations with language objectives, and open training infrastructure makes reproduction and improvement possible.
What really determines adoption outcomes is still the developer’s own evaluation system, resource planning, and engineering capability. It’s worth starting from these questions:
- Does the business task really need trillion-scale parameters and ultra-long context?
- Can the current compute and budget support the target throughput and latency?
- Are there controllable guardrails for output quality and compliance?
Think these three questions through before you start deploying, and only then can you turn frontier-model capability into real business value.
