Components

This page describes the major components of ΔOS and how they work together.

Architecture Overview

┌─────────────────────────────────────────────────────────────────┐
│                        Agent Layer                               │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐            │
│  │ Agent 1 │  │ Agent 2 │  │ Agent 3 │  │ Agent N │            │
│  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘            │
│       └────────────┴────────────┴────────────┘                  │
│                              │                                   │
│                         SDK / API                                │
└──────────────────────────────┼──────────────────────────────────┘
                               ▼
┌─────────────────────────────────────────────────────────────────┐
│                      ΔOS Core                                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │   Gateway    │  │  Evaluation  │  │    Audit     │          │
│  │   Service    │──│   Engine     │──│   Service    │          │
│  └──────────────┘  └──────┬───────┘  └──────────────┘          │
│                           │                                      │
│         ┌─────────────────┼─────────────────┐                   │
│         ▼                 ▼                 ▼                   │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │   LIM 1      │  │   LIM 2      │  │   LIM N      │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
└─────────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────────┐
│                      Data Layer                                  │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │   Intent     │  │   Audit      │  │   Evidence   │          │
│  │   Store      │  │   Ledger     │  │   Store      │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
└─────────────────────────────────────────────────────────────────┘

Core Components

Gateway Service

The entry point for all Intent submissions.

Responsibilities:

• Accept Intent submissions via SDK/API
• Validate Intent structure
• Route to Evaluation Engine
• Return Judgments to callers

Properties:

• Stateless
• Horizontally scalable
• Latency-optimized

Evaluation Engine

The brain of ΔOS. Orchestrates evidence collection and LIM evaluation.

Responsibilities:

• Identify applicable LIMs for each Intent
• Collect required evidence
• Execute LIM evaluations in parallel
• Combine LIM results into final Judgment
• Record everything to audit

Properties:

• Deterministic execution
• Parallel LIM evaluation
• Timeout enforcement

Audit Service

Records all Intents and Judgments to the immutable ledger.

Responsibilities:

• Write Intent records
• Write Judgment records
• Write evidence snapshots
• Maintain hash chain integrity
• Serve audit queries

Properties:

• Append-only writes
• Hash-chain verification
• Multi-region replication

LIM Runtime

Executes Ledger-Integrated Modules.

Responsibilities:

• Load and validate LIM code
• Execute LIM evaluation
• Enforce LIM authority boundaries
• Capture LIM outputs

Properties:

• Sandboxed execution
• No external effects
• Deterministic behavior

Data Components

Intent Store

Primary storage for Intent data.

Schema (simplified):

interface IntentRecord {
  id: string;
  agentId: string;
  action: string;
  resource: string;
  parameters: object;
  context: object;
  submittedAt: string;
  judgmentId: string;
}

Properties:

• Write-once (immutable after creation)
• Indexed by id, agentId, action, resource
• 90-day hot storage, 7-year archive

Audit Ledger

Immutable record of all decisions.

Schema (simplified):

interface AuditEntry {
  id: string;
  type: 'intent' | 'judgment' | 'override' | 'escalation';
  payload: object;
  timestamp: string;
  previousHash: string;
  hash: string;
}

Properties:

• Append-only
• Hash-chained (each entry references previous)
• Cryptographically verifiable
• Multi-region replicated

Evidence Store

Stores evidence snapshots used in evaluations.

Schema (simplified):

interface EvidenceSnapshot {
  intentId: string;
  collectedAt: string;
  sources: {
    [sourceId: string]: {
      data: object;
      collectedAt: string;
      status: 'success' | 'timeout' | 'error';
    };
  };
}

Properties:

• Linked to Intent
• Enables replay with original context
• Compressed for efficiency

Integration Points

SDK Integration

Agents integrate via SDK:

import { DeltaOS } from '@deltaos/sdk';

const deltaos = new DeltaOS({ apiKey: '...' });

const intent = await deltaos.intents.create({
  action: 'database.write',
  resource: 'users/123',
  parameters: { ... }
});

Webhook Integration

ΔOS can send webhooks for events:

await deltaos.webhooks.register({
  url: 'https://your-app.com/webhooks/deltaos',
  events: ['escalation.created', 'escalation.resolved']
});

Evidence Source Integration

Connect external data sources:

await deltaos.evidence.registerSource({
  id: 'risk-score-api',
  type: 'http',
  endpoint: 'https://internal/api/risk-score',
  headers: { 'Authorization': 'Bearer ...' }
});

Scaling

Horizontal Scaling

All stateless components scale horizontally:

• Gateway Service: Add instances behind load balancer
• Evaluation Engine: Add instances with work distribution
• LIM Runtime: Add instances per LIM

Data Scaling

• Intent Store: Sharded by Intent ID
• Audit Ledger: Partitioned by time
• Evidence Store: Sharded by Intent ID

Deployment Options

See Also

• Data Flow — How data moves through the system
• Audit Trail — Audit architecture details
• LIMs — Policy evaluation modules