Generative Artificial Intelligence has made significant strides, but Large Language Models (LLMs) often seem stuck in a conversational loop. They answer questions, generate text, but rarely interact with the real world. This is where the concept of ‘Agent Skills‘ comes in—a methodology that allows LLMs to go beyond text, executing concrete actions through external functions.
Agent Skills, as proposed by Addy Osmani’s repository, bridges the gap between LLMs’ linguistic capabilities and real-world task execution. Imagine an AI agent that can not only tell you the weather but also send an email, update a calendar, or query a database. This evolution transforms LLMs from mere ‘talkers’ into ‘doers,’ capable of automating complex processes and significantly improving operational efficiency. Read also: TeamAI-CLI: AI Automation for Devs This approach is crucial in enterprise environments where workflow automation is a priority, and an agent’s ability to interact with external systems can drastically reduce manual workload and human errors. I have personally witnessed how implementing similar functionalities can accelerate support ticket triage, transforming a reactive process into a proactive one, where AI not only understands the problem but also begins to resolve it.
Tested on: Python 3.10 · OpenAI API · September 2026
Prerequisites / Test Environment
To implement and test Agent Skills, you will need a Python 3.8+ environment and access to a Large Language Model (LLM) via API. This can be OpenAI GPT-3.5/4, Anthropic Claude, or a compatible open-source model. The ideal test environment also includes the ability to simulate interaction with external services, such as REST APIs for sending emails or updating a calendar. Ensure you have the necessary API credentials and have installed the required Python libraries.
pip install openai # or other LLM libraries
pip install agent-skills # if available as a package, otherwise clone the repo1. Understanding the ‘Skill’ Concept
A ‘skill’ in this context is a defined function that an AI agent can invoke. Think of it as an internal or external API that the LLM can call when the conversation’s context requires it. Each skill is characterized by:
- Name: A unique identifier for the skill.
- Description: A clear explanation of what the skill does and when it should be used. This description is critical because the LLM will use it to decide if and how to invoke the skill.
- Parameters: Necessary inputs for skill execution, with their types and descriptions.
This structure allows the LLM to ‘reason’ about whether to use a skill and to prepare the correct parameters for invocation. It is similar to the concept of ‘tool use’ or ‘function calling’ found in many LLM frameworks, but with an emphasis on modularity and reusability.
2. Defining a Simple Skill: Sending Email
Let’s define a skill for sending an email. Assume we have a Python function that handles sending emails via an SMTP service or a third-party API.
import smtplib
from email.mime.text import MIMEText
def send_email_skill(recipient: str, subject: str, body: str) -> str:
"""Sends an email to a specific recipient.
Args:
recipient (str): The email address of the recipient.
subject (str): The subject of the email.
body (str): The body of the message.
Returns:
str: A confirmation or error message.
"""
# Simulate email sending
try:
# In a real environment, this would contain SMTP logic or an API call
print(f"Simulating email send to {recipient} with subject '{subject}' and body: {body[:50]}...")
return f"Email successfully sent to {recipient}."
except Exception as e:
return f"Error sending email: {e}"
# This function would then be registered within the Agent Skills framework
# The description and parameters would be automatically extracted or explicitly definedThe key is the clarity of the description and parameters. The LLM must unambiguously understand when send_email_skill is the right choice and what information it needs to extract from the conversation to call it. Read also: MFA Admin: Unblocking Operations
3. Registering and Using Skills with an LLM Agent
Once skills are defined, they must be registered with the LLM agent. The exact process depends on the LLM framework used (e.g., LangChain, LlamaIndex, or custom implementations). The general idea is to provide the LLM with a list of available functions and their descriptions, so it can autonomously decide when to invoke them.
For example, using an approach based on OpenAI Function Calling:
from openai import OpenAI
client = OpenAI()
# Skill definition for the OpenAI API
email_tool = {
"type": "function",
"function": {
"name": "send_email_skill",
"description": "Sends an email to a specific recipient with a defined subject and body.",
"parameters": {
"type": "object",
"properties": {
"recipient": {"type": "string", "description": "The recipient's email address"},
"subject": {"type": "string", "description": "The email subject"},
"body": {"type": "string", "description": "The message body"},
},
"required": ["recipient", "subject", "body"],
},
},
}
def chat_with_agent(prompt: str, tools: list):
messages = [{"role": "user", "content": prompt}]
response = client.chat.completions.create(
model="gpt-3.5-turbo-0125",
messages=messages,
tools=tools,
tool_choice="auto", # Allow the LLM to decide whether to call a tool
)
response_message = response.choices[0].message
tool_calls = response_message.tool_calls
if tool_calls:
# Here, the skill is executed, and the result is sent back to the LLM for the final response
function_name = tool_calls[0].function.name
function_args = json.loads(tool_calls[0].function.arguments)
if function_name == "send_email_skill":
result = send_email_skill(**function_args)
messages.append(response_message)
messages.append(
{
"tool_call_id": tool_calls[0].id,
"role": "tool",
"name": function_name,
"content": result,
}
)
# Final call to the LLM to generate the response based on the skill result
final_response = client.chat.completions.create(
model="gpt-3.5-turbo-0125",
messages=messages,
)
return final_response.choices[0].message.content
else:
return response_message.content
import json
# Example usage
# print(chat_with_agent("Send an email to support@example.com with subject 'Network Issue' and body 'The connection is unstable from the remote site.'", [email_tool]))The LLM receives the user’s prompt, evaluates if one of the registered skills is relevant, extracts the necessary parameters, and then generates an output indicating which skill to call and with what arguments. The host system executes the skill and returns the result to the LLM, which then formulates the final response to the user. Read also: Cloudflare Security Audit: Automate 100+ Checks
Common Errors and Troubleshooting
- Ambiguous skill descriptions: If the LLM does not clearly understand what a skill does or what parameters it requires, it might not invoke it correctly or provide incorrect arguments. Ensure descriptions are precise and complete. Read also: vSphere Pre-Migration Script: Avoid Surprises
- Lack of error handling in skills: External functions can fail. It is crucial that each skill handles its own errors and returns clear feedback to the LLM, which can in turn inform the user or attempt an alternative solution.
- Authentication/authorization issues: Skills that interact with external services often require credentials. Ensure the environment where the agent runs has secure access to these credentials and that the agent is authorized to perform the requested actions. Read also: MFA Admin: Unblocking Operations
- Infinite loops or unwanted skill calls: In complex scenarios, an LLM might enter a loop of skill calls or invoke inappropriate skills. Implement safety mechanisms, such as limits on the number of consecutive skill calls or context validations.
FAQ — Frequently Asked Questions
Is Agent Skills a specific framework or a general concept?
It is a general concept referring to an AI agent’s ability to perform external actions. Addy Osmani’s repository proposes a practical implementation of this concept, but the idea of ‘tool use’ or ‘function calling’ is common to many modern LLM frameworks, such as LangChain and LlamaIndex, which offer similar mechanisms to extend model capabilities.
Can I use Agent Skills with any LLM?
In principle, yes, provided the LLM supports ‘function calling’ or can be instructed to generate output in a format your system can interpret as a function call. Recent OpenAI and Anthropic models have excellent native support for this functionality, simplifying integration.
What is the difference between Agent Skills and a ChatGPT plugin?
ChatGPT plugins are a specific implementation of the ‘skill’ or ‘tool use’ concept, designed for the ChatGPT ecosystem. Agent Skills is a more generic idea that can be applied to any LLM agent, offering greater flexibility and control over the development and integration of external functions.
Is it safe to allow an AI to perform external actions?
Security is a primary concern. It is essential to implement rigorous controls: limit skill capabilities, use the principle of least privilege, and carefully monitor actions performed by the agent. Skills should be designed to be as atomic and secure as possible, with strict input validations.
Conclusions with Operational Takeaways
Agent Skills represents a fundamental evolutionary step for AI agents, transforming them from text engines into true task executors. This ability to interact with the external world opens up previously unexplored automation scenarios, allowing for the creation of much smarter and more reactive systems. The operational takeaway is clear: if you are developing LLM-based solutions, integrating external functions via ‘skills’ is no longer an option but a necessity to unlock AI’s true potential. Start with simple, well-defined skills, thoroughly test each interaction, and implement robust security mechanisms. The key is modularity: each skill should do one thing and do it well, making the agent more robust and easier to maintain.
Sources
Updated: September 2026
