Documentation

$ npm install -g agentnode-cli

added 1 package in 2.1s

$ agentnode login
? Email: developer@example.com
? Password: ********
? 2FA Code: 123456

Authenticated as developer@example.com
API key stored in ~/.agentnode/credentials

$ agentnode search "pdf extraction"

Results for "pdf extraction":

  pdf-reader-pack          v1.0.0  trusted   Extract text, tables, and metadata from PDFs
  pdf-extractor-pack       v1.0.0  verified  High-fidelity PDF text extraction
  ocr-reader-pack          v1.1.0  trusted   OCR-based document reading including PDFs

3 results found

$ agentnode install pdf-reader-pack

Installing pdf-reader-pack@1.2.0...
  Downloading package       done
  Verifying hash (SHA-256)  done
  Installing dependencies   done
  Writing lockfile           done

Installed pdf-reader-pack@1.2.0

from agentnode_sdk import run_tool

# Run with automatic subprocess isolation (all trust levels)
result = run_tool("pdf-reader-pack", file_path="quarterly-report.pdf")
print(result.result["text"])
print(result.mode_used)  # "subprocess" (default) or "direct" (explicit opt-in)

# Multi-tool packs: specify the tool name
result = run_tool("csv-analyzer-pack", tool_name="describe", file_path="data.csv")

$ pip install agentnode-sdk

from agentnode_sdk import AgentNodeClient, run_tool

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

# Resolve capability → install best match (trust-verified)
client.resolve_and_install(["pdf_extraction"])

# Run with trust-aware isolation (auto = safe default)
result = run_tool("pdf-reader-pack", file_path="report.pdf")
print(result.result["text"])

from agentnode_sdk import AgentNodeClient

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

# If process_pdf fails because pdfplumber is missing,
# AgentNode detects the gap, installs a PDF skill, and retries
result = client.smart_run(
    lambda: process_pdf("report.pdf"),
    auto_upgrade_policy="safe",  # only verified+ skills
)

print(result.success)        # True
print(result.upgraded)       # True (skill was installed)
print(result.installed_slug) # "pdf-reader-pack"

from agentnode_sdk import AgentNodeClient, run_tool

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

# 1. Resolve: find the best package for a capability
result = client.resolve(capabilities=["pdf_extraction"])
best = result.results[0]
print(f"Best match: {best.slug} v{best.version}")
print(f"  Trust: {best.trust_level}  Score: {best.score}")

# 2. Pre-flight check (optional): verify trust + permissions
check = client.can_install(best.slug, require_trusted=True)
if not check.allowed:
    print(f"Blocked: {check.reason}")
    exit(1)

# 3. Install locally (download → verify hash → extract → pip install → lockfile)
installed = client.install(best.slug)
print(installed.message)  # "Installed pdf-reader-pack@1.2.0"

# 4. Run with isolation (auto-mode routes by trust level)
data = run_tool(best.slug, file_path="report.pdf")
print(data.result["text"])
print(f"Ran in {data.mode_used} mode ({data.duration_ms}ms)")

{
  "pdf-reader-pack": {
    "version": "1.2.0",
    "hash": "sha256:a1b2c3d4...",
    "entrypoint": "pdf_reader.extract:run",
    "tools": ["extract_pdf", "extract_tables"],
    "installed_at": "2026-03-24T10:30:00Z"
  }
}

$ pip install agentnode-sdk

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": "Count the words in 'Hello world'"}],
)
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 on AgentNode"}],
)

from google import genai
from agentnode_sdk import AgentNodeRuntime

runtime = AgentNodeRuntime()
client = genai.Client()

result = runtime.run(
    provider="gemini",
    client=client,
    model="gemini-2.5-flash",
    messages=[{"role": "user", "content": "What AgentNode tools are available?"}],
)

from openai import OpenAI
from agentnode_sdk import AgentNodeRuntime

runtime = AgentNodeRuntime()
client = OpenAI(
    api_key="sk-or-...",
    base_url="https://openrouter.ai/api/v1",
)

result = runtime.run(
    provider="openai",
    client=client,
    model="mistralai/mistral-large",
    messages=[{"role": "user", "content": "Find and install a PDF reader tool"}],
)

runtime = AgentNodeRuntime()

# Get tool definitions in your provider's format
tools = runtime.as_openai_tools()    # OpenAI function-calling format
tools = runtime.as_anthropic_tools() # Anthropic format
tools = runtime.as_gemini_tools()    # Gemini format
tools = runtime.as_generic_tools()   # Generic / baseline format

# When the LLM makes a tool call, dispatch it:
result = runtime.handle("agentnode_search", {"query": "pdf extraction"})
# → {"success": true, "result": {"total": 5, "results": [...]}}

AgentNodeRuntime(
    client=None,                     # Optional AgentNodeClient
    api_key=None,                    # Optional API key
    minimum_trust_level="verified",  # "verified" | "trusted" | "curated"
)

$ agentnode install deep-research-agent

from agentnode_sdk import run_tool

result = run_tool("deep-research-agent",
    goal="Compare React vs Vue adoption in 2026")

print(result.result["report"])
print(result.result["sources"])

$ npm install -g agentnode-cli

$ agentnode --version
agentnode/0.3.1

$ agentnode --help
Usage: agentnode <command> [options]

Commands:
  login             Authenticate with the registry
  search            Search for packages
  resolve           Resolve capabilities to packages
  install           Install a package
  update            Update a package to the latest version
  rollback          Roll back to a specific version
  info              Show package details
  explain           Explain capabilities, permissions, and use cases
  auth              Manage local credentials (own API tokens)
  credentials       Manage server-side credentials (OAuth)
  audit             View the policy decision audit trail
  doctor            Analyze setup and suggest improvements
  list              Show installed packages
  publish           Publish a package
  validate          Validate a manifest
  report            Generate a security report
  recommend         Get recommendations for missing capabilities
  resolve-upgrade   Find upgrade packages for capability gaps
  policy-check      Check policy constraints
  api-keys          Manage API keys
  import            Import tools from other frameworks

# Interactive login — stores the API key locally
$ agentnode login
Enter your API key: ********
✓ Logged in as developer (ank_****f456)

# Or set the key directly
$ agentnode api-keys set ank_live_abc123def456

# For CI/CD — use an environment variable
$ export AGENTNODE_API_KEY=ank_live_abc123def456

# Check which key is active
$ agentnode api-keys list
  Source:   ~/.agentnode/config.json
  Key:     ank_****f456

$ agentnode search "web scraping"

Results for "web scraping":

  webpage-extractor-pack   v1.0.0  trusted   Extract clean text and metadata from any webpage
  browser-automation-pack  v1.1.0  verified  Automate browser interactions for data extraction
  web-search-pack          v1.0.0  trusted   Search the web and retrieve structured results

3 results found

# Only show packs compatible with LangChain
$ agentnode search "pdf" --framework langchain

# Only show trusted or curated packs
$ agentnode search "email" --trust trusted

# Filter by runtime
$ agentnode search "data analysis" --runtime python

# Filter by specific capability ID
$ agentnode search --capability pdf_extraction

# Combine filters
$ agentnode search "document processing" --framework crewai --trust verified

$ agentnode explain pdf-reader-pack

pdf-reader-pack@1.2.0
  Publisher:    agentnode-official
  Trust:        trusted
  Runtime:      python >=3.10
  Frameworks:   langchain, crewai, generic

  Capabilities:
    - pdf_extraction: Extract text, tables, and metadata from PDF documents

  Permissions:
    Network:        none
    Filesystem:     read (reads input PDF files)
    Code Execution: none
    Data Access:    input_only

  Use Cases:
    - Extract text from PDF reports for summarization
    - Parse tables from financial PDFs
    - Read metadata and page counts from document archives

  Install: agentnode install pdf-reader-pack

$ agentnode resolve pdf_extraction web_search --framework langchain

Resolving 2 capabilities for langchain...

  pdf_extraction:
    1. pdf-reader-pack       v1.0.0  score: 0.94  trusted
    2. pdf-extractor-pack    v1.0.0  score: 0.81  verified

  web_search:
    1. web-search-pack       v1.0.0  score: 0.92  trusted
    2. browser-automation-pack v1.1.0 score: 0.73  verified

Recommended: agentnode install pdf-reader-pack web-search-pack

from agentnode_sdk import AgentNodeClient

client = AgentNodeClient(api_key="ank_live_abc123def456")

# Resolve multiple capability gaps at once
result = client.resolve(
    capabilities=["pdf_extraction", "web_search", "email_sending"],
    framework="langchain",
    limit=5,
)

for match in result.results:
    print(f"{match.matched_capabilities}: {match.slug} (score: {match.score})")
    print(f"  Trust: {match.trust_level}")
    print()

# Only resolve packages that are trusted or curated
$ agentnode resolve pdf_extraction --trust trusted

# Only resolve packages with no network access
$ agentnode resolve pdf_extraction --policy-no-network

# Check if a specific package meets your policy
$ agentnode policy-check pdf-reader-pack --trust trusted --no-code-execution
Policy check for pdf-reader-pack@1.2.0:
  Trust level:     trusted     PASS
  Network:         none        PASS
  Filesystem:      read        PASS
  Code execution:  none        PASS
  Data access:     input_only  PASS

Package passes all policy constraints.

$ agentnode install pdf-reader-pack

Installing pdf-reader-pack@1.2.0...
  Downloading package       done
  Verifying hash (SHA-256)  done
  Installing dependencies   done
  Writing lockfile           done

Installed pdf-reader-pack@1.2.0

$ agentnode install pdf-reader-pack@1.1.0

$ agentnode install pdf-reader-pack web-search-pack email-drafter-pack

# Auto-generated by agentnode. Do not edit manually.
lockfile_version: 2

packages:
  csv-analyzer-pack:
    version: "1.1.0"
    hash: "sha256:a1b2c3d4e5f6..."
    installed_at: "2025-01-15T10:30:00Z"
    entrypoint: "csv_analyzer_pack.tool"
    tools:
      - name: "describe"
        entrypoint: "csv_analyzer_pack.tool:describe"
        capability_id: "csv_analysis"
      - name: "filter"
        entrypoint: "csv_analyzer_pack.tool:filter_rows"
        capability_id: "data_cleaning"

  pdf-reader-pack:
    version: "1.2.0"
    hash: "sha256:f6e5d4c3b2a1..."
    installed_at: "2025-01-15T10:31:00Z"
    entrypoint: "pdf_reader_pack.tool"
    tools: []

from agentnode_sdk.installer import load_tool

# v0.2 multi-tool pack — load specific tools by name
describe = load_tool("csv-analyzer-pack", tool_name="describe")
filter_rows = load_tool("csv-analyzer-pack", tool_name="filter")

result = describe({"file_path": "data.csv"})
filtered = filter_rows({"file_path": "data.csv", "column": "status", "value": "active"})

# v0.1 single-tool packs — no tool_name needed
extract = load_tool("pdf-reader-pack")
pdf_result = extract({"file_path": "report.pdf"})

search = load_tool("web-search-pack")
search_result = search({"query": "AgentNode", "max_results": 5})

# Update to latest version
$ agentnode update pdf-reader-pack
Updating pdf-reader-pack 1.2.0 -> 1.3.0... done

# Roll back to a specific version
$ agentnode rollback pdf-reader-pack@1.2.0
Rolling back pdf-reader-pack 1.3.0 -> 1.2.0... done

# List all installed packs
$ agentnode list
Installed packages:
  pdf-reader-pack    v1.0.0  trusted
  web-search-pack    v1.0.0  trusted

my-pack/
  agentnode.yaml          # ANP manifest (required)
  pyproject.toml          # Python package config (required)
  src/
    my_pack/
      __init__.py
      tool.py             # Tool functions (required)

manifest_version: "0.2"
package_id: "github-integration-pack"
package_type: "toolpack"
name: "GitHub Integration Pack"
publisher: "your-namespace"
version: "1.0.0"
summary: "Interact with GitHub repos, issues, and PRs."
description: "A comprehensive toolkit for GitHub automation including issue creation, PR review, repository management, and webhook handling."

runtime: "python"
entrypoint: "github_integration_pack.tool"
install_mode: "package"
hosting_type: "agentnode_hosted"

capabilities:
  tools:
    - name: "create_issue"
      capability_id: "github_integration"
      description: "Create a new GitHub issue"
      entrypoint: "github_integration_pack.tool:create_issue"
      input_schema:
        type: "object"
        properties:
          token:
            type: "string"
            description: "GitHub personal access token"
          repo:
            type: "string"
            description: "Repository in owner/repo format"
          title:
            type: "string"
          body:
            type: "string"
        required: ["token", "repo", "title"]
    - name: "list_repos"
      capability_id: "github_integration"
      description: "List repositories for authenticated user"
      entrypoint: "github_integration_pack.tool:list_repos"
      input_schema:
        type: "object"
        properties:
          token:
            type: "string"
        required: ["token"]

permissions:
  network:
    level: "unrestricted"
    justification: "Requires access to GitHub API"
  filesystem:
    level: "none"
  code_execution:
    level: "none"
  data_access:
    level: "input_only"

compatibility:
  frameworks: ["generic"]
  python: ">=3.10"

tags: ["github", "integration", "devtools", "automation"]

from agentnode_sdk.exceptions import AgentNodeToolError

def create_issue(inputs: dict) -> dict:
    """Create a new GitHub issue."""
    token = inputs["token"]
    repo = inputs["repo"]
    title = inputs["title"]
    body = inputs.get("body", "")

    # Your implementation here
    response = _github_api(token, f"/repos/{repo}/issues", {
        "title": title, "body": body
    })
    return {"issue_number": response["number"], "url": response["html_url"]}

def list_repos(inputs: dict) -> dict:
    """List repositories for authenticated user."""
    token = inputs["token"]
    repos = _github_api(token, "/user/repos")
    return {"repos": [{"name": r["name"], "url": r["html_url"]} for r in repos]}

# Optional: backward-compatible run() wrapper for v0.1 callers
# Not required for v0.2 — per-tool entrypoints (tool:create_issue, tool:list_repos) are used instead
def run(inputs: dict) -> dict:
    operation = inputs.get("operation", "list_repos")
    dispatch = {"create_issue": create_issue, "list_repos": list_repos}
    handler = dispatch.get(operation)
    if not handler:
        raise AgentNodeToolError(f"Unknown operation: {operation}", tool_name=operation)
    return handler(inputs)

$ agentnode validate .

Validating github-integration-pack...
  Manifest syntax       OK
  Capability IDs        OK (1 tool, 0 resources)
  Permissions           OK (network: unrestricted)
  Entrypoint            OK (github_integration_pack.tool)
  Compatibility         OK (3 frameworks)

Package is valid and ready to publish.

$ agentnode publish .

Publishing github-integration-pack@1.0.0...
  Uploading package       done
  Security scan           passed (no issues found)
  Signing package         done (Ed25519)
  Indexing capabilities   done

Published! https://agentnode.net/packages/github-integration-pack

$ pip install agentnode-sdk

from agentnode_sdk import AgentNodeClient

# API key authentication (recommended)
client = AgentNodeClient(api_key="ank_live_abc123def456")

# Or use a bearer token
client = AgentNodeClient(token="your_bearer_token")

# Custom base URL (for self-hosted registries)
client = AgentNodeClient(
    api_key="ank_live_abc123def456",
    base_url="https://api.your-registry.com/v1"
)

result = client.search(
    query="pdf extraction",
    framework="langchain",
    per_page=10
)

print(f"Found {result.total} packages")
for hit in result.hits:
    print(f"  {hit.slug}  {hit.trust_level}  {hit.summary}")

result = client.resolve(
    capabilities=["pdf_extraction", "web_search"],
    framework="langchain"
)

for match in result.results:
    print(f"{match.slug} v{match.version}")
    print(f"  Score: {match.score}  Trust: {match.trust_level}")
    print(f"  Breakdown: cap={match.breakdown.capability} "
          f"fw={match.breakdown.framework} "
          f"trust={match.breakdown.trust}")

check = client.can_install(
    "pdf-reader-pack",
    require_trusted=True,
    denied_permissions=["network", "code_execution"]
)

if check.allowed:
    print(f"OK — trust: {check.trust_level}")
else:
    print(f"Blocked: {check.reason}")

result = client.install("pdf-reader-pack", require_trusted=True)

print(result.message)       # "Installed pdf-reader-pack@1.2.0"
print(result.installed)     # True
print(result.hash_verified) # True

# Load a tool from an installed package
extract = client.load_tool("pdf-reader-pack")
result = extract({"file_path": "report.pdf"})

# Multi-tool packs: load a specific tool by name
describe = client.load_tool("csv-analyzer-pack", tool_name="describe")
summary = describe({"file_path": "data.csv"})

# Resolve + trust check + install in one call
result = client.resolve_and_install(
    capabilities=["pdf_extraction"],
    require_trusted=True  # only install trusted/curated packages
)

if result.installed:
    tool = client.load_tool(result.slug)
    data = tool({"file_path": "report.pdf"})
else:
    print(f"Could not install: {result.message}")

from agentnode_sdk import detect_gap

gap = detect_gap(ImportError("No module named 'pdfplumber'"))
print(gap.capability)   # "pdf_extraction"
print(gap.confidence)   # "high"
print(gap.source)       # "import_error"

# Context helps when the error itself isn't specific
gap = detect_gap(RuntimeError("failed"), context={"file": "report.pdf"})
print(gap.capability)   # "pdf_extraction"
print(gap.confidence)   # "low"

try:
    result = my_agent_logic()
except Exception as exc:
    upgrade = client.detect_and_install(
        exc,
        auto_upgrade_policy="safe",  # only verified+ skills
        on_detect=lambda cap, conf, err: print(f"Detected: {cap} ({conf})"),
        on_install=lambda slug: print(f"Installed: {slug}"),
    )

    if upgrade.installed:
        result = my_agent_logic()  # retry manually
    else:
        print(f"Detection: {upgrade.capability} ({upgrade.confidence})")
        print(f"Error: {upgrade.error}")

result = client.smart_run(
    lambda: process_pdf("report.pdf"),
    auto_upgrade_policy="safe",
)

if result.success:
    print(result.result)          # your function's return value
    print(result.upgraded)        # True if a skill was installed
    print(result.installed_slug)  # e.g. "pdf-reader-pack"
    print(result.duration_ms)     # total time including retry
else:
    print(result.error)
    print(result.original_error)  # the first error, always available

# Package details
pkg = client.get_package("pdf-reader-pack")
print(f"{pkg.name} v{pkg.latest_version}")
print(f"Downloads: {pkg.download_count}")
print(f"Deprecated: {pkg.is_deprecated}")

# Install metadata (capabilities, permissions, artifact info)
meta = client.get_install_metadata("pdf-reader-pack")
print(f"Runtime: {meta.runtime}")
print(f"Entrypoint: {meta.entrypoint}")
for cap in meta.capabilities:
    print(f"  {cap.name} ({cap.capability_id})")
if meta.permissions:
    print(f"  Network: {meta.permissions.network_level}")
    print(f"  Filesystem: {meta.permissions.filesystem_level}")

curl -H "X-API-Key: ank_live_abc123def456" \
  https://api.agentnode.net/v1/packages/pdf-reader-pack

# POST /v1/search
curl -X POST "https://api.agentnode.net/v1/search" \
  -H "Content-Type: application/json" \
  -d '{"q": "pdf extraction", "framework": "langchain", "trust": "verified"}'

# Response:
{
  "results": [
    {
      "slug": "pdf-reader-pack",
      "name": "PDF Reader Pack",
      "version": "1.2.0",
      "summary": "Extract text, tables, and metadata from PDF documents",
      "trust_level": "trusted",
      "publisher": "agentnode-official",
      "frameworks": ["generic"],
      "capabilities": ["pdf_extraction"]
    }
  ],
  "total": 1
}

# GET /v1/packages/:slug
curl "https://api.agentnode.net/v1/packages/pdf-reader-pack"

# Response:
{
  "slug": "pdf-reader-pack",
  "name": "PDF Reader Pack",
  "version": "1.2.0",
  "publisher": "agentnode-official",
  "trust_level": "trusted",
  "summary": "Extract text, tables, and metadata from PDF documents",
  "runtime": "python",
  "capabilities": [
    {
      "name": "extract_pdf",
      "capability_id": "pdf_extraction",
      "description": "Extract text, tables, and metadata from PDF documents"
    }
  ],
  "permissions": {
    "network": "none",
    "filesystem": "read",
    "code_execution": "none",
    "data_access": "input_only"
  },
  "compatibility": {
    "frameworks": ["generic"],
    "python": ">=3.10"
  }
}

# POST /v1/resolve
curl -X POST "https://api.agentnode.net/v1/resolve" \
  -H "X-API-Key: ank_live_abc123def456" \
  -H "Content-Type: application/json" \
  -d '{
    "capabilities": ["pdf_extraction", "web_search"],
    "framework": "langchain",
    "policy": {
      "min_trust": "verified"
    }
  }'

# Response:
{
  "results": [
    {
      "slug": "pdf-reader-pack",
      "version": "1.2.0",
      "score": 0.94,
      "trust_level": "trusted",
      "matched_capabilities": ["pdf_extraction"]
    },
    {
      "slug": "web-search-pack",
      "version": "1.0.0",
      "score": 0.92,
      "trust_level": "trusted",
      "matched_capabilities": ["web_search"]
    }
  ]
}

# POST /v1/check-policy
curl -X POST "https://api.agentnode.net/v1/check-policy" \
  -H "X-API-Key: ank_live_abc123def456" \
  -H "Content-Type: application/json" \
  -d '{
    "package_slug": "pdf-reader-pack",
    "policy": {
      "min_trust": "trusted",
      "max_permissions": {
        "network": "none",
        "code_execution": "none"
      }
    }
  }'

# Response:
{
  "passes": true,
  "checks": [
    { "name": "trust_level", "passed": true, "actual": "trusted", "required": "trusted" },
    { "name": "network", "passed": true, "actual": "none", "max": "none" },
    { "name": "code_execution", "passed": true, "actual": "none", "max": "none" }
  ]
}

# POST /v1/packages/publish
curl -X POST "https://api.agentnode.net/v1/packages/publish" \
  -H "X-API-Key: ank_live_abc123def456" \
  -H "Content-Type: multipart/form-data" \
  -F "artifact=@./dist/my-pack-1.0.0.tar.gz" \
  -F "manifest=@./agentnode.yaml"

# Response:
{
  "slug": "my-pack",
  "version": "1.0.0",
  "url": "https://agentnode.net/packages/my-pack",
  "trust_level": "unverified"
}

# GET /v1/capabilities
curl "https://api.agentnode.net/v1/capabilities"

# Response:
{
  "capabilities": [
    { "id": "pdf_extraction", "category": "Document Processing", "description": "Extract text and data from PDF files" },
    { "id": "web_search", "category": "Web & Browsing", "description": "Search the web and return structured results" },
    { "id": "email_sending", "category": "Communication", "description": "Compose and send emails" }
  ]
}

$ pip install agentnode-mcp

# Expose a single pack as MCP tools
$ agentnode-mcp --pack pdf-reader-pack

# Expose the full AgentNode platform API
$ agentnode-mcp-platform --api-url https://api.agentnode.net

{
  "mcpServers": {
    "agentnode": {
      "command": "agentnode-mcp-platform",
      "args": ["--api-url", "https://api.agentnode.net"],
      "env": {
        "AGENTNODE_API_KEY": "ank_live_abc123def456"
      }
    }
  }
}

{
  "mcpServers": {
    "agentnode": {
      "command": "agentnode-mcp-platform",
      "args": ["--api-url", "https://api.agentnode.net"],
      "env": {
        "AGENTNODE_API_KEY": "ank_live_abc123def456"
      }
    }
  }
}

{
  "mcpServers": {
    "pdf-reader": {
      "command": "agentnode-mcp",
      "args": ["--pack", "pdf-reader-pack"]
    }
  }
}

name: Publish to AgentNode
on:
  release:
    types: [published]

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Publish pack
        uses: agentnode/publish@v1
        with:
          api-key: ${{ secrets.AGENTNODE_API_KEY }}

name: Validate AgentNode Pack
on:
  pull_request:
    paths:
      - "agentnode.yaml"
      - "src/**"

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Validate pack
        uses: agentnode/publish@v1
        with:
          api-key: ${{ secrets.AGENTNODE_API_KEY }}
          dry-run: true

Run agentnode/publish@v1
  Validating agentnode.yaml...
    Manifest syntax       OK
    Capability IDs        OK (1 tool, 0 resources)
    Permissions           OK (network: unrestricted)
    Entrypoint            OK (github_integration_pack.tool)
    Compatibility         OK (3 frameworks)

  Running security scan...
    Bandit scan           passed (0 issues)
    Dependency audit      passed

  Publishing github-integration-pack@1.0.0...
    Uploading package     done
    Signing package       done (Ed25519)
    Indexing capabilities done

  Published: https://agentnode.net/packages/github-integration-pack

name: Publish to AgentNode
on:
  push:
    tags:
      - "v*"

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Publish pack
        uses: agentnode/publish@v1
        with:
          api-key: ${{ secrets.AGENTNODE_API_KEY }}

# Store a GitHub token
$ agentnode auth github
  Create a token at: https://github.com/settings/tokens
  Recommended scopes: repo, read:user

Paste your token: ********
Validating token... valid
GitHub credential stored.

# Store a Slack token
$ agentnode auth slack

# List stored credentials
$ agentnode auth list

# Remove a credential
$ agentnode auth remove github

# List server-side credentials
$ agentnode credentials list

# Test connectivity
$ agentnode credentials test <id>

# Revoke a credential
$ agentnode credentials delete <id>

export AGENTNODE_CRED_GITHUB=ghp_xxxxxxxxxxxxx
export AGENTNODE_CRED_SLACK=xoxb-xxxxxxxxxxxxx

{
  "credentials": {
    "resolve_mode": "auto"
  }
}

$ agentnode info pdf-reader-pack
$ agentnode policy-check pdf-reader-pack --trust trusted --no-network

{
  "trust": {
    "minimum_trust_level": "verified"
  },
  "permissions": {
    "network": "prompt",
    "filesystem": "prompt",
    "code_execution": "sandboxed"
  },
  "audit": {
    "max_size_mb": 10,
    "max_files": 5
  }
}

# Show recent decisions
$ agentnode audit show

# Show statistics
$ agentnode audit stats

# Export as JSON for analysis
$ agentnode audit show --limit 100 --json > decisions.json

$ agentnode import mcp_server.py --from mcp

Detected 3 tools in mcp_server.py:
  search_web      -> capability: web_search
  extract_page    -> capability: webpage_extraction
  send_email      -> capability: email_sending

Generated agentnode.yaml with 3 tools.
Review and edit the manifest, then publish with: agentnode publish .

$ agentnode import search_tool.py --from langchain

Detected 1 tool in search_tool.py:
  SearchTool (BaseTool subclass)
    name: "web_search"
    description: "Search the web for information"
    -> capability: web_search

Generated agentnode.yaml with 1 tool.

$ agentnode import functions.json --from openai

Detected 2 functions in functions.json:
  get_weather     -> capability: weather_lookup
  search_docs     -> capability: document_search

Generated agentnode.yaml with 2 tools.

$ agentnode import crew_tools.py --from crewai

Detected 2 tools in crew_tools.py:
  @tool search_internet  -> capability: web_search
  @tool analyze_data     -> capability: data_analysis

Generated agentnode.yaml with 2 tools.