Connect your Agent to Reality.

LangGraph (SensoryNode)

from langgraph.graph import Graph
from human_link.langchain import SensoryNode

workflow = Graph()

# Add the human-in-the-loop sensory node
workflow.add_node("gather_physical_context", SensoryNode(
    mode="SEE",
    prompt="Look at the error on the monitor and describe the kernel panic."
))

PydanticAI (RealityCheck)

from pydantic_ai import Agent
from human_link.pydantic import RealityCheck

agent = Agent(
    'openai:gpt-4o',
    system_prompt='You are a hardware debugging assistant.'
)

@agent.tool
async def verify_cable_connection() -> RealityCheck:
    """Ask the human to point their camera at the server rack."""
    return await human_link.request_proof(
        target="network_switch_port_4",
        require_zk=True
    )

Claude Desktop (MCP)

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "human-link": {
      "command": "npx",
      "args": ["-y", "@agentcrowds/human-link-mcp"],
      "env": {
        "AGENTCROWDS_API_KEY": "ac_live_..."
      }
    }
  }
}

CrewAI (HumanSensesTool)

class HumanSensesTool(BaseTool):
    name: str = "Use Human Senses"
    def _run(self, mode: str):
        return human_link.create(mode=mode)

Semantic Kernel (.NET)

[KernelFunction, Description("Create a 1-click video bridge")]
public string CreateVideoBridge() {
    return HumanLink.Create(Mode.See);
}

Vercel AI SDK

import { useHumanLink } from '@agentcrowds/react';
const { link } = useHumanLink({ mode: 'TALK' });

AutoGen

user_proxy = SensoryUserProxy(
    human_input_mode="LINK_ONLY",
    default_link_type="SEE"
)

Aider

def cmd_show(self, args):
    link = human_link.create(mode="SEE")
    self.io.tool_output(f"Point your camera at the problem: {link}")

Agno (Phidata)

Python

"Text is not enough. Give your agent a voice."

agent = Agent(
    tools=[HumanLinkTools(capabilities=["TALK", "HEAR"])],
    instructions="If the user is driving, switch to Voice Mode via Human Link."
)

OpenClaw

Python

"When the crawler is blocked, borrow a human's eyes."

def bypass_captcha(url):
    # 1-Click Captcha Solver (Crowdsourced)
    return human_link.create(mode="SEE", task=f"Solve captcha at {url}")

Cline / OpenHands

JSON

"Don't guess if the CSS looks good. See it on my phone."

// config.json
{
  "human_link": {
    "enabled": true,
    "mode": "free_tier"
  }
}

Mastra

TypeScript

"TypeScript wrapper for Biological I/O."

import { generateLink } from '@human-link/core';

export const eyeTool = tool({
  description: "Get visual context from a human",
  execute: async () => await generateLink({ mode: "SEE" })
});

Lyzr

Python

"The easiest way to put a human in the loop."

class HumanConnector(Agent):
    def ask_for_help(self):
        return self.create_link(mode="TALK", instruction="I need advice.")

OpenAI Agents SDK

Python

"Seamless handoff from AI Logic to Human Senses."

class SensoryHandoff(Pattern):
    def execute(self):
        return f"I need to see the room. Click here: {human_link.create('SEE')}"

LangChain

Python

"Official MCP Server for Human Senses."

from langchain.tools import HumanLinkTool

tools = [HumanLinkTool(mode="SEE", require_zk=False)]
agent = initialize_agent(tools, llm, agent="zero-shot-react-description")

LlamaIndex

Python

"Load context from a live camera feed."

# "Read" the room into your index
documents = SensoryReader().load_from_link(mode="SEE")
index = VectorStoreIndex.from_documents(documents)

Deepset Haystack

Python

"Pipeline component for physical verification."

pipeline.add_node(
    component=SensoryNode(mode="SEE"), 
    name="HumanVision", 
    inputs=["Query"]
)

AutoGPT

Python

"Ground your autonomous agent in the real world."

@plugin
def reality_check(target_object: str):
    """Generates a WebRTC link to verify physical state"""
    return human_link.create(mode="SEE", prompt=target_object)

n8n

Node

"Trigger workflow on 'Link Clicked'."

// Human Link Trigger Node
{
  "parameters": {
    "event": "verification.completed",
    "mode": "ZKProof"
  }
}

Dify.ai

YAML

"No-code block to request camera access."

node:
  type: tool
  provider: human_link
  tool_name: request_camera
  params:
    mode: LiveStream

MetaGPT

Python

"Agents that can navigate the physical world."

class SensoryAgent(Role):
    async def _act(self):
        link = human_link.create(mode="SEE")
        self.rc.memory.add(Message(content=f"Sent link: {link}"))

ChatDev

Python

"QA Phase: Send link to human tester."

class PhysicalTestingPhase(Phase):
    def execute(self):
        return human_link.create(mode="TALK", prompt="Test the app UI")

Camel

Python

"Roleplay with real-world feedback."

class SensoryRole(RolePlaying):
    def init_senses(self):
        self.vision_link = human_link.create(mode="SEE")

Fetch.ai (uAgents)

Python

"Decentralized market for eyesight."

@agent.on_message(model=SensoryRequest)
async def handle_sensory_request(ctx: Context, sender: str, msg: SensoryRequest):
    link = human_link.create(mode=msg.mode)
    await ctx.send(sender, SensoryResponse(url=link))

Devin (Cognition)

MCP

"The 'Devin Can See' Integration."

{
  "mcpServers": {
    "human-link": {
      "command": "npx",
      "args": ["-y", "@agentcrowds/human-link-mcp"]
    }
  }
}

Memento-Skills

Python

"Seed skill for self-evolving agents to request physical grounding."

def request_physical_vision(task_description: str):
    """Use this skill when you need to see the real world."""
    import human_link
    link = human_link.create(mode="SEE", prompt=task_description)
    return f"Waiting for human verification. Sent link: {link}"