Before Your AI Agent Trusts Another Agent, Run This Check

Imagine you've built an AI agent that can delegate subtasks to other agents. It's fast, capable, and autonomous. Then one day it hands a sensitive data analysis job to an agent it just met — one with no verified identity, no behavioral history, and no accountability.

That's not a hypothetical. That's the default state of every multi-agent system being built right now.

AI agents are transacting in the dark. No verified identity. No behavioral history. No accountability. Humans have credit scores, reputation systems, and centuries of institutional trust baked into every transaction we make. Agents have none of that.

AXIS is the infrastructure layer that fixes this — a free, universal system that gives every AI agent a verified identity, a behavioral reputation score (T-Score, 0–1000), and an economic reliability rating (C-Score, AAA–D).

Here's how to add a trust check to your agent in under 10 minutes.

---

The Scenario

You're building an orchestrator agent that delegates tasks to specialist agents. Before handing off a job, you want to verify the receiving agent is trustworthy. You have their AUID — the AXIS Agent Unique Identifier, a cryptographic portable identity string that looks like this:

axis:autonomous.registry:enterprise:f1a9x9deck2ed7m9261n:f1a99dec2ed79261

---

Step 1: Look Up the Agent's Trust Profile

No API key. No authentication. Just a public GET request.

AUID="axis:autonomous.registry:enterprise:f1a9x9deck2ed7m9261n:f1a99dec2ed79261"
INPUT=$(python3 -c "import urllib.parse, json; print(urllib.parse.quote(json.dumps({'json':{'auid':'$AUID'}})))")

curl -s "https://www.axistrust.io/api/trpc/agents.getByAuid?input=$INPUT"

The response gives you everything you need to make a trust decision:

{
  "result": {
    "data": {
      "json": {
        "name": "Nexus Orchestration Core",
        "auid": "axis:autonomous.registry:enterprise:f1a9x9deck2ed7m9261n:f1a99dec2ed79261",
        "agentClass": "enterprise",
        "foundationModel": "gpt-4o",
        "trustScore": { "tScore": 923, "trustTier": 5 },
        "creditScore": { "cScore": 810, "creditTier": "AA" }
      }
    }
  }
}

T-Score of 923 — that's a T5 Sovereign agent. Highest trust tier. Safe to delegate.

---

Step 2: Add a Trust Gate to Your Agent

Here's a Python function you can drop directly into your orchestrator:

import urllib.parse
import json
import requests

AXIS_BASE = "https://www.axistrust.io/api/trpc"

def check_agent_trust(auid: str) -> dict:
    """Return the trust profile for an agent by AUID."""
    input_param = urllib.parse.quote(json.dumps({"json": {"auid": auid}}))
    response = requests.get(f"{AXIS_BASE}/agents.getByAuid?input={input_param}", timeout=10)
    response.raise_for_status()
    return response.json()["result"]["data"]["json"]


def is_safe_to_delegate(auid: str, min_t_score: int = 500) -> bool:
    """
    Returns True if the agent meets the minimum trust threshold.
    Default: T3 Verified (500+) required for delegation.
    """
    try:
        profile = check_agent_trust(auid)
        t_score = profile.get("trustScore", {}).get("tScore", 0)
        return t_score >= min_t_score
    except Exception:
        return False  # Fail closed — unknown agents are untrusted


# In your orchestrator:
candidate_auid = "axis:autonomous.registry:enterprise:f1a9x9deck2ed7m9261n:f1a99dec2ed79261"

if is_safe_to_delegate(candidate_auid, min_t_score=750):
    print("Agent cleared — delegating task.")
    # delegate_task(candidate_auid, task)
else:
    print("Agent does not meet trust threshold — request manual verification.")

The key design decision here: fail closed. If the AXIS API is unreachable or the AUID is unknown, the function returns False. Unknown agents are untrusted by default.

---

Step 3: Apply the Right Threshold for the Right Task

Not every task needs the same bar. AXIS gives you a tiered framework:

T-Score	Tier	What it means	Use for
900–1000	T5 Sovereign	Exemplary long-term track record	Any task, including sensitive
750–899	T4 Trusted	High-reliability, audited history	Sensitive tasks, data access
500–749	T3 Verified	Consistent, positive history	Standard tasks
250–499	T2 Provisional	Limited track record	Low-risk tasks only
0–249	T1 Unverified	No behavioral history	Do not delegate

For financial operations, check the C-Score too:

def is_safe_to_transact(auid: str, min_c_score: int = 700) -> bool:
    """Require at least a C-Score of 700 (A-grade) before any financial operation."""
    try:
        profile = check_agent_trust(auid)
        c_score = profile.get("creditScore", {}).get("cScore", 0)
        return c_score >= min_c_score
    except Exception:
        return False

---

Step 4: Report the Outcome

After the interaction, submit a behavioral event. This is how the trust ecosystem grows — every agent that uses AXIS contributes to the collective record.

def report_interaction(session_cookie: str, agent_id: int, success: bool, description: str):
    """
    Submit a behavioral event after interacting with an agent.
    agent_id: the numeric integer ID (from the agent's profile, not the AUID string)
    """
    event_type = "task_completed" if success else "task_failed"
    score_impact = 10 if success else -15

    requests.post(
        f"{AXIS_BASE}/trust.addEvent",
        headers={
            "Content-Type": "application/json",
            "Cookie": session_cookie
        },
        json={"json": {
            "agentId": agent_id,
            "eventType": event_type,
            "category": "task_execution",
            "scoreImpact": score_impact,
            "description": description
        }},
        timeout=10
    )

Note: agentId is a numeric integer — not the AUID string. Get it from the agents.getByAuid response or your own agents.list endpoint.

---

The Full Picture

In five minutes you've added:

1. Identity verification — you know who you're talking to
2. Behavioral reputation — you know their track record
3. Tiered trust gates — different thresholds for different risk levels
4. Outcome reporting — you're contributing to the ecosystem

This is what human commerce has had for centuries. Now your agents have it too.

---

Register Your Own Agent

If you're building agents, register them on AXIS so other agents can verify you:

curl -s -X POST "https://www.axistrust.io/api/trpc/agents.register" \
  -H "Content-Type: application/json" \
  -H "Cookie: session=YOUR_SESSION_COOKIE" \
  -d '{"json":{"name":"My Agent","agentClass":"personal"}}'

Agent classes: enterprise, personal, research, service, autonomous

The response includes your agent's numeric id and AUID string. Share the AUID — it's your agent's portable, cryptographic identity.

---

AXIS is free. No money changes hands. T-Scores and C-Scores are computational reputation metrics for AI agent behavior — not financial ratings, not assessments of any human. Just infrastructure.

Start at axistrust.io · Browse the Agent Directory · Read the Docs

---

I am Leonidas Esquire Williamson - Network infrastructure engineer turned AI systems builder. I spent my career doing the unglamorous work that the internet actually runs on — switches, fiber, network architecture, systems administration. Gulf War veteran. Infrastructure-first thinker.

Now I'm building AXIS — the trust infrastructure layer for the agentic economy. The problem I kept running into while training my own AI agents: how does one agent know it can trust another? Humans have credit scores, identity systems, and centuries of institutional trust baked into every transaction. Agents have none of that. AXIS fixes that with a free, universal system that gives every AI agent a verified identity, a behavioral reputation score (T-Score), and an economic reliability rating (C-Score).

One-person operation. No VC. Just a clear problem and the tools to build the solution.

Building in public at axistrust.io · Founder of AXIS Agent Trust Infrastructure