Concepts7 min read

What Are Agent Skills? Understanding Portable AI Capabilities

Agent skills are portable, verified AI capabilities packaged in the ANP format. Learn how they differ from regular packages, why portability matters, and how the ANP standard enables cross-framework tool sharing.

By agentnode

Beyond Libraries: What AI Agents Actually Need

When a developer needs to add PDF parsing to a web application, they install a library — pip install PyPDF2 — import it, and write the integration code themselves. The library provides functions. The developer provides the glue.

AI agents work differently. An agent does not just need a library with functions. It needs a capability — a self-describing, callable unit of work with a clear contract: what goes in, what comes out, what permissions it requires, and what it can do. The agent needs to understand the tool programmatically, decide when to use it, construct valid inputs, and interpret the outputs — all without human intervention.

This is what an agent skill is: a portable, self-describing AI capability that any agent can discover, understand, and invoke.

Agent Skills vs. Regular Packages

A regular Python package (on PyPI) or JavaScript package (on npm) is designed for human developers. It has documentation, example code, and an API that humans read and integrate manually. There is no machine-readable contract that says "this function takes a URL string and returns structured markdown text."

An agent skill, by contrast, is designed for both humans and machines. The differences are fundamental:

  • Typed schemas — every skill declares its input and output types using JSON Schema. An agent can validate inputs before calling and parse outputs without guessing.
  • Capability declarations — skills are tagged with what they do ("web-scraping", "text-analysis", "pdf-parsing"), so agents can find tools by function rather than by name.
  • Permission declarations — skills declare whether they need network access, filesystem access, code execution, or data access. This lets agents and platforms enforce security policies.
  • Verification scores — every skill is tested on publish, with a public score that tells you how thoroughly it has been validated.
  • Framework agnostic — a single skill works across LangChain, CrewAI, AutoGPT, MCP, and plain Python. No rewrites needed.

Think of it this way: a Python package is a jar of ingredients. An agent skill is a complete recipe card with nutritional labels, allergen warnings, and a quality certification stamp.

The ANP Package Format

Agent skills are packaged using the ANP (AgentNode Package) format. ANP is a lightweight specification (currently at manifest_version 0.2) that standardizes how agent tools are described and distributed.

An ANP package has three components:

1. The Manifest

A manifest.json file that describes the package metadata, its capabilities (tools), compatibility information, and permission requirements. This is the machine-readable contract that makes the tool discoverable and usable by any agent.

2. The Implementation

One or more Python modules containing the actual tool logic. Each tool function is referenced by its entrypoint string (e.g., tools.scrape:scrape_page), which tells the runtime exactly where to find the callable.

3. Optional Tests

Test files that validate the tool's behavior. Publisher-provided tests carry more weight in the verification score than auto-generated tests, because they demonstrate the author's confidence in their own code.

Anatomy of a Capability Declaration

The most important part of the ANP manifest is the capabilities array. Each entry describes one tool within the package. Here is a realistic example for a sentiment analysis tool:

{
  "name": "analyze_sentiment",
  "capability_id": "text-analysis.sentiment",
  "capability_type": "tool",
  "description": "Analyze the sentiment of a text passage and return a score with explanation",
  "entrypoint": "tools.sentiment:analyze",
  "input_schema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string",
        "description": "The text to analyze",
        "minLength": 1,
        "maxLength": 10000
      },
      "language": {
        "type": "string",
        "description": "ISO 639-1 language code",
        "default": "en"
      }
    },
    "required": ["text"]
  },
  "output_schema": {
    "type": "object",
    "properties": {
      "score": {
        "type": "number",
        "minimum": -1.0,
        "maximum": 1.0,
        "description": "Sentiment score from -1 (negative) to 1 (positive)"
      },
      "label": {
        "type": "string",
        "enum": ["positive", "negative", "neutral", "mixed"]
      },
      "confidence": {
        "type": "number",
        "minimum": 0,
        "maximum": 1
      }
    }
  }
}

Notice what this gives an agent: it knows the tool's purpose from the description, it knows exactly what input to provide (a text string, optionally with a language code), and it knows exactly what to expect back (a numeric score, a label, and a confidence value). No documentation reading required.

Multi-Tool Packs

A single ANP package can contain multiple tools. This is common when a set of related capabilities naturally belong together. For example, a "text-utils" package might expose:

  • summarize_text — condense a long document into key points
  • extract_keywords — pull out the most important terms
  • analyze_sentiment — determine the emotional tone
  • detect_language — identify the language of input text

Each tool has its own entrypoint, input schema, and output schema. They share the same package dependencies and installation, but function independently. An agent can load one tool or all of them:

from agentnode_sdk import load_tool

# Load a specific tool from a multi-tool pack
summarizer = load_tool("text-utils", tool_name="summarize_text")
keywords = load_tool("text-utils", tool_name="extract_keywords")

result = summarizer.run({"text": long_document, "max_length": 200})

Portability in Practice

Portability is the defining feature of agent skills. A tool packaged as an ANP skill works in every supported framework without modification. Here is the same tool used across different agent frameworks:

Vanilla Python

from agentnode_sdk import load_tool

scraper = load_tool("web-scraper")
result = scraper.run({"url": "https://example.com"})

LangChain

from agentnode_sdk import load_tool

# AgentNode tools are LangChain-compatible
scraper = load_tool("web-scraper")
agent = initialize_agent(
    tools=[scraper],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)

CrewAI

from agentnode_sdk import load_tool
from crewai import Agent, Task

scraper = load_tool("web-scraper")
researcher = Agent(
    role="Web Researcher",
    tools=[scraper],
    goal="Find and extract information from web pages",
)

The tool code does not change. The schema does not change. The behavior does not change. This is what portability means in practice — write once, use everywhere.

Permission Declarations

Agent skills declare what system resources they need. This is critical for security. An agent platform can inspect a skill's permissions before installing it and enforce policies like "no tools with filesystem access" or "only tools with verified trust level."

The four permission dimensions are:

  • Network — none, local, or external. A tool that calls a third-party API declares "external." A tool that only does local computation declares "none."
  • Filesystem — none, read, or write. Tools that create or modify files must declare this upfront.
  • Code Execution — none or sandboxed. Tools that execute dynamically generated code must declare this.
  • Data Access — none, read, or write. Tools that access databases or data stores declare their access patterns.

These declarations are verified during the sandbox verification process. A tool that declares "network: none" but attempts to make HTTP calls during smoke testing will be flagged.

Why Agent Skills Will Define the Next Era of AI

The shift from libraries to agent skills mirrors a shift that has happened before in software. In the early days of the web, every developer wrote their own HTTP client, their own JSON parser, their own authentication layer. Over time, these became shared packages — and the ecosystem exploded with productivity.

AI agents are at that same inflection point. Today, thousands of developers are writing overlapping tool code in isolated framework silos. Agent skills — portable, verified, self-describing capabilities — are the shared layer that unlocks the next wave of innovation. Instead of building tools, developers can focus on building agents that compose tools in novel ways.

AgentNode and the ANP format provide the foundation. The catalog is growing daily. Every skill that gets published makes every agent framework more capable. That is the network effect of a shared tool ecosystem, and it is just getting started.

Ready to explore? Search the AgentNode catalog to see what agent skills are available today.

LLM Runtime: Let the Model Handle It

If your agent uses OpenAI or Anthropic tool calling, AgentNodeRuntime handles tool registration, system prompt injection, and the tool loop automatically. The LLM discovers, installs, and runs AgentNode capabilities on its own — no hardcoded tool calls needed.

from openai import OpenAI
from agentnode_sdk import AgentNodeRuntime

runtime = AgentNodeRuntime()

result = runtime.run(
    provider="openai",
    client=OpenAI(),
    model="gpt-4o",
    messages=[{"role": "user", "content": "your task here"}],
)
print(result.content)

The Runtime registers 5 meta-tools (agentnode_capabilities, agentnode_search, agentnode_install, agentnode_run, agentnode_acquire) that let the LLM search the registry, install packages, and execute tools autonomously. Works with Anthropic too — just change provider="anthropic" and pass an Anthropic client.

See the LLM Runtime documentation for the full API reference, trust levels, and manual tool calling.

#agent-skills#portable-ai-capabilities#anp-package#agent-tool#ai-agents#guide
← Back to Tutorial