Trust Infrastructure
for the Agentic Economy

The Seven Foundation Algorithms

The core insight: a sybil ring invisible to PageRank (because it has high in-degree) will be caught by the Fiedler spectral score (it forms a bridge cluster) and by absorbing walks (it is far from verified anchors). No single algorithm catches everything. The ensemble does.

Nine Derived Composite Signals

On top of raw scores, nine cross-algorithm signals detect specific attack patterns:

The 22-Dimensional Feature Vector

Top-10 Feature Importance (Production Model)

Training Data Sources

Training class balance: 9,429 honest vs 2,308 sybil (4.09:1 ratio, handled via XGBoost scale_pos_weight). 80/20 train-test split. 5-fold stratified cross-validation for threshold selection.

XGBoost Configuration

Security — 4/4 PASS

Accuracy — 4/4 PASS

Economics — 3/3 PASS

Pending — Not Yet Built

Attack Detection Coverage

TA Economics: Skin in the Game

Revocation Cascade Architecture

When a Trust Anchor is compromised or deregistered, the system must propagate revocation through all attested agents. The design separates security (instant, $0.000002 soft-revoke) from cleanup (cheap, parallelizable hard cleanup).

Three-State Upgrade Path

Dual-Consent Upgrade Protocol

Two separate on-chain transactions from two different keys are required. This prevents TAs from unilaterally enrolling agents they control.

KYC Confidence Weight Formula

SCS → Economic Access Tiers

The Existing Shyft Contract Stack (Live on Mainnet)

This is not a whitepaper. These contracts are deployed and processing attestations today.

What a Trust Channel Actually Is

A Trust Channel is a governance namespace with a programmable rules engine. It is an on-chain address that binds together:

The 7 Built-In Rule Types

Each rule slot is configurable per channel. The critical innovation is that Rules 3 and 5 transform KYC compliance infrastructure into a reputation-gated economy:

De Bruijn Bit-Indexed Routing (The Novel Data Structure)

The ShyftCacheGraph uses De Bruijn sequence-based bit manipulation for efficient trust channel route lookups. This is the technically novel routing mechanism:

// DebruijnBitUtils.sol — Bit manipulation for packed trust channel routing
// Uses De Bruijn sequences for O(1) least-significant-bit position finding
//
// How it works:
// 1. Each address pair's channel membership is packed into a uint256 bitmap
// 2. Each bit position represents a trust channel index
// 3. De Bruijn sequence enables O(1) lookup of which channels are shared
// 4. setupDebruijnTable() precomputes the lookup table once
// 5. reconstructCacheGraph() rebuilds after attestation changes
//
// Result: getActiveTrustChannelRoutePossible(A, B, channelIdx)
//         resolves in a single SLOAD + bitwise AND — not iteration

// Key sequence from Shyft integration rules:
// 1. TAS must be cross-linked to SCG BEFORE creating attestations
// 2. SCG.setupDebruijnTable() MUST be called before reconstructCacheGraph
// 3. Trust channel index 0 = first channel via adminSetupTrustChannel
  

How a Transaction Routes Through the System

Domain Channels: Scoped Reputation Contexts

The DomainFactory contract creates isolated (Resolver + CitationCounters) pairs per domain, each scoped to a different trust channel index. This enables domain-specific reputation:

What Makes This Combination Unique

Trust today is binary: KYC or not, approved or not. Trust Channels make trust continuous, earned, delegatable, and composable.

What This Infrastructure Enables Beyond Compliance

The Shyft infrastructure was built for KYC routing. But the primitives — programmable rule slots, per-channel external routing contracts, De Bruijn O(1) route verification, multi-sig governance — are general-purpose. Here's what they enable when pointed at agent reputation instead of compliance:

Session Key Delegation Hierarchy

AI agents can delegate capped payment authority to sub-agents, creating autonomous spending hierarchies:

// Agent hierarchy: traceable, capped, revocable in 1 tx

Orchestrator Agent ($500/day cap, minRMT 200)
  └─ 20 Sub-Agents ($25/day each, ttl: 24h)
       └─ Each buys: API calls, data, compute autonomously
            └─ All spend: traceable, capped, revocable in 1 tx

// Key parameters:
delegation_max_depth:     5          // max chain length
spending_cap_default:     $100       // per session key
rate_limit:               100 req/hr  // per session key
consent_timeout:          168h       // 7 days
credit_line_multiplier:   2.0x       // of SCS-based line
  

Cross-Chain Architecture: Hub and Spoke

All trust state anchors on the Stable Network (Chain 988) — near-zero gas (<$0.001/tx), ~2s finality, USDT/USDC native. Spoke chains verify trust via Merkle proofs.

Total daily bridge cost: $148–407/day. Self-sustaining beyond ~$3M daily volume.

Core Settlement Flow

X402YieldEscrow: Idle Funds Generate Yield

Multi-Method Payment Acceptance

Contract Registry

Autonomous Credit Line Contract Flow

// Rule5CreditLine.sol — autonomous credit from trust channel history

function openCreditLine(address borrower) external {
    // 1. Query RMT oracle for current Sweep Credit Score
    uint256 scs = rmtOracle.getScore(borrower);

    // 2. Check identity tier via EAS attestation
    Tier tier = identityRegistry.getTier(borrower);

    // 3. Resolve credit terms from (scs, tier) pair
    CreditTerms memory terms = _resolveTerms(scs, tier);
    require(terms.maxPrincipal > 0, "INELIGIBLE");

    // 4. Collect collateral (if required by tier)
    if (terms.collateralBps > 0) {
        uint256 collateral = terms.maxPrincipal * terms.collateralBps / 10000;
        usdt.transferFrom(borrower, address(this), collateral);
    }

    // 5. Issue session key with spending cap = credit line
    sessionKeyManager.createKey(
        borrower, terms.maxPrincipal, terms.termSeconds, address(this)
    );

    // 6. Emit EAS attestation for credit issuance
    eas.attest(CREDIT_SCHEMA, borrower, abi.encode(terms));

    // Total time: ~2 seconds (1 Base block)
    // Total cost: ~$0.001 gas
    // Human involvement: zero
}
  

Basis-Point Integer Math

All financial parameters use basis points (1bp = 0.01%) for fixed-point integer arithmetic on-chain, avoiding floating-point entirely:

// All rates and weights stored as uint16 basis points
// 10000bp = 100% — fits in uint16 (max 65535)

struct CreditTerms {
    uint256 maxPrincipal;          // USDT (6 decimals)
    uint16  aprBps;                // 500 = 5.00% APR
    uint16  collateralBps;         // 5000 = 50% collateral ratio
    uint32  termSeconds;           // credit line duration
    uint32  gracePeriodSeconds;    // late payment grace
}

// KYC seed weights (integer-only multiplication)
uint256[4] constant KYC_MULTIPLIER_BPS = [0, 100, 150, 200];
// BASIC: min(2000 * 100 / 100, 5000) = 2000bp
// ENHANCED: min(2000 * 150 / 100, 5000) = 3000bp
// PREMIUM: min(2000 * 200 / 100, 5000) = 4000bp

// Cascade penalty (integer-only, no floats)
// depth1: score * 7000 / 10000 (= 0.70)
// depth2: score * 4900 / 10000 (= 0.49)
// depth3: score * 3430 / 10000 (= 0.343)

// TA attestation cap (sqrt via Newton's method in Solidity)
function getAttestationCap(uint256 staked) pure returns (uint256) {
    // floor(sqrt(staked / MIN_STAKE_PER_ATTESTATION))
    // Sublinear: doubling stake does NOT double capacity
    return Math.sqrt(staked / MIN_STAKE_PER_ATTESTATION);
}
  

Verified Shyft Mainnet Contracts (Live)

Live topology: 21 registered TAs, ~96,183 total attestations. Power-law distribution (exponent ≈ -1.8). 2 TAs control 85% of all attestations.

SDK & Developer Experience

import { TrustChannelSDK } from '@antilles/x402-sdk';

const sdk = new TrustChannelSDK({ network: 'stable', signer: wallet });

// Deploy a channel from template in 2 minutes
const channel = await sdk.deploy('api-access', {
  price: '0.001',     // USDC per request
  dailyCap: 100,       // max daily spend
  minRMT: 0,           // open access (no reputation gate)
});

console.log(channel.address);     // deployed contract
console.log(channel.x402Header);  // ready to embed in HTTP responses
  

# CLI one-liner
$ npx create-trust-channel api-access --price 0.001 --cap 100

Rule 5 Contracts: The Programmability Layer

"Rule 5" contracts are customizable smart contract logic governing payment splitting, conditional access, and fee structures within a Trust Channel. They are the composability primitive that makes templates extensible.

Fee Architecture

RMT-Based Fee Discounts

High-trust users cost less to serve and pay lower fees — creating a natural flywheel where reputation improvement is economically rational:

Revenue Projections

Five Reinforcing Flywheel Loops

TAM Breakdown