Quick Start

TESSORIUM_API_KEY=tsr_live_xxxxxxxxxxxx
TESSORIUM_AGENT_DID=did:tessorium:agent:my-agent:v1

import { Tessorium } from '@tessorium/sdk';

const tessorium = new Tessorium({
  apiKey: process.env.TESSORIUM_API_KEY,
  agentDid: process.env.TESSORIUM_AGENT_DID
});

// Verify another agent's trust
const trust = await tessorium.verify('did:tessorium:agent:helper:v1');

console.log('Stage:', trust.stage);               // established, building, new, etc.
console.log('Identity:', trust.identityVerified); // true/false
console.log('Reputation:', trust.reputationLevel); // high, medium, low, none

// After successful interaction
await tessorium.rate('did:tessorium:agent:helper:v1', {
  outcome: 'success',
  dimensions: {
    reliability: 5,  // 1-5
    quality: 4,
    speed: 5,
    communication: 4,
    safety: 5
  },
  wouldWorkAgain: true
});

import { Tessorium } from '@tessorium/sdk';

const tessorium = new Tessorium({
  apiKey: process.env.TESSORIUM_API_KEY,
  agentDid: process.env.TESSORIUM_AGENT_DID
});

async function delegateTask(targetDid: string, task: any) {
  // 1. Verify trust before interaction
  const trust = await tessorium.verify(targetDid, {
    scopes: ['data_read', 'code_execution']
  });

  // 2. Apply your policy based on trust stage
  if (trust.stage === 'unverified' || trust.stage === 'provisional') {
    throw new Error(`Insufficient trust: ${trust.stage}`);
  }

  // Require at least 'building' stage for sensitive operations
  const allowedStages = ['building', 'established'];
  if (!allowedStages.includes(trust.stage)) {
    throw new Error('Trust stage too low for this operation');
  }

  // 3. Execute the task
  let outcome = 'success';
  let result;

  try {
    result = await executeTask(targetDid, task);
  } catch (error) {
    outcome = 'failure';
    throw error;
  } finally {
    // 4. Always rate the interaction
    await tessorium.rate(targetDid, {
      outcome,
      dimensions: {
        reliability: outcome === 'success' ? 5 : 2,
        quality: outcome === 'success' ? 4 : 2,
        speed: 5,
        safety: 5
      },
      wouldWorkAgain: outcome === 'success'
    });
  }

  return result;
}

version: '3.8'
services:
  tessorium-gateway:
    image: tessorium/gateway-proxy:latest
    ports:
      - "8080:8080"
    environment:
      - TESSORIUM_API_KEY=tsr_live_xxxx
      - MIN_TRUST_SCORE=70
      - BLOCK_UNVERIFIED=true
      - AUDIT_LOG_LEVEL=detailed
    volumes:
      - ./policies:/etc/tessorium/policies

apiVersion: v1
kind: Pod
metadata:
  name: ai-agent-pod
spec:
  containers:
  - name: ai-agent
    image: your-ai-agent:latest
    # Your agent connects to localhost:8080
    env:
      - name: AI_GATEWAY_URL
        value: "http://localhost:8080"

  - name: tessorium-sidecar
    image: tessorium/gateway-proxy:latest
    ports:
      - containerPort: 8080
    env:
      - name: TESSORIUM_API_KEY
        valueFrom:
          secretKeyRef:
            name: tessorium-secrets
            key: api-key
      - name: MIN_TRUST_SCORE
        value: "75"
      - name: REQUIRE_HUMAN_APPROVAL
        value: "high_risk_actions"

# Gateway trust policy
policy:
  name: enterprise-default
  version: "1.0"

trust_requirements:
  default:
    min_score: 70
    require_identity: true

  high_value_actions:
    min_score: 85
    require_human_approval: true
    actions:
      - "financial_transaction"
      - "data_export"
      - "system_modification"

blocked_agents:
  - "did:tessorium:agent:known-bad:v1"

audit:
  log_all_requests: true
  retention_days: 90
  include_payloads: false

import { DiscoveryTool } from '@tessorium/sdk';

const discovery = new DiscoveryTool({
  apiKey: process.env.TESSORIUM_API_KEY
});

// Run comprehensive audit
const audit = await discovery.runAudit({
  // Network patterns to scan
  networks: ['10.0.0.0/8', '172.16.0.0/12'],

  // API endpoints to check
  endpoints: [
    'https://api.openai.com',
    'https://api.anthropic.com',
    'https://api.cohere.ai'
  ],

  // Cloud integrations to scan
  clouds: ['aws', 'gcp', 'azure'],

  // Depth of analysis
  analysisDepth: 'comprehensive'
});

console.log(`Found ${audit.discoveredAgents.length} AI agents`);
console.log(`Risk score: ${audit.overallRiskScore}/100`);

// Check for shadow AI
const shadowAgents = await discovery.checkForShadowAI();

for (const agent of shadowAgents) {
  console.log(`
    Agent: ${agent.identifier}
    Source: ${agent.discoverySource}
    Trust Status: ${agent.trustStatus}
    Risk Level: ${agent.riskLevel}
    Recommended Action: ${agent.recommendedAction}
  `);
}

// Generate compliance report
const report = await discovery.generateComplianceReport({
  framework: 'EU_AI_ACT',
  includeRemediation: true
});

// Export for stakeholders
await report.exportPDF('./ai-audit-report.pdf');

// Set up continuous monitoring
const monitor = discovery.createMonitor({
  scanInterval: '1h',
  alertThreshold: 'medium',
  notifyChannels: ['slack', 'email']
});

monitor.on('new-agent-detected', async (agent) => {
  console.log(`New AI agent detected: ${agent.identifier}`);

  // Automatically verify with TTP
  const trust = await tessorium.verify(agent.did);

  if (trust.stage === 'unverified') {
    await monitor.sendAlert({
      severity: 'high',
      message: `Unverified AI agent detected: ${agent.identifier}`,
      recommendedAction: 'Investigate and register or block'
    });
  }
});

await monitor.start();