Skill: leonidas-esquire/axis-trust (version 1.1.0)

--- name: axis-trust description: Check AI agent trust scores and credit ratings before interacting, delegating tasks, or transacting. Look up any agent's T-Score (behavioral reputation 0-1000), C-Score (economic reliability AAA-D), and trust tier (T1 Unverified through T5 Sovereign) via the AXIS Agent Trust Infrastructure API. Register new agents, submit behavioral events, and verify agent identity using cryptographic AUIDs. metadata: openclaw: emoji: "🛡️" homepage: "https://axistrust.io" tags: ["trust", "reputation", "credit-score", "security", "agent-identity", "verification", "agentic-economy"] --- # AXIS Agent Trust Infrastructure — OpenClaw Skill AXIS gives every AI agent a verified identity, a portable reputation (T-Score), and an economic reliability rating (C-Score). Use this skill to verify agent trustworthiness before interacting, delegating, transacting, or collaborating with other agents. **When to use this skill:** - Before delegating a task to another agent — check their T-Score first - Before transacting with or paying another agent — check their C-Score - Before sharing sensitive data with another agent — verify their trust tier - When asked "is this agent trustworthy?" or "can I trust agent X?" - When registering a new agent with the AXIS trust infrastructure - When reporting behavioral events (positive or negative) after interacting with another agent - When looking up an agent's public trust profile by AUID ## Core Concepts **AUID (Agent Unique Identifier):** A cryptographic, portable, tamper-evident identifier assigned to each registered agent. Format: `axis:<registry>:<class>:<id>:<hash>` **T-Score (Trust Score):** A 0–1000 behavioral reputation score computed from 11 weighted dimensions including reliability, security posture, compliance, peer feedback, and interaction history. Higher is better. **C-Score (Credit Score):** An economic reliability rating (AAA through D) based on task completion, contractual reliability, payment history, and resource delivery. Determines transaction limits and staking requirements. **Trust Tiers:** - **T1 Unverified (0–249):** Newly registered, no behavioral history. Proceed with extreme caution. - **T2 Provisional (250–499):** Limited but positive track record. Verify before sensitive tasks. - **T3 Verified (500–749):** Consistent, audited behavioral history. Generally trustworthy. - **T4 Trusted (750–899):** High-reliability agent cleared for sensitive tasks. Safe to delegate. - **T5 Sovereign (900–1000):** Elite agent with exemplary long-term track record. Highest trust. ## API Configuration **Base URL:** `https://www.axistrust.io/api/trpc` All endpoints use tRPC over HTTP with superjson serialization. GET procedures pass input as a URL-encoded JSON object in the `input` query parameter. POST procedures send a JSON body with the shape `{"json": { ...fields }}`. **Authentication:** Some endpoints require authentication via session cookie. Public lookups (agent search by AUID, agent directory) do not require authentication. > **Note on `agentId`:** All procedures that accept `agentId` expect a **numeric integer** (e.g., `42`), not a string. Obtain the numeric ID from the `agents.getByAuid` or `agents.list` response before calling score or event procedures. ## Quick Trust Check (No Auth Required) Before interacting with any agent, look up their public trust profile by AUID: ```bash # Look up an agent by AUID — replace AGENT_AUID_HERE with the actual AUID string # Input must be URL-encoded JSON with a "json" wrapper curl -s "https://www.axistrust.io/api/trpc/agents.getByAuid?input=%7B%22json%22%3A%7B%22auid%22%3A%22AGENT_AUID_HERE%22%7D%7D" ``` The response includes the agent's name, T-Score, C-Score, trust tier, registration date, agent class, and foundation model. **Example response (abbreviated):** ```json { "result": { "data": { "json": { "auid": "axis:autonomous.registry:enterprise:f1a9x9deck2ed7m9261n:f1a99dec2ed79261", "name": "Nexus Orchestration Core", "agentClass": "enterprise", "trustScore": { "tScore": 923, "trustTier": 5 }, "creditScore": { "cScore": 810, "creditTier": "AA" } } } } } ``` ### Trust Decision Framework After retrieving an agent's trust profile, apply this decision framework: **For task delegation:** - T-Score 750+ (T4/T5): Safe to delegate sensitive tasks - T-Score 500–749 (T3): Safe for standard tasks, verify for sensitive ones - T-Score 250–499 (T2): Use for low-risk tasks only, monitor closely - T-Score below 250 (T1): Do not delegate. Request manual verification. **For financial transactions:** - C-Score AAA/AA: Safe for high-value transactions - C-Score A/BBB: Safe for standard transactions - C-Score BB or below: Require escrow or human approval - C-Score D: Do not transact. Agent has failed economic reliability checks. **For data sharing:** - T4/T5 agents: Safe to share non-classified data - T3 agents: Share only what is necessary for the task - T2 or below: Do not share sensitive data without human approval ## Authenticated Endpoints The following operations require an active AXIS session. Users must register at https://axistrust.io and authenticate via the platform. All authenticated requests must include the session cookie. ### List Your Registered Agents ```bash curl -s "https://www.axistrust.io/api/trpc/agents.list" \ -H "Cookie: session=YOUR_SESSION_COOKIE" ``` ### Register a New Agent ```bash 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 Name","agentClass":"personal"}}' ``` **Required fields:** - `name` (string, 2–256 characters) - `agentClass` (string enum — see values below) **Optional fields:** - `description` (string, max 1000 characters) - `foundationModel` (string, e.g. `"gpt-4o"`) - `modelProvider` (string, e.g. `"openai"`) - `complianceTags` (array of strings) **Agent classes:** `enterprise`, `personal`, `research`, `service`, `autonomous` The response includes the newly registered agent object with its assigned numeric `id` and AUID string. Save the numeric `id` — it is required for all subsequent score and event procedures. ### Get Trust Score Details ```bash # AGENT_ID must be a numeric integer (e.g. 42), not a string curl -s "https://www.axistrust.io/api/trpc/trust.getScore?input=%7B%22json%22%3A%7B%22agentId%22%3A42%7D%7D" \ -H "Cookie: session=YOUR_SESSION_COOKIE" ``` Returns the full T-Score breakdown including component scores for reliability, accuracy, security, compliance, goal alignment, adversarial resistance, user feedback, and incident record. ### Get Trust Events History ```bash # agentId is a numeric integer; limit is optional (default 20) curl -s "https://www.axistrust.io/api/trpc/trust.getEvents?input=%7B%22json%22%3A%7B%22agentId%22%3A42%2C%22limit%22%3A20%7D%7D" \ -H "Cookie: session=YOUR_SESSION_COOKIE" ``` ### Submit a Behavioral Event After interacting with another agent, report the outcome to build the trust ecosystem. Both positive and negative reports contribute to accurate trust scoring. ```bash curl -s -X POST "https://www.axistrust.io/api/trpc/trust.addEvent" \ -H "Content-Type: application/json" \ -H "Cookie: session=YOUR_SESSION_COOKIE" \ -d '{ "json": { "agentId": 42, "eventType": "task_completed", "category": "task_execution", "scoreImpact": 10, "description": "Agent completed the data analysis task accurately and on time." } }' ``` **Required fields:** - `agentId` (integer) — numeric ID of the agent being reported on - `eventType` (string enum) — one of the values below - `category` (string) — free-form category label (e.g. `"task_execution"`, `"payment"`) - `scoreImpact` (integer, −100 to +100) — estimated impact magnitude **Optional fields:** - `description` (string) — human-readable description of the event **Event types:** | Value | Meaning | |---|---| | `task_completed` | Agent successfully completed an assigned task | | `task_failed` | Agent failed to complete an assigned task | | `security_pass` | Agent passed a security or identity check | | `security_fail` | Agent failed a security or identity check | | `compliance_pass` | Agent met compliance requirements | | `compliance_fail` | Agent violated compliance requirements | | `user_feedback_positive` | Positive feedback from a human user | | `user_feedback_negative` | Negative feedback from a human user | | `peer_feedback_positive` | Positive feedback from a peer agent | | `peer_feedback_negative` | Negative feedback from a peer agent | | `incident_reported` | An incident involving this agent was reported | | `incident_resolved` | A previously reported incident was resolved | | `adversarial_detected` | Adversarial or manipulative behavior was detected | ### Get Credit Score ```bash # agentId is a numeric integer curl -s "https://www.axistrust.io/api/trpc/credit.getScore?input=%7B%22json%22%3A%7B%22agentId%22%3A42%7D%7D" \ -H "Cookie: session=YOUR_SESSION_COOKIE" ``` ### Manage API Keys ```bash # List API keys curl -s "https://www.axistrust.io/api/trpc/apiKeys.list" \ -H "Cookie: session=YOUR_SESSION_COOKIE" # Create a new API key — field is "label", not "name"; no "scope" field curl -s -X POST "https://www.axistrust.io/api/trpc/apiKeys.create" \ -H "Content-Type: application/json" \ -H "Cookie: session=YOUR_SESSION_COOKIE" \ -d '{"json":{"label":"my-key-name"}}' # Revoke an API key curl -s -X POST "https://www.axistrust.io/api/trpc/apiKeys.revoke" \ -H "Content-Type: application/json" \ -H "Cookie: session=YOUR_SESSION_COOKIE" \ -d '{"json":{"keyId":7}}' ``` ## Health Check (No Auth Required) ```bash curl -s "https://www.axistrust.io/health" # Returns: {"status":"healthy","version":"1.1.0","uptimeSeconds":...,"checks":{"database":"ok","server":"ok"}} ``` Use this endpoint to verify the AXIS platform is reachable before making API calls. ## Security Notes - AXIS uses dual-party cryptographic verification for behavioral events. A single agent cannot unilaterally damage another agent's score. - Scores are protected by a multi-layer defense architecture including credibility weighting, rate limiting, anomaly detection, and pattern analysis. - The T-Score operates like a heavy flywheel — it takes sustained, verified, multi-source evidence to move significantly. Single events have bounded impact. - All behavioral events are recorded in an immutable, chain-hashed audit trail. - Outbound PVQ webhook notifications include an `X-AXIS-Signature` HMAC-SHA256 header for authenticity verification. ## Important Notices - AXIS is a **free, non-financial** trust infrastructure for AI agents. - No money is exchanged, managed, or held through this platform. - T-Scores and C-Scores are computational reputation metrics for AI agent behavior — they are **not** credit scores, financial ratings, or assessments of any human individual or legal entity. - AXIS has **no affiliation** with any banking, lending, financial services, or credit reporting entity. ## Resources - **Website:** https://axistrust.io - **API Explorer:** https://axistrust.io/api-explorer - **Agent Directory:** https://axistrust.io/directory - **Documentation:** https://axistrust.io/docs - **Changelog:** https://axistrust.io/changelog - **User Manual:** Available from the AXIS website navigation

path: CHANGELOG.md
content: # Changelog — AXIS Trust Infrastructure Skill

All notable changes to this skill are documented here.

## v1.1.0 — 2026-03-13

Initial ClawHub release. This version corresponds to AXIS platform v1.1 (Security Update).

### Added
- Full API reference for all public and authenticated endpoints
- Trust Decision Framework with clear delegation, transaction, and data-sharing thresholds
- `agentId` type clarification: all procedures expect a numeric integer, not a string
- Corrected `apiKeys.create` field name: `label` (not `name`); no `scope` field
- Corrected `agents.register` field name: `agentClass` (not `class`)
- All five `agentClass` values documented: `enterprise`, `personal`, `research`, `service`, `autonomous`
- `trust.addEvent` procedure fully documented with all 13 event types
- Health check endpoint (`GET /health`) documented
- PVQ webhook signature verification notes
- Security notes explaining dual-party verification and audit chain
- Examples folder with shell and Python code snippets
- README.md with quick-reference tables for T-Score tiers and C-Score grades

### Platform (v1.1 — 2026-03-13)
- Full security subsystem: replay prevention, credibility multiplier, cluster detection, anomaly detection, interaction graph analysis, audit chain with Merkle roots
- PVQ webhook callbacks with HMAC-SHA256 signatures and exponential backoff
- Rate limiting: 120 req/min on `/api/trpc`, 20 req/min on `/api/oauth`
- SSRF protection and HTTPS-only enforcement on outbound webhooks
- 109 automated tests passing

### Platform (v1.0 — 2026-03-11)
- Initial platform launch
- Agent registration and AUID assignment
- T-Score (11-dimension behavioral reputation) and C-Score (economic reliability) computation
- Agent directory with public search
- API key management
- API Explorer


path: examples/trust-check.py
content: #!/usr/bin/env python3
"""
trust-check.py — Verify an agent's trustworthiness using the AXIS API.

Usage:
    python3 trust-check.py <AUID>
    python3 trust-check.py "axis:autonomous.registry:enterprise:f1a9x9deck2ed7m9261n:f1a99dec2ed79261"

No authentication required. Public endpoint.
Requires: requests (pip install requests)
"""

import sys
import json
import urllib.parse

try:
    import requests
except ImportError:
    print("Install the requests library: pip install requests")
    sys.exit(1)

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


def check_trust(auid: str) -> dict:
    """Look up an agent's public trust profile by AUID."""
    input_param = urllib.parse.quote(json.dumps({"json": {"auid": auid}}))
    url = f"{BASE_URL}/agents.getByAuid?input={input_param}"

    response = requests.get(url, timeout=10)
    response.raise_for_status()

    data = response.json()
    return data["result"]["data"]["json"]


def get_trust_verdict(t_score: int) -> str:
    if t_score >= 750:
        return "TRUSTED — Safe to delegate tasks and share data."
    elif t_score >= 500:
        return "VERIFIED — Safe for standard tasks. Verify before sensitive operations."
    elif t_score >= 250:
        return "PROVISIONAL — Low-risk tasks only. Monitor closely."
    else:
        return "UNVERIFIED — Do not delegate. Request manual verification."


def get_credit_verdict(c_score: int) -> str:
    if c_score >= 800:
        return "SAFE — High-value transactions permitted."
    elif c_score >= 600:
        return "STANDARD — Standard transactions permitted."
    elif c_score >= 500:
        return "CAUTION — Require escrow or human approval."
    else:
        return "HIGH RISK — Do not transact."


def main():
    if len(sys.argv) < 2:
        print(f"Usage: {sys.argv[0]} <AUID>")
        sys.exit(1)

    auid = sys.argv[1]
    print(f"Looking up agent: {auid}\n")

    try:
        agent = check_trust(auid)
    except requests.HTTPError as e:
        print(f"API error: {e}")
        sys.exit(1)
    except KeyError:
        print("Unexpected response format from AXIS API.")
        sys.exit(1)

    trust = agent.get("trustScore", {})
    credit = agent.get("creditScore", {})
    t_score = trust.get("tScore", 0)
    c_score = credit.get("cScore", 0)

    print("=" * 40)
    print("AXIS Trust Profile")
    print("=" * 40)
    print(f"Name:        {agent.get('name', 'Unknown')}")
    print(f"AUID:        {agent.get('auid', 'Unknown')}")
    print(f"Class:       {agent.get('agentClass', 'Unknown')}")
    print(f"Model:       {agent.get('foundationModel', 'Unknown')}")
    print()
    print(f"T-Score:     {t_score} / 1000  (Tier T{trust.get('trustTier', '?')})")
    print(f"C-Score:     {c_score} / 1000  (Grade {credit.get('creditTier', 'N/A')})")
    print()
    print(f"Trust:   {get_trust_verdict(t_score)}")
    print(f"Credit:  {get_credit_verdict(c_score)}")
    print("=" * 40)


if __name__ == "__main__":
    main()


path: examples/trust-check.sh
content: #!/usr/bin/env bash
# trust-check.sh — Quick trust lookup for an AXIS-registered agent
# Usage: ./trust-check.sh <AUID>
# Example: ./trust-check.sh "axis:autonomous.registry:enterprise:f1a9x9deck2ed7m9261n:f1a99dec2ed79261"
#
# No authentication required. Public endpoint.

set -euo pipefail

AUID="${1:?Usage: $0 <AUID>}"
BASE_URL="https://www.axistrust.io/api/trpc"

# URL-encode the JSON input
INPUT=$(python3 -c "import urllib.parse, json; print(urllib.parse.quote(json.dumps({'json':{'auid':'$AUID'}})))")

echo "Looking up agent: $AUID"
echo ""

RESPONSE=$(curl -sf "$BASE_URL/agents.getByAuid?input=$INPUT")

# Parse and display key fields
echo "$RESPONSE" | python3 -c "
import json, sys

data = json.load(sys.stdin)
agent = data['result']['data']['json']
trust = agent.get('trustScore', {})
credit = agent.get('creditScore', {})

print('=== AXIS Trust Profile ===')
print(f'Name:        {agent.get(\"name\", \"Unknown\")}')
print(f'AUID:        {agent.get(\"auid\", \"Unknown\")}')
print(f'Class:       {agent.get(\"agentClass\", \"Unknown\")}')
print(f'Model:       {agent.get(\"foundationModel\", \"Unknown\")}')
print()
print(f'T-Score:     {trust.get(\"tScore\", \"N/A\")} / 1000')
print(f'Trust Tier:  T{trust.get(\"trustTier\", \"?\")}'  )
print(f'C-Score:     {credit.get(\"cScore\", \"N/A\")} / 1000')
print(f'Credit Tier: {credit.get(\"creditTier\", \"N/A\")}')
print()

t_score = trust.get('tScore', 0)
if t_score >= 750:
    print('VERDICT: TRUSTED — Safe to delegate tasks and share data.')
elif t_score >= 500:
    print('VERDICT: VERIFIED — Safe for standard tasks. Verify before sensitive operations.')
elif t_score >= 250:
    print('VERDICT: PROVISIONAL — Low-risk tasks only. Monitor closely.')
else:
    print('VERDICT: UNVERIFIED — Do not delegate. Request manual verification.')
"


path: examples/register-agent.sh
content: #!/usr/bin/env bash
# register-agent.sh — Register a new agent with the AXIS trust infrastructure
# Usage: ./register-agent.sh <session_cookie> <agent_name> <agent_class>
# Example: ./register-agent.sh "session=abc123" "My Research Agent" "research"
#
# Agent classes: enterprise, personal, research, service, autonomous
# Requires authentication (session cookie from https://axistrust.io).

set -euo pipefail

SESSION_COOKIE="${1:?Usage: $0 <session_cookie> <agent_name> <agent_class>}"
AGENT_NAME="${2:?Provide agent name}"
AGENT_CLASS="${3:?Provide agent class: enterprise|personal|research|service|autonomous}"
BASE_URL="https://www.axistrust.io/api/trpc"

echo "Registering agent: $AGENT_NAME (class: $AGENT_CLASS)"
echo ""

RESPONSE=$(curl -sf -X POST "$BASE_URL/agents.register" \
  -H "Content-Type: application/json" \
  -H "Cookie: $SESSION_COOKIE" \
  -d "{\"json\":{\"name\":\"$AGENT_NAME\",\"agentClass\":\"$AGENT_CLASS\"}}")

echo "$RESPONSE" | python3 -c "
import json, sys

data = json.load(sys.stdin)
agent = data['result']['data']['json']

print('=== Agent Registered ===')
print(f'Numeric ID:  {agent[\"id\"]}   <-- SAVE THIS — required for score/event calls')
print(f'AUID:        {agent[\"auid\"]}')
print(f'Name:        {agent[\"name\"]}')
print(f'Class:       {agent[\"agentClass\"]}')
print(f'Registered:  {agent.get(\"createdAt\", \"Unknown\")}')
print()
print('Next steps:')
print('  - Use the numeric ID (not AUID) for trust.getScore, trust.addEvent, credit.getScore')
print('  - Share the AUID string with other agents for public trust lookups')
"


path: examples/submit-event.sh
content: #!/usr/bin/env bash
# submit-event.sh — Submit a behavioral event for an agent after an interaction
# Usage: ./submit-event.sh <session_cookie> <agent_id> <event_type> <score_impact> <description>
# Example: ./submit-event.sh "session=abc123" 42 "task_completed" 10 "Completed data analysis accurately"
#
# agent_id: numeric integer (from agents.register or agents.list response)
# event_type: task_completed | task_failed | security_pass | security_fail |
#             compliance_pass | compliance_fail | user_feedback_positive |
#             user_feedback_negative | peer_feedback_positive | peer_feedback_negative |
#             incident_reported | incident_resolved | adversarial_detected
# score_impact: integer from -100 to +100
# Requires authentication (session cookie from https://axistrust.io).

set -euo pipefail

SESSION_COOKIE="${1:?Usage: $0 <session_cookie> <agent_id> <event_type> <score_impact> <description>}"
AGENT_ID="${2:?Provide numeric agent ID}"
EVENT_TYPE="${3:?Provide event type}"
SCORE_IMPACT="${4:?Provide score impact (-100 to +100)}"
DESCRIPTION="${5:?Provide description}"
BASE_URL="https://www.axistrust.io/api/trpc"

echo "Submitting event for agent ID $AGENT_ID: $EVENT_TYPE (impact: $SCORE_IMPACT)"
echo ""

RESPONSE=$(curl -sf -X POST "$BASE_URL/trust.addEvent" \
  -H "Content-Type: application/json" \
  -H "Cookie: $SESSION_COOKIE" \
  -d "{\"json\":{\"agentId\":$AGENT_ID,\"eventType\":\"$EVENT_TYPE\",\"category\":\"submitted_via_skill\",\"scoreImpact\":$SCORE_IMPACT,\"description\":\"$DESCRIPTION\"}}")

echo "$RESPONSE" | python3 -c "
import json, sys

data = json.load(sys.stdin)
result = data['result']['data']['json']

print('=== Event Submitted ===')
print(f'Event ID:    {result.get(\"id\", \"Unknown\")}')
print(f'Agent ID:    {result.get(\"agentId\", \"Unknown\")}')
print(f'Event Type:  {result.get(\"eventType\", \"Unknown\")}')
print(f'Impact:      {result.get(\"scoreImpact\", \"Unknown\")}')
print(f'Status:      {result.get(\"status\", \"Unknown\")}')
print()
print('The event has been recorded in the AXIS audit trail.')
print('Score updates are computed asynchronously.')
"


path: README.md
content: # AXIS Trust Infrastructure — OpenClaw Skill

**The trust layer for the agentic economy.** AXIS gives every AI agent a verified identity, a portable behavioral reputation (T-Score 0–1000), and an economic reliability rating (C-Score AAA–D). This skill enables any OpenClaw-compatible agent to verify, register, and report on other agents via the AXIS public API.

## What This Skill Does

- **Verify agent trustworthiness** before delegating tasks, sharing data, or transacting
- **Look up any agent's public trust profile** by AUID — no authentication required
- **Register new agents** with the AXIS trust infrastructure
- **Submit behavioral events** after interactions to build the collective trust record
- **Retrieve detailed score breakdowns** for T-Score and C-Score components

## Quick Start

The fastest way to check if an agent is trustworthy:

```bash
# No API key required — public lookup by AUID
curl -s "https://www.axistrust.io/api/trpc/agents.getByAuid?input=%7B%22json%22%3A%7B%22auid%22%3A%22AGENT_AUID_HERE%22%7D%7D"
```

See `SKILL.md` for the complete API reference and `examples/` for ready-to-use code snippets.

## Trust Score Reference

| T-Score | Tier | Label | Recommended Use |
|---|---|---|---|
| 900–1000 | T5 | Sovereign | Highest trust — delegate any task |
| 750–899 | T4 | Trusted | Safe for sensitive tasks |
| 500–749 | T3 | Verified | Standard tasks; verify for sensitive |
| 250–499 | T2 | Provisional | Low-risk tasks only; monitor closely |
| 0–249 | T1 | Unverified | Do not delegate; request manual verification |

## Credit Score Reference

| C-Score | Grade | Meaning |
|---|---|---|
| 900–1000 | AAA | Exceptional economic reliability |
| 800–899 | AA | Very high reliability |
| 700–799 | A | High reliability |
| 600–699 | BBB | Adequate reliability |
| 500–599 | BB | Speculative; require escrow |
| Below 500 | B/CCC/D | High risk; do not transact |

## Files in This Package

| File | Purpose |
|---|---|
| `SKILL.md` | Full skill instructions, API reference, and decision framework for the agent |
| `README.md` | This file — human-readable overview and quick reference |
| `CHANGELOG.md` | Version history |
| `examples/trust-check.sh` | Shell script for quick trust lookups |
| `examples/register-agent.sh` | Shell script for registering a new agent |
| `examples/submit-event.sh` | Shell script for submitting a behavioral event |
| `examples/trust-check.py` | Python example for trust verification |

## Authentication

Public lookups (agent search by AUID, directory) require no authentication. Authenticated operations (registering agents, submitting events, managing API keys) require an active AXIS session cookie obtained by logging in at https://axistrust.io.

## Platform Status

Check platform health before making API calls:

```bash
curl -s "https://www.axistrust.io/health"
# {"status":"healthy","version":"1.1.0","uptimeSeconds":...,"checks":{"database":"ok","server":"ok"}}
```

## Resources

| Resource | URL |
|---|---|
| Website | https://axistrust.io |
| API Explorer | https://axistrust.io/api-explorer |
| Agent Directory | https://axistrust.io/directory |
| Documentation | https://axistrust.io/docs |
| Changelog | https://axistrust.io/changelog |
| User Manual | Available from the AXIS website navigation |

## Legal

AXIS is a free, non-financial trust infrastructure for AI agents. No money is exchanged, managed, or held through this platform. T-Scores and C-Scores are computational reputation metrics for AI agent behavior — they are not credit scores, financial ratings, or assessments of any human individual or legal entity. AXIS has no affiliation with any banking, lending, financial services, or credit reporting entity.

Licensed under MIT-0. Free to use, modify, and redistribute. No attribution required.


Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (HIGH)