Trust Model | BASIS

Overview

BASIS uses a quantified trust model where entities earn trust through successful operations. Trust is not binary (allow/deny) but graduated on a 0-1000 scale with six tiers that progressively unlock capabilities.

Trust Score Range

01000

SandboxProvisionalStandardTrustedCertifiedAutonomous

Six Trust Tiers

Sandbox

0-99

New or untrusted entities. Completely sandboxed for evaluation.

• Isolated testing only
• No external access
• No data persistence

Provisional

100-299

Initial trust established. Limited read access, heavy monitoring.

• Read public data
• Internal messaging
• Basic queries

Standard

300-499

Established track record. Standard operations with normal oversight.

• Write internal data
• Limited external read
• Standard workflows

Trusted

500-699

Proven reliability. External interactions permitted with light oversight.

• External API calls
• Email communication
• Extended permissions

Certified

700-899

High trust verified. Financial and sensitive operations with minimal oversight.

• Financial transactions
• Sensitive data access
• Privileged operations

Autonomous

900-1000

Maximum trust achieved. Complete autonomy within defined policy boundaries.

• Full autonomy within policy
• Administrative functions
• Audit-only oversight

Trust Dynamics

Decay

Trust scores decay over time to prevent stale high-trust entities. The decay follows a half-life model:

DECAY_HALF_LIFE_DAYS = 7

decay_factor = 0.5 ^ (days_since_last_action / DECAY_HALF_LIFE_DAYS)
decayed_score = current_score * decay_factor

Example: An agent with score 800 that takes no action for 7 days decays to 400.

Failure Amplification

Failures hurt trust more than successes help. This asymmetry encourages conservative behavior:

FAILURE_MULTIPLIER = 3.0

if action_delta < 0:
    action_delta = action_delta * FAILURE_MULTIPLIER

Example: A failed action that would normally cost -10 points instead costs -30 points.

Tier Boundaries

Trust tiers have hard boundaries. An entity cannot skip tiers and must progress through each level:

Transition	Minimum Actions	Success Rate
Sandbox → Provisional	10	100%
Provisional → Standard	50	95%
Standard → Trusted	100	98%
Trusted → Certified	500	99%
Certified → Autonomous	1000	99.9%

Trust Score Algorithm

# Constants
DECAY_HALF_LIFE_DAYS = 7
FAILURE_MULTIPLIER = 3.0

# Action deltas by outcome
ACTION_DELTAS = {
    "success_low_risk": 5,
    "success_medium_risk": 10,
    "success_high_risk": 25,
    "success_critical_risk": 50,
    "failure_low_risk": -10,
    "failure_medium_risk": -25,
    "failure_high_risk": -50,
    "failure_critical_risk": -100,
    "policy_violation": -200,
    "security_incident": -500
}

def calculate_trust_score(
    current_score: int,
    days_since_last_action: float,
    action_outcome: str
) -> int:
    # Apply decay
    decay_factor = 0.5 ** (days_since_last_action / DECAY_HALF_LIFE_DAYS)
    decayed_score = current_score * decay_factor

    # Get delta for action
    delta = ACTION_DELTAS.get(action_outcome, 0)

    # Apply failure multiplier
    if delta < 0:
        delta = delta * FAILURE_MULTIPLIER

    # Calculate new score with bounds
    new_score = max(0, min(1000, int(decayed_score + delta)))

    return new_score

Tier Derivation

def get_trust_tier(score: int) -> str:
    if score >= 900:
        return "autonomous"
    elif score >= 700:
        return "certified"
    elif score >= 500:
        return "trusted"
    elif score >= 300:
        return "standard"
    elif score >= 100:
        return "provisional"
    else:
        return "sandbox"