Noddocs

Use Cases

How Nod fits into different agentic frameworks and patterns

Looking for ready-made quickstarters and downloadable templates? See the Templates section.

Claude Code (persistent coding agent)

Claude Code is an AI coding agent that runs in your terminal. Our open-source Nod CLI wraps Claude Code with a persistent WebSocket connection, turning it into a mobile-controlled assistant.

How it works

  • The CLI connects via WebSocket and stays connected while Claude Code runs
  • Claude Code's PreToolUse hooks route tool calls through Nod's permission system
  • Users approve risky actions (file writes, shell commands) from their phone
  • Users can send messages to Claude Code from the Nod app — like chatting with a colleague
  • Agent heartbeats show a live "thinking" indicator while Claude works

Example workflow

Terminal
$ nod connect    # Set up agent credentials + permissions
$ nod up agent   # Start the agent in the background

From your phone, you message: "Refactor the auth module to use JWT." Claude Code starts working. When it needs to run npm install jsonwebtoken, Nod sends a permission request to your phone. You tap Always Allow for npm installs. Claude continues, finishes, and sends you a summary.

Meanwhile, you were at lunch. No terminal needed.

See CLI documentation for setup instructions and command reference.

CrewAI (multi-agent systems)

CrewAI orchestrates teams of specialized agents. Nod can plug into any crew member as a human-in-the-loop checkpoint.

Example: Research crew with human review

Python
import requests

NOD_API = "https://api.asknod.ai"
AGENT_ID = "agt_..."
AGENT_SECRET = "nod_..."

def nod_request(event: dict):
    return requests.post(f"{NOD_API}/api/agent/events", json=event, headers={
        "Content-Type": "application/json",
        "X-Nod-Agent-Id": AGENT_ID,
        "X-Nod-Secret": AGENT_SECRET,
    }).json()

# After the research crew generates a report...
result = nod_request({
    "type": "decision",
    "title": "Publish Q2 Market Report?",
    "description": "The crew drafted a 15-page report. Approve to send to the mailing list.",
    "kind": "approval",
})
# User approves on their phone → proceed with publishing

Each crew can be a separate Nod agent, or the entire crew can share one agent. Multiple agents show up as separate conversations in the app — great for keeping different AI teams organized.

n8n (workflow automation)

n8n connects hundreds of services into automated workflows. Add Nod as a step in any flow to gate risky actions behind human approval.

Example: Refund approval workflow

n8n HTTP Request node
// Step 1: Customer requests refund (triggers n8n workflow)
// Step 2: n8n checks if amount > $500
// Step 3: If yes, send approval request to Nod

POST https://api.asknod.ai/api/agent/events
Headers:
  X-Nod-Agent-Id: (your agent ID)
  X-Nod-Secret: (your agent secret)

Body:
{
  "type": "decision",
  "title": "Approve refund #4821?",
  "description": "$730 refund to customer@example.com",
  "kind": "approval"
}

// Step 4: n8n webhook receives the resolution from Nod
// Step 5: If approved, process the refund via Stripe

Using webhooks for the response

Set a webhook_url on your Nod agent that points to an n8n webhook trigger. When the user approves or rejects, n8n receives the resolution and continues the workflow.

Event-triggered tasks

You can also use Nod's inbound webhooks to trigger tasks from n8n. Create an event task in Nod, then add the webhook URL as a step in your n8n flow.

LangChain / LangGraph

LangChain and LangGraph build complex reasoning chains. Nod plugs in as a tool or callback for human-in-the-loop decisions.

Example: Support ticket triage

Python
from langchain.tools import tool

@tool
def ask_human(question: str, options: list[str] = None) -> str:
    """Ask a human for input via Nod."""
    event = {
        "type": "decision",
        "title": question,
        "description": "The agent needs your input to continue.",
    }
    if options:
        event["kind"] = "choice"
        event["options"] = options
    else:
        event["kind"] = "question"

    result = nod_request(event)
    decision_id = result["decision_id"]

    # Poll for resolution (or use WebSocket for real-time)
    while True:
        decision = get_decision(decision_id)
        if decision["status"] != "pending":
            return decision.get("note", decision["status"])
        time.sleep(5)

# In your LangChain agent:
# agent.tools = [..., ask_human]
# When the agent encounters an ambiguous ticket, it calls ask_human()

Server-side agents (any framework)

Any long-running process can be a Nod agent. Connect via WebSocket for real-time communication, or use REST + webhooks for simpler patterns.

Example: Monitoring agent

Python
# A monitoring script that runs 24/7
# Uses REST API — no WebSocket needed

def on_alert(alert):
    # Send the alert as a message
    nod_request({
        "type": "message",
        "text": f"Alert: {alert.title}\n{alert.description}\nSeverity: {alert.severity}",
    })

    # If critical, ask for human action
    if alert.severity == "critical":
        nod_request({
            "type": "decision",
            "title": f"Acknowledge: {alert.title}",
            "description": alert.description,
            "kind": "choice",
            "options": ["Acknowledge", "Escalate", "Snooze 1h"],
        })

Webhook-only integration (no code)

The simplest integration: use Nod's inbound webhooks to trigger tasks from any service that supports outgoing webhooks — no custom code required.

  • GitHub — Trigger a code review task on every push to main
  • Stripe — Trigger a payment processing task on charge events
  • Sentry — Trigger a bug analysis task on new error events
  • Any webhook-capable service — Point it at https://api.asknod.ai/webhook/{trigger_id}

The webhook payload is passed directly to your agent as part of the task prompt, so the agent has full context about what triggered it.