Engineering 35B-Level Dual-Facing Models and AI Self-Evolution Practices
This article explores how 35B-level "dual-facing" models can simultaneously handle general business tasks and complex research duties. It breaks down the four-layer capability architecture, explains why 35B serves as an engineering sweet spot, and details how to build a self-evolution closed loop. Additionally, it covers the rational interpretation of benchmark results, engineering implementation practices using platforms like Baidu AI Cloud, and risk governance strategies for enterprise deployment.
1. Background: Why “Dual-Facing Models” Matter
Recent public materials have sparked discussions around 35B-level model use cases that target both conventional general-purpose tasks and research-oriented tasks, such as AI research, computational science, and robotic simulation. Without evaluating any specific product, we can abstract this phenomenon into a general technical question: Can a medium-parameter model simultaneously shoulder “general business capabilities” and “research assistance capabilities,” and continuously improve through a self-evolution closed loop?
Traditionally, general capability evaluation focuses on Q&A, coding, retrieval, and tool calling. Research capability evaluation, however, emphasizes hypothesis generation, experimental design, code reproduction, numerical computation, simulation verification, and result analysis. The two are not entirely aligned. General tasks prioritize coverage and stability, while research tasks require multi-step reasoning, verifiability, and the ability to utilize failure feedback. A model that only excels at single-turn Q&A cannot easily enter the research loop; conversely, pursuing high-difficulty reasoning while ignoring engineering stability makes enterprise deployment difficult. Therefore, being “dual-facing” is not merely about stacking tasks. It requires the model to possess comprehensive capabilities: being able to call tools, execute code, accept evaluation feedback, and be constrained by safety gates.
2. Why 35B is the Engineering Sweet Spot
Bigger is not always better. While 500B and 800B models may excel in high-difficulty evaluations, their costs for training, inference, evaluation, and iteration are high, and their deployment pipelines are complex. 35B-level models typically sit in the compromise zone between “capability” and “cost.” On one hand, they have sufficient representational capacity to handle multi-step tasks; on the other hand, inference costs, fine-tuning costs, and evaluation throughput are easier to control, making them suitable for building high-frequency iterative self-evolution pipelines.
It should be emphasized that 35B is merely a scale range, not a fixed architecture. Common industry approaches include dense models and sparse activation/Mixture of Experts (MoE) architectures. The former is engineering-friendly and behaviorally stable; the latter offers a trade-off between total parameters and single-activation computation but places higher demands on routing stability, load balancing, and evaluation consistency. Regardless of the architecture, the key to a dual-facing model lies in whether a closed loop is formed across training data ratios, tool calling protocols, code execution sandboxes, tiered evaluation sets, and safety rollback mechanisms.
3. Breaking Down Dual-Facing Capabilities
Capabilities can be broken down into four layers:
- Basic General Layer: Q&A, writing, information extraction, multi-turn dialogue, code generation, and deep search. This layer requires low hallucination, stable formatting, and strong instruction following.
- Tool Execution Layer: The model can call retrieval, computation, code execution, and simulation tools as agreed, and parse the returned results. Tool calling is not just “knowing how to write a function name,” but handling timeouts, empty results, exception codes, and partial failures.
- Research Assistance Layer: The ability to propose testable hypotheses, design controlled experiments, generate reproducible code, explain numerical results, and revise plans upon failure. This layer emphasizes verifiability over fluency.
- Self-Evolution Layer: Converting evaluation failure samples, tool feedback, and manual review results into improvements for the next round of training or prompt strategy, while preventing overfitting through holdout sets and safety gates.
Interface constraints are necessary between these four layers. For example, intermediate conclusions from research tasks must be traceable to tool outputs; code execution results must enter the evaluation log; failure samples must pass quality filtering before entering training. Otherwise, “self-evolution” easily degrades into “self-reinforcing errors.”
4. Rational Interpretation of Evaluation Results
Public materials claim that the 35B-level case achieved leading results in 20 out of 21 benchmarks against same-scale controls, led in 18 and tied in 1 against 40B-level controls, and even surpassed 500B and 800B models in some high-difficulty evaluations. These data points indicate that mid-size models are competitive on specific evaluation combinations, but readers should not directly extrapolate this to a comprehensive victory.
There are three main reasons for this: First, the selection of benchmark sets influences conclusions; different weights for general Q&A, code, agent tasks, and simulations can change rankings. Second, if the inference configurations, prompt templates, tool permissions, and evaluation budgets of control models are inconsistent, comparability drops. Third, small sample fluctuations in high-difficulty evaluations can amplify differences. Therefore, engineering teams should establish their own tiered evaluation sets: a general holdout set, a domain holdout set, a tool calling set, a long-chain research task set, and a safety red teaming set, recording the configuration version for each evaluation. The pseudocode is as follows:
suite = [general_qa, code_fix, retrieval_qa, tool_call, numerical_calc, simulation_analysis]for task in suite:outputs = model.generate(task.prompt, tools=task.allowed_tools)score = task.metric(outputs, task.reference, trace=outputs.trace)record(task.name, score, outputs.trace, config_version)
Evaluation records must include the prompt version, tool whitelist, timeout settings, random seed, and model artifact version; otherwise, results cannot be reproduced.
5. Core Design of the Self-Evolution Closed Loop
Self-evolution does not mean the model “makes itself smarter.” Rather, it is system engineering that encompasses “failure discovery—task synthesis—tool verification—quality filtering—training update—regression evaluation—safety rollback.” A practical closed loop includes:
- Failure Clustering: Group by error types, such as factual errors, tool parameter errors, non-executable code, reasoning jumps, and simulation configuration errors.
- Task Synthesis: Generate variant tasks around failure types, but must retain reference answers or executable verifiers.
- Tool Verification: Code tasks are executed in a sandbox; calculation tasks are cross-checked with an independent calculator; simulation tasks verify boundary conditions.
- Quality Gates: Low-confidence samples, unverifiable samples, and samples containing sensitive information must not enter the training set.
- Regression Evaluation: After each update, run the fixed holdout set and safety set. Roll back if metrics drop.
The schematic loop is as follows:
for round in range(max_rounds):failures = collect_failures(eval_suite)candidates = synthesize_tasks(failures)verified = verify_with_tools(candidates)train_set = quality_filter(verified)candidate_model = update(base_model, train_set)metrics = evaluate(candidate_model, holdout_suite + safety_suite)if promote(metrics) and pass_safety_gate(metrics):base_model = candidate_modelelse:rollback()
The key to this loop is not “synthesizing more data,” but “synthesizing verifiable data.” Unverifiable synthetic data will amplify hallucinations and ultimately contaminate both evaluation and training.
6. Engineering Implementation Details
In terms of training and evaluation engineering, teams should unify the management of data versions, task configurations, evaluation results, and model artifacts. You can leverage the Baidu AI Cloud generic container platform to host elastically scalable evaluation tasks, use object storage to save datasets and artifacts, and combine log services with monitoring alerts to pinpoint anomalies. The emphasis here is on general category capabilities rather than specific interfaces or customized services.
Specific recommendations include: First, containerize evaluation tasks to ensure environment consistency. Second, set timeouts, retries, and isolated sandboxes for tool calls. Third, strictly deduplicate training data and evaluation sets to prevent leakage. Fourth, record the complete call chain for easy failure tracing. Fifth, perform tiered sampling for high-cost evaluations—run the fast regression set first, then the full set. For research-oriented tasks, intermediate artifacts like code, logs, numerical tables, and simulation configurations should be retained for manual review.
7. Risk Governance and Deployment Recommendations
Risks associated with dual-facing models include benchmark overfitting, tool abuse, code execution escape, irreproducible research conclusions, and synthetic data pollution. Governance should adhere to the principles of “verification first, least privilege, tiered evaluation, and executable rollback.” When deploying in an enterprise, you can start with low-risk general tasks and read-only tool calls as the first phase, gradually introducing code execution and simulation environments later. Research assistance scenarios should retain manual review nodes and not directly use model outputs as final conclusions.
In summary, the value of a 35B-level dual-facing model lies not in a single leaderboard ranking, but in whether it can form a reproducible, governable, and rollback-capable self-evolution closed loop. When evaluating similar solutions, readers should focus on the transparency of evaluation configurations, the safety of tool execution, data deduplication, and holdout set design, rather than just looking at the “number of leading items.” Only by integrating model capabilities, engineering pipelines, and safety gates into a unified system can AI self-evolution achieve long-term viability.
