From Answering Questions to Getting Work Done: The Evolution and Practice of Agentic Large Language Models

From Answering Questions to Getting Work Done: The Evolution and Practice of Agentic Large Language Models

In recent years, the capabilities of large language models (LLMs) have undergone a profound shift. Early models focused primarily on memorizing and understanding massive text corpora, which translated into the ability to answer questions—retrieving knowledge, summarizing content, and generating text in Q&A scenarios. Enterprise applications and real-world business scenarios, however, demand more than text output. Organizations want models that can directly get work done: autonomously understand business intent, break down execution steps, invoke external tools, and complete closed-loop tasks. This transition from single-shot text generation to multi-step task execution is a defining marker of Agentic AI.

1. From Knowledge Emergence to Action Emergence

Traditional LLMs operate within a constrained output space limited to text tokens. When a user asks, “What is the current CPU load on the system?” or “Send a marketing email to this month’s new registered users,” a conventional model can only generate instructions on how to check CPU usage based on its training data, or draft email copy. It cannot execute system commands or trigger a message queue.

Agentic evolution breaks through this limitation. The model no longer serves merely as a knowledge base but evolves into a control hub. By introducing function calling, code interpreters, and external API interactions, the model’s output expands from natural language text to structured instructions and code operations. This “action emergence” enables LLMs to connect directly with underlying infrastructure—such as object storage, container platforms, and logging services—translating natural language intent into concrete engineering execution.

2. Three Core Capabilities of Agentic LLMs

Bridging the gap from answering questions to getting work done requires deep reconstruction across three technical dimensions:

2.1 Accurate Intent Understanding and Task Planning

When faced with complex business requirements, an agent must first be able to decompose a high-level goal into executable micro-steps. This demands strong logical reasoning as a foundation. Upon receiving a user instruction, the model needs to internally construct a task execution tree that clarifies dependencies, expected outputs, and rollback paths for each step. For example, when given the instruction “Analyze last month’s sales data, generate a visualization report, and send it to my manager,” the model must autonomously break this down into sub-tasks such as querying the database, extracting relevant fields, writing chart-generation code, and calling an email API.

2.2 Structured Tool Calling and API Interaction

Getting work done requires the model to operate on the external world. This depends on the model’s precise understanding and invocation of structured interfaces. Modern agent frameworks typically provide tool descriptions in JSON Schema format, enabling the model to determine during inference whether a tool is needed, which tool to select, and how to generate a call request that satisfies parameter constraints.

The following example illustrates how a model outputs structured instructions based on user intent:

// Tool description registered with the model (querying system alert logs)
{
  "name": "query_alert_logs",
  "description": "Query system alert logs within a specified time range, with optional severity filtering",
  "parameters": {
    "type": "object",
    "properties": {
      "start_time": {"type": "string", "description": "Start time in YYYY-MM-DD format"},
      "end_time": {"type": "string", "description": "End time in YYYY-MM-DD format"},
      "severity_level": {"type": "string", "enum": ["warning", "error", "critical"]}
    },
    "required": ["start_time", "end_time"]
  }
}
// Structured call output generated by the model after receiving:
// "Check if there were any critical errors yesterday"
{
  "tool_calls": [
    {
      "name": "query_alert_logs",
      "arguments": {
        "start_time": "2023-10-26",
        "end_time": "2023-10-27",
        "severity_level": "critical"
      }
    }
  ]
}

This mechanism bridges the ambiguity of natural language with the determinism of machine execution, forming the physical foundation of a model’s ability to get work done.

2.3 Contextual Memory and Dynamic Environment Feedback

Real task execution is rarely a one-shot process. Models must continuously adjust their behavior while interacting with the environment. For instance, when a model-generated database query fails due to a syntax error, the agent needs to capture the error message returned by the system, incorporate it into the context, revise the code, and retry. This “observe-think-act-feedback” loop enables the model to remain robust in complex, dynamic production environments.

3. Cloud-Native Architectures for Agent Deployment

Deploying models with these capabilities in production typically requires a complete agent runtime architecture. Drawing on established cloud-native practices from platforms such as Baidu AI Cloud, a typical agentic execution architecture should include the following key layers:

3.1 Model Inference and Scheduling Layer

This layer handles natural language input processing, multi-turn conversation context management, and inference computation. To support high-concurrency task execution, the underlying infrastructure typically relies on elastic, scalable compute resources such as GPU container clusters, ensuring that task scheduling does not become a bottleneck during peak business periods.

3.2 Tool Integration and Permission Management Layer

Enterprise systems are vast and complex. Agents need to connect with various middleware, databases, and business APIs. This layer is responsible for wrapping internal enterprise services into standardized tools that the model can invoke. At the same time, strict permission controls and sandbox isolation mechanisms must be established. For example, when a code interpreter needs to execute dynamically generated Python scripts, execution must occur within a secure container sandbox to prevent malicious code from compromising the host. Calls to message queues or object storage should follow the principle of least privilege to prevent unauthorized access.

3.3 State Management and Streaming Monitoring Layer

Long-running tasks—such as data cleaning or model training jobs that span hours—require stable state persistence mechanisms. The system should record the execution status of each sub-task and support checkpoint recovery in the event of interruption. Additionally, all tool invocation behavior and model inputs/outputs should be integrated into a unified logging service and monitoring platform, allowing developers and enterprise users to trace the agent’s reasoning and execution processes end to end.

4. Conclusion

The leap from answering questions to getting work done marks AI technology’s entry into the realm of production tools, moving beyond demonstration-oriented applications. By strengthening intent understanding, tool invocation, and closed-loop feedback capabilities—supported by secure, elastic cloud-native infrastructure—AI is gradually becoming an automated execution engine for enterprise digital transformation. As model reasoning capabilities continue to improve and the tool ecosystem matures, agents will be able to handle increasingly complex, multimodal, unstructured tasks, enabling seamless integration between AI and core business workflows.