VOIDINIUM Technical Documentation

Private Agents

Each agent is an autonomous computational unit that processes data within privacy boundaries. Agents can be:

• Data Processors - Transform encrypted inputs
• Verifiers - Validate computation correctness
• Orchestrators - Coordinate multi-agent workflows
• Attesters - Generate cryptographic proofs

Swarm Intelligence

Agents collaborate through a coordination layer that enables:

• Task Decomposition - Break complex problems into private subtasks
• Parallel Execution - Run agents concurrently without data leaks
• Result Composition - Aggregate outputs while preserving privacy
• Adaptive Workflows - Dynamic agent routing based on trust requirements

Zero-Knowledge Orchestration

The orchestration layer coordinates agents without seeing their data:

• Workflow Definitions - Declare agent pipelines and policies
• Privacy Policies - Specify what can be revealed at each stage
• Proof Verification - Validate execution without inspecting data
• Audit Trails - Immutable logs of computation proofs

Workflow Definition

Workflows are declarative descriptions of agent pipelines:

workflow = Workflow(
  name="private_data_pipeline",
  privacy_policy=Policy.MINIMAL_DISCLOSURE,
  agents=[
    Agent(role="extractor", runtime="TEE"),
    Agent(role="analyzer", runtime="ZK"),
    Agent(role="aggregator", runtime="HYBRID")
  ],
  verification=VerificationSchema.FULL_ZK
)

Task Routing

The orchestrator routes tasks based on:

• Privacy Requirements - Match agents to data sensitivity levels
• Trust Models - Select TEE vs ZK based on threat model
• Performance Constraints - Balance latency vs security guarantees
• Compliance Rules - Enforce regulatory requirements per-task

Proof Composition

Multi-stage workflows produce composite proofs:

• Per-Agent Proofs - Each agent generates proof of correct execution
• Chained Verification - Downstream agents verify upstream proofs
• Aggregated Proofs - Final proof covers entire workflow
• Audit Trails - Immutable proof chain for compliance

Data-in-Use Protection

VOIDINIUM protects data during computation:

• Encrypted Execution - Data remains encrypted during processing
• Memory Isolation - TEE prevents memory inspection
• Zero-Knowledge Proofs - Prove correctness without revealing inputs
• Minimal Disclosure - Only approved outputs are released

Threat Model

VOIDINIUM defends against:

• Honest-but-Curious Parties - Participants who follow protocol but try to learn extra information
• Malicious Agents - Compromised or adversarial computation nodes
• Infrastructure Operators - Cloud providers, sysadmins with physical access
• Side-Channel Attacks - Timing, power analysis, speculative execution

Trusted Execution Environments (TEE)

Hardware-backed secure enclaves provide:

• Code Attestation - Cryptographic proof of running code
• Memory Encryption - Hardware-level data protection
• Sealed Storage - Encrypted persistence tied to enclave identity
• Remote Attestation - Verify enclave authenticity before sending data

Supported TEE platforms: Intel SGX, AMD SEV, ARM TrustZone

Zero-Knowledge Proofs (ZKP)

Cryptographic proofs enable verification without data:

• zk-SNARKs - Succinct non-interactive proofs for complex computations
• zk-STARKs - Transparent proofs without trusted setup
• Bulletproofs - Range proofs for financial applications
• Recursive Proofs - Compose proofs from multi-stage workflows

privacy_policy = {
  "data_classification": "CONFIDENTIAL",
  "allowed_outputs": ["aggregate_statistics", "boolean_result"],
  "forbidden_outputs": ["raw_data", "individual_records"],
  "audit_level": "FULL_PROOF_CHAIN",
  "retention": "ZERO_PERSISTENCE"
}

Untrusted Zone

Components that require zero trust:

• Infrastructure Providers - Cloud platforms, hosting providers
• Network Layer - All network traffic is encrypted and authenticated
• Storage Systems - Data encrypted at rest, keys sealed in TEE
• Operating System - Compromised OS cannot access TEE/enclave data

Trusted Computing Base (TCB)

Minimal components that must be trusted:

• TEE Hardware - CPU security extensions (Intel SGX, AMD SEV)
• ZK Circuits - Audited cryptographic circuits and proving systems
• Agent Code - Application logic running inside secure enclaves
• Orchestration Logic - Workflow coordination and proof verification

Verification Zone

Public verification without trust:

• Proof Validators - Anyone can verify ZK proofs independently
• Attestation Checkers - Verify TEE remote attestations
• Audit Logs - Publicly verifiable computation logs
• Compliance Reports - Generate regulatory reports from proofs

Intel SGX (Software Guard Extensions)

• Enclave Size - Up to 256GB encrypted memory
• Attestation - Intel Attestation Service (IAS) or DCAP
• Performance - Near-native speed for most workloads
• Availability - 3rd gen Xeon Scalable processors and newer

AMD SEV (Secure Encrypted Virtualization)

• VM-level Protection - Entire virtual machine memory encrypted
• Attestation - AMD Secure Processor attestation
• Performance - ~5% overhead on encrypted memory access
• Availability - EPYC 7003 series and newer

ARM TrustZone

• Secure World - Isolated execution environment on ARM processors
• Attestation - Platform-specific attestation mechanisms
• Use Case - Edge devices, IoT deployments
• Availability - Most ARM Cortex-A processors

tee_config = {
  "platform": "SGX",
  "attestation_service": "DCAP",
  "enclave_size": "64GB",
  "sealing_policy": "MRSIGNER",
  "quote_verification": "STRICT"
}

zk-SNARKs (Succinct Non-Interactive Arguments of Knowledge)

• Proof Size - Constant ~200 bytes regardless of computation size
• Verification Time - Milliseconds, suitable for on-chain verification
• Trusted Setup - Requires ceremony (Powers of Tau, circuit-specific)
• Proving Time - Minutes to hours for complex computations
• Implementations - Groth16, Plonk, Marlin

zk-STARKs (Scalable Transparent Arguments of Knowledge)

• Proof Size - 10-100KB, grows logarithmically with computation
• Verification Time - Milliseconds to seconds
• Trusted Setup - None required (transparent)
• Proving Time - Faster than SNARKs for very large computations
• Post-Quantum Secure - Resistant to quantum attacks

Bulletproofs

• Proof Size - Logarithmic in computation size
• Verification Time - Linear in proof size
• Trusted Setup - None required
• Use Case - Range proofs, confidential transactions
• Performance - Fast proving for specific primitives

zk_config = {
  "proving_system": "PLONK",
  "curve": "BN254",
  "circuit_type": "R1CS",
  "optimization": "HIGH",
  "proof_aggregation": true,
  "recursive_composition": true
}

Private Input Commitments

Commit to inputs without revealing them:

commitment = hash(private_input, randomness)
prove: "I know input such that hash(input, r) = commitment"

Range Proofs

Prove a value is within a range without revealing it:

prove: "I know value V such that 0 ≤ V ≤ 1000000"

Membership Proofs

Prove inclusion in a set without revealing which element:

prove: "I know element E such that E ∈ authorized_set"

┌─────────────────────────────────────┐
│         Hybrid Agent                │
│  ┌───────────────────────────────┐  │
│  │   TEE Enclave                 │  │
│  │  ┌─────────────────────────┐  │  │
│  │  │  Agent Computation      │  │  │
│  │  │  (Fast Execution)       │  │  │
│  │  └──────────┬──────────────┘  │  │
│  │             │ Execution Trace │  │
│  │  ┌──────────▼──────────────┐  │  │
│  │  │  Trace Logger           │  │  │
│  │  └──────────┬──────────────┘  │  │
│  └─────────────┼──────────────────┘  │
│                │ Trace Export        │
│     ┌──────────▼──────────────┐     │
│     │  ZK Prover              │     │
│     │  (Generate Proof)       │     │
│     └──────────┬──────────────┘     │
│                │ ZK Proof            │
└────────────────┼─────────────────────┘
                 │
                 ▼
         ┌──────────────┐
         │  Verifier    │
         │  - Check TEE │
         │  - Check ZK  │
         └──────────────┘

hybrid_config = {
  "execution_mode": "TEE",
  "verification_mode": "ZK",
  "tee_platform": "SGX",
  "zk_system": "PLONK",
  "trace_granularity": "FULL",
  "proof_frequency": "PER_WORKFLOW",
  "fallback_on_tee_failure": true
}

Financial Data Processing

Problem: Process millions of transactions per day with privacy and auditability.

Solution: Hybrid mode allows:

• Fast batch processing in TEE (high throughput)
• ZK proofs for regulatory audits (verifiable compliance)
• Detect TEE compromises via proof validation
• Public verification by external auditors

Defense in Depth

Hybrid mode provides multiple security layers:

• TEE Protection - Prevents most attacks at execution time
• ZK Verification - Detects TEE compromises after execution
• Attestation Binding - ZK proof includes TEE identity hash
• Tamper Detection - Invalid proofs reveal computation tampering

Trust Model Comparison

Property	TEE Only	ZK Only	Hybrid
Execution Speed	🟢 Fast	🔴 Slow	🟢 Fast
Hardware Trust	🔴 Required	🟢 None	🟡 Minimal
Public Verification	🔴 No	🟢 Yes	🟢 Yes
Side-Channel Resistance	🔴 Vulnerable	🟢 Resistant	🟢 Resistant*
Cost	🟢 Low	🔴 High	🟡 Medium

*Side-channel attacks detected via proof validation

Use Case: External Service Integration

Integrate VOIDINIUM as a privacy-preserving API service.

┌──────────────┐      HTTPS      ┌──────────────────┐
│  Client App  │ ───────────────►│ VOIDINIUM API    │
│              │◄─────────────── │ Gateway          │
└──────────────┘    Encrypted    │  ┌────────────┐  │
                    Response      │  │ TEE/ZK     │  │
                                  │  │ Agents     │  │
                                  │  └────────────┘  │
                                  └──────────────────┘

Implementation:

from voidinium import VoidiniumGateway, Agent

gateway = VoidiniumGateway(
    runtime="HYBRID",
    attestation_required=True
)

@gateway.private_endpoint("/analyze")
def analyze_data(encrypted_input):
    agent = Agent(role="analyzer")
    result = agent.run(encrypted_input)
    return result.with_proof()

gateway.serve(host="0.0.0.0", port=8443, tls=True)

Use Case: Async Data Processing Pipelines

Process sensitive data streams with privacy guarantees.

┌──────────────┐      Events      ┌──────────────────┐
│ Data Sources │ ───────────────►│ Message Queue    │
└──────────────┘                 └────────┬─────────┘
                                          │
                             ┌────────────▼─────────────┐
                             │ VOIDINIUM Orchestrator   │
                             │  ┌────────────────────┐  │
                             │  │ Agent Pool         │  │
                             │  │  - Transform       │  │
                             │  │  - Analyze         │  │
                             │  │  - Aggregate       │  │
                             │  └────────────────────┘  │
                             └────────────┬─────────────┘
                                          │ Results + Proofs
                             ┌────────────▼─────────────┐
                             │ Verification Service     │
                             └──────────────────────────┘

Implementation:

from voidinium import Workflow, Agent

workflow = Workflow("privacy_pipeline")
workflow.add_agent(Agent(role="extractor", runtime="TEE"))
workflow.add_agent(Agent(role="analyzer", runtime="ZK"))
workflow.add_agent(Agent(role="aggregator", runtime="HYBRID"))

workflow.connect_to_stream(
    source="kafka://data-stream",
    privacy_policy=Policy.STRICT
)

workflow.on_event(lambda event: 
    workflow.process(event.data)
)

workflow.deploy()

Use Case: Collaborative Analysis Without Data Sharing

Multiple parties jointly compute on private data.

┌──────────────┐                     ┌──────────────┐
│  Party A     │                     │  Party B     │
│  Private DB  │                     │  Private DB  │
└──────┬───────┘                     └──────┬───────┘
       │ Encrypted Input                    │ Encrypted Input
       │                                    │
       └────────────┬───────────────────────┘
                    │
          ┌─────────▼──────────┐
          │ VOIDINIUM MPC      │
          │ Orchestrator       │
          │  ┌──────────────┐  │
          │  │ Joint Agents │  │
          │  │ (TEE + ZK)   │  │
          │  └──────────────┘  │
          └─────────┬──────────┘
                    │ Aggregate Result + Proof
          ┌─────────▼──────────┐
          │ Public Verifier    │
          └────────────────────┘

Implementation:

from voidinium import MultiPartyWorkflow, Party

workflow = MultiPartyWorkflow("joint_analysis")

# Each party adds their data source
party_a = Party("A", data_source="postgres://db-a")
party_b = Party("B", data_source="postgres://db-b")

workflow.add_parties([party_a, party_b])

# Define joint computation
workflow.define_computation("""
  aggregate_sum = sum(party_a.values, party_b.values)
  prove: aggregate_sum computed correctly
  reveal: only aggregate_sum
  hide: individual party values
""")

result = workflow.execute()
print(f"Result: {result.value}")
print(f"Proof valid: {result.verify_proof()}")

Use Case: On-Chain Verification of Off-Chain Computation

Execute complex computation off-chain, verify on-chain.

┌──────────────────┐
│ VOIDINIUM Agents │
│ (Off-Chain)      │
│  - Heavy Compute │
│  - Private Data  │
└────────┬─────────┘
         │ ZK Proof
         │
┌────────▼─────────┐
│ Solana Smart     │
│ Contract         │
│  - Verify Proof  │
│  - Update State  │
└──────────────────┘

Implementation:

from voidinium import Agent, SolanaIntegration

agent = Agent(
    role="off_chain_compute",
    runtime="ZK",
    proving_system="GROTH16"
)

result = agent.run(large_dataset)

# Submit proof to Solana
solana = SolanaIntegration(
    network="mainnet",
    program_id="VOIDINIUM_PROGRAM_ID"
)

tx = solana.submit_proof(
    proof=result.proof,
    public_inputs=result.public_outputs
)

print(f"Proof verified on-chain: {tx.confirmed}")

Python SDK

pip install voidinium

from voidinium import Agent, Workflow, Runtime

# Single agent
agent = Agent(name="analyzer", runtime=Runtime.TEE)
result = agent.process(sensitive_data)

# Multi-agent workflow
workflow = Workflow("data_pipeline")
workflow.add_agents([
    Agent("extractor"),
    Agent("transformer"),
    Agent("loader")
])
workflow.execute()

TypeScript/JavaScript SDK

npm install @voidinium/sdk

import { Agent, Workflow, Runtime } from '@voidinium/sdk';

const agent = new Agent({
  name: 'analyzer',
  runtime: Runtime.ZK
});

const result = await agent.process(sensitiveData);
console.log('Proof:', result.proof);

Rust SDK

cargo add voidinium

use voidinium::{Agent, Workflow, Runtime};

let agent = Agent::new("analyzer", Runtime::Hybrid);
let result = agent.process(sensitive_data)?;
assert!(result.verify_proof());

Anti-Money Laundering (AML) Across Banks

Challenge: Banks need to detect suspicious patterns across institutions without sharing customer data.

VOIDINIUM Solution:

• Each bank runs TEE agents on their private transaction database
• Agents compute local risk scores without exposing transactions
• ZK proofs verify correct risk computation
• Orchestrator aggregates scores to detect cross-bank patterns
• Only alerts (not raw data) are shared with regulators

Privacy Guarantees: Individual transactions never leave bank premises. Only aggregate risk signals and ZK proofs are exchanged.

Confidential Trading Strategies

Challenge: Execute algorithmic trading without revealing strategy to exchange or competitors.

VOIDINIUM Solution:

• Trading algorithm runs in TEE enclave
• Market data is encrypted before entering enclave
• ZK proofs demonstrate compliance with exchange rules
• Only trade orders (not strategy logic) are revealed

Privacy Guarantees: Proprietary alpha remains confidential while proving regulatory compliance.

Multi-Institutional Medical Research

Challenge: Analyze patient data across hospitals without violating HIPAA or patient privacy.

VOIDINIUM Solution:

• Each hospital deploys TEE agents with local patient data
• Agents compute statistics on encrypted records
• ZK proofs verify data meets inclusion criteria without revealing records
• Orchestrator aggregates statistics into research insights
• Audit trail proves HIPAA compliance to regulators

Privacy Guarantees: Patient PII never leaves hospital. Researchers only see aggregate statistics with ZK proofs of correctness.

AI-Powered Diagnosis Without Data Leaks

Challenge: Use AI models on patient data without exposing sensitive medical information to model provider.

VOIDINIUM Solution:

• AI model runs in TEE at hospital
• Patient data never sent to external parties
• ZK proof demonstrates model was used correctly
• Model provider can verify usage without seeing patient data

Privacy Guarantees: Patient confidentiality maintained while enabling advanced AI diagnostics.

Cross-Agency Intelligence Sharing

Challenge: Intelligence agencies need to correlate signals without exposing sources and methods.

VOIDINIUM Solution:

• Each agency runs agents on classified data
• Agents detect patterns without revealing raw intelligence
• ZK proofs allow verification by oversight bodies
• Only high-level alerts are shared between agencies

Privacy Guarantees: Classified data remains compartmentalized while enabling cross-agency correlation.

Private DeFi with Public Verification

Challenge: Execute complex DeFi strategies on Solana without revealing positions to MEV bots.

VOIDINIUM Solution:

• Trading logic executes in TEE off-chain
• ZK proof generated for transaction validity
• Proof submitted to Solana for on-chain verification
• State update occurs only after proof validation
• MEV protection: no transaction details leaked before execution

Privacy Guarantees: Trading strategy and positions remain private while settlement is publicly verifiable.

Confidential DAO Voting

Challenge: Enable private DAO votes while proving fair vote counting.

VOIDINIUM Solution:

• Voters submit encrypted ballots
• TEE agent tallies votes without seeing individual choices
• ZK proof demonstrates correct vote counting
• Only final tally (not individual votes) revealed
• Proof posted on-chain for public verification

Privacy Guarantees: Vote secrecy maintained with cryptographic proof of honest tallying.

Supply Chain Verification Without Data Sharing

Challenge: Verify supply chain compliance across vendors without exposing proprietary processes.

VOIDINIUM Solution:

• Each vendor runs agent on internal supply chain data
• Agents generate ZK proofs of compliance (labor standards, environmental, etc.)
• Orchestrator verifies proofs without seeing vendor data
• Compliance report generated for customers/regulators

Privacy Guarantees: Trade secrets protected while demonstrating supply chain integrity.

Confidential Market Research

Challenge: Aggregate customer insights across competitors without revealing individual customer data.

VOIDINIUM Solution:

• Companies contribute encrypted customer analytics
• Multi-party workflow computes industry trends
• ZK proofs ensure no individual data leaked
• Only aggregate market insights revealed

Privacy Guarantees: Competitive intelligence and customer privacy both maintained.

Managed VOIDINIUM Service

Fully managed deployment with minimal operational overhead.

• Platforms: AWS Nitro Enclaves, Azure Confidential Computing, GCP Confidential VMs
• Auto-scaling: Agent pools scale based on workload
• High Availability: Multi-region deployment with failover
• Monitoring: Built-in observability (proof metrics, attestation status)

Setup:

voidinium cloud deploy \
  --platform aws \
  --region us-east-1 \
  --runtime hybrid \
  --agents 10 \
  --auto-scale enabled

Kubernetes Deployment

Deploy on existing Kubernetes infrastructure with TEE support.

apiVersion: v1
kind: Deployment
metadata:
  name: voidinium-orchestrator
spec:
  replicas: 3
  template:
    spec:
      nodeSelector:
        sgx.intel.com/enabled: "true"
      containers:
      - name: orchestrator
        image: voidinium/orchestrator:latest
        resources:
          limits:
            sgx.intel.com/epc: "10Mi"
        env:
        - name: RUNTIME_MODE
          value: "HYBRID"
        - name: ZK_PROVING_SYSTEM
          value: "PLONK"

Self-Hosted Infrastructure

Full control for regulated industries and sensitive workloads.

• Hardware Requirements: Intel Xeon with SGX or AMD EPYC with SEV
• Network Isolation: Deploy in air-gapped networks
• Custom Policies: Fine-grained privacy policy configuration
• Audit Integration: Export proof chains to internal audit systems

Installation:

# Install VOIDINIUM orchestrator
curl -fsSL https://install.voidinium.io | bash

# Configure on-premise deployment
voidinium init \
  --deployment on-premise \
  --attestation-service self-hosted \
  --storage local \
  --audit-export /var/log/voidinium/audits

# Start services
voidinium start --runtime hybrid

Multi-Environment Architecture

Combine on-premise and cloud for optimal balance of control and scalability.

┌────────────────────────────────────┐
│  On-Premise (Sensitive Data)       │
│  ┌──────────────────────────────┐  │
│  │ TEE Agents (Data Processing) │  │
│  │ - Customer DB                │  │
│  │ - Private Compute            │  │
│  └────────────┬─────────────────┘  │
└───────────────┼────────────────────┘
                │ Encrypted Results + Proofs
┌───────────────▼────────────────────┐
│  Cloud (Orchestration & Scale)     │
│  ┌──────────────────────────────┐  │
│  │ Orchestrator                 │  │
│  │ ZK Proof Aggregation         │  │
│  │ Public Verification Service  │  │
│  └──────────────────────────────┘  │
└────────────────────────────────────┘

Use Case: Keep sensitive data on-premise while leveraging cloud for proof verification and orchestration.

IoT and Edge Computing

Deploy lightweight agents on edge devices with ARM TrustZone.

• Devices: Raspberry Pi 4+, NVIDIA Jetson, ARM-based servers
• Bandwidth Optimization: Local computation, minimal data transfer
• Proof Aggregation: Batch proofs from multiple edge devices
• Offline Support: Generate proofs locally, sync when connected

GDPR (General Data Protection Regulation)

VOIDINIUM enables GDPR compliance through technical enforcement:

• Data Minimization (Art. 5): Privacy policies enforce minimal data disclosure
• Purpose Limitation (Art. 5): Workflow definitions specify allowed data uses
• Right to Erasure (Art. 17): Zero-persistence mode leaves no data traces
• Data Protection by Design (Art. 25): ZK/TEE ensures protection at architectural level
• Accountability (Art. 5): Immutable audit trails prove compliance

HIPAA (Health Insurance Portability and Accountability Act)

Healthcare deployments leverage VOIDINIUM for HIPAA compliance:

• Privacy Rule: PHI remains encrypted in TEE, never in cleartext
• Security Rule: Technical safeguards via hardware security (TEE/ZK)
• Breach Notification: Cryptographic proofs detect unauthorized access
• Business Associate Agreements: ZK proofs eliminate need for data sharing
• Audit Controls: Immutable logs of all data access and computation

SOC 2 Type II

Enterprise deployments can achieve SOC 2 compliance:

• Security: TEE/ZK provide technical security controls
• Availability: High-availability orchestrator with failover
• Processing Integrity: ZK proofs guarantee correct computation
• Confidentiality: Hardware-enforced data isolation
• Privacy: Minimal disclosure policies and audit trails

Proof Chain Export

Generate audit reports from immutable proof chains:

audit_report = voidinium.export_audit(
  workflow_id="privacy_pipeline_v1",
  time_range="2025-01-01:2025-12-31",
  format="PDF",
  include_proofs=True,
  verification_instructions=True
)

# Report contains:
# - All workflow executions
# - ZK proofs for each execution
# - Attestation quotes from TEE agents
# - Privacy policy compliance evidence
# - Independent verification instructions

Independent Verification

Auditors can verify proofs without accessing VOIDINIUM infrastructure:

# Auditor downloads proof chain
proofs = download_proof_chain(workflow_id)

# Verify each proof independently
for proof in proofs:
    assert verify_zk_proof(proof.zk_proof)
    assert verify_tee_attestation(proof.attestation)
    assert check_policy_compliance(proof.policy)
    
print("All proofs valid ✓")
print("Privacy policy enforced ✓")
print("Computation correctness proven ✓")

Policy Definition Language

Declarative privacy policies enforced at runtime:

privacy_policy = {
  "data_classification": "HIGHLY_SENSITIVE",
  "processing_purpose": "fraud_detection",
  "allowed_operations": [
    "aggregate_statistics",
    "anomaly_detection",
    "threshold_alerts"
  ],
  "forbidden_operations": [
    "individual_record_access",
    "raw_data_export",
    "re-identification"
  ],
  "retention": {
    "proof_chain": "7_years",
    "raw_data": "0_days",  # Zero persistence
    "derived_insights": "30_days"
  },
  "access_control": {
    "data_owner": ["read_proofs", "revoke_access"],
    "analyst": ["read_aggregates"],
    "auditor": ["verify_proofs"],
    "public": ["verify_proofs"]
  }
}

Automated Compliance Evidence

Generate compliance reports for regulators:

• Data Processing Records (GDPR Art. 30): Automated from workflow logs
• Security Safeguards Audit (HIPAA): TEE attestation report
• Access Logs: Immutable log of all data access attempts
• Incident Reports: Automatic detection of policy violations
• Third-Party Verification: Export proofs for external auditors