From Test-Taker to Doer: How Large Language Models Are Evolving into AI Agents

    Large language models are shifting from answering isolated questions to completing end-to-end tasks. This article explains the five core capabilities behind agentic execution: requirement clarification, task planning, tool use, state and memory management, and verification and delivery. It also examines how system design must adapt to support execution records, error recovery, permission controls, and reliable final outputs.

    1. Capability Evaluation Is Changing

    For the past two years, large language models have primarily been used to answer questions. Their quality was usually measured by benchmark scores and single-response latency. This model resembles a student who excels at exams: knowledgeable and fast, but often dependent on step-by-step human instructions when handling real-world work that requires multiple stages.

    The focus is now shifting toward delivering results. Users typically provide a goal, such as “organize last week’s customer feedback and create a draft weekly report.” To complete it, a model must understand the scope of the request, break the work into steps, call external tools, check intermediate results, and finally produce an output that can be used directly. This continuous process is referred to as agentic task execution, or a task loop in this article.

    For developers, this shift requires a different approach to system design:

    • Inputs change from individual questions to goal descriptions.
    • Outputs change from a piece of text to a result package that includes execution records.
    • Error handling changes from “ask the question again” to “identify the failed step and recover.”
    • Permission design must cover every operation the model can trigger.

    Product launches are often scheduled within specific release windows. During holidays, users may have more time to try new tools, while demand for travel planning, content creation, and social interaction may also increase. These scenarios place concrete demands on task-oriented capabilities, such as searching across multiple information sources, generating multimodal content, and keeping audio synchronized with visuals.

    2. Core Technical Elements of the Task Loop

    A task loop can be divided into five stages. Each stage can be optimized independently.

    2.1 Requirement Understanding and Intent Clarification

    Requirement understanding is the starting point for every subsequent stage. Goal descriptions are often ambiguous, so the system needs to extract four types of information:

    • The goal itself
    • The input data
    • The required output format
    • The acceptance criteria

    When information is missing, the system should ask targeted follow-up questions instead of guessing and executing immediately. The following template can serve as the basis for structured input:

    1. Goal: Generate categorized statistics for last week's customer feedback
    2. Input: Exported support tickets containing ticket ID, content, and submission time
    3. Output: A categorization table plus a summary of the three main issues
    4. Constraints: Exclude customers' personal information; include only closed tickets
    5. Acceptance criteria: Each piece of feedback must belong to exactly one category; each summary must cite the original ticket ID

    2.2 Task Decomposition and Planning

    The planning stage breaks a broad goal into subtasks with dependencies. These dependencies can be represented by a directed acyclic graph (DAG). Subtasks without prerequisite dependencies can be processed in parallel.

    For the weekly report task above, the plan might include reading the tickets, cleaning the fields, categorizing the feedback, calculating statistics, writing the summary, and verifying the citations. Reading and cleaning must happen sequentially, while categorization can be parallelized by ticket batch.

    The granularity of decomposition requires a balance. Steps that are too broad may force the system to redo the entire task when one operation fails. Steps that are too small increase scheduling overhead and context-switching costs.

    2.3 Tool Calling

    Tool calling enables a model to read from and write to external systems. Common tool categories include object storage, message queues, database queries, container platforms, logging services, and monitoring and alerting systems.

    Tool integration requires attention to three areas:

    1. Clear tool descriptions: Document the tool’s purpose, parameter types, required fields, and return structure.
    2. Parameter validation: Validate arguments before execution. Do not directly concatenate model-generated strings into database queries or command-line instructions.
    3. Structured results: Return results in a structured format whenever possible so that later steps can determine whether the operation succeeded.

    2.4 State and Memory

    State management consists of short-term state and long-term memory.

    Short-term state records intermediate results, completed steps, and pending work for the current task. It can be cleared when the task is finished.

    Long-term memory stores user preferences, frequently used templates, and experience from previous tasks. The system should clearly inform users what has been stored and allow them to delete it.

    Memory design should follow the principle of data minimization. Store only the information required for future tasks, and anonymize sensitive fields before they are persisted.

    2.5 Verification and Delivery

    Each step should be verified after execution. Checks may include whether the format is correct, whether values fall within a reasonable range, whether cited sources exist, and whether any constraints have been violated.

    When verification fails, the system should carry the feedback into the next execution round instead of abandoning the task immediately.

    The final deliverable should include an execution record listing each step’s inputs, outputs, duration, and verification result. This record helps users assess the reliability of the result and provides an entry point for troubleshooting.

    The following example illustrates a task loop. Exception handling and concurrency control have been omitted:

    1. class Step:
    2. def __init__(self, name, tool, args, depends_on=None):
    3. self.name = name
    4. self.tool = tool
    5. self.args = args
    6. self.depends_on = depends_on or []
    7. self.result = None
    8. def run_task(goal, planner, tools, verifier, max_rounds=10):
    9. """Loop for planning, execution, verification, and correction."""
    10. plan = planner(goal) # Returns a list of Step objects
    11. done = {}
    12. for _ in range(max_rounds):
    13. pending = [s for s in plan if s.name not in done]
    14. if not pending:
    15. break
    16. for step in pending:
    17. if all(dep in done for dep in step.depends_on):
    18. output = tools[step.tool](**step.args)
    19. ok, feedback = verifier(step, output)
    20. if ok:
    21. step.result = output
    22. done[step.name] = step
    23. else:
    24. step.args["hint"] = feedback # Feed verification feedback into the next round
    25. return done

    The key feature of this code is the feedback loop provided by verifier. When a step fails, its verification feedback is passed into the next round so the system can correct the step instead of treating the entire task as a failure.