Skip to main content

Give AI agents new capabilities โ€” without losing control.

Agents discover and install verified capabilities at runtime, governed by trust tiers, policy checks, and lockfiles. Untrusted community code is sandboxed or refused when isolation is required. Works with LangChain, CrewAI, MCP, and Python โ€” local-first, on models you own.

Tools run locally on your machine. Your tool inputs, outputs, and prompts never reach AgentNode.

Powered by ANP. One portable package format for all AI agents.

terminal

Small models. Right tools. No cloud bill.

AgentNode is the open-source alternative to overpriced AI stacks. Run a local model โ€” Ollama works out of the box โ€” and let your agent extend itself at runtime: it detects the capability it is missing and installs exactly that tool. For many tasks, a small model with the right tool beats a big model without it.

๐Ÿ’ป

Runs on your machine

Tools execute locally. Your prompts, inputs, and outputs never reach AgentNode โ€” only package discovery talks to the registry.

๐Ÿงฉ

Self-extending agents

Instead of paying for a bigger model, your agent fetches the exact capability it needs โ€” verified, permission-declared, and sandboxed by trust level.

๐Ÿ”“

Free & open source

The SDK and runtime are MIT-licensed and free to use. No per-call fees, no lock-in โ€” bring your own models and keys.

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 + manifestโ†’โœ“Validateagentnode validateโ†’โ†‘Publishsign + uploadโ†’โ˜…Verifysandbox 0โ€“100โ†’โ—ŽDiscoversearch + resolveโ†’โ†“Installhash + 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.

Built for every side of the agent ecosystem

Whether you build capabilities, govern them, or are an agent that needs them.

For builders & publishers

Package Tool Packs, Skills, and Agents once, then publish them so any compatible agent can discover and install them.

For teams & security reviewers

Evaluate trust tiers, policy checks, lockfiles, and verification results โ€” untrusted community code is sandboxed or refused when isolation is required.

For AI agents

Machine-readable guides help an AI discover AgentNode, pick the right docs, and install it without unsafe assumptions.

Verified with 222+ models

Native runtime for OpenAI, Anthropic, and Gemini. Framework adapters for LangChain, CrewAI, and MCP. Tested against 246 models from 40 providers โ€” 90% achieve perfect tool-calling compatibility.

Native Runtime Integration

ChatGPT
Claude
Gemini

Framework Adapters

LangChain
CrewAI
MCP

Compatible (standard Python)

Mistral
Ollama
DeepSeek
Qwen
246
Models Tested
222
Perfect Score
40
Providers
90%
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.

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.

2

Detect and install automatically

AgentNode analyzes the error, detects the missing capability with confidence scoring, and installs the best verified match.

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.

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 โ€” under your policies and trust tiers.

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 tested in an isolated environment 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 and run them in an isolated test environment, and score them 0โ€“100. Broken packages are quarantined. Passing packages earn trust tiers based on their score.

โœ”InstallIsolated env
โœ”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 execution in an isolated environment
  • โ€ข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. Read the security model

A policy-controlled runtime

Today, agents detect missing capabilities and acquire verified skills under configured guardrails. 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 โ€” predictably, governed by your policies and trust tiers.

Start building smarter agents

Detect your first capability gap and let your agents handle the rest.

Python ยท for agents & apps
pip install agentnode-sdk
CLI ยท search, install & publish
pip install agentnode-sdk
Frameworks ยท LangChain, MCP
pip install agentnode-langchain
pip install agentnode-mcp