Rethinking AI Agent Skills from the Agent's Perspective: In-Depth Practices in Tool Calling and Interaction

AI Agent technology is evolving quickly. When developers build agents, they often fall into the one-way thinking of traditional software, treating the large language model (LLM) as an inanimate tool that is only called to fulfill user intent. As agents grow more complex, we need a new perspective: looking at the world the way an agent does. Engineers need to understand the real difficulties agents face while solving problems, and how the form of a tool affects how effectively an agent executes. This article analyzes the core engineering practices of AI Agent skill design and explores how optimizing tool calling and interaction mechanisms can unlock an agent’s full potential.

1. The “Double-Sided Software” Concept and Mining Agents’ Latent Demand

Industry experts have proposed a useful concept: “Latent Demand.” In traditional software development, requirements analysis only considers end users. In AI Agent development, however, software is “double-sided.” One side connects to the user, and the other side connects to the LLM itself. When designing an agent and its toolset, we must consider not only what the user wants to achieve, but also the model’s working habits and what it handles comfortably during task execution.

For example, does the model forget key instructions when handling long contexts? Does it hallucinate when parameters are ambiguous? Only by understanding the model’s capability boundaries and preferences can we design smoother execution paths. Many well-regarded industry solutions, including some context protocols and skill frameworks, are based on this idea. Developers observe where an agent gets stuck, build auxiliary tools to address those obstacles, let the agent try them, and then watch how it performs and keep refining the tools’ shortcomings. This model-centered engineering perspective is key to overcoming current bottlenecks in agent capability.

2. Programmatic Tool Calling: Breaking the Bottleneck of Multi-Turn Reasoning

In a typical agent workflow, when the model calls an external tool, such as querying a database or calling an API, each result triggers a new LLM inference. If a complex task includes several consecutive tool calls, the system needs multiple round trips. This significantly increases latency and token consumption. It also quickly fills the limited context window, so early key information can be pushed out and lost, which reduces the task success rate.

To address this problem, the industry has adopted programmatic tool calling. The core idea is to combine multiple discrete tool calls into one complete script and execute it through a single tool call. For example, instead of having the model call “create file,” “write data,” and “close file” tools in three separate steps, the model can generate one control script that contains all three operations and run it in a local secure sandbox or a cloud container environment.

This approach has become practical because the code generation capability of modern LLMs has matured. Models can write stable, fault-tolerant scripts. Engineering teams, based on their understanding of and trust in the model’s coding ability, can safely hand control of sequential operations to a script executor. This reduces the number of inference rounds, saves context space, and noticeably improves task execution efficiency.

3. Structured Human-Agent Interaction: Balancing Flexibility and Structure

When executing complex tasks, an agent often needs to ask the user for information or request confirmation. Designing this interaction is one of the hardest parts of agent engineering. Early attempts tended to swing between two extremes. If the design emphasizes flexibility, the model’s free-text questions can vary widely, which makes them hard for the front end to render consistently and leaves users unsure how to respond. If the design emphasizes structure, rigid fixed forms limit the model’s ability to phrase questions naturally based on context.

After extensive engineering practice, the industry has moved toward a better balance: presenting questions to users in a modal dialog. Specifically, the model outputs structured question data through a dedicated tool call, including fields such as a title, an option list, and an input type. The front end converts this data into a standardized modal dialog for display and data collection.

This design keeps the semantic flexibility of model-generated questions and gives the interaction a clear structure through fixed UI components. As a result, collecting user feedback becomes highly efficient. Developers have also observed that models show a strong preference for this interaction tool in practice. Structured input and output make it much easier for the model to parse user responses, which reduces misunderstanding and improves the likelihood of task success.

4. Summary and Engineering Takeaways

Designing AI Agent skills involves much more than writing a few API endpoints. It is a comprehensive engineering discipline that requires a deep understanding of model behavior and user needs. From the “double-sided software” concept, to programmatic tool calling that lowers inference costs, to structured interaction, each step reflects a deliberate effort to think from the agent’s perspective.

For developers and enterprise architects building enterprise-grade agent applications or integrating cloud AI capabilities, it is worth moving away from traditional one-way thinking and treating the LLM as a collaborator. By observing execution traces, uncovering latent demand, and refining tool design and interaction protocols, teams can build agent applications that are efficient, reliable, and pleasant to use. In future cloud-native AI development, this engineering approach, which focuses on model execution efficiency, will likely become a mainstream technical foundation.