Getting Started6 min read

Getting Started with AgentNode: Install and Use Your First Agent Skill

A step-by-step tutorial to install the AgentNode SDK, search for agent skills, install your first package, and use load_tool() to run a verified AI capability in Python.

By agentnode

What You Will Build

By the end of this tutorial, you will have:

  • Installed the AgentNode Python SDK
  • Searched the registry for agent skills
  • Installed your first ANP package
  • Loaded a tool and executed it with typed inputs and outputs
  • Understood how to integrate agent skills into a real project

The entire process takes about five minutes. No account is required for browsing and installing public packages.

Prerequisites

You need:

  • Python 3.9 or later — check with python --version
  • pip — the standard Python package installer
  • A terminal (any OS — Linux, macOS, or Windows)

Optionally, if you want to use the CLI tools as well:

  • Node.js 18+ and npm for the AgentNode CLI

Step 1: Install the AgentNode SDK

The AgentNode SDK is a standard Python package distributed on PyPI. Install it with pip:

pip install agentnode-sdk

This installs the core library including the AgentNodeClient, the load_tool() function, and all the resolution and installation machinery.

Verify the installation:

python -c "from agentnode_sdk import AgentNodeClient; print('AgentNode SDK installed successfully')"

If you see the success message, you are ready to go.

Optional: Install the CLI

The AgentNode CLI provides command-line tools for searching, publishing, and managing packages. It is distributed via npm:

npm install -g agentnode-cli

The CLI is not required for this tutorial, but it is useful for publishing packages and quick searches from the terminal.

Step 2: Browse the Registry

Before installing anything, take a moment to explore what is available. You have three options:

Option A: Web Search

Visit agentnode.net/search to browse the catalog visually. You can filter by capability type, framework compatibility, verification tier, and trust level. Each result shows the package name, summary, download count, and verification badge.

Option B: SDK Search

Use the SDK to search programmatically:

from agentnode_sdk import AgentNodeClient

client = AgentNodeClient()

# Search by keyword
results = client.search("text analysis")
for hit in results:
    print(f"{hit.name} ({hit.verification_tier}) - {hit.summary}")

Option C: CLI Search

If you installed the CLI:

agentnode search "web scraping"

All three methods query the same underlying registry and return the same results.

Step 3: Install a Package

Let's install a package. For this tutorial, we will use a text analysis tool as our example. There are two ways to install:

Install by Package Name

If you know the exact package slug from your search results:

from agentnode_sdk import AgentNodeClient

client = AgentNodeClient()
client.install("word-counter")

Install by Capability (Resolve and Install)

If you do not know the exact package name but know what capability you need, use resolve_and_install. This is the recommended approach — it finds the best-matching, highest-trust package for your need:

from agentnode_sdk import AgentNodeClient

client = AgentNodeClient()
client.resolve_and_install(["text-analysis"])

The resolve_and_install method searches the registry for packages that match the requested capability, ranks them by verification score and trust level, and installs the top result. This is powerful for building agents that discover their own tools at runtime.

Step 4: Load and Use the Tool

Once a package is installed, you use load_tool() to get a callable tool object:

from agentnode_sdk import load_tool

# Load the tool by package slug
counter = load_tool("word-counter")

# Check what the tool expects
print(counter.name)
print(counter.description)
print(counter.input_schema)
print(counter.output_schema)

The tool object has several useful attributes:

  • name — the human-readable tool name
  • description — what the tool does (used by LLMs for tool selection)
  • input_schema — JSON Schema describing the expected input
  • output_schema — JSON Schema describing the return value
  • run(input_dict) — the method to execute the tool

Now call the tool:

result = counter.run({
    "text": "AgentNode makes it easy to share AI agent capabilities across frameworks."
})

print(result)
# Output might look like:
# {"word_count": 11, "character_count": 72, "sentence_count": 1}

The input is a dictionary matching the tool's input schema. The output is a dictionary matching the output schema. Everything is typed and validated.

Step 5: A Complete Working Example

Let's put it all together in a complete, runnable script that searches for a tool, installs it, and uses it:

"""Complete AgentNode example: search, install, and use an agent skill."""

from agentnode_sdk import AgentNodeClient, load_tool

def main():
    # Initialize the client
    client = AgentNodeClient()

    # Search for text analysis tools
    print("Searching for text analysis tools...")
    results = client.search("text analysis")

    if not results:
        print("No results found.")
        return

    # Show top results
    print(f"Found {len(results)} results:")
    for hit in results[:5]:
        tier = hit.verification_tier or "unscored"
        print(f"  {hit.name} [{tier}] - {hit.summary}")

    # Install the top result
    top_package = results[0].slug
    print(f"\nInstalling {top_package}...")
    client.install(top_package)

    # Load and use the tool
    tool = load_tool(top_package)
    print(f"\nLoaded tool: {tool.name}")
    print(f"Description: {tool.description}")

    # Run with sample input
    sample_text = (
        "Artificial intelligence agents are becoming more capable every day. "
        "They can reason, plan, and execute complex multi-step tasks. "
        "But they need access to tools and capabilities to interact with the real world."
    )

    result = tool.run({"text": sample_text})
    print(f"\nResult: {result}")

if __name__ == "__main__":
    main()

Save this as agentnode_demo.py and run it:

python agentnode_demo.py

Working with Multi-Tool Packages

Some packages contain multiple tools. When you call load_tool() on a multi-tool package, you get the primary tool by default. To load a specific tool, pass the tool_name parameter:

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

# Use each independently
summary = summarizer.run({"text": long_document})
keywords = keyword_extractor.run({"text": long_document})

Understanding Verification Badges

When browsing or installing packages, pay attention to the verification tier. This tells you how thoroughly the package has been tested:

  • Gold (90-100) — the highest level. All verification steps passed with high reliability. These tools have been smoke tested with real inputs, produce consistent outputs, and include publisher-provided tests.
  • Verified (70-89) — strong verification. The tool installs, imports, and passes most checks, but may have minor gaps like missing custom tests.
  • Partial (50-69) — the tool works but could not be fully verified. This is common for tools that require API credentials or external services — the sandbox cannot test them completely, but installation and imports were confirmed.
  • Unverified (<50) — significant issues were found during verification. Use with caution.

For production agents, prefer Gold and Verified tier tools. For experimentation, Partial tier tools are often perfectly functional — they just need external credentials that the sandbox could not provide.

Next Steps

Now that you have installed and used your first agent skill, here are some directions to explore:

  • Browse the full catalog at agentnode.net/search to discover more tools
  • Integrate with your agent framework — AgentNode tools work natively with LangChain, CrewAI, AutoGPT, and MCP
  • Publish your own skill — if you have built a useful tool, package it as ANP and share it with the community at agentnode.net/publish
  • Use the Builder — describe a tool in plain language at agentnode.net/builder and let AgentNode generate the code for you
  • Import existing tools — already have a LangChain tool or MCP server? Import it into the ANP format

The AgentNode ecosystem grows with every new skill published. Whether you are consuming tools or creating them, you are part of building the shared capability layer for AI agents.

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.

#agentnode-tutorial#getting-started#install-agent-skill#agentnode-sdk#python#tutorial
← Back to Tutorial