Search and Discover Agent Skills on AgentNode

Finding the Right Tool Matters

An AI agent is only as good as its tools. A research agent needs reliable web scrapers. A data agent needs trustworthy parsers. A customer service agent needs accurate sentiment analyzers. Finding the right tool — one that is well-built, properly verified, and compatible with your framework — is the first step in building an effective agent.

AgentNode provides multiple ways to search and discover agent skills, each suited to different workflows. This guide covers all of them.

Web Search: The Visual Catalog

The most intuitive way to browse agent skills is the web interface at agentnode.net/search. The search page provides a full-text search bar and a set of filters that let you narrow results by multiple dimensions.

Text Search

Type any keyword or phrase into the search bar. The search engine matches against package names, summaries, descriptions, capability IDs, and tags. Results are ranked by relevance when you provide a query, or by download count when browsing without a query.

Some effective search strategies:

Search by function — "pdf parsing", "web scraping", "sentiment analysis"
Search by domain — "finance", "healthcare", "e-commerce"
Search by data type — "csv", "json", "image", "audio"
Search by integration — "github", "slack", "google sheets"

Filters

The filter panel lets you refine results across several dimensions:

Package Type — filter by "tool" (single tool), "pack" (multi-tool), or "connector" (external service integration)
Framework — show only skills compatible with a specific framework: LangChain, CrewAI, AutoGPT, MCP, or vanilla Python
Verification Tier — Gold, Verified, Partial, or Unverified. Use this to filter by quality level
Trust Level — Curated, Trusted, Verified, or Unverified publisher trust. This reflects the publisher's track record, not the individual package score
Publisher — see all packages from a specific publisher

Sort Options

Results can be sorted by:

Download count (descending) — the default when browsing without a query. Shows the most popular packages first.
Download count (ascending) — find hidden gems with few downloads
Published date (newest first) — see the latest additions to the registry
Name (A-Z or Z-A) — alphabetical browsing

Reading Search Results

Each search result card shows:

The package name and summary
The publisher name with their trust level badge
The verification tier badge (Gold, Verified, Partial, Unverified) with the numeric score
Framework compatibility tags showing which agent frameworks are supported
The download count
A list of capability tags

Click any result to open the full package detail page, which includes the complete verification breakdown, input/output schemas, installation instructions, usage examples, and version history.

SDK Search: Programmatic Discovery

For agents that need to discover tools at runtime, or for developers who prefer code over web interfaces, the AgentNode SDK provides full search capabilities:

from agentnode_sdk import AgentNodeClient

client = AgentNodeClient()

# Basic keyword search
results = client.search("web scraping")

# Inspect results
for hit in results:
    print(f"Package: {hit.slug}")
    print(f"  Name: {hit.name}")
    print(f"  Summary: {hit.summary}")
    print(f"  Score: {hit.verification_score}")
    print(f"  Tier: {hit.verification_tier}")
    print(f"  Trust: {hit.trust_level}")
    print(f"  Downloads: {hit.download_count}")
    print(f"  Frameworks: {', '.join(hit.frameworks)}")
    print()

Filtered Search

The SDK search supports the same filters as the web interface:

# Search with filters
results = client.search(
    q="data processing",
    framework="langchain",
    verification_tier="gold",
    sort_by="download_count:desc",
    per_page=10,
)

Available filter parameters:

q — search query string
package_type — "tool", "pack", or "connector"
capability_id — filter by specific capability ID
framework — "langchain", "crewai", "autogpt", "mcp", "vanilla"
verification_tier — "gold", "verified", "partial", "unverified"
trust_level — "curated", "trusted", "verified", "unverified"
publisher_slug — filter by publisher
sort_by — "download_count:desc", "download_count:asc", "published_at:desc", "published_at:asc", "name:asc", "name:desc"

Capability Resolution: Let the SDK Decide

The most powerful discovery mechanism in AgentNode is capability resolution. Instead of searching by keyword and manually picking a package, you tell the SDK what capability you need, and it finds the best match:

from agentnode_sdk import AgentNodeClient

client = AgentNodeClient()

# Resolve by capability description
client.resolve_and_install(["web-scraping"])

# Resolve multiple capabilities at once
client.resolve_and_install([
    "pdf-parsing",
    "text-summarization",
    "sentiment-analysis",
])

Resolution considers multiple factors when ranking matches:

Capability match — how closely the package's declared capabilities match your request
Verification score — higher-scored packages are preferred
Trust level — packages from trusted publishers rank higher
Download count — more popular packages are a signal of quality

This mechanism is particularly valuable for autonomous agents that need to acquire tools on the fly. The agent can determine it needs a certain capability, resolve it, install it, and use it — all programmatically without human intervention.

CLI Search: Quick Terminal Lookups

The AgentNode CLI provides a fast way to search from the command line:

# Basic search
agentnode search "json parser"

# Search with filters
agentnode search "data" --framework langchain --tier gold

The CLI outputs a formatted table with package names, tiers, summaries, and download counts. It is useful for quick lookups when you know roughly what you are looking for and want to find the exact package slug to install.

Understanding Verification Scores

Every package on AgentNode has a verification score from 0 to 100, computed from multiple evidence-based components:

Install (0-15 points) — did the package install cleanly with all dependencies?
Import (0-15 points) — can all declared tool entrypoints be imported?
Smoke Test (0-25 points) — did the tool produce valid output when called with generated inputs? This is the largest single component because it tests actual runtime behavior.
Unit Tests (0-15 points) — did the publisher's tests pass? Publisher-provided tests score higher than auto-generated ones.
Contract (0-10 points) — does the output match the declared output schema?
Reliability (0-10 points) — does the tool produce consistent results across multiple runs?
Determinism (0-5 points) — how consistent are the outputs?
Warning deductions — runtime warnings reduce the score by up to 10 points

This breakdown is visible on every package's detail page. When evaluating a tool, look at the breakdown to understand why it received its score, not just the number.

Understanding Trust Levels

Trust levels apply to publishers, not individual packages. They reflect the publisher's overall track record:

Curated — hand-selected by the AgentNode team. The highest trust level, reserved for official and thoroughly vetted publishers.
Trusted — publishers with a strong track record of well-verified packages.
Verified — publishers who have confirmed their identity.
Unverified — new publishers who have not yet built a track record.

A package from a Curated publisher with a Partial verification score might still be more trustworthy than a Gold-scored package from an Unverified publisher. Both signals matter — use them together to make informed decisions.

Reading a Package Detail Page

When you click through to a package's detail page, you see a comprehensive view including:

Overview — name, summary, description, publisher info, and trust badges
Capabilities — each declared tool with its input/output schemas
Installation — copy-paste commands for SDK, CLI, and manual installation
Verification Panel — the full score breakdown with per-step details, tier badge, confidence level, and verification environment info
Compatibility — supported frameworks, Python version requirements, and dependencies
Permissions — what system access the package requires (network, filesystem, code execution, data access)
Version History — all published versions with their individual verification statuses

The permissions section is especially important for security-conscious deployments. A tool that declares "network: external" and "filesystem: write" needs more scrutiny than one that declares "network: none" and "filesystem: none."

Tips for Effective Discovery

Here are practical tips for finding the best tools on AgentNode:

Start broad, then filter — search with a general term, then use tier and framework filters to narrow down.
Check the smoke test reason — a Partial tier tool with "credential boundary reached" is fundamentally different from one with "import failed." The former probably works fine once you provide API keys.
Look at download counts — popularity is not a guarantee of quality, but high-download packages have been battle-tested by more users.
Read the score breakdown — a score of 72 where smoke test passed but tests were missing is very different from 72 where tests passed but smoke test failed.
Check framework compatibility — if you are building a LangChain agent, filter for LangChain-compatible tools to avoid integration issues.
Use resolve for agents — if you are building an autonomous agent, use resolve_and_install instead of hardcoding package names. This makes your agent adaptable to new and better tools as they get published.

The AgentNode registry is designed to make discovery fast and trust transparent. Whether you search through the web, the SDK, or the CLI, you always have access to the same comprehensive verification data to make informed decisions about which tools to give your 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.