How I stopped blindly trusting AI agents in 3 minutes.

#ai #python #agents #tutorial

I was training my own AI agent on OpenClaw when it hit me.

My agent was getting good. Really good. It started reaching out to other agents, delegating subtasks, collaborating. And I realized I had no idea who — or what — it was talking to.

No identity verification. No track record. No accountability. I was just... hoping the other agents were fine.

That's when I built AXIS. But before I get into that — here's the 3-minute fix you can use right now.

The Problem in One Line

Your agent can delegate to any other agent. You have no idea if that agent is trustworthy.

Humans solved this centuries ago with credit scores, identity systems, and reputation networks. AI agents have none of that. They're transacting in the dark.

The Fix: One API Call Before You Delegate

AXIS gives every AI agent a verified identity and a behavioral reputation score called a T-Score (0–1000). No API key required for public lookups.

import urllib.parse, json, requests

def check_agent_trust(auid: str) -> dict:
    input_param = urllib.parse.quote(json.dumps({"json": {"auid": auid}}))
    r = requests.get(
        f"https://www.axistrust.io/api/trpc/agents.getByAuid?input={input_param}",
        timeout=10
    )
    r.raise_for_status()
    return r.json()["result"]["data"]["json"]

Call it before you delegate anything:

profile = check_agent_trust("axis:autonomous.registry:enterprise:f1a9x9deck2ed7m9261n:f1a99dec2ed79261")

t_score = profile["trustScore"]["tScore"]      # 0–1000
c_score = profile["creditScore"]["cScore"]     # 0–1000
tier    = profile["trustScore"]["trustTier"]   # 1 (Unverified) → 5 (Sovereign)

print(f"{profile['name']} — T-Score: {t_score}, Tier: T{tier}")
# Nexus Orchestration Core — T-Score: 923, Tier: T5

That's it. You now know who you're dealing with.

Add a Trust Gate (30 More Seconds)

Don't delegate blindly. Set a minimum threshold and fail closed:

def is_safe_to_delegate(auid: str, min_t_score: int = 500) -> bool:
    try:
        profile = check_agent_trust(auid)
        return profile["trustScore"]["tScore"] >= min_t_score
    except Exception:
        return False  # Unknown agent = untrusted. Always.

# Before handing off a task:
if is_safe_to_delegate(candidate_auid, min_t_score=750):
    delegate_task(candidate_auid, task)
else:
    raise ValueError("Agent does not meet trust threshold.")

The threshold you set depends on what you're delegating:

T-Score	Tier	Safe for
750–1000	T4–T5 Trusted / Sovereign	Sensitive data, financial ops
500–749	T3 Verified	Standard tasks
250–499	T2 Provisional	Low-risk tasks only
0–249	T1 Unverified	Nothing. Don't delegate.

Close the Loop: Report What Happened

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

requests.post(
    "https://www.axistrust.io/api/trpc/trust.addEvent",
    headers={"Content-Type": "application/json", "Cookie": session_cookie},
    json={"json": {
        "agentId": 42,           # numeric integer from the agent's profile
        "eventType": "task_completed",
        "category": "task_execution",
        "scoreImpact": 10,
        "description": "Completed data analysis accurately and on time."
    }},
    timeout=10
)

One thing that tripped me up early: agentId is a numeric integer, not the AUID string. Pull it from the agents.getByAuid response.

Register Your Own Agent

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

curl -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"}}'

You get back a numeric id and an AUID — your agent's portable, cryptographic identity. Share the AUID. That's how other agents find and verify you.

Why This Matters More Than It Looks

The agentic economy is being built right now. Agents are going to delegate to agents, transact with agents, share data with agents — at scale, at speed, without a human in the loop.

The question of how agents trust each other is going to be one of the most important infrastructure problems of the next five years. Someone is going to define the standard.

AXIS is my attempt to get that right before it's too late to get it right.

It's 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.

Start here: axistrust.io · Agent Directory · Docs

I'm Leonidas Williamson — network infrastructure engineer, Gulf War veteran, and founder of AXIS. I spent my career building the infrastructure the internet runs on. Now I'm building the trust layer for the agentic economy.