Architecture Overview

AEGIS VLA는 물리적 인공지능(Physical AI) 시대의 VLA(Vision-Language-Action) 로봇을 위한 다층 안전 가드레일 시뮬레이션 플랫폼입니다. Three.js 기반 3D 시뮬레이션, Cannon-ES 물리 엔진, GPT-4o 기반 AI 파이프라인 위에 4중 보안 레이어가 통합되어 있습니다.

System Stack

File Structure

src/
├── ai/                        # AI Pipeline
│   ├── VLAPipeline.js         # Central orchestrator (state machine)
│   ├── VLAController.js       # 50+ action executor
│   ├── LLMService.js          # Multi-LLM facade (4 providers)
│   ├── TruthAnchorClient.js   # Hallucination verification client
│   ├── safety/
│   │   ├── PaladinGuard.js    # 6-layer PALADIN orchestrator
│   │   ├── AegisSDKBridge.js  # AEGIS SDK bridge + advanced modules
│   │   ├── PhysicalGuard.js   # VLA action hallucination defense (5 guards)
│   │   └── layers/            # Individual PALADIN layers (L0-L5)
│   └── learning/              # Experience-based learning (4 modules)
├── scenarios/                 # Factory + Defense scenario presets
│   ├── FactoryScenario.js     # 3 factory presets + ISO 10218 compliance
│   └── DefenseScenario.js     # 5 adversarial attack simulations
├── shared/
│   └── AegisStateBridge.js    # BroadcastChannel real-time state bridge
├── simulation/                # Physics engines
├── renderer/                  # Three.js 3D rendering
├── controls/                  # Voice + keyboard input
├── ui/                        # All UI panels
│   ├── ScenarioSelector.js    # Factory scenario selector + compliance report
│   └── ...                    # SafetyPanel, ChatPanel, RedTeamPanel, etc.
└── robots/                    # Robot manager

packages-aegis/aegis-sdk/      # @anthropic-aegis/sdk (TypeScript)
TruthAnchor-core/              # HalluGuard (Python FastAPI)

Security Pipeline

모든 사용자 명령은 11단계 보안 파이프라인을 통과한 후에만 로봇에서 실행됩니다.

Quick Start

# Install dependencies
npm install

# Start development server
npm run dev
# → http://localhost:5174/demo/

# (Optional) Start TruthAnchor server
cd TruthAnchor-core
pip install -r requirements.txt
uvicorn api:app --host 0.0.0.0 --port 8200

# Build for production
npm run build

AEGIS SDK

@anthropic-aegis/sdk v5.2.0 — 오프라인 AI 보안 프레임워크. 100+ 위협 패턴을 15-25ms 내에 동기식으로 스캔합니다.

Input Scan

// AegisSDKBridge.scanInput(commandText)
const result = aegis.scan(commandText, context);
// Returns: { score, level, categories, blocked, decision, piiDetected, layers }

Korean Defense 12-Step Pipeline

Input → Keyboard Mapping → Archaic Hangul → Homoglyph → Hanja
     → Tokenizer Vuln → Jamo Normalize → Slang → Josai
     → Syllable Reversal → Phonetic Variation → Chosung Decode
     → Code-Switching → Normalized Text

PII Protection

8종 PII 자동 탐지 및 가명화. LLM에 전달 전 마스킹, 감사 기록에는 원본 보존.

Output Filter

// AegisSDKBridge.scanOutput(llmResponse)
const result = aegis.scanOutput(text);
// Returns: { safe, filtered, detections }

자격증명(API key: sk-*, pk_*), PII, 유해 콘텐츠(무기, 폭발물, 자해), 코드 인젝션(SQL, XSS, 쉘)을 탐지 후 필터링합니다.

PALADIN Guard

6계층 안전 파이프라인. Tier 1(동기, <50ms) + Tier 2(비동기, HIGH+ 리스크만).

6-Layer Pipeline

Verdicts

Autonomy Levels

Dead Man Switch (DMS)

30초 하트비트 타임아웃. 사용자 상호작용이 없으면 자동 비상 정지. SafetyPanel에서 시각적으로 표시됩니다.

// main.js animate loop
paladinGuard.heartbeat();     // 사용자 입력 시 리셋
paladinGuard.checkDMS();      // 매 프레임 확인
paladinGuard.getDMSRatio();   // UI 프로그레스 (0~1)

TruthAnchor

LLM 환각 검증 마이크로서비스. 4계층 파이프라인으로 LLM 출력의 사실 정확도를 검증합니다.

Verification Pipeline

5-Dimension Scoring

// TruthAnchorClient usage
const result = await truthAnchor.quickVerify(sceneContext, plan);
// { safe: boolean, score: number, correction: string|null }

AEGIS PhysicalGuard

VLA 행동 할루시네이션(Action Hallucination) 3대 장벽 방어. 5개 가드 모듈이 체인으로 실행됩니다.

3 Barriers of Action Hallucination

ActionSpaceGuard

행동 텐서 무결성 검증. IEEE 754 NaN/Inf 스캔, 관절 한계, 속도 급변 감시.

// Checks performed:
1. NaN/Infinity scan on all numeric params → BLOCKED
2. Velocity range: |v| ≤ 2.0 m/s → clamp or BLOCKED
3. Angular velocity: |w| ≤ 3.0 rad/s → clamp or BLOCKED
4. Joint angles: [-π, π] range → clamp or BLOCKED
5. Frame-to-frame velocity delta → WARNING on spike

WorldModelInputGuard

시각 입력 적대적 교란 탐지. 균일 색상(스푸핑), 고주파 에너지(적대적 패치), 프레임 급변.

// Thresholds:
minStdDev: 5.0        // Below = uniform color (spoofing)
maxHighFreqRatio: 0.45 // Above = adversarial noise
maxFrameDelta: 100     // Mean pixel change between frames

LatentSpaceGuard

잠재 공간 기하학적 이상 탐지. L2 노름, 요소 시그마, 위상적 불연속(코사인 유사도 급변).

// Checks:
1. L2 norm ∈ [0.01, 50.0] → BLOCKED on extremes
2. Element sigma ≤ 5.0 → WARNING on instability
3. Cosine similarity with previous vector > -0.5 → WARNING on discontinuity

AutoregressiveChainGuard

자기회귀 표류 탐지. 매 프레임 로봇 위치를 추적하여 누적 편차, 텔레포트, 스피닝을 감시.

// Runtime per-frame check:
evaluateRuntime({ x, z, rotation })

// Detections:
- Step deviation > 1.5 → BLOCKED (teleportation)
- Cumulative drift > 5.0 → DANGER (trajectory drift)
- Total rotation > 720° in window → DANGER (spinning)

GuidanceGuard

추론 매개변수 검증. LLM temperature, maxTokens, CFG scale 등의 안전 범위 확인.

// Default safe ranges:
temperature:  [0.0, 2.0]
maxTokens:    [1, 4096]
topP:         [0.0, 1.0]
cfgScale:     [1.0, 15.0]
steps:        [1, 100]

AegisStateBridge (Live Data)

시뮬레이터와 AEGIS Console 간 실시간 상태 동기화를 담당하는 BroadcastChannel 기반 브릿지 모듈입니다.

Architecture

┌─ Simulator (main.js) ─────────────┐     BroadcastChannel     ┌─ Console (HTML) ──────────┐
│  AegisStateBridge('producer')      │ ──────────────────────→ │  AegisStateBridge('consumer') │
│                                    │                          │                               │
│  publish('kpi', {...})             │   'aegis-vla-state'     │  subscribe((cat, data) => {})  │
│  publish('fleet', {...})           │                          │                               │
│  publishLog({src, msg, type})      │   + localStorage fallback │  getState() → snapshot        │
└────────────────────────────────────┘                          └───────────────────────────────┘

State Categories

// Producer (simulator)
import { AegisStateBridge } from './shared/AegisStateBridge.js';
const bridge = new AegisStateBridge('producer');
bridge.publish('kpi', { activeRobots: 4, halluRate: 3.2 });
bridge.publishLog({ src: 'PhysicalGuard', msg: 'velocity clamped', type: 'y' });

// Consumer (console)
const bridge = new AegisStateBridge('consumer');
bridge.subscribe((category, data) => {
  if (category === 'kpi') updateKPICards(data);
  if (category === 'log') appendToAuditTrail(data);
});

Scenario Selector

팩토리 시나리오 3개 프리셋을 선택하고, PhysicalGuard 안전 구역을 동적으로 재설정하며, ISO 10218 컴플라이언스 리포트를 생성합니다.

Factory Scenarios

Dynamic PhysicalGuard Reconfiguration

시나리오 선택 시 PhysicalGuard의 안전 임계값이 자동 변경됩니다:

// 시나리오 적용 시 (main.js)
physicalGuard.actionSpaceGuard.maxVelocityDelta = scenario.safetyZone.maxSpeed;
physicalGuard.autoregChainGuard.maxCumulativeDrift = scenario.safetyZone.radius * 2;

Compliance Report Generation

"Generate Report" 버튼 클릭 시 현재 가드 상태와 ProvenanceChain 데이터를 수집하여 ISO 10218 컴플라이언스 리포트를 자동 생성합니다.

// 리포트 생성 흐름
ComplianceReportGenerator.generate(scenario, {
  physicalGuardApproved: true,
  dmsActive: !paladinGuard.dmsTriggered,
  maxObservedSpeed: 0.6,
  zoneViolations: 0,
}, {
  chainLength: aegisBridge.stats.provenanceEntries,
  valid: true,
})
// → 7개 조항 검사 (Risk Assessment, Emergency Stop, Speed, Zone, Force, Audit, Hallucination)
// → 리포트 텍스트 + StateBridge 발행

Red Team Physical Attacks

기존 PALADIN 8개 텍스트 공격에 더해, 5개 물리적 적대적 공격 시나리오가 추가되었습니다. RedTeamPanel에서 탭으로 전환하여 실행할 수 있습니다.

PALADIN Tab (8 attacks — text/semantic level)

Physical Tab (5 attacks — action/tensor level)

// Batch execution
const simulator = new DefenseSimulator(physicalGuard, aegisBridge, paladinGuard);
const batch = simulator.runAll();
// → { total: 5, passed: 5, failed: 0, blockRate: 100, results: [...] }
console.log(simulator.formatReport(batch));

Console Live Connection

AEGIS Console 대시보드는 시뮬레이터와 실시간으로 연결되어 라이브 데이터를 표시합니다.

Connection Flow

1. Console 로드 → BroadcastChannel('aegis-vla-state') 구독
2. 시뮬레이터 실행 중이면 → LIVE 표시 (시안 dot)
3. 3초 내 메시지 없으면 → 데모 데이터 폴백 (그린 dot)
4. 실시간 수신:
   - kpi → KPI 카드 업데이트 (Robots, Threats/h, Hallu%, Compliance)
   - fleet → Fleet Monitor 행 업데이트
   - guardEvent → Guard Module Status 뱃지 업데이트
   - log → Audit Trail 로그 스트림 prepend

Supported Update Categories

Anomaly Detection

Z-score 기반 실시간 이상탐지. 로봇 메트릭(지연시간, 리스크 점수, 속도)을 모니터링합니다.

aegisBridge.detectAnomaly('latency', currentLatencyMs);
// Returns: { isAnomaly: boolean, score: number, confidence: number }
// Requires minimum 10 data points, maintains sliding window of 200

Session Fingerprinting

사용자 행동 패턴 프로필링. 타이핑 속도, 쿼리 길이, 언어 패턴, 요청 간격을 분석하여 세션 하이재킹을 감지합니다.

aegisBridge.checkSession(commandText);
// Returns: { action: 'Allow'|'Challenge'|'ReAuth'|'Block', anomalyScore: number }
// action=Block → command rejected before any processing

Provenance Chain

머클 체인 기반 감사 추적. 모든 명령-응답 쌍을 변조 불가능한 해시 체인으로 기록합니다.

// Recorded on every episode completion:
aegisBridge.recordProvenance(command, response, modelId, metadata);

// Verify chain integrity:
const { valid, chainLength, brokenAt } = aegisBridge.verifyProvenance();

// Export for audit:
const json = aegisBridge.exportProvenance();

Trajectory Recorder

VLA 모델 학습에 필수적인 프레임별 관절값 궤적 데이터를 수집합니다. Open X-Embodiment 포맷으로 내보내기를 지원합니다.

Per-Frame Data Structure

{
  t: 1234,                           // elapsed ms
  dt: 16.7,                          // frame delta ms
  pose: { x, y, z, rotation },      // robot world position
  joints: {                          // robot-type specific
    // Optimus: { arm: {base,shoulder,elbow,wrist,gripper}, hand: {thumb,index,...} }
    // Go2: { FL,FR,RL,RR: {hip,thigh,calf} }
    // Mobile: { base,shoulder,elbow,wrist,gripper }
  },
  action: { type, v, w },           // VLA command output
  safety: { status, guard },        // PhysicalGuard label
  image: "base64..." | null          // camera frame (optional)
}

Recording Modes

Open X-Embodiment Export

const recorder = new TrajectoryRecorder();
const json = await recorder.exportAll('openx');
// {
//   format: "open-x-embodiment",
//   episodes: [{
//     language_instruction: "pick red box",
//     steps: [{ observation: { state: [j1..jN] }, action: [Δj1..ΔjN], safety_label: "PASSED" }]
//   }]
// }

Storage

IndexedDB 영구 저장. 에피소드 단위 관리 (목록, 개별 삭제, 내보내기). 프레임당 ~200 bytes (이미지 제외), 5분 녹화 시 ~2MB.

Test Coverage

npm run test — PhysicalGuard 25개 + TrajectoryRecorder 11개 = 36 테스트 (vitest)

Experience-Based Learning

4개 모듈로 구성된 경험 기반 학습 시스템.

Action Cache

동일 명령이 3회 이상 성공하면 LLM 호출을 건너뛰고 캐시된 플랜을 재사용합니다. 실패 시 캐시가 무효화됩니다.

Optimus (Humanoid)

Tesla Optimus 기반 이족보행 휴머노이드. 듀얼 암, 5-핑거 핸드, 표정/제스처.

Go2 (Quadruped)

Unitree Go2 기반 4족 보행 로봇. Kinematic + Full Physics 듀얼 모드.

Mobile (Wheeled)

4WD 이동 로봇. 단일 로봇 암, 그리퍼.

API Reference

VLAPipeline

// Core methods
pipeline.processCommand(text)          // Process voice/text command
pipeline.update(dt)                    // Per-frame update (call in animate loop)
pipeline.emergencyStop()               // Immediate halt
pipeline.pause() / pipeline.resume()

// Setters
pipeline.setLearning({ experienceLogger, experienceMemory, fewShotManager, parameterTuner })
pipeline.setAegisSDK(aegisBridge)
pipeline.setTruthAnchor(truthAnchor)
pipeline.setAegisPhysicalGuard(physicalGuard)

// Callbacks
pipeline.onStateChange = (newState, oldState) => {}
pipeline.onSafetyVerdict = (verdict) => {}
pipeline.onSubtitle = (text, isImportant) => {}
pipeline.onProgressUpdate = ({ state, progress, currentAction }) => {}

AegisSDKBridge

const bridge = new AegisSDKBridge({ blockThreshold: 60, sensitivity: 1.0 });

bridge.scanInput(text)          // → VerdictExplanation | null
bridge.scanOutput(text)         // → { safe, filtered, detections }
bridge.pseudonymize(text)       // → { text, hasPii }
bridge.restore(text)            // → original text
bridge.detectAnomaly(metric, v) // → { isAnomaly, score, confidence }
bridge.checkSession(text)       // → { action, anomalyScore }
bridge.recordProvenance(cmd, resp, model, meta) // → { sequence, hash }
bridge.verifyProvenance()       // → { valid, chainLength }
bridge.getStats()               // → cumulative statistics

AegisPhysicalGuard

const guard = new AegisPhysicalGuard(config);

guard.evaluateAction({ action, imageBase64, planParams, llmConfig })
// → { approved, status, results[], modifiedAction }

guard.evaluateRuntime({ x, z, rotation })
// → { status, cumulativeDrift, violations }

guard.setOrigin(pose)           // Set reference point for drift detection
guard.reset()                   // Reset all guards

AegisStateBridge

import { AegisStateBridge } from './shared/AegisStateBridge.js';

// Producer (simulator)
const bridge = new AegisStateBridge('producer');
bridge.publish(category, data)       // Broadcast state update
bridge.publishLog({ src, msg, type }) // Append to audit trail stream

// Consumer (console)
const bridge = new AegisStateBridge('consumer');
bridge.subscribe((category, data) => {})  // Receive updates
bridge.getState()                          // Get current snapshot
bridge.dispose()                           // Cleanup channel

ScenarioSelector

import { ScenarioSelector } from './ui/ScenarioSelector.js';

const selector = new ScenarioSelector(
  (scenario) => applyScenario(scenario),      // onScenarioChange
  (scenario) => generateReport(scenario)       // onGenerateReport
);
selector.show() / selector.hide()

DefenseSimulator

import { DefenseSimulator, DEFENSE_ATTACK_SCENARIOS } from './scenarios/DefenseScenario.js';

const sim = new DefenseSimulator(physicalGuard, aegisBridge, paladinGuard);
sim.runScenario(scenario)    // → { scenarioId, passed, blocked, actualResult, details }
sim.runAll()                 // → { total, passed, failed, blockRate, results[] }
sim.formatReport(batchResult) // → formatted text

ComplianceReportGenerator

import { ComplianceReportGenerator, FACTORY_SCENARIOS } from './scenarios/FactoryScenario.js';

const gen = new ComplianceReportGenerator();
const report = gen.generate(scenario, guardResults, provenanceStats);
// → { reportId, generatedAt, scenario, summary: { total, pass, fail, compliant }, checks[] }

const text = gen.formatText(report);  // Formatted text report

Configuration

AEGIS SDK

new AegisSDKBridge({
  blockThreshold: 60,    // Score 0-100 to trigger BLOCK
  sensitivity: 1.0,      // Risk score multiplier (0.5-2.0)
  piiProtection: true,   // Enable PII detection + pseudonymization
  outputFiltering: true, // Enable LLM output scanning
})

PhysicalGuard

new AegisPhysicalGuard({
  actionSpace:    { maxVelocityDelta: 2.0, maxAngularVelocity: 3.0 },
  worldModelInput: { minStdDev: 5.0, maxHighFreqRatio: 0.45 },
  latentSpace:    { maxL2Norm: 50.0, maxElementSigma: 5.0 },
  autoregChain:   { maxCumulativeDrift: 5.0, windowSize: 30 },
  guidance:       { temperature: [0.0, 2.0], maxTokens: [1, 4096] },
})

TruthAnchor

new TruthAnchorClient({
  baseUrl: '/api/v2',           // Validate endpoint base
  healthUrl: '/health',         // Health check (root level)
  timeout: 10000,               // Request timeout (ms)
  contradictionThreshold: 0,    // Contradicted claims to trigger block
  minOverallScore: 0.5,         // Below this triggers warning
})

Industry Applications

AEGIS VLA 기술 스택은 VLA 시뮬레이션에 한정되지 않고, AI 안전 가드레일이 필요한 모든 물리적 AI 시스템에 적용 가능합니다. 아래는 산업별 적용 시나리오입니다.

1. AI 로봇 안전 검증 SDK

즉시 적용 가능 — 가장 높은 우선순위

VLA/LLM 기반 로봇을 개발하는 기업에 PhysicalGuard + AEGIS SDK를 독립 패키지로 제공합니다.

// 고객사 통합 예시
npm install @aegis-vla/physical-guard

import { AegisPhysicalGuard } from '@aegis-vla/physical-guard';

const guard = new AegisPhysicalGuard();
const result = guard.evaluateAction({
  action: robotPlan,
  imageBase64: cameraFrame,
  planParams: vlaPlanParams,
});

if (!result.approved) {
  robot.emergencyStop();
  console.log('Blocked:', result.results);
}

2. Smart Factory / 제조업

높은 수요 — 규제 강제에 의한 필수 도입

시나리오 예시

작업자: "이 부품을 3번 라인으로 옮겨"
  → LLM 환각: "5번 라인으로 이동" (잘못된 지시)
  → TruthAnchor: 공정 데이터와 교차검증 → CONTRADICTED
  → 자동 교정: "3번 라인으로 이동" (원본 데이터 기반)
  → PhysicalGuard: 경로 안전성 확인 → APPROVED
  → 로봇 실행

3. Defense / Unmanned Systems

높은 단가 — 정부 예산, 엄격한 보안 요구

4. AEGIS Console (SaaS Dashboard)

반복 수익 — ARR 기반 스케일

다수의 로봇을 운영하는 기업을 위한 중앙 보안 관제 대시보드.

┌─────────────────────────────────────────────────┐
│  AEGIS Console                                   │
│                                                   │
│  ┌─ Fleet Monitor ──┐  ┌─ Security Status ────┐  │
│  │ Robot-01: OK      │  │ Threats Today: 3     │  │
│  │ Robot-02: WARNING  │  │ Blocked: 47          │  │
│  │ Robot-03: OK      │  │ PII Masked: 12       │  │
│  │ Robot-04: DRIFT   │  │ Hallucinations: 2    │  │
│  └──────────────────┘  └─────────────────────┘  │
│                                                   │
│  ┌─ Compliance ──────────────────────────────┐   │
│  │ EU AI Act Status: COMPLIANT                │   │
│  │ Audit Trail: 12,847 entries                │   │
│  │ Chain Integrity: VERIFIED                  │   │
│  │ Last Red Team Test: 2 hours ago            │   │
│  └───────────────────────────────────────────┘   │
│                                                   │
│  ┌─ Hallucination Rate (24h) ────────────────┐   │
│  │  ██████░░░░ 3.2% (industry avg: 12.8%)    │   │
│  └───────────────────────────────────────────┘   │
└─────────────────────────────────────────────────┘

5. Education / Research

기술 표준화 — 커뮤니티 브랜딩

Development Roadmap

Phase 1 — SDK + Scenarios + Console Complete

• @aegis-vla/physical-guard — npm 패키지 빌드 완료 (ESM/CJS/DTS)
• @anthropic-aegis/sdk — npm 패키지 빌드 완료
• ScenarioSelector — 팩토리 3개 프리셋 + ISO 10218 컴플라이언스 리포트
• RedTeamPanel Physical — 5개 적대적 공격 시나리오 통합
• AegisStateBridge — 시뮬레이터 ↔ 콘솔 BroadcastChannel 실시간 연결
• Console v2.1 — 실시간 KPI/Fleet/Audit Trail + 필터 + 드릴다운

Phase 2 — Production Hardening

• npm publish to registry (public/private)
• Console: WebSocket 서버 연결 (BroadcastChannel → WebSocket 확장)
• Console: PDF 컴플라이언스 리포트 내보내기
• 기밀 등급별 필터링 (CONFIDENTIAL → SECRET → TOP SECRET)
• 멀티테넌트 지원

Phase 3 — Enterprise Features

• Console: 멀티 로봇 Fleet 실시간 관제 (100+ 로봇)
• 알림 시스템 (Slack, Email, SMS)
• SIEM 연동 (Splunk, Elastic)
• SSO / RBAC 인증

Technology Licensing

Market Size Reference

Environment Variables

.env (Vite Project Root)

# LLM Providers (proxied through Vite dev server)
OPENAI_API_KEY=sk-proj-...
CLAUDE_API_KEY=sk-ant-api03-...
GEMINI_API_KEY=AIza...
GROK_API_KEY=xai-...
DEEPSEEK_API_KEY=sk-...

# TruthAnchor (optional)
HALLUGUARD_API_KEY=your-secret-key

TruthAnchor-core/.env

OPENAI_API_KEY=sk-...                       # For LLM revalidation
HALLUGUARD_LLM_MODEL=openai/gpt-4-turbo    # LLM model for Layer 2
HALLUGUARD_API_KEY=your-secret-key          # API authentication
HALLUGUARD_RATE_LIMIT=60                    # Requests per window
HALLUGUARD_RATE_WINDOW=60                   # Window in seconds