Weekly LLM Trends: Post-Training, Agent Cost Reduction, and Personal Assistants

    This article explores three major trends in the evolution of large language models (LLMs): the push for stronger capabilities through post-training, the significant cost reduction in lightweight Agent models via open weights and inference optimization, and the shift of personal assistants towards cloud-based asynchronous task execution. It also introduces a comprehensive "capability-cost-traffic-engineering" evaluation framework, providing engineering implementation recommendations and future outlooks for developers navigating these trends.

    1. Trend Overview and Observation Methodology

    Recent technological advancements in large language models (LLMs) have revealed three interwoven main trends. First, post-training versions continue to push the state-of-the-art with larger parameter scales and stronger long-task execution capabilities. Second, lightweight models designed for Agent scenarios are continuously compressing task costs through open weights, inference optimization, and price reductions. Third, personal assistant products are shifting from “conversational Q&A” to “cloud-based asynchronous task execution,” beginning to handle continuous work such as emails, scheduling, and financial analysis. Meanwhile, third-party aggregated observations indicate that total token volume is growing again, but with clear divergence among different models and versions.

    Observing such weekly trends requires more than looking at individual releases; it necessitates a reusable metrics system. On the capability side, focus on comprehensive evaluation, long-task success rate, tool-calling accuracy, and multi-turn stability. On the cost side, track the price per million tokens, actual cost per task, retry rate, and tool-calling costs. On the engineering side, monitor online inference latency, throughput, availability, and permission auditing. On the traffic side, observe total tokens, request count, average tokens per request, model alias calibers, and week-over-week (WoW) changes. Only by placing “capability-cost-traffic-engineering” within a unified framework can we avoid being misled by a single price point or a single evaluation.

    2. Post-Training Models: Capability Improvement and the Cost Paradox

    Public information indicates that a certain post-training version has reached a 3T-level parameter scale, with input/output pricing at 13/68 (in CNY) per million tokens. Its comprehensive intelligence evaluation index scored 55, an 11-point increase from the previous generation and slightly higher than a competitor’s 53 in the same tier. Its enhanced capabilities in long-task coding, 3D modeling, and financial research are planned to be available via open weights in the short term. From a technical perspective, post-training is not simply “continued training” but involves multi-stage optimization around instruction following, preference alignment, tool calling, long-context stability, and inference-time computation. While parameter scale provides the capacity ceiling, the quality of post-training data, reinforcement learning strategies, tool usage trajectories, and evaluation set design often more directly impact actual task performance.

    More noteworthy is the paradox between “capability improvement” and “actual cost.” The actual task cost of this version is about 1.5 to 2 times that of competitors in the same intelligence tier. Reasons may include higher output prices, more rounds required for long tasks, additional tokens brought by tool calls and retries, and complex tasks triggering longer contexts and inference-time computation. Therefore, evaluating a model should not solely rely on the unit price per million tokens but should calculate the “unit cost of intelligence” or “unit cost of a successful task.” This can be estimated using the following pseudocode:

    1. def unit_task_cost(input_price, output_price, in_tokens, out_tokens, success_rate):
    2. # Calculate the raw cost based on token usage
    3. raw_cost = (in_tokens / 1_000_000) * input_price + (out_tokens / 1_000_000) * output_price
    4. # Divide by success rate to get the cost per successful task
    5. return raw_cost / max(success_rate, 1e-9)

    The success_rate should be derived from an enterprise’s proprietary evaluation set rather than a single public leaderboard. For Agent tasks, retries, tool calls, and multi-turn contexts must also be factored in:

    1. def agent_task_cost(prompt_tokens, completion_tokens, in_price, out_price,
    2. retry_factor=1.2, tool_calls=0, tool_cost=0):
    3. # Calculate base cost for tokens consumed
    4. base = (prompt_tokens / 1_000_000) * in_price + (completion_tokens / 1_000_000) * out_price
    5. # Include retry overhead and tool calling costs
    6. return base * retry_factor + tool_calls * tool_cost

    This implies that high-capability models are better suited for high-value, low-fault-tolerance, long-chain tasks. For high-frequency, low-risk tasks, cost should be controlled through model routing and caching.

    3. Lightweight Agent Models: Open Weights and Inference Optimization

    Another main trend is the opening of weights for lightweight models aimed at Agent scenarios, leading to significant cost reductions. Public information shows that a certain lightweight Agent version is priced at $0.15/$0.60 (input/output) per million tokens, with Agent task usage costs dropping by 70% compared to the previous generation. Online inference has sped up nearly 3-fold, with enhanced capabilities for cross-software office work and desktop automation. The value of open weights lies in reducing marginal call costs, supporting private deployment, and enabling domain fine-tuning. However, enterprises must still bear the costs of deployment, scaling, monitoring, security, and version maintenance. Inference speedups typically come from general optimizations like quantization, batching, KV caching, operator fusion, and speculative decoding, which cannot be simply equated to a proportional latency reduction across all tasks.

    The key to reducing Agent costs lies in the efficiency of multi-turn task orchestration. An Agent task often involves planning, tool selection, parameter filling, result validation, and failure retry. The cost is jointly determined by “model tokens + tool calls + retry counts + manual confirmation.” Lightweight models, with their lower unit prices and higher throughput, are suitable for sub-tasks like high-frequency tool calls, information extraction, form filling, and cross-software operations. High-capability models are responsible for complex planning and final validation. Enterprises can adopt a tiered architecture of “lightweight model execution, high-capability model fallback” to reduce average costs while ensuring a high success rate.

    4. Personal Assistants: Cloud-Based Asynchronous Task Execution

    Leading vendors are beginning to follow suit in the personal assistant domain. Public information indicates that a vendor has opened a research preview for a personal assistant based on a high-capability general model. It can continuously process emails, schedules, and financial analysis in the cloud, functioning even when the user is offline, and shares the subscription quota. The core difference between such products and chatbots lies in “asynchronous long tasks”: after the user sets a goal, the system decomposes the task in the cloud, calls tools, maintains state, waits for external events, and requests manual confirmation at critical nodes.

    Its technical architecture typically includes task orchestration, state persistence, permission delegation, audit logs, and idempotency and rollback mechanisms. Personal assistants handle sensitive data such as emails, schedules, and finances, so they must adhere to principles of least privilege, explicit authorization, operation logging, and manual review. If an enterprise intends to build similar capabilities, it can archive task states, audit events, and results to object storage, use logging services for retrieval, and combine monitoring and alerting to track failure rates and abnormal calls. When adopting general cloud products such as those from Baidu AI Cloud, enterprises should also treat permission boundaries and data lifecycle management as forward-looking designs rather than afterthoughts.

    5. Token Traffic Observation: Recovery and Structural Divergence

    Third-party aggregated observations show that as of a recent week, the total tokens over the past 7 days were approximately 184.01 trillion, a 9.3% increase WoW; text requests were about 7.018 billion, a 4.7% increase WoW. Based on model alias calibers, the old and new versions of a certain open-weight model totaled 49.55 trillion tokens, an increase of about 35.5% WoW; a certain lightweight Agent model newly recorded 14.13 trillion tokens; a certain high-capability general model reached 8.26 trillion, an increase of about 36.5% WoW; and a certain preview version dropped to 2.84 trillion, a decrease of about 79.6% WoW.

    This set of data indicates that the recovery in total token growth is primarily driven by the scaling of new versions, but structural divergence is significant. Estimating by dividing total tokens by request count, the average request is about 26,000 tokens, reflecting an increased share of long-context, multi-turn dialogues, and Agent tasks. The WoW calculation can be standardized as:

    1. def wow(current, previous):
    2. # Calculate week-over-week percentage change
    3. return (current - previous) / previous * 100

    When interpreting traffic, be cautious of caliber changes: model alias adjustments, version migrations, cache hits, batching, and free quotas can all affect total volume. Enterprises should simultaneously track request counts, average tokens, task success rates, and costs, rather than just looking at total token rankings.

    6. Engineering Implementation Recommendations and Outlook

    Engineering implementation recommendations include: establishing a proprietary enterprise evaluation set to track success rates and unit success costs by task type; implementing model routing where high-value tasks use high-capability models and high-frequency sub-tasks use lightweight models; introducing caching, batching, and context compression; setting retry limits, budget caps, and manual confirmation nodes for Agents; and building observability dashboards to track tokens, latency, failure rates, tool calls, and permission audit events. General capabilities such as object storage, logging services, monitoring and alerting, and container platforms from Baidu AI Cloud can be leveraged to build evaluation data archiving, log retrieval, and elastic runtime environments.

    Looking ahead, post-training versions will continue to compete around long tasks and tool calling, but cost governance will become the core of model selection. Open-weight models will drive Agent costs further down, while also bringing security and operational challenges. Personal assistants will transition from research previews to controlled production, where permissions, auditing, and reliability will be more important than single-point capabilities. For developers, the rational approach is to establish a four-dimensional evaluation framework of “capability-cost-traffic-risk,” replacing the hype of single releases with reproducible evaluations and engineering metrics.