Skip to main content

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.

terminal

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.

Writecode + manifestValidateagentnode validatePublishsign + uploadVerifysandbox 0–100Discoversearch + resolveInstallhash + lockfile
🔗

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

ChatGPT
Claude
Gemini

Framework Adapters

LangChain
CrewAI
MCP

Compatible (standard Python)

Mistral
Ollama
DeepSeek
Qwen
182
Models Tested
175
Perfect Score
35
Providers
96%
S-Tier Rate

Agents don't wait for developers

One loop. Fully automatic.

FailsMissing capability
🔍DetectAnalyze error
📦InstallVerified skill
🔁RetryExactly once
WorksCapability added

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.

Before
  • Fails on missing libraries
  • No idea what's missing
  • Manual installs for every gap
  • Limited, static capabilities
After AgentNode
  • 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.

1

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")
2

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 → install
3

Retry 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.

agent.py
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.

openai_agent.py
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)
anthropic_agent.py
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.

InstallClean sandbox
ImportEntrypoints load
Smoke TestTools called
ScoreReliability proven
Gold
Score 90+
Verified
Score 70–89
Partial
Score 50–69
Unverified
Score <50

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.

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.

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