Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.continum.co/llms.txt

Use this file to discover all available pages before exploring further.

​
System Overview

Continum uses a distributed architecture to achieve zero-latency compliance monitoring. The system is designed around the principle of “sovereignty-first” - your API keys stay on your server, and compliance runs asynchronously. 
Your Application (SDK)
      │
      ├─→ [Direct] → OpenAI/Claude/Gemini → Response (instant) ⚡
      │
      └─→ [Async] → Continum Platform
                        ↓
                    Compliance Monitoring
                        ↓
                    Evidence & Signals
                        ↓
                    Dashboard

​
How It Works

​
1. SDK Integration

The Continum SDK integrates into your application and manages:
  1. Direct LLM Calls: Your application calls LLM providers directly using your API keys
  2. Guardian Protection: Optional pre-LLM detection and redaction (< 100ms)
  3. Async Monitoring: Sends interaction details to Continum for compliance checking (non-blocking)
Key insight: The SDK never waits for compliance results before returning the LLM response to your users.

​
2. Continum Platform

The Continum Platform provides:
  • Account and API key management
  • Monitoring configuration (sandboxes)
  • Compliance signal storage
  • Evidence generation
  • Dashboard access

​
3. Compliance Monitoring

Your interactions are monitored for compliance:
  • Analyzes prompts and responses for violations
  • Applies your configured monitoring rules
  • Generates risk assessments and violation reports
  • Creates cryptographically-signed evidence records
Privacy: Each monitoring check runs in isolation with no data retention beyond compliance signals.

​
4. Dashboard & Evidence

Access your compliance data:
  • Real-time signal viewing
  • Risk level breakdown
  • Incident management
  • Evidence package generation
  • Regulatory attestations

​
Data Flow

​
1. LLM Call with Monitoring

import { protect } from '@continum/sdk';
import OpenAI from 'openai';

const openai = new OpenAI();

const response = await protect(
  () => openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: 'Hello' }]
  }),
  {
    apiKey: process.env.CONTINUM_API_KEY!
  },
  {
    preset: 'customer-support'
  }
);
What happens:
  1. SDK calls OpenAI directly → response in ~500ms
  2. SDK returns response to your app immediately
  3. SDK sends interaction to Continum for monitoring (non-blocking)

​
2. Compliance Monitoring

Your interaction is monitored asynchronously:
  1. Continum receives interaction details
  2. Applies your monitoring configuration
  3. Analyzes for compliance violations
  4. Generates risk assessment
  5. Creates compliance signal

​
3. Evidence Creation

Compliance signals become evidence:
  1. Signal cryptographically signed
  2. Linked to previous signals (hash chain)
  3. Mapped to regulatory requirements
  4. Available in dashboard
  5. Included in evidence packages

​
4. Access & Reporting

View and use your compliance evidence:
  • Dashboard: Real-time signal viewing
  • API: Programmatic access
  • Evidence Packages: Audit-ready reports
  • Auditor Access: External auditor tokens

​
Security & Privacy

​
Your Data Sovereignty

  • Your API Keys: Never leave your server - stored only in your environment
  • Direct LLM Calls: Your application calls LLM providers directly
  • Monitoring Data: Only interaction details sent to Continum for compliance checking
  • No Data Storage: Continum stores only compliance signals, not your full data

​
Compliance Evidence Security

  • Cryptographic Integrity: Every signal linked in tamper-proof hash chain
  • Encrypted Storage: Military-grade encryption for all compliance data
  • Access Controls: Role-based access with audit logging
  • Auditor Tokens: Time-limited, permission-scoped external access

​
Regulatory Compliance

Continum itself adheres to:
  • SOC 2 Type II compliance
  • GDPR data protection requirements
  • CCPA privacy standards
  • Industry-standard encryption (AES-256)

​
Performance

​
User Experience

  • User Latency: 0ms added (direct LLM call)
  • Guardian: < 100ms for pre-LLM detection
  • Monitoring: 2-5 seconds (async, user doesn’t wait)
  • Dashboard: < 100ms query response

​
Scalability

  • SDK: Runs on your servers (scales with your app)
  • Platform: Auto-scales based on traffic
  • Monitoring: Processes thousands of checks concurrently
  • Dashboard: Optimized for fast queries

​
Integration

​
SDK Setup

Install the SDK in your application: 
npm install @continum/sdk
Configure with your API key: 
import { continum } from '@continum/sdk';

continum.configure({
  apiKey: process.env.CONTINUM_API_KEY!,
  preset: 'customer-support'
});

​
Environment Variables

Your Application: 
CONTINUM_API_KEY=ctn_live_xxx
OPENAI_API_KEY=sk-xxx
ANTHROPIC_API_KEY=sk-ant-xxx
GOOGLE_API_KEY=xxx

​
Next Steps

Zero Latency

Learn how zero-latency monitoring works

Presets

Understand automatic detection configuration

Evidence

Transform monitoring into audit-ready evidence

Alerts

Configure real-time notifications

Signal

Understand monitoring results

Incidents

Track and resolve compliance incidents