From L1 to L5: AGI Evolution Paths and Engineering Practices for Large Models
This article presents a capability-level framework for large-model AGI, from L1 language and knowledge acquisition to L5 conscious intelligence, with a practical focus on the engineering tasks, metrics, and release gates for L1–L4. It examines how three flagship model generations can be shipped within six months through training infrastructure, data flywheels, evaluation loops, and tiered releases; breaks code capability into four evaluation dimensions with a sandbox-based patch evaluation example; and discusses multimodal and agent engineering, inference cost, open-source versus closed-source strategy, compliance, and a reusable maturity self-assessment checklist. Readers gain a practical way to judge whether a model provider’s capability claims are verifiable, evaluation-driven, and cost-aware.
1. Why Large-Model Companies Need a Capability Framework
The capability boundary of large models has long been one of the blurriest parts of the industry and one of the easiest to obscure with marketing language. A single successful call in a demo video and the stable behavior of thousands of calls in a real business context are often very different. To let R&D, product, and investment teams talk on the same map, the industry has gradually developed a “capability-level” approach centered on capability ladders: splitting the large goal of artificial general intelligence into stages that can be defined and accepted.
The value of such levels is not only in communicating a technical route externally, but also in allocating resources internally. Each level of capability building corresponds to different infrastructure, data assets, and talent structures: L1 is about compute and corpora; L2 is about alignment data and evaluation systems; L3 is about the ability to design training signals; L4 begins to test engineering governance and risk boundaries. Mixing all of these together and simply saying “the model is strong” is a common root cause of poor technology selection.
At the same time, it must be emphasized that the levels themselves are not the goal; verifiability is. Without corresponding acceptance metrics and isolated evaluation sets, any level will eventually degrade into a marketing phrase. A level with real engineering value must answer three questions: what capability does this level represent, what metric measures it, and how is it determined that a model has crossed this level?
2. Breaking Down the Five-Level Path
L1: Language and Knowledge Acquisition (Pretraining)
This is the capability foundation. Engineering work centers on data mix, cleaning and deduplication, token budget allocation, and long-context training strategies. Acceptance metrics usually include held-out perplexity trends, domain knowledge QA accuracy, and long-document retrieval and citation consistency. The key at this level is not “how much data the model has seen,” but the reproducibility of the data and the traceability of the data mix. Without a clean corpus ledger, none of the later capabilities can be attributed.
L2: Alignment and Reasoning
Supervised fine-tuning addresses “can it do it,” while preference alignment and reinforcement learning with verifiable rewards address “does it do it correctly and follow instructions.” Acceptance metrics expand from simple pass rates to instruction-following rate, format compliance rate, safe refusal rate, and hallucination rate. There is an engineering detail that is often overlooked: evaluation sets must be isolated from training sets through contamination detection. Otherwise, a score increase may simply reflect memorization rather than capability.
L3: Self-Learning
The machine begins to acquire self-reflection, self-critique, and self-correction capabilities, and training signals shift from “human preference” to “verifiable signals.” Whether a math problem is correct, whether code passes tests, and the status returned by a tool call are naturally high-quality rewards. Acceptance metrics include the improvement in pass rate after self-correction and the completion rate of long-horizon tasks.
L4: Self-Awareness and Autonomy
The model forms relatively stable behavioral policies in long tasks and can autonomously decompose goals, select tools, and decide when to ask for help. The stronger the capability at this level, the greater the risk. Permission boundaries, behavior auditing, and rollback mechanisms must be built in parallel.
L5: Conscious Intelligence
There is currently no verifiable criterion. This is a research topic rather than an engineering delivery target. The realistic industry approach is to treat it as a long-term direction while focusing short-term resources on measurable capabilities from L2 to L4.
3. Three Flagship Generations in Six Months: Engineering Feasibility of the Iteration Cadence
The industry has already seen a cadence in which three flagship model generations are launched within six months. This speed is not achieved by “stacking compute” alone. Instead, four things must work at the same time:
- Training infrastructure: elastic compute scheduling, automatic tuning of parallel strategies, and checkpoint resume so that the cost of a failed training run is reduced to an acceptable level.
- Data flywheel: real online traffic → log collection → automatic/manual labeling → return to the training set, forming a closed loop.
- Evaluation closed loop: automated evaluation sets run in daily batches, key metrics have threshold gates, and nothing is released if it fails.
- Tiered model releases: flagship models define the capability ceiling, while distilled small models serve cost-sensitive scenarios, forming a product matrix.
Example: a capability-level definition and evaluation gate configuration (illustrative)
# Capability levels and acceptance gates (illustrative configuration, not any vendor API)levels:L1_language:metrics: [heldout_ppl, domain_qa_acc]gate: {domain_qa_acc: ">= 0.80"}L2_reasoning_alignment:metrics: [math_pass@1, code_pass@1, refusal_rate, format_ok]gate: {math_pass@1: ">= previous + 0.02", format_ok: ">= 0.99"}L3_self_improvement:metrics: [self_correct_gain, long_horizon_success]gate: {self_correct_gain: "> 0.05"}L4_autonomy:metrics: [tool_call_success, plan_revision_rate, unsafe_action_rate]gate: {unsafe_action_rate: "<= 0.001"}
The value of this configuration is that it translates statements such as “we have reached L3” into a repeatable judgment from an evaluation pipeline.
4. Code Capability: Dimension Breakdown and Custom Evaluation
Code capability is currently the most objectively verifiable capability dimension, and also the one most easily hidden by a single score. It is recommended to split it into four subdimensions and build evaluations separately:
- Competitive code generation: single-function or algorithm problems, looking at pass@1 and the strength of test-case coverage.
- Real repository bug fixing: given an issue description and repository context, whether the patch passes unit tests without breaking existing behavior. This is the closest to engineering value.
- Multilingual and cross-language transfer: performance differences for the same requirement across language stacks, reflecting the model’s generalization across language ecosystems.
- Terminal and toolchain tasks: completing builds, debugging, and configuration changes in a command-line environment, testing long-chain action capability rather than single-point generation.
The lowest-cost approach to custom evaluation is a containerized sandbox: each task runs in an isolated container, “whether all unit tests pass” is used as a binary signal, and the distribution of failure types is recorded at the same time.
Example: an evaluation skeleton for bug-fixing tasks
def evaluate_patch(task, model, sandbox):# task: {repo_snapshot, issue_text, hidden_tests, timeout}patch = model.generate_patch(task.repo_snapshot, task.issue_text)result = sandbox.run(apply_patch=patch,commands=["pytest -q hidden_tests/"],timeout=task.timeout,)return {"task_id": task.task_id,"resolved": result.exit_code == 0,"fail_kind": classify_failure(result), # compile / test / timeout / patch_conflict"latency_ms": result.latency_ms,"tokens": result.prompt_tokens + result.completion_tokens,}
In real evaluations, using the distribution of fail_kind as a first-class metric is more diagnostically valuable than the total pass rate alone: compile failures indicate insufficient understanding of syntax and types, patch conflicts indicate weak context localization, and timeouts indicate that the action policy lacks convergence judgment.
5. Multimodal and Agents: From “Can Talk” to “Can Act”
Beyond code and reasoning, multimodality and agents are currently the two lines that best reflect product differentiation. The core engineering difficulties in multimodal work are image-text alignment quality, document layout parsing accuracy, and visual grounding. For agents, the core is the closed-loop reliability of perception—planning—execution—feedback.
Take an agent that “autonomously operates mobile devices” as an example. Its technology stack usually includes UI element parsing and semantic annotation, task decomposition and step planning, action execution (tap, input, swipe), and execution result verification and retry. Evaluation metrics should include task completion rate, average number of steps, misoperation rate, and human intervention rate. This type of agent naturally has verifiable signals—whether the interface state has changed as expected—so it is also one of the best training grounds for L3.
6. Cost, Open Source, and Commercialization: Three Unavoidable Questions
- Inference cost: capability improvements are often accompanied by higher token consumption. Engineering teams need dynamic batching, KV cache reuse, routing, and model distillation to offset this; otherwise, capability growth cannot translate into commercial viability.
- Open source versus closed source: open source can quickly build an ecosystem and feedback loop, while closed source makes it easier to control quality and safety boundaries. A mature approach is usually “core capabilities closed, some weights open, unified supply through APIs.”
- Capital and compliance: large models are a capital-intensive business, with compute, talent, and data labeling as major cost items. At the same time, data security, content compliance, and model behavior auditing mechanisms are needed. These are both regulatory requirements and hard thresholds for enterprise customers during procurement.
7. A Reusable Maturity Self-Assessment Checklist
- Does each capability level have clear criteria and isolated evaluation sets?
- Is there an evaluation-set contamination detection mechanism, and can score improvements be attributed to capability rather than memorization?
- Is the distillation pipeline from flagship models to small models connected, and is the cost curve controllable?
- Are there independent metric dashboards for the code, multimodal, and agent lines?
- Do high-risk agent actions have whitelists, auditing, and one-click rollback?
- Is the iteration cadence supported by evaluation gates, avoiding “release as incident”?
Conclusion
The L1-to-L5 levels are essentially an engineering roadmap: they define the tasks, resources, and acceptance methods for each stage. For developers and enterprise users, judging whether a model provider is mature should depend less on marketing language and more on whether its levels are verifiable, its evaluation is closed-loop, its iterations have gates, and its costs have a downward path. The same criteria apply when evaluating selectable models and toolchain services on cloud platforms, such as Baidu AI Cloud where relevant; using one consistent yardstick is more reliable than relying on any single claim.
