For Tool Developers

Published skills can be installed by agents at runtime when policies permit

Agents detect missing capabilities, find your skill, and install it when policies permit. The higher your trust level, the more agents can use your tool without human approval.

Create Publisher Account Import Existing Tools

General-purpose registries weren't built for AI tools

PyPI and npm are great for libraries. But they weren't designed for how AI agents discover and use tools.

Invisible to agents

Agents can't search by capability. Your tool sits among hundreds of thousands of packages — and agents never find it.

No trust or permissions

Agents can't tell what your tool accesses before installing it. No permission model, no trust tiers, no security scanning.

Fragmented ecosystem

Every framework uses different formats. You rewrite and maintain the same tool for LangChain, CrewAI, MCP, and OpenAI.

Publish once. Agents acquire on demand.

AgentNode is a registry built specifically for AI agent tools. When an agent hits a missing capability at runtime, it detects the gap, resolves your published skill, installs it, and retries — all in one call.

From code to installable capability in minutes

No approval queues, no gatekeepers. Validate locally, publish instantly.

Create your account

Claim your namespace and start publishing.

Define your tool

Describe what your tool does, what it needs, and how agents can use it.

agentnode.yaml

manifest_version: "0.2"
package_id: "github-integration-pack"
name: "GitHub Integration Pack"
entrypoint: "github_integration_pack.tool"

capabilities:
  tools:
    - name: "create_issue"
      capability_id: "github_integration"
      description: "Create a new GitHub issue"
      entrypoint: "github_integration_pack.tool:create_issue"
    - name: "list_repos"
      capability_id: "github_integration"
      description: "List user repositories"
      entrypoint: "github_integration_pack.tool:list_repos"

permissions:
  network: { level: "unrestricted" }
  filesystem: { level: "none" }

compatibility:
  frameworks: ["generic"]

Import existing tools (optional)

Already using LangChain, MCP or OpenAI? Import in one command.

terminal

agentnode import tools.py --from langchain

Validate

terminal

$ agentnode validate .

Validating github-integration-pack...
  Manifest syntax       OK
  Capability IDs        OK
  Permissions           OK
  Entrypoint            OK

Package is valid and ready to publish.

Publish

terminal

$ agentnode publish .

Publishing github-integration-pack@1.0.0...
  Uploading package       done
  Security scan           passed
  Indexing capabilities   done

Published! Your tool is now discoverable and installable by agents.

Everything your tool needs to succeed

AgentNode is not just a file host. It's infrastructure built to get your tools in front of the right audience.

Targeted audience

Every person on AgentNode is actively building AI agents. No noise, no unrelated searches. Your tool is in front of people who need exactly what you built.

Capability-based discovery

Agents find your tool by what it does, not by name. If your tool provides "pdf_extraction", any agent searching for that capability will find you.

Trust badges

Packages progress through trust tiers: unverified, verified, trusted, and curated. A "trusted" badge signals quality before anyone reads your code.

Cross-framework compatibility

Publish once, work everywhere. A single ANP package works across LangChain, CrewAI, and custom agents. No separate integrations.

Security scanning

Every published package is scanned for vulnerabilities, signed with provenance metadata, and tracked for dependency issues.

CI/CD ready

Publish from your pipeline with the agentnode/publish@v1 GitHub Action. Push a tag, and your package is validated, built, and published automatically.

Install analytics

Coming Soon

See how many agents install your package, which capabilities are most requested, and which frameworks your users prefer.

Revenue sharing

Coming Soon

Monetize your tools. Set a price, and AgentNode handles billing, licensing, and distribution.

Already built tools? Don't rewrite them. Import them.

Import your existing tools and make them installable instantly.

MCP

Claude Code, Cursor, Windsurf

agentnode import mcp_server.py --from mcp

LangChain

LangChain, LangGraph agents

agentnode import search_tool.py --from langchain

OpenAI Functions

GPT Actions, Assistants API

agentnode import functions.json --from openai

Also supports CrewAI, ClawhHub, Skills.sh, and more.

Try the web-based import tool →

The package format for agent tools

ANP (AgentNode Package) defines how tools become installable capabilities for AI agents.

Capability IDs

Map your tool to capabilities agents already know how to request.

Permissions

Declare network, filesystem, code execution, and data access levels.

Cross-framework

Every ANP package works across all frameworks automatically — LangChain, CrewAI, MCP, and more.

Typed schemas

JSON schemas for inputs and outputs. Agents validate calls before execution.

Every package follows the same contract — no adapters, no rewrites.

How agents acquire your skills at runtime

Agents detect missing capabilities, resolve your published skill, install it, and retry — all in one line of code. No manual setup, no hardcoded dependencies.

agent.pysmart_run

from agentnode_sdk import AgentNodeClient

client = AgentNodeClient(api_key="ank_live_...")

result = client.smart_run(
    lambda: process_pdf("quarterly-report.pdf"),
    auto_upgrade_policy="safe",
)
print(result.result)     # extracted text
print(result.upgraded)   # True — skill was installed by policy

Want more control?

agent.pydetect_and_install

# Detect → resolve → install, then run yourself
try:
    process_pdf("report.pdf")
except Exception as e:
    result = client.detect_and_install(e, auto_upgrade_policy="strict")
    print(result.installed)  # ["pdf-reader-pack"]

Detect — agent hits a missing capability

Resolve — finds your skill by capability ID

Install — downloads, verifies, extracts

Retry — re-runs with the new skill active

For LLM agents

llm_agent.pyAgentNodeRuntime

from openai import OpenAI
from agentnode_sdk import AgentNodeRuntime

runtime = AgentNodeRuntime()

# The LLM discovers, installs, and uses your tool autonomously
result = runtime.run(
    provider="openai",
    client=OpenAI(),
    model="gpt-4o",
    messages=[{"role": "user", "content": "Extract text from report.pdf"}],
)

Higher trust levels mean automatic installation. See LLM Runtime docs or the Runtime QuickStart for the full SDK reference.

Get verified. Get discovered.

Your verification status directly controls whether agents can install your skill at runtime. The better your trust level, the wider your reach.

Trust Level	"safe" policy	"strict" policy	"off" policy
curated	✔ auto	✔ auto	✘ manual
trusted	✔ auto	✔ auto	✘ manual
verified	✔ auto	✘ manual	✘ manual
unverified	✘ manual	✘ manual	✘ manual

Publish → get verified → agents discover and install your skill. No marketing needed — agents find you by capability.

Why not just use PyPI or npm?

Feature	PyPI / npm	AgentNode
Capability-based discovery	✘	✔
Permission model	✘	✔
Trust tiers	✘	✔
Cross-framework support	✘	✔
Agent-native installation	✘	✔
Runtime gap detection + policy-based install	✘	✔

Start publishing your first AI agent tool

Create your account, publish your first package, and make your tools discoverable, trusted, and installable by AI agents.

Create Publisher Account Import Existing Tools Read the Docs

Python · for agents & apps

pip install agentnode-sdk

Terminal · install & publish

npm install -g agentnode-cli

Frameworks · LangChain, MCP

pip install agentnode-langchain

pip install agentnode-mcp