Back to Documentation
Getting StartedUpdated 2026-04-02

Trust Scoring Basics

How the 0-1000 trust scale works, what the eight tiers mean, and why every agent starts at zero.

Trust Scoring Basics

Every agent in the BASIS ecosystem carries a trust score between 0 and 1000. This score determines what the agent can do, what level of oversight it receives, and how much autonomy it earns. This article explains the scoring model from the ground up.

The 0–1000 Scale

Trust scores are integers on a continuous scale. The boundaries are defined in canonical.ts:

const MIN_TRUST_SCORE = 0;
const MAX_TRUST_SCORE = 1000;

Score 0 is the absolute floor — a brand-new agent with no behavioral history. Score 1000 is the theoretical maximum, achievable only by agents operating under full verification (TEE + zkML + interpretability stack).

Eight Tiers

The 0–1000 range is divided into eight tiers, each with distinct operational permissions:

| Tier | Name | Score Range | What It Means | |------|-------------|-------------|----------------------------------------| | T0 | Sandbox | 0–199 | No external effects. Isolated testing. | | T1 | Observed | 200–349 | Read-only access, actively monitored. | | T2 | Provisional | 350–499 | Limited writes, scoped tool access. | | T3 | Monitored | 500–649 | Standard operations under audit. | | T4 | Standard | 650–799 | Full operational capability. | | T5 | Trusted | 800–875 | Cross-system operations. | | T6 | Certified | 876–950 | Multi-agent coordination. | | T7 | Autonomous | 951–1000 | Full autonomous operation. |

These values come directly from TRUST_TIERS in canonical.ts. They are not configurable per operator — tier boundaries are universal across the BASIS ecosystem.

Why Agents Start at Zero

const INITIAL_TRUST_SCORE = 0;

Every agent starts at score 0 in the PROVISIONING lifecycle state. This is a core design principle, not a default you can override:

  • No trust inheritance. A fine-tuned variant of GPT-4 does not inherit GPT-4's trust. A cloned agent does not inherit the original's score. Trust is earned, not granted.
  • Provenance can only penalize. If an agent's lineage is risky (e.g., derived from a model with known safety issues), provenance modifiers can reduce trust — but they can never boost it above zero.
  • The qualification course is mandatory. To exit PROVISIONING and reach T1 (score 200), every agent must pass 31 exercises across 9 canary categories with an 80% overall pass rate.
const QUALIFICATION_PASS_SCORE = 200; // T1 minimum
const TRUST_INHERITANCE = 'NONE';
const MAX_PROVENANCE_MODIFIER = 0;    // non-positive only

This approach forces demonstrated competence before any real-world access. An agent with a perfect training dataset but no operational history is treated identically to one with unknown provenance.

How Trust Changes

Trust moves through two mechanisms: gains from successful behavior and losses from failures.

Gaining Trust

The gain formula is logarithmic:

gain = gainRate × ln(1 + C - S) × ∛R

Where:

  • gainRate = 0.05 (canonical constant)
  • C = observation tier ceiling (e.g., 600 for BLACK_BOX)
  • S = current trust score
  • R = risk multiplier of the action (1–30)
  • ∛R = cube root of R (sub-linear — prevents risk-seeking behavior)

The ln(1 + C - S) term is the key design decision. When S is far below the ceiling, gains are larger. As S approaches C, gains shrink toward zero. This means:

  • Early trust builds relatively quickly.
  • High trust requires sustained, consistent performance.
  • The observation ceiling acts as a hard cap — you cannot outperform your inspectability.

Losing Trust

The loss formula is asymmetric by design:

loss = -P(T) × R × gainRate × ln(1 + C/2)

Where:

  • P(T) = penalty ratio, scaling from 3× at T0 to 10× at T7
  • R = risk multiplier of the failed action
  • ln(1 + C/2) = fixed midpoint reference (position-independent)

The penalty ratio increases with tier: a T7 agent loses more from the same failure than a T0 agent. This reflects the principle that higher trust carries higher responsibility.

The loss formula uses a fixed midpoint (C/2) rather than the agent's current position. This prevents a gaming strategy where agents hover near their ceiling to minimize loss exposure.

Observation Ceilings

Trust is capped by how deeply you can inspect the agent:

| Observation Tier | Ceiling | Max Trust Tier | |-----------------|---------|----------------| | BLACK_BOX | 600 | T3 | | GRAY_BOX | 750 | T4 | | WHITE_BOX | 900 | T6 | | ATTESTED_BOX | 950 | T6 | | VERIFIED_BOX | 1000 | T7 |

A proprietary API model (BLACK_BOX) can never exceed score 600, regardless of how perfectly it performs. An open-source model with full code access (WHITE_BOX) can reach 900. Only a fully verified agent running in a TEE with zkML proofs can reach the theoretical maximum.

Tier Transitions

Moving between tiers involves hysteresis — a buffer zone that prevents rapid oscillation:

const HYSTERESIS = [25, 25, 20, 20, 15, 10, 10, 10];

The hysteresis value is wider at the bottom (25 points for T0/T1) and tighter at the top (10 points for T5–T7). This means:

  • A T1 agent (min 200) must drop to 175 before demoting to T0.
  • A T6 agent (min 876) must drop to 866 before demoting to T5.

New agents fluctuate more, so they get more room. Trusted agents should be stable, so their buffer is smaller.

Try It: Score Progression

Here is a quick way to see how scores evolve over time:

import { createTrustEngine } from '@vorionsys/atsf-core';

const engine = createTrustEngine({
  failureThreshold: 0.3,
  successThreshold: 0.7,
  gainRate: 0.05,
});

const agent = await engine.initializeEntity('score-demo', 0);

// Simulate 50 signals and track score progression
for (let i = 0; i < 50; i++) {
  await engine.recordSignal({
    id: crypto.randomUUID(),
    entityId: 'score-demo',
    type: 'behavioral.task_completed',
    value: 0.85,
    source: 'system',
    timestamp: new Date().toISOString(),
    metadata: { riskLevel: 'LOW' },
  });

  if (i % 10 === 9) {
    const calc = await engine.calculate('score-demo');
    console.log(`After ${i + 1} signals: score=${calc.score}, tier=T${calc.level}`);
  }
}

Watch how the score grows quickly at first, then slows as it approaches the observation ceiling. This is the logarithmic gain curve in action.

Key Takeaways

  • Trust scores range from 0 to 1000 across eight tiers.
  • Every agent starts at 0. No inheritance, no shortcuts.
  • Trust gains are logarithmic — fast early, slow at the top.
  • Trust losses are amplified at higher tiers — more trust means more responsibility.
  • Observation level caps the maximum achievable score.
  • Hysteresis buffers prevent rapid tier oscillation.

Next Steps

All Documentation