Verified Agent Skills for Every AI Agent
Your agent detects what's missing, installs verified skills, and keeps going. Works with LangChain, CrewAI, MCP, and plain Python.
Powered by ANP. One portable package format for all AI agents.
One package. Any agent.
AgentNode is built on ANP (AgentNode Package), a portable package format for AI agent capabilities. Build a capability once and use it with any Python agent framework.
Cross-framework
Works across LangChain, CrewAI, and custom agents. One package format, multiple ecosystems.
Same interface everywhere
Every ANP package exposes typed tool functions via load_tool() — one pack can provide multiple tools, each individually addressable.
No rewrites, no adapters
Install once and use across your stack. No framework lock-in, no custom adapters.
Verified with 175+ models
Native runtime for OpenAI, Anthropic, and Gemini. Framework adapters for LangChain, CrewAI, and MCP. Tested against 182 models from 35 providers — 96% achieve perfect tool-calling compatibility.
Native Runtime Integration
Framework Adapters
Compatible (standard Python)
Agents don't wait for developers
One loop. Fully automatic.
Gap Detection
Analyzes ImportErrors, error messages, and context hints. Three confidence levels: high, medium, low.
Smart Resolution
Finds the best package by capability match, trust level, and compatibility score.
Trust-Gated Install
Policies control what gets installed. off / safe / strict — your rules.
Single Retry
After installing, your function is retried exactly once. No loops, no runaway installs.
Close capability gaps instantly
Turn limited agents into modular systems that grow with every task.
- ✕Fails on missing libraries
- ✕No idea what's missing
- ✕Manual installs for every gap
- ✕Limited, static capabilities
- ✓Detects missing capabilities
- ✓Installs verified skills automatically
- ✓Retries with the new capability
- ✓Extends itself under your control
From runtime failure to working capability
Wrap your logic once. AgentNode handles detection, installation, and retry.
Wrap your agent logic
Use smart_run() to wrap any callable. If it fails due to a missing capability, AgentNode takes over.
result = client.smart_run(fn, auto_upgrade_policy="safe")Detect and install automatically
AgentNode analyzes the error, detects the missing capability with confidence scoring, and installs the best verified match.
# Automatic: detect → resolve → trust check → installRetry and succeed
After installing the missing skill, your function is retried exactly once. The result includes full transparency: what was detected, what was installed, and timing.
print(result.success, result.installed_slug, result.duration_ms)Or use detect_and_install() for fine-grained control over detection and installation separately.
Three lines. That's it.
Wrap your logic. AgentNode handles the rest.
from agentnode_sdk import AgentNodeClient
client = AgentNodeClient(api_key="ank_...")
result = client.smart_run(
lambda: process_pdf("report.pdf"),
auto_upgrade_policy="safe",
)
# If pdfplumber was missing → detected, installed, retried
print(result.success) # True
print(result.installed_slug) # "pdf-reader-pack"Want more control? Use detect_and_install() to handle detection and installation separately. See docs
Or let the LLM decide
Connect any OpenAI or Anthropic agent to AgentNode. The Runtime registers tools, injects the system prompt, and runs the tool loop automatically.
from openai import OpenAI
from agentnode_sdk import AgentNodeRuntime
runtime = AgentNodeRuntime()
client = OpenAI()
result = runtime.run(
provider="openai",
client=client,
model="gpt-4o",
messages=[{
"role": "user",
"content": "Extract text from report.pdf"
}],
)
print(result.content)from anthropic import Anthropic
from agentnode_sdk import AgentNodeRuntime
runtime = AgentNodeRuntime()
client = Anthropic()
result = runtime.run(
provider="anthropic",
client=client,
model="claude-sonnet-4-6",
messages=[{
"role": "user",
"content": "Search for PDF tools"
}],
)The LLM discovers, installs, and runs tools autonomously — no hardcoded tool calls. Runtime docs
Not just a registry. A policy-controlled runtime.
Everything your agent needs to grow — safely and autonomously.
Capability gap detection
Analyzes runtime errors to identify missing capabilities. Three confidence levels. No LLM — fully deterministic.
Auto-upgrade policies
off safe strict — you decide what gets installed, not the agent.
Scored and verified
Every package is sandbox-tested and scored 0–100 on publish. Broken tools are quarantined. Verified tools earn higher trust tiers.
AgentNode Guard
Pre-execution policy gateway. Every install and run is checked against trust levels, permissions, and environment context. Fail-closed. Learn more
Cross-framework (ANP)
Build once, run on any agent. LangChain, CrewAI, or custom. One package format, no adapters.
Capability-first resolution
Agents search by what they need, not by name. The engine scores and ranks matches automatically.
Every tool verified. Every score earned.
We don't just list tools — we install them in a sandbox, run them, and score them 0–100. Broken packages are quarantined. Passing packages earn trust tiers based on their score.
What we test
- ✔Real pip install in isolated environment
- ✔Every declared entrypoint imports
- ✔Tools called with schema-generated inputs
- ✔Multi-run reliability and determinism
What we don't fake
- •No mocking — real sandbox execution
- •No self-reported badges — scores from evidence
- •No pass/fail binary — nuanced tiers
- •Verification runs on every publish
A registry is only useful if the tools inside it work. AgentNode doesn't just check — it proves it, scores it, and keeps checking.
Popular capabilities
Trusted ANP packages ready to extend your agents.
pdf-reader-pack
Extract text, tables, and metadata from PDF documents with high fidelity.
web-search-pack
Search the web and retrieve structured results for your AI agent.
webpage-extractor-pack
Extract clean text and metadata from any webpage for your AI agent.
A policy-controlled runtime
Today, agents detect missing capabilities and safely acquire verified skills on demand. With ANP, those capabilities are portable, reusable, and designed to work across agent systems.
AgentNode is no longer just a tool registry. It's a runtime that installs and executes capabilities — safely, predictably, and governed by your policies.
Start building smarter agents
Detect your first capability gap and let your agents handle the rest.
pip install agentnode-sdknpm install -g agentnode-clipip install agentnode-langchainpip install agentnode-mcp