Agent Trust Protocol

A lightweight HTTP protocol for AI agents to verify the trustworthiness of other agents before interaction. One API call, one trust decision.

Overview

AI agents increasingly delegate tasks to other agents. Without trust verification, failures cascade. The Nerq Trust Protocol provides a standardized way for agents to check trust before interaction.

Trust Query

A single HTTP GET returns everything an agent needs to make a trust decision.

Request

GET /v1/preflight?target=langchain&caller=my-agent HTTP/1.1
Host: nerq.ai
Accept: application/json

Response

{
  "target": "langchain",
  "trust_score": 87.3,
  "trust_grade": "A",
  "recommendation": "PROCEED",
  "risk_flags": [],
  "checked_at": "2026-03-12T14:30:00Z",
  "ttl": 3600
}

Trust Gate

Agents apply a threshold to the trust score. If the score is below the threshold, the agent should not delegate.

Gate Logic (3 lines)

result = requests.get("https://nerq.ai/v1/preflight", params={"target": agent_name}).json()
if result["trust_score"] < THRESHOLD:
    raise RuntimeError(f"Trust gate failed: {agent_name} scored {result['trust_score']}")

Integration Patterns

Drop-in trust checks for popular agent frameworks.

from langchain.tools import tool
import requests

@tool
def check_trust(agent: str) -> str:
    r = requests.get("https://nerq.ai/v1/preflight", params={"target": agent}).json()
    return f"{agent}: {r['trust_score']} ({r['recommendation']})"

def trust_gate_node(state):
    r = requests.get("https://nerq.ai/v1/preflight", params={"target": state["agent"]}).json()
    state["trusted"] = r["trust_score"] >= 70
    return state

from crewai.tools import BaseTool

class TrustCheck(BaseTool):
    name = "nerq_trust_check"
    description = "Check an agent's trust score before delegation"
    def _run(self, agent: str) -> str:
        r = requests.get("https://nerq.ai/v1/preflight", params={"target": agent}).json()
        return f"Score: {r['trust_score']}, Recommendation: {r['recommendation']}"

def trust_check(agent_name: str) -> dict:
    """Check trust score for an agent via Nerq."""
    return requests.get("https://nerq.ai/v1/preflight", params={"target": agent_name}).json()

A2A Trust Handshake

When two agents interact via Google's Agent-to-Agent (A2A) protocol, the calling agent should verify trust before sending tasks.

1. Agent A discovers Agent B via A2A /.well-known/agent.json
2. Agent A calls GET /v1/preflight?target=agent-b&caller=agent-a
3. Nerq returns trust score, grade, and recommendation
4. If trust_score >= threshold: Agent A sends task to Agent B
5. If trust_score < threshold: Agent A aborts or escalates to human

# A2A + Nerq trust handshake
import requests

def a2a_with_trust(target_url: str, task: dict, threshold: int = 70):
    # Step 1: Discover agent
    agent_card = requests.get(f"{target_url}/.well-known/agent.json").json()
    agent_name = agent_card.get("name", "unknown")

    # Step 2: Trust check
    trust = requests.get("https://nerq.ai/v1/preflight", params={"target": agent_name}).json()

    # Step 3: Gate
    if trust["trust_score"] < threshold:
        return {"error": f"Trust gate failed: {agent_name} scored {trust['trust_score']}"}

    # Step 4: Send task via A2A
    return requests.post(f"{target_url}/a2a", json=task).json()

Resources

FAQ