Agent Runtime Framework Officially Released: Tool Orchestration and Skill Extension

    A modern AI agent needs more than a language model. This article explains how the newly released agent runtime framework manages models, permissions, plugins, tools, MCP services, and reusable skills. It also introduces common agent presets and a practical path for gradually deploying agents from read-only analysis to controlled execution and multi-agent collaboration.

    Introduction: Agent Capabilities Go Beyond the Model

    As large language model applications evolve from question answering to complex task execution, the value of an agent runtime framework is becoming increasingly clear. A model alone can usually generate content, organize information, and analyze possible solutions. However, when a task involves local files, external data, system commands, task decomposition, or business APIs, the model needs tools and an execution environment to complete the workflow.

    A complete agent can therefore be abstracted as:

    Agent = LLM + prompts + tools + runtime environment + task memory

    The model handles understanding and reasoning. Prompts define the agent’s role and behavioral boundaries. Tools connect the agent to the real world. The runtime environment hosts execution, while memory and state management allow complex tasks to continue over time.

    The newly released agent runtime framework is designed to provide more than a chat interface. It establishes configurable, extensible, and composable infrastructure for building agents. Users can define model integrations, permission policies, and plugin capabilities through shared settings, or quickly create task-specific agents through predefined modes.

    1. General Configuration: Managing Models, Permissions, and Extensions

    A mature agent framework first needs a clear configuration system. In most cases, configuration can be organized into three areas.

    1.1 Model Integration

    The model is the agent’s core reasoning engine. The framework should provide centralized configuration for model services, including access credentials, service endpoints, model types, and context capabilities.

    Different tasks have different model requirements:

    • Everyday question answering prioritizes response speed and cost.
    • Code analysis requires strong context understanding and logical reasoning.
    • Long-running workflows require stability and continuous execution.
    • Complex planning requires stronger task decomposition and tool-calling capabilities.

    Centralized model management avoids repeated configuration across projects and makes it easier to switch models based on task requirements. For enterprise users, a unified entry point can also support access control, credential protection, and usage auditing.

    1.2 Permission Policies

    Once an agent can read and write files, execute commands, or access the network, the key question is not only what it can do, but also what it is allowed to do.

    Permission policies should cover at least the following areas:

    • File access scope;
    • Whether files can be modified or deleted;
    • Whether system commands can be executed;
    • Whether external network access is allowed;
    • Whether high-risk tools can be called;
    • Whether human confirmation is required before execution.

    Permissions may be relaxed in development and testing environments to improve efficiency. In production, however, the principle of least privilege should be applied, exposing only the capabilities required for a task. High-risk operations should preferably require confirmation to prevent data damage or service interruptions caused by misunderstandings.

    1.3 Plugin and Extension Management

    A plugin system allows additional capabilities to be connected to the framework as modular components. File processing, network access, task management, knowledge retrieval, and business API calls can all be packaged as independent tools.

    This approach provides several benefits:

    1. Tools are decoupled from models, making replacement and upgrades easier.
    2. The same tools can be reused by different agents.
    3. Tool permissions can be managed independently.
    4. New capabilities can be added without changing the core framework.
    5. Tool calls can be logged for troubleshooting and traceability.

    2. Agent Presets: Matching Runtime Modes to Different Tasks

    To reduce configuration complexity, an agent framework commonly provides several predefined modes. These presets do more than change interface options. They combine prompts, tool permissions, execution policies, and task loops into ready-to-use configurations.

    2.1 Standard Mode

    Standard mode is suitable for most everyday development and office tasks. It typically provides a relatively complete toolset for viewing files, editing content, retrieving information, and planning tasks.

    For first-time users, standard mode is a practical starting point. Users only need to describe the goal. The agent can then select tools based on the task and continue execution.

    2.2 Minimal Mode

    Minimal mode is better suited to conversational consultation, text organization, and simple analysis. It generally reduces the number of tools and execution steps, lowering resource consumption and the risk of unintended operations.

    For tasks such as drafting an explanation, improving a passage of text, or explaining a section of code, minimal mode is often more efficient than a full execution mode.

    2.3 Planning and Tool Coordination Mode

    Complex tasks often cannot be completed in a single step. The agent must first analyze the objective, divide it into subtasks, and then call tools in sequence. Planning and tool coordination mode emphasizes task planning, state maintenance, and verification at each stage.

    For example, an agent handling a code refactoring task could follow this process:

    1. Scan the project directory and identify relevant files.
    2. Analyze the existing code structure and dependencies.
    3. Create a modification plan.
    4. Apply code changes in batches.
    5. Run tests or static checks.
    6. Summarize the changes and highlight potential risks.

    This mode reduces unstructured operations and makes execution easier to observe and correct.

    2.4 Creative and Self-Extension Mode

    Creative mode allows an agent to generate new workflows, supporting prompts, or skill definitions when required by a task. This does not mean that the model can modify itself without limits. Instead, it provides controlled configuration mechanisms that give the agent a degree of workflow extension capability.

    For example, a user can ask the agent to turn a repetitive troubleshooting procedure into a reusable skill. When the same type of issue occurs again, the agent can call that skill instead of repeating the entire interaction.

    Self-extension must be built on permission controls, version management, and human review. Any automatically generated skill should be tested before production use to confirm that its inputs, outputs, and side effects meet expectations.

    3. Built-In Tools: Turning Agents from Talkers into Doers

    Tools are execution interfaces that connect agents to real systems. Without tools, a model can only reason from the available context. With tools, it can read files, retrieve information, perform operations, and verify results.

    3.1 File System Tools

    File tools are used for browsing directories, reading files, searching content, and writing files. They are among the most frequently used capabilities in coding agents.

    Typical use cases include:

    • Finding configuration files in a project;
    • Reading logs and locating errors;
    • Analyzing relationships between multiple source files;
    • Modifying repeated configuration items in batches;
    • Generating scripts or documentation;
    • Comparing content before and after changes.

    When using file tools, the working directory and access scope should be clearly defined to prevent the agent from reading unrelated files. For write, overwrite, and delete operations, change records should be retained, and human confirmation should be added at critical steps.

    3.2 Command Execution Tools

    Command execution allows an agent to run tests, build projects, inspect dependencies, check runtime status, and execute automation scripts.

    It is also a relatively high-risk capability. Configuration should consider the following:

    • Whether the range of executable commands should be restricted;
    • Whether access to sensitive directories should be blocked;
    • Whether network requests should be limited;
    • Whether execution timeouts should be configured;
    • Whether standard output and error output should be retained;
    • Whether confirmation should be required before execution.

    In engineering practice, it is advisable to start with read-only commands for analysis, then gradually allow operations related to modification and release.

    3.3 Web Search Tools

    Web access enables agents to retrieve current information, consult public documentation, verify technical specifications, and supplement background knowledge.

    To improve retrieval quality, prompts should specify:

    • The subject to search;
    • The relevant time range;
    • Source requirements;
    • Whether cross-validation is needed;
    • The expected output format;
    • Whether uncertain conclusions should be labeled.

    Web search does not make results inherently reliable. The agent still needs to summarize, compare, and fact-check retrieved content, especially for technology selection and security decisions.

    3.4 Task Management Tools

    Without state management, complex tasks can easily result in missed steps, repeated execution, or loss of control. Task management tools divide an objective into multiple items and record the status of each subtask.

    Common statuses include:

    • Not started;
    • In progress;
    • Completed;
    • Awaiting confirmation;
    • Failed;
    • Paused pending input.

    A task list gives users a quick view of overall progress. It also helps the agent maintain a clear direction when the context becomes lengthy.

    3.5 Multi-Agent Collaboration Tools

    Large tasks can be divided among agents with different responsibilities. For example, one agent can analyze requirements, another can inspect code, a third can validate tests, and a coordinating agent can consolidate the results.

    Multi-agent collaboration requires clearly defined roles, input and output formats, and handoff procedures. Otherwise, agents may duplicate work or produce contradictory conclusions.

    4. MCP Services: Standardized Access to External Capabilities

    MCP can be understood as a standardized way to connect models with context and tool-calling capabilities. Through this type of protocol, an agent can discover and use external services in a consistent format without requiring a separate integration implementation for every service.

    When connecting external services, consider the following areas.

    4.1 Are Service Capabilities Clearly Defined?

    Each service should clearly describe the tools it provides, input parameters, return values, and possible errors. The clearer the description, the more reliably the model can call the service.

    4.2 Are Permissions Controllable?

    External services may involve databases, internal systems, or sensitive data. Independent credentials, least-privilege access, and environment-specific configurations should be used instead of directly providing the agent with a highly privileged account.

    4.3 Are Calls Traceable?

    Logs should record the call time, caller, tool name, input summary, execution result, and error information. Complete logs make it easier to locate problems when failures occur.

    4.4 Are Results Easy for the Model to Understand?

    External services should return structured data whenever possible and avoid large amounts of irrelevant content. Clear field names, stable error formats, and appropriate data filtering can improve execution accuracy.

    5. Skills: Turning Repetitive Workflows into Reusable Capabilities

    The core value of a skill is to package a relatively stable task workflow so that an agent can reuse it.

    A complete skill usually includes:

    • Skill name and applicable scenarios;
    • Input requirements;
    • Execution steps;
    • Available tools;
    • Output format;
    • Error-handling procedures;
    • Permission and security restrictions;
    • Example inputs and outputs.

    For example, the workflow for analyzing runtime logs and generating a troubleshooting report can be packaged as a skill. The skill can instruct the agent to read the logs, extract error patterns, associate them with configuration changes, and generate a report covering symptoms, causes, evidence, and recommendations.

    When writing a skill, do not describe only the final objective. Key steps and boundary conditions should also be explicit. For skills that may modify data, the analysis phase should be separated from the execution phase to prevent irreversible actions.

    6. Deployment in Practice: Expanding Scope Gradually

    Agent capabilities should be enabled from lower-risk use cases to higher-value workflows.

    Phase 1: Start with read-only tools for file analysis, information retrieval, and task summarization.

    Phase 2: Add controlled write access so the agent can generate documents, modify code, or create configuration files while retaining version control and human review.

    Phase 3: Connect testing, build, and quality-checking tools to create an automated analyze–modify–verify loop.

    Phase 4: Consider connecting business systems and data services, and introducing multi-agent collaboration after establishing comprehensive permission, auditing, and rollback mechanisms.

    Throughout the process, continuously monitor three indicators: task completion rate, tool-call accuracy, and the proportion of abnormal operations. Permissions should be expanded only when the agent can complete tasks reliably and the associated risks remain acceptable.

    Conclusion

    The real value of an agent runtime framework is not the number of features it provides, but whether it creates an effective coordination mechanism among models, tools, skills, and execution environments.

    General configuration enables centralized management of models, permissions, and extensions. Agent presets make it easier to adapt agents to different types of work. Built-in tools allow agents to handle files, commands, networks, and task states. MCP services standardize connections to external systems. Skills turn individual experience into reusable automation workflows.

    When these capabilities are combined appropriately, an agent is no longer just a window for answering questions. It can gradually become a digital work assistant that understands objectives, plans steps, calls tools, verifies results, and continues to improve.