Skip to main content

Platform

Delentia OS 2026.03 Snapshot

Constitutional AI Operating System — 10-layer architecture, a 41-algorithm framework, a public SDK proof lane, and enterprise-private deployment evidence.

Get Started Request Demo

Platform Summary

Short Answer: What This Platform Does

RCT Ecosystem acts as an operating system for enterprise AI by handling verification, memory, routing, governance, and deployment discipline so AI systems can be more auditable, safer, and easier to operate at scale.

Why Buyers Evaluate This Page

  • Explains the architecture layer by layer.
  • Shows explicit performance and validation numbers.
  • Connects protocols, memory, routing, and compliance in one system.

10-Layer Constitutional AI Architecture

From hardware abstraction to enterprise hardening — complete AI operating system stack

10

Enterprise Hardening

2.4.0

JWT RS256, RBAC, CircuitBreaker - Security-first architecture with comprehensive access control and fault tolerance.

9

Universal Adapter

Integration Ready

Seamless integration with external systems, APIs, and third-party services through standardized protocols.

8

Regional Language Adapter

8 Markets

Support for 8 markets with localized LLM models and compliance frameworks (PDPA, APPI, PIPA, PIPL).

7

FloatingAI

Conversational AI

L3 API microservice for conversational AI with real-time context awareness and knowledge base integration.

6

JITNA Protocol

RFC-001

Just-In-Time Natural Action language for precise intent specification and validation.

5

SignedAI

not claimed

Optional jury of independent models with an Ed25519-signed verdict (scripted-voter tests only).

4

RCTDB

8D Memory

Memory as a hash-chained event log with per-person erasure and a delta state store. Quantum-resistant encryption is not built.

3

Algorithm Kernel

41 Algos

41-algorithm framework across 9 tiers from basic operations to self-evolving systems.

2

Kernel Services

Runtime Core

Core infrastructure services including memory management, context switching, and event processing.

1

OS Primitives

Foundation

Foundation layer providing process isolation, resource allocation, and hardware abstraction.

Architecture Stats

Total Layers10
Algorithms41
Runtime Components52+
Verified Tests7820
Availability TargetNo SLA offered; uptime is not independently monitored

Legend

Security & Enterprise
Integration & Language
AI & Intelligence
Core Infrastructure

Architecture

10-Layer System Architecture

From cognitive kernel to enterprise hardening — every layer formally specified with 6 Kernel RFCs.

Layer 10
Hardening

Enterprise Hardening

Security (JWT RS256, RBAC), Validation, Performance, Resilience, LLM Intelligence

Layer 9
Control plane

Control Plane

JITNA Wire Schema, ED25519 Signed Execution, Deterministic Replay Engine

Layer 8
8 Markets

Regional Language Adapter

An editable language-to-model table (JP, KR, CN, TW, TH, VN, ID, US as a starting guess) and a data-residency policy; not legal advice

Layer 7
2.4.0

Universal Adapters

Telegram, Discord, Slack, LINE, WhatsApp, Signal and e-mail gateways with sender allow-lists, and external MCP servers through the same gate

Layer 6
RFC-001

JITNA Protocol

RFC-001 v2.0 — AI-to-AI communication with PROPOSE→COUNTER→ACCEPT/REJECT

Layer 5
not claimed

SignedAI

Optional jury of independent models you name, with a signed verdict

Layer 4
8D Memory

RCTDB v2.0

8-dimensional universal memory: Registry, Vault, and Governance zones

Layer 3
41 Algos

41 Production Algorithms

Tier 1-3: Foundation (15) | Tier 4-6: Intelligence (14) | Tier 7-9: Consciousness (12)

Layer 2
Kernel v1.4

OS Primitives

Process Model, Scheduler, IPC, Syscall Interface, Fault Isolation — 6 RFCs

Layer 1
Foundation

7 Genome System

Architect, ARTENT, JITNA, Codex, SignedAI, Delentia Knowledge Vault, ReCoT-7 + SHA256 proof

Verified

SignedAI

An optional jury of independent models you name. Each votes agree, disagree or abstain; abstentions never help a proposal pass; the verdict is signed with Ed25519. Scripted-voter tests only; no hallucination rate is claimed.

  • No hallucination rate claimed (none was measured)
  • ED25519 cryptographic output signing (RFC 8032)
  • Members are models you choose; a jury of one model is not a jury
  • Deterministic replay with SHA-256 checkpoints
Learn More
{
  "output": "Analysis complete",
  "signature": {
    "note": "illustrative shape only, not a real output",
    "algorithm": "Ed25519",
    "digest": "sha256:..."
  },
  "verified": "re-check with delentia jury verify",
  "timestamp": "2026-03-04T12:00:00Z"
}

Vector

Semantic search

Graph

Relationships

SQL

Structured data

Unified Query Interface

RCTDB v2.0

8-dimensional universal memory schema with infinite scalability. Three zones: Registry (Identity & Discovery), Vault (Infinite Storage), and Governance (Rules & Evolution).

  • 8-dimensional universal schema
  • 74% lossless context compression
  • 3-zone architecture (Registry, Vault, Governance)
  • pgvector HNSW + Apache AGE graph + async batch ops

Specialist Studio

A planned way to package domain-specific skills. Not available yet.

Legal

Planned; not built

Medical

Planned; not built. Delentia is not a medical device and gives no medical advice

Finance

Planned; not built. No financial advice

Infrastructure

Deployment files

v2.5.0 Phase 5-11: Docker, Kubernetes, API Gateway, and monitoring stack.

33 Containers

Docker Compose

31+ services unified deployment with health checks (736 lines)

57 Resources

Kubernetes

57 resources: HPA, PDB, NetworkPolicy, ArgoCD GitOps, Backup CronJobs

10 Routes

API Gateway

Bun + Hono TypeScript: JWT RS256 auth, RBAC, rate limiting, 10 routes

Real-time

Monitoring

Prometheus scrape configs + Grafana dashboards (health, RPS, latency, errors)

7820 Public SDK tests

Test Infrastructure

Locust + k6 load testing, OWASP security, Chaos (9 scenarios), E2E (7 flows)

14 Endpoints

Documentation

OpenAPI 3.1.0 (14 endpoints), C4 Architecture, Deployment Guide, Runbooks

2.4.0 — Enterprise Integration Suite

Chat gateways

Real-time AI collaboration through 2-Chat Architecture and automated knowledge synchronization.

Public snapshot

Slack Gateway

Messages from people on an allow-list become governed episodes; risky actions wait for a signature before they run.

  • Fail-closed sender allow-list
  • Approvals wait for a human signature
  • Read-only slash commands
  • Every request is one audited episode
Public snapshot

Documentation

Quickstarts and guides in Thai and English, kept in the open-source repository.

  • Quickstart in Thai and English
  • A model-free demo you can run in two minutes
  • A changelog per release
  • A measured-results page with limits stated
8 Markets Active

Regional Language Adapter

Language detection from Unicode scripts and an editable language-to-model table, plus a data-residency policy checked before every model call. There are no pilot tenants yet.

LanguageRegionDefault ModelCompliance
EnglishUSClaude Opus 4.6—
ไทยTHTyphoon v2 70B—
ญี่ปุ่นJPClaude Sonnet 5—
เกาหลีKRGPT-4 Turbo—
Chinese (Simplified)CNQwen 2.5 72B—
Chinese (Traditional)TWQwen 2.5 72B—
เวียดนามVNQwen 2.5 7B—
อินโดนีเซียIDQwen 2.5 7B—

Performance

Measured results

Metric2.4.0Industry AvgImprovement
Hallucination (not claimed)not claimedn/aNever measured
Context Compression39–90% smaller than full snapshots, measured in bytesn/aMeasured in bytes
Response LatencyDepends on the model (CPU: tens of seconds per goal)n/aNot compared
Availability TargetNo SLA offered; uptime is not independently monitored99.5%Operational target
Test Coverage7820 verified / 91.37%70-80%Public SDK proof lane
Cost (not measured)not measured1x baselineInternal estimate

FAQ

Key Questions Technical Evaluators Ask

What is the Delentia Labs platform?

Delentia is an open-source agent runtime with a safety gate, human-signed approvals, a signed audit log and verifiable memory. The 10-layer architecture is the design being built toward. There is no hosted service yet.

Who is the platform designed for?

It is designed for organizations that need lower hallucination risk, stronger auditability, persistent context across workflows, and enterprise AI deployments in regulated or multilingual environments.

How is it different from a typical LLM integration stack?

RCT goes beyond orchestration by combining verification, deterministic routing, memory architecture, protocol layers, and signed outputs so AI behavior can be explained, audited, and deployed safely at enterprise scale.

Related Resources

Continue Through the Related System Pages

10-Layer Architecture
Inspect the full system layers and service boundaries.
Open Protocols
Understand JITNA, FDIA, and the RCT-7 mental model.
Benchmark and Validation
Review performance, latency, and hallucination comparisons.
Technical Case Study
See a deterministic integration example end to end.

Ready to Build?

Start building with RCT Ecosystem v2.5.0. Full documentation, 14 OpenAPI endpoints, and enterprise support.

View Documentation Contact Sales