Delentia OS — a governed AI agent runtime

A governed AI agent runtime: it stops and asks before it acts, and it can prove what it did

Delentia OS is an agent runtime. An agent here is not a loop that does whatever the model says. Every episode passes the same fixed cycle:

GUARD (is the request itself an attack?) → THINK (plan) → ROUTE (fast or careful) → ACT (each tool call is judged first; anything that writes, sends or runs code waits for a person's Ed25519 signature) → COMPRESS → VERIFY (does the answer match what was asked?) → RECORD (hash-chained, signed audit log you can re-verify offline) → LEARN (only verified episodes become skills).

Why you might care: the model can be wrong, or be talked into something by text it reads on a web page. The runtime does not rely on the model behaving. Text from outside (a web page, a file in an untrusted folder, a message) marks the episode as tainted, and from then on anything that could send or change something needs a human signature, whatever the model says.

Try it in two minutes: no model, no API key

pip install delentia-os
delentia demo init                          # a folder with three sample vendor quotes and a demo approver key
delentia demo run compare --scripted        # the agent reads the quotes, answers, and the answer is checked against what is known to be true
delentia demo run edit --scripted           # asks to change a file: the agent STOPS and waits for a signature
delentia demo approve <id> --scripted       # you sign; only now does the file change
delentia demo status                        # the audit chain: how many rows, how many signed, intact or not

Not ready to install anything? Here is what these commands print (a real run).

--scripted means a fixed program stands in for the model and nothing else: the files, the tools, the safety gate, the wait for a signature, the signature check and the audit log are real. It is there so that you can see the mechanism without installing a model; it says nothing about how good any model is, and every report says so on its first line. To use a real model: delentia setup, then the same commands without --scripted (a local Ollama model or any OpenAI-compatible endpoint).

What is measured, and what is not

Measured (and where)	Not yet
The public test suite: 7,109 passed, 32 skipped, 0 failed, 91.08% coverage (CI run)	A strong hosted model driving the runtime for days with real users
The gate, the approvals and the taint rule against a scripted attacker (a hijacked model: 18 harmful side effects without the gate, 0 with it)	Independent witnesses for the audit chain: until they exist, the log is hash-chained and signed, not tamper-proof
Local small models: they complete some simple tasks, not reliably (3 of 5 and 0 of 5 on a probe)	A public hosted service. Nothing here runs anywhere except on your machine

Details and the history of every claim: docs/testing/TESTING_CANONICAL.md and CHANGELOG.md.

What is in this repository

The agent runtime (rct_control_plane/), the 41 algorithms, the SDK modules and 5 reference microservices. A separate, private service layer is not part of this repository; the runtime can use any HTTP service that publishes an OpenAPI document through the same gate (python -m rct_control_plane.openapi_mcp_bridge --help).

---

What is RCT?

Delentia OS is the open SDK layer of the RCT Ecosystem — an experimental Causal-Constraint AI Operating System SDK built to test weight-level AI safety. This project is a research hobby experiment by a self-taught creator with a facilities management background (optimizing resource flow under hardware limits). It is not a commercial enterprise product and is not yet production-stable for critical workloads.

It provides:

• Auditability — every decision traces back to a signed evidence chain
• Governance — multi-tier consensus prevents unilateral AI action
• Interpretability — the FDIA equation makes intent and confidence explicit
• Regional awareness — built-in adapters for ASEAN, JP, KR, CN contexts

The ecosystem is undergoing development at delentia.com.
This SDK exposes the core components under Apache 2.0 to invite developer feedback.

🌐 Website: delentia.com · 🔗 GitHub: github.com/delentia-labs

---

Install & Run (5-10 minutes, fully local, no API keys)

Linux / macOS / WSL2:

curl -fsSL https://raw.githubusercontent.com/delentia-labs/delentia-os/main/install.sh | bash

Windows PowerShell:

iex (irm https://raw.githubusercontent.com/delentia-labs/delentia-os/main/install.ps1)

Or, if you just want the CLI without cloning the repo:

pip install delentia-os

Either way, then:

delentia doctor     # real preflight check - tells you exactly what's missing
delentia init        # creates a local .env from the template
delentia chat        # start the terminal chat UI

For a fully local, zero-cloud setup (nothing leaves your machine, no account, no API key): install Ollama, run ollama pull llama3.1, and delentia talks to it at http://127.0.0.1:11434 by default.

Both installer scripts only create a project-local virtualenv - no sudo, no elevation, no system-wide changes. Read them before running them if you'd rather not pipe-to-shell: install.sh, install.ps1.

Start Here in 5 Minutes (verify the claims yourself)

If you're arriving from social media or seeing RCT Platform for the first time and want to check our work rather than take our word for it, use this path:

1. Try the offline demo - run python examples/quickdemo.py or open notebooks/rct_playground.ipynb
2. Verify the claims - see docs/testing/TESTING_CANONICAL.md for the current authoritative test and coverage checkpoint
3. Understand the scope boundary - compare the open SDK surface vs enterprise-only surface in the table below
4. Check release readiness - see docs/release/RELEASE_READINESS_CHECKLIST.md
5. Find support channels - see docs/community/GITHUB_UI_LAUNCH_CHECKLIST.md for Discussions, milestones, About, Topics, and profile setup

---

What's Included in This SDK

Component	In This SDK (Apache 2.0)	Enterprise Only (Proprietary)
FDIA Scorer + equation engine	✅ core/fdia/fdia.py	—
SignedAI multi-LLM consensus	✅ signedai/core/	—
HexaCoreRole registry (10 roles v2.3)	✅ signedai/core/registry.py	—
Delta Engine (memory deltas: ~39% smaller after 20 ticks, ~90% after 500, measured in bytes; see Round 52)	✅ core/delta_engine/	—
Regional Language Adapter	✅ core/regional_adapter/	—
RCT Control Plane DSL (22 modules)	✅ rct_control_plane/	—
JITNA Protocol v3 (Intake + Negotiation)	✅ rct_control_plane/jitna_protocol_v3.py	—
TOON Formatter (ALGO-42 compression engine)	✅ rct_control_plane/toon_formatter.py	—
CORD Security Engine (100 injection patterns)	✅ rct_control_plane/cord_security.py	—
ZK-FDIA (Zero-Knowledge Pedersen proofs)	✅ rct_control_plane/zk_fdia.py	—
Helix-TTD (Topological drift detector)	✅ rct_control_plane/helix_ttd.py	—
PaymentEngine (Metered billing & trust gates)	✅ rct_control_plane/payment_engine.py	—
NodeNetwork (2/3 supermajority consensus)	✅ rct_control_plane/node_network.py	—
Groq LPU Adapter (Llama 3.3 integration)	✅ signedai/core/groq_adapter.py	—
PostgresPersistence (Layer 5/6 DB bridge)	✅ rct_control_plane/persistence_pg.py	—
rct-edge (TypeScript Edge Package)	✅ sdk-typescript/packages/rct-edge/	—
fdia-wasm (TypeScript WebAssembly Package)	✅ sdk-typescript/packages/fdia-wasm/	—
5 Reference Microservices	✅ microservices/ (297 passing tests)	—
CLI (delentia entry point)	✅ editable install or built wheel	—
Genome / Creator Profile API	❌ 501 stub (genome_api.py)	✅ Full implementation
Full Production Microservice Stack	❌	✅ private
Enterprise Dashboard	❌	✅
Docker Compose + full infra	❌	✅
Private test suite (count not published)	❌	✅ private

Stable SDK means: API is stable, the full suite is 7,109 passed, 32 skipped, 0 failed (CI, 2026-10-12, see TESTING_CANONICAL), CI enforces a 72% coverage floor (--cov-fail-under=72; Codecov separately targets 90% with tolerance), packages published on PyPI + npm.
Enterprise means: runs at delentia.com — contact for licensing.

---

Products

Product	Description	Link
🤖 Delentia Platform	Core intent-centric AI platform — full ecosystem access	delentia.com/products/delentia-platform
🎨 Delentia AI	AI-powered creative studio — intent-driven content generation	delentia.com/products/delentia-ai
✍️ SignedAI	Cryptographic verification layer — ED25519 signed AI outputs	delentia.com/products/signed-ai

All three products run on the same RCT OS constitutional core. SignedAI powers hallucination prevention via multi-LLM consensus + ED25519 attestation.

---

The FDIA Equation

$$F = D^I \times A$$

Symbol	Meaning
F	Future — the desired output the AI must deliver
D	Data quality — accuracy and completeness of inputs (0.0–1.0)
I	Intent precision — clarity of intent acts as an exponent (higher = amplifies result)
A	Architect — Human-in-the-loop approval gate (0.0–1.0)

When Intent is high (I→2), even moderate Data quality produces excellent results.
When A = 0, all output is blocked — Constitutional AI guarantee. The system never acts without human approval.

---

Key Numbers

Metric	Value
Public SDK validation	See docs/testing/TESTING_CANONICAL.md for the current verified checkpoint
Algorithms	41 (Tier 1–9, reference implementations)
LLM Models	10 HexaCore roles (3 Western + 3 Eastern + 1 Regional + 1 Thai + 1 Local + 1 LPU) - v2.3
Hallucination Rate	Not currently claimed. The earlier 0.3% figure was withdrawn 2026-09-28 because it could not be reproduced (see docs/benchmark/hallucination-methodology.md)
Memory Compression	stores state diffs, not full state: 39% (20 ticks) to 90% (500 ticks) smaller than a full snapshot per tick, measured in bytes (scripts/measure_delta_engine_real.py). The earlier 91.5% was a formula estimate, not a measurement
Intent Recall Speed	Cold start 3–5s -> Warm recall <50ms (synthetic benchmark)
Uptime SLA	N/A (Experimental Hobby Platform, no enterprise SLA guaranteed)
Languages	8 regional pairs (JP, KR, CN, TW, TH, VN, ID, US)
Universal Adapters	13 (Home Assistant, Terraform, n8n, Obsidian, Playwright, ...)
FDIA Accuracy	0.9167 rank accuracy (11 of 12 hand-written cases; classification accuracy on the same set is 0.5833, 7 of 12). Tiny set: treat as a smoke test, not a benchmark. Baseline 0.65 is a design reference.

For the current single source of truth, see docs/testing/TESTING_CANONICAL.md.

---

Architecture

┌──────────────────────────────────────────────────────────┐
│               DELENTIA OS SDK v2.3.0                     │
│         Intent-Centric AI Operating System               │
└──────────────────────────────────────────────────────────┘

Layer 11: CI/CD & Quality Gates
├─ GitHub Actions (ci.yml + security-scan.yml)
├─ See docs/testing/TESTING_CANONICAL.md for the current, live test/coverage checkpoint (this number moves every round - do not hardcode it in two places that can drift apart, see Round 44's own audit) · Python 3.10/3.11/3.12
└─ E2E integration tests (no Docker required)

Layer 10: Enterprise Hardening
├─ Security (JWT RS256, RBAC, ABAC, Rate Limiting)
├─ Validation (SQL Injection 3-layer, Pydantic v2, XSS)
└─ Resilience (Circuit Breaker, Retry policies)

Layer 9: Control Plane
├─ JITNA Wire Schema (JITNAPacket: I, D, Δ, A, R, M)
├─ TOON Formatter (ALGO-42 compression, 40-50% token savings)
├─ Ed25519 Signed Execution (RFC 8032)
├─ Replay Engine (SHA-256 checkpoints)
└─ rct_control_plane: 15-module DSL + intent schema

Layer 8: Regional Language + data residency (routing and call-time enforcement)
├─ LanguageDetector (EN, TH, JA, KO, ZH, VI, ID)
└─ RegionalModelRouter (LRU cache, 4-level resolution)

Layer 7: Universal Adapters (13 integrations)
└─ Home Assistant · Terraform · n8n · Obsidian · Playwright · ...

Layer 6: JITNA Protocol (RFC-001 v2.0)
└─ AI-to-AI intent wire format + task negotiation

Layer 5: SignedAI — Multi-LLM Consensus
├─ TIER_S (1) · TIER_4 (4) · TIER_6 (6) · TIER_8 (8 + veto)
└─ Hallucination rate: not measured (earlier 0.3% claim withdrawn, see docs/benchmark)

Layer 4: RCTDB v2.0 — 8-Dimensional Universal Memory
└─ Registry Zone · Vault Zone · Governance Zone

Layer 3: 41 Production Algorithms (Tier 1–9)
Layer 2: OS Primitives (6 Kernel RFCs)
Layer 1: 7 Genome System + Cognitive Kernel

SDK Modules: signedai/ · core/ · rct_control_plane/
             5 reference microservices

What is in this repository: the agent runtime (rct_control_plane/), the 41 algorithms, the SDK modules and 5 reference microservices. What is not: a separate, proprietary service layer that lives in a private repository and is not part of this release. Enterprise licensing and early access: delentia.com.

---

Quick Install (No API Keys Required)

# 1. Clone & install
git clone https://github.com/delentia-labs/delentia-os.git
cd delentia-os
pip install -e .

# 1b. (Only if you want to run the test suite) install the full dependency set.
#     `pip install -e .` is enough for the CLI and demos, but tests import torch,
#     numpy, opencv, faiss and others that pyproject.toml lists as optional extras.
pip install -r requirements.txt -r requirements-dev.txt
python -m pytest -q --no-header   # needs internet + Ollama for ~40 network-dependent tests

# 2. Validate the CLI surface without API keys
delentia version
delentia start --ui-test

# 3. Create a local .env template for real runs
delentia init
delentia doctor

# 4. Run the 5-minute offline demo — zero API keys needed
python examples/quickdemo.py

# 5. Run the FDIA benchmark (target: 0.92 accuracy)
python benchmark/fdia_benchmark.py --verbose

# 6. Try the CLI
delentia compile 'Protect resources from hostile agents'
delentia governance
delentia timeline

Expected output (quickdemo.py):

✅  Best action: act_001 (cooperate) — highest FDIA score
Consensus: PASSED ✅ (threshold: 4/6)
Final decision: EXECUTE — all 7 gates cleared, FDIA ≥ threshold, intent signed
Memory compression ratio: 5.0× (baseline + 4 deltas vs 5 full-state copies)

Expected output (fdia_benchmark.py):

RCT FDIA Score       : 0.9167
Industry Baseline    : 0.6500
Delta vs Baseline    : +0.2667 (+41.0%)
✅  Benchmark PASSED

Quick Start (With API Keys)

# 1. Generate a local .env template
delentia init
# Edit .env with your API keys

# 2. Run tests
python -m pytest microservices/ -q

# 3. Try the SignedAI demo
python examples/signed_ai_demo.py

# 4. Try the Hexa-Core demo
python examples/hexa_core_demo.py

Expected output (signed_ai_demo.py):

ALL IMPORTS OK
Tier 6: 6 signers, required=4
Consensus: True, confidence=75.00%
Supreme Architect: anthropic/claude-opus-4.6

Verify This Repository Quickly

Use these paths when you need evidence, not marketing copy:

• Property-based safety verification - Audit the FDIA safety gate natively by running the Hypothesis properties suite:

  pytest tests/hypothesis/test_fdia_properties.py -v
  

• The whole system against a scripted model (Round 52) - 15 cases, 76 checks: guard, a real tool call, warm recall, signed approvals, memory, model failures, budget, data residency, delegation, three subagents in three OS processes and git worktrees, a forged subagent answer, audit tampering and the .jitna handoff. The model is a real HTTP endpoint that follows a script, so a result is about the system, not about a model:

  python scripts/full_pipeline_cases.py            # add --no-subagents for the 30-second version
  python scripts/real_model_tool_probe.py qwen2.5:7b   # the other question: is this MODEL good enough to drive it?
  

• Current test and coverage checkpoint - docs/testing/TESTING_CANONICAL.md
• Release gate checklist - docs/release/RELEASE_READINESS_CHECKLIST.md
• Public export and provenance policy - docs/release/PUBLIC_RELEASE_PROVENANCE.md
• GitHub UI launch tasks - docs/community/GITHUB_UI_LAUNCH_CHECKLIST.md

---

Core Components

FDIA Engine (core/fdia/fdia.py)

The FDIA Scorer evaluates candidate NPC/agent actions using a weighted constitutional formula. All methods are pure functions — deterministic, no side effects.

from core.fdia.fdia import FDIAScorer, FDIAWeights, NPCAction, NPCIntentType

scorer = FDIAScorer(weights=FDIAWeights())
score = scorer.score_action(
    agent_intent=NPCIntentType.DISCOVER,
    action=NPCAction(action_id="a1", action_type="explore"),
    world_resources={"knowledge": 50.0},
    agent_reputation=0.85,
    other_intents=[NPCIntentType.PROTECT],
    governance_penalty=0.0,
)
print(f"FDIA score: {score:.4f}")  # deterministic float in [0.0, 1.0]

SignedAI Consensus (signedai/core/)

Multi-tier verification framework for AI decisions. Routes to the appropriate tier based on risk level.

from signedai.core.registry import SignedAITier, RiskLevel, SignedAIRegistry
from signedai.core.router import TierRouter

# Tier selection by risk level
tier_config = SignedAIRegistry.get_tier_by_risk(RiskLevel.HIGH)
print(f"High-risk → {tier_config.tier.value}: {len(tier_config.signers)} signers")

# Consensus calculation
result = SignedAIRegistry.calculate_consensus(
    tier=SignedAITier.TIER_6,
    votes_for=4,
    votes_against=2,
)
print(f"Consensus: {result.consensus_reached}, confidence={result.confidence:.2%}")

# Cost estimation
total_cost, breakdown = SignedAIRegistry.estimate_tier_cost(
    SignedAITier.TIER_6, input_tokens=10_000, output_tokens=5_000
)
print(f"TIER_6 cost: ${total_cost:.4f}")

SignedAI Tier Reference:

Tier	Signers	Geopolitical Balance	Required Votes	Use Case
TIER_S	1	—	1	Chat, low-risk queries
TIER_4	4	2 West + 2 East	3 (75%)	Code review, API design
TIER_6	6	3 West + 3 East	4 (67%)	Production releases, DB migrations
TIER_8	6 + chairman veto	3W + 3E + override	6 (75%)	Critical infrastructure, crisis

Delta Engine (core/delta_engine/memory_delta.py)

Stores agent memory as compressed delta sequences — only what changed, not full state.

Property	Value
Compression	39% (20 ticks) to 90% (500 ticks) measured in bytes — stores DIFF, not full state; the gain grows with history length, and plain zstd over full snapshots does as well or better
Deduplication	SHA-256 content hash per record
Rollback	Replay any agent to any past tick via delta chain

from core.delta_engine.memory_delta import (
    MemoryDeltaEngine, AgentMemoryState, NPCIntentType
)

engine = MemoryDeltaEngine()
engine.register_agent("agent-1", AgentMemoryState(
    agent_id="agent-1", tick=0,
    intent_type=NPCIntentType.ACCUMULATE,
    resources={"gold": 100.0},
))
engine.record_delta(
    agent_id="agent-1", tick=5,
    intent_type=NPCIntentType.ACCUMULATE,
    action_type="trade", outcome="success",
    resource_changes={"gold": 10.0},
)
state = engine.get_state_at_tick("agent-1", tick=5)
print(f"Gold at tick 5: {state.resources['gold']}")
print(f"Compression: {engine.compute_compression_ratio():.1%}")

Intent Loop Engine

Every user intent passes through a 7-state pipeline:

RECEIVED → VALIDATED (FDIA) → MEMORY_CHECK → COMPUTING
         → VERIFYING (SignedAI) → COMMITTING (RCTDB) → COMPLETED

Property	Value
Cold Start	3–5 seconds (full computation + SignedAI consensus)
Warm Recall	<50ms (memory hit, semantic similarity > 0.95)
Cost Trend	Decreases as memory fills — approaches $0 for repeated intents

JITNA Protocol (RFC-001 v2.0)

Just In Time Nodal Assembly — agents are assembled into working groups just in time based on intent, then dissolved when the task completes.

Full documentation: docs/concepts/jitna.md | RFC-001 Specification

JITNA is a three-layer system:

• Layer 1 — Protocol (rct_control_plane/jitna_protocol.py): RFC-001 wire format, Ed25519 signed packets, The 9 Codex
• Layer 2 — Language (6-field I/D/Δ/A/R/M): a parser and formatter for the text form (rct_control_plane/jitna_file.py, Round 52) and the .jitna signed file; no template library ships in this repository, and earlier text that cited "50+ workflow templates" is withdrawn
• Layer 3 — Intake (microservices/intent-loop/loop_engine.py): user-facing JITNAPacket + LoopMetrics

from signedai.core.models import JITNAPacket

# SignedAI Semantic Layer — verification-focused variant
# (D=Domain, A=Assumptions, R=Requirements, M=Metrics)
packet = JITNAPacket(
    I="Refactor authentication module",
    D="Backend engineering",
    **{"Δ": "Adopt clean architecture pattern"},
    A="No breaking changes to public API",
    R="Test coverage must remain > 90%",
    M="All existing tests pass, cyclomatic complexity < 10",
)

The canonical 6-field JITNA Language schema uses I=Intent, D=Data, Δ=Delta, A=Approach, R=Reflection, M=Memory — the SignedAI variant above uses different field semantics for verification context. See docs/concepts/jitna.md for the full disambiguation.

The .jitna file (Round 52)

A JITNA packet can be written as a signed file and sent over any network or medium; the receiver needs only the sender's public key. The 6-field language is plain text:

I: Refactor the authentication module
D: 800-line monolith, no tests
Δ: separate domain logic from infrastructure
A: hexagonal architecture
M: all tests must pass

delentia jitna keygen --out ~/.delentia/keys/jitna.pem        # prints the public key to publish
delentia jitna pack --language intent.txt --source planner --target worker --key ~/.delentia/keys/jitna.pem -o task.jitna
delentia jitna verify task.jitna --trust <sender public key>   # exit 0 valid+trusted, 3 valid but not trusted, 1 invalid
delentia jitna unpack task.jitna --trust <sender public key>   # prints the language, only from a file that verifies

Each packet carries its own Ed25519 signature, and the file carries a seal over the whole body. The seal matters because a packet's own hash leaves priority, correlation_id, metadata and status outside what is signed. "Valid" (nothing changed after signing) and "trusted" (you pinned the signer's key) are reported separately: anyone can generate a key and sign anything. A .jitna file is signed, not encrypted. Receivers can also POST /v1/jitna/verify. Code: rct_control_plane/jitna_file.py.

Regional Adapter and data sovereignty (core/regional_adapter/, rct_control_plane/residency.py)

You can do all of the following from the Desk (Models and Sovereignty pages) without the command line: pick a country, provider and model (or Other), declare where the endpoint processes data, test the connection (no prompt is sent, and an endpoint the policy would block is not contacted), and set the policy. A key typed there stays in the server's memory; only the name of its environment variable is saved.

The idea: any country or organisation plugs in its own AI, and personal data does not leave the boundary it sets.

Two parts, both real and tested:

1. Routing (regional_adapter.py): picks a model and prompt style per region and language, with compliance tags (TH PDPA, KR PIPA, CN PIPL, JP APPI, GDPR-ready for the US/EU entries) and a registry of pilot tenants.
2. Enforcement (sovereignty.py, residency.py, Round 52): a SovereigntyPolicy states the home region, the regions a call may reach, whether cross-border calls are allowed and what happens to personal data in one (block, redact, allow). Every model call is checked before it is sent:
   • an endpoint outside the allowed regions is refused (stopped_reason=residency_blocked, nothing leaves);
   • a permitted cross-border call that carries personal data is blocked or the data is replaced by placeholders; the scanner knows Thai national ID, Japanese My Number, Chinese resident ID and Korean RRN checksums, plus e-mail, phone and card numbers;
   • an endpoint whose location is unknown counts as cross-border (fail closed); a broken policy file raises instead of silently allowing;
   • the audit chain records the decision (kinds, counts, a hash), never the personal data.

# plug in your own AI: any OpenAI-compatible endpoint (a national provider, vLLM, llama.cpp, a gateway in your country)
delentia model set typhoon-v2-70b-instruct --provider openai-compat     --base-url https://llm.example.th/v1 --kind in_region --region TH --credential-env TYPHOON_TOKEN
delentia sovereignty set --region TH            # nothing may leave Thailand
delentia sovereignty check "Call 081-234-5678"  # would this text be sent? (nothing is sent)

This resembles data-localisation duties but is not legal compliance by itself. Thailand's PDPA does not require data to stay in Thailand; it restricts transfers abroad unless the destination has adequate protection or a basis such as consent or contract safeguards applies (s.28-29), and requires a lawful basis, purpose limits and data-subject rights. The policy therefore lets an owner choose "stay in-region" (strict) or "cross-border with redaction and a recorded legal basis". China's PIPL and Korea's PIPA are stricter about transfers. Have counsel confirm the setting for your case.

Not covered yet: egress by the crawl tool and the TypeScript MCP bridge are not checked by the policy, and the entry-point filter sees only text that goes through the model provider.

Entry	Languages
Thailand	TH, EN
Japan	JA, EN
South Korea	KO, EN
China	ZH, EN
Taiwan	ZH-TW, EN
Vietnam	VI, EN
Indonesia	ID, EN
US/Global	EN

rct_control_plane

15-module DSL + intent schema for composing multi-step agent pipelines:

from rct_control_plane import IntentObject, ExecutionGraph, DSLParser

parser = DSLParser()
graph = parser.parse(dsl_text)
print(f"Nodes: {len(graph.nodes)}, Edges: {len(graph.edges)}")

Available modules: intent_schema · dsl_parser · execution_graph_ir · intent_compiler · policy_language · observability · control_plane_state · jitna_protocol · signed_execution · replay_engine · default_policies · cli · api · middleware · rich_formatter · plan_engine · architect_policy_loader · approval_gateway · otel_adapter

Enterprise CLI Commands (v1.1.0)

Historical, not currently runnable (noted 2026-09-24, version note updated 2026-09-25): this block describes v1.1.0's command surface; the current public CLI (delentia) does not have plan, apply, memory, policy, or approve commands - confirmed against delentia --help's real, current command list (adapter, audit, build, chat, compile, doctor, evaluate, governance, init, list, logs, metrics, replay, reset, serve, start, status, timeline, version). plan_engine.py and approval_gateway.py are real modules with real logic (see "Available modules" above), just not wired to any CLI command today. Also: rct here means the CLI's old name - the real, current command is delentia (pyproject.toml's delentia = "rct_control_plane.cli:main"). The rct serve line's own (GET /metrics for Prometheus) sub-claim is also fabricated - see the API Contract table's own correction below; no route in this repo has ever exposed /metrics, in v1.1.0 or since.

# Lifecycle
rct plan "Refactor auth module"         # Terraform-style simulation — cost, risk, model roster
rct apply "Deploy payment service"       # compile → evaluate → execute
rct apply -f examples/pipeline.yaml     # Run JITNA pipeline file

# Memory
rct memory history                       # AI decision timeline with SHA-256 audit chain
rct memory rollback 3                    # Roll back 3 ticks

# Policy Governance
rct policy add -f config/architect_policy.yaml   # Load policy rules from YAML
rct policy list                          # List active rules
rct policy test "Migrate database"       # Dry-run policy evaluation
rct approve --pending                    # Interactive approval queue

# Monitoring
rct serve                                # Start API server (GET /metrics for Prometheus)

TypeScript SDK (sdk-typescript/)

import { computeFDIA, RCTClient, selectSignedAITier } from './src/index';

// FDIA formula
const score = computeFDIA(0.85, 0.90, 1.0);  // F = D^I × A

// REST client
const client = new RCTClient('http://localhost:8000');
const result = await client.compile({ natural_language: 'Deploy service' });

// Governance tier selection
const tier = selectSignedAITier('enterprise', 'high');

GitHub Action

- uses: delentia-labs/delentia-os/github-action@v1.1.0
  with:
    intent: "Deploy to production"
    rct_api_url: ${{ secrets.RCT_API_URL }}
    user_tier: enterprise
    min_governance_score: "0.8"
    fail_on_reject: "true"

Analysearch Intent (microservices/analysearch-intent/)

Multi-disciplinary deep analysis engine with adversarial self-refinement:

Mode	Pipeline	Use Case
quick	Single-pass lookup	Fast factual queries
standard	Analysis + research synthesis	Standard decisions
deep	Mirror Mode (3 passes)	Critical analysis
mirror	PROPOSE → COUNTER → REFINE loop	Adversarial self-challenge

Key capabilities:

• GIGO Protection — Entropy-based input validation; garbage in = rejected before any LLM call
• Golden Keyword Crystallization — ALGO-41 extracts the 3–5 decisive keywords from any query
• Cross-Disciplinary Synthesis — Connects insights across unrelated domains automatically
• Intent Conservation — Original intent preserved and checked through every refinement pass

HexaCore Registry (signedai/core/registry.py)

10 purpose-specific AI roles with full geopolitical balance (v2.3):

Role	Model	Country	Specialty
SUPREME_ARCHITECT	claude-opus-4.6	US	Architecture, reasoning, final decisions
LEAD_BUILDER	kimi-k2.5	CN	Complex coding, visual analysis
JUNIOR_BUILDER	minimax-m2.1	CN	Routine coding, unit tests
SPECIALIST	gemini-3-flash	US	Finance, health, multimodal, speed
LIBRARIAN	grok-4.1-fast	US	Long context (2M tokens), RAG, science
HUMANIZER	deepseek-v3.2	CN	Natural language, creative, translation
REGIONAL_CORE	pluggable (e.g. typhoon-v2, HyperCLOVA, Rakuten AI)	VARIOUS	Pluggable regional LLM, cultural & legal compliance
REGIONAL_THAI	typhoon-v2-70b	TH	Legacy Thai NLP specialist (maps to REGIONAL_CORE)
OLLAMA_ADAPTER	ollama (local)	LOCAL	Local LLM fallback supporting the 1+4 Pillar Architecture (Executor, Router, Guardian, Scribe) for air-gapped inference
GROQ_ADAPTER	llama-3.3-70b-versatile	LPU	Ultra-fast LPU inference, 128k ctx

from signedai.core.registry import HexaCoreRegistry, HexaCoreRole

# All 10 roles
for role, model in HexaCoreRegistry.MODELS.items():
    print(f"{role.value}: {model.id} ({model.country})")

# Geopolitical balance
balance = HexaCoreRegistry.get_geopolitical_balance()
# → {'US': 3, 'CN': 3, 'TH': 1, 'REGION': 1}

# Pluggable regional specialist
regional = HexaCoreRegistry.get_model(HexaCoreRole.REGIONAL_CORE)
print(regional.specialties)  # ['Regional NLP', 'Local culture', 'Local legal', ...]

# Dynamic model resolution based on request context (e.g. Vietnam)
model_id = HexaCoreRegistry.get_model_id(
    HexaCoreRole.REGIONAL_CORE,
    context_lang="vi",
    context_region="VN"
)
# → 'alibaba/qwen-2.5-7b' (or any custom registered model)

SignedAI jury (signedai/runner.py, delentia jury)

Several different models vote on a proposal and the verdict is signed. Give each tier role an endpoint in a JSON file (a key is never in the file; credential_env names a variable), then:

delentia jury run --config jury.json --tier tier_4 --question "Is this migration safe?" --proposal-file plan.md --sign-key jury-key.pem --out verdict.json
delentia jury verify verdict.json --pubkey <hex>

What it guarantees: members are asked independently and at the same time; a reply that is not a clear vote, a timeout, an error or a member the sovereignty policy forbids is an abstention (it never counts as agreement and cannot lift the ratio); a jury whose answering members are one model is not a consensus (opt out with --allow-shared-model, recorded in the verdict); in tier 8 the chairman can veto but cannot force a pass; the verdict carries a SHA-256 digest and an optional Ed25519 signature that verify re-checks together with the vote counts and the tier rules. What it does not do yet: the governed loop does not call it by itself, and no multi-vendor vote has been run with real keys.

API hardening (Round 53)

delentia serve rate-limits per caller (DELENTIA_RATE_LIMIT, default 600/60 s; an agent run costs 20 requests, a subagent fan-out 30). Model endpoints that keep failing are paused by a circuit breaker shared across episodes. Without DELENTIA_API_TOKEN the API answers only loopback clients; since Round 53 it also refuses a request whose Origin is a web page from another site or whose Host is not a loopback name (CORS used to be *, so any page the user opened could drive a local agent), and CORS answers only the local Desk and origins listed in DELENTIA_CORS_ORIGINS.

The owner's policy for A (rct_control_plane/fdia_policy.py, Desk page FDIA, delentia fdia)

F = D^I x A: A is the accountable human. You write that responsibility down: which tools run freely, which need a human signature (from which approver role, how many distinct keys), which paths are off limits, which roles may ask, which tools are refused outright, and when a SignedAI jury must agree first (per rule, or per goal risk). Without a file only the built-in gate applies; with one, every tool call is judged, the most restrictive matching rule wins, a broken file refuses everything, and the policy can only tighten the built-in floor (path safety, the 0.5 threshold, repository writes always wait for a human). A signature never lifts a path or pattern you forbade.

delentia fdia template balanced --out ~/.delentia/fdia_policy.json
delentia approvals keygen --out ~/keys/sec.pem --trust alice --role Security_Admin
delentia fdia test delentia_write_repo_file --args '{"relative_path": ".env"}' --approved

The Desk page explains the equation with a live calculator and worked examples, edits the rules, and tests an unsaved draft. Roles come from the identity the server attached to the request, so use one API token per user if roles are to mean anything.

Other MCP servers, web search, starter skills, three more channels

~/.delentia/mcp_servers.json lists MCP servers whose tools the agent may use as mcp__<server>__<tool>; they pass the same gate as the built-in tools (FDIA judgement, owner policy, audit), anything not declared read-only waits for a human signature, results are screened as third-party content, tool descriptions are screened against tool poisoning, and delentia mcp inspect <server> prints a digest you can pin. delentia_web_search works with a SearXNG instance or Brave (DELENTIA_SEARCH_PROVIDER) and says plainly when none is configured. delentia skills starter install adds 20 bundled playbooks (labelled as written by people, not learned). delentia_crawl_url now refuses cloud-metadata and this machine's own internal addresses. WhatsApp (signed webhook), Signal (through signal-cli-rest-api) and Email (IMAP/SMTP; the sender must be on the allowlist and the receiving server must have verified DKIM or SPF) join Telegram, Discord, Slack and LINE; every channel stays closed until its allowlist is set. Tested against local fakes of those services, not against the real ones. Thai prompt-injection screening: on a Thai set the rules did not see before they block about half of the attacks (15 of 31), about two thirds with a small local model's second opinion (21 of 31), with no harmless text blocked in 32; small, maintainer-written sets, indicative only.

One token per person, signed policy changes, a second opinion for CORD

delentia tokens create alice prints a token once and stores only its SHA-256 in ~/.delentia/api_tokens.json; with any entry the server is in per-user mode and the identity (namespace, memory, FDIA role) comes from the token, never from the request body. Since Round 62 a token is either a person's or an owner's (delentia tokens create alice --owner, delentia tokens owner alice): a person may talk to the agent and manage their own jobs, tasks, approvals and memory; every other route (the Desk, audit, policies, the MCP gateway) is default-denied for them. On a server with an API token, changing or turning off the owner's policy waits for an approver signature bound to that exact policy. DELENTIA_CORD_SECOND_OPINION=flag|block plus delentia model set <small-model> --profile classifier adds a small model's judgment of goals and third-party content on top of the rules (it can only add a finding and fails open); on a public labelled set the rules block 10% of attacks and rules + qwen2.5:7b 23%, with no false blocks. Tool Forge also has a Desk page (/forge).

Parallel tool calls and the Tool Forge

DELENTIA_PARALLEL_TOOLS=1 lets the model ask for several independent tool calls in one decision; they run as waves over the Execution Graph IR (dag_executor.py), every call is gated before any runs, and one refusal stops the batch. Measured on real tools: four independent 0.5 s waits 3.8x, a diamond 1.3x, a chain 1.0x, CPU-bound Python about 1.1x (scripts/dag_wave_benchmark.py).

delentia forge is Genesis grown into a governed loop: repeated unmet goals (forge gaps) lead to a proposed pure-function tool (written by the model or by you; checked statically, smoke-tested in another process), a human signs the exact code hash, and only then can the agent call it (delentia_run_forged_tool). Pure functions only; not a jail against someone who can also get a human to sign.

---

Microservices

Five reference microservices demonstrating production patterns:

Service	Port	Description
intent-loop	8001	Core FDIA execution loop
analysearch-intent	8020	Semantic search + intent analysis
vector-search	8016	Vector similarity search over RCTDB
crystallizer	8004	Output crystallization + fact verification
gateway-api	8000	Unified entry point + rate limiting

Each service includes a Dockerfile and follows the OpenAPI contract in contracts/openapi.yaml. All 5 build, run, and report healthy under docker compose up --build (verified for real 2026-09-25, see microservices/docker-compose.yml's own port mapping, which these match).

---

Benchmark Results

Reproducible benchmarks are in benchmark/.

Run against your own setup:

python benchmark/run_benchmark.py --config benchmark/default_config.json

See benchmark/README.md for methodology.

---

API Contract

Full OpenAPI 3.1.0 specification: contracts/openapi.yaml

Endpoint	Method	Description
/health	GET	Service health
/v1/kernel/execute	POST	Execute RCT Kernel with intent
/v1/rctdb/query	POST	Query RCTDB knowledge vault

Corrected 2026-09-24/25: GET /metrics for Prometheus does not exist in this repo's real routes (rct_control_plane/api.py, microservices/*/gateway_main.py/main.py) - confirmed via grep, no route registers that path. This same fabricated claim was found and fixed twice already this session in docs/architecture/observability.md and docs/getting-started/cli-reference.md; this was the third occurrence, in this README. config/prometheus.yml exists as a scrape-target config file, but nothing in this repo currently exposes a /metrics endpoint for it to scrape.

---

Enterprise Platform — v1.1.0 (Current SDK) · v5.5.0 (Private)

Note: This section records the enterprise platform history. The public SDK versioning starts at v1.0.0-alpha. See CHANGELOG.md for SDK release notes.

✅ 7,109 Passed (public CI, 2026-10-12; see TESTING_CANONICAL.md for the checkpoint and caveats) — Full delentia-os test suite
✅ Plan Engine — plan_engine.py real Terraform-style pre-execution simulation logic (corrected 2026-09-24: not currently wired to any real CLI command - plan isn't in delentia --help's command list; the module itself is real)
✅ Policy Governance — approval_gateway.py real omni-channel human approval logic, plus the real delentia governance command (shows governance violations from the audit log) (corrected 2026-09-24: rct policy doesn't exist as a command; approval_gateway.py isn't currently wired to any CLI command either)
✅ TypeScript SDK — sdk-typescript/: fdia, jitna, signedai, client modules

Previous milestone:
Private enterprise test suite: count not published (not independently verifiable from this repository)

Full SDK changelog → CHANGELOG.md

---

Whitepapers

• Whitepaper 3.0 (ภาษาไทย) — the current single source: FDIA and its four invariants, RCT-7, the Constitutional Cycle, the 10 layers as built, measured evidence and withdrawn claims
• Earlier papers (historical): Foundation (01), Architecture (02)

---

Project Structure

delentia-os/
├─ core/                        # Core algorithms + AI engine
│  ├─ fdia/fdia.py              # FDIA Scorer (NPCIntentType, FDIAWeights)
│  ├─ delta_engine/             # Delta-Memory (39-90% in measured bytes on a synthetic simulation, grows with run length)
│  └─ regional_adapter/         # regional routing + sovereignty policy (data residency)
├─ signedai/                    # SignedAI consensus framework
│  └─ core/
│     ├─ registry.py            # HexaCoreRegistry (9 roles) + SignedAIRegistry
│     ├─ router.py              # TierRouter (risk → tier selection)
│     └─ models.py              # JITNAPacket, AnalysisJob
├─ rct_control_plane/           # 19-module DSL + intent schema + enterprise platform
│  ├─ plan_engine.py            # PlanEngine — Terraform-style pre-execution simulation
│  ├─ architect_policy_loader.py # PolicyRule YAML loader
│  ├─ approval_gateway.py       # Omni-channel human approval (SHA-256 tokens)
│  └─ otel_adapter.py           # OpenTelemetry bridge for FDIA metrics
├─ sdk-typescript/              # TypeScript SDK (fdia, jitna, signedai, client)
├─ github-action/               # rct-policy-gate GitHub Action (Node 20)
├─ microservices/               # 5 reference microservices
│  ├─ intent-loop/              # Core FDIA execution loop (port 8001)
│  ├─ analysearch-intent/       # Deep analysis + Mirror Mode (port 8020)
│  ├─ vector-search/            # RCTDB semantic search (port 8016)
│  ├─ crystallizer/             # Output crystallization (port 8004)
│  └─ gateway-api/              # Unified entry + rate limiting (port 8000)
├─ config/                      # Configuration files
│  ├─ architect_policy.yaml     # 6 constitutional policy rules
│  ├─ prometheus.yml            # Prometheus scrape config
│  └─ grafana-datasources.yml   # Grafana auto-provision
├─ docker-compose.monitoring.yml # Prometheus + Grafana + OTel Collector stack
├─ examples/                    # Working code demos + pipeline.yaml
├─ contracts/openapi.yaml       # OpenAPI 3.1.0 spec
├─ apps/gui/                    # Desktop GUI, Next.js + Tauri (was Delentia-OS-Gui)
├─ plugins/adapters/            # Adapter SDK, manifest schema and registry (was Delentia-Ecosystem)
├─ deploy/                      # Docker, Kubernetes, Helm, Terraform (was Delentia-Infra-Public)
└─ docs/                        # Architecture docs + whitepaper/ (3.0) + whitepapers/ (historical)
   └─ assets/grafana-dashboard.json  # Pre-built Control Plane dashboard

---

Built With

---

Contributing

Contributions welcome! See CONTRIBUTING.md for guidelines.

• 🐛 Report Bugs
• 💡 Suggest Features
• 📖 Improve docs
• 🧪 Add tests
• 🔌 Build adapters for new integrations

---

Security

For vulnerability reports, see SECURITY.md.
Do not open public issues for security findings.

---

👤 About the Author

Ittirit Saengow (อิทธิฤทธิ์ แซ่โง้ว)
Architect & Sole Creator of RCT Platform and the RCT Ecosystem

"I'm a solo developer from Klong Toei, Bangkok. I believe AI governance should be a mathematical guarantee — not a setting you can turn off."

Origin Story

In June 2025, I started asking a question no one had answered clearly: Why does AI safety depend on configuration files instead of math?

On August 11, 2025 — a personal turning point — I wrote the first version of the FDIA equation on paper:

F = D^I × A

The insight: when A = 0, the output F = 0 by the properties of multiplication — no code path can bypass it. That's a constitutional guarantee, not a setting.

Over the next 10 months, working alone from a room in Klong Toei, Bangkok, I built that equation into:

• A 11-layer constitutional AI operating system
• 41 production algorithms (Tier 1–9)
• The JITNA Protocol (RFC-001) — an open standard for AI-to-AI communication
• SignedAI: multi-LLM consensus with ED25519 cryptographic attestation
• 1,287 passing tests, 92% coverage, with 0 skips
• A 450+ page whitepaper documenting every decision

This is not a research paper. It runs in production at delentia.com.

GitHub	@ittirit-delentia
Email	ittirit720@gmail.com
Org	founder@delentia.com
Website	delentia.com
LinkedIn	linkedin.com/in/ittirit-saengow
X / Twitter	@ittirit_rct
Reddit	u/WindLate5307
BIO	ittiritsaengow.link
Docs	delentia-labs.github.io/Delentia-OS
Location	Klong Toei, Bangkok, Thailand 🇹🇭
Started	June 2025
Turning Point	August 11, 2025

Timeline

Period	Milestone
Jun 2025	First FDIA equation written
Aug 11, 2025	Commitment to build RCT OS
Oct 2025	JITNA Protocol RFC-001 drafted
Dec 2025	Foundation whitepaper (~100 pages)
Jan 2026	41 algorithms complete
Feb 2026	3,053 Python files, Level 4 Virtuoso stress test
Apr 2026	Public SDK — 723 tests, 89%+ coverage, Apache 2.0 release
May 2026	Enterprise CLI Design System — Unicode block wordmark, FDIA formula card, boot animation, PyPI v1.0.4b0 live
June 2026	Enterprise Platform v1.1.0 — Plan/Apply/Memory/Policy/Approve CLI, TypeScript SDK, GitHub Action, OTel + Prometheus + Grafana, 800 tests 0 failed
Sep 2026 (current)	Round 41-44 engineering pass — CI fully green (was red ~4 weeks), all 41/41 algorithms confirmed real, GovernedAutonomousLoop wires FDIA/JITNA/RCT-7/Delta into the agent loop for the first time, DAG-workflow-YAML + Skill Library re-application shipped, all 5 reference microservices verified via real docker compose up, dozens of fabricated numbers found and corrected across docs/CLI/README - see CHANGELOG.md for the itemized commit history

See ROADMAP.md for what comes next.

---

The Delentia Ecosystem

Delentia OS is the open-source core. The full ecosystem extends across:

Repository	Purpose	Status
Delentia-OS	Agent runtime and core SDK — plus the GUI (apps/gui), adapter registry (plugins/adapters) and public deployment files (deploy/), merged here in 2026-09	✅ Apache 2.0
delentia-mcp	MCP server (6 tools on Cloudflare Workers) and Delentia Guard, source in ecosystem/	✅ Apache 2.0
Delentia-AI-SLM	SLM fine-tuning experiments	🗄️ Archived
Delentia-Infra-Enterprise	Enterprise HA — EKS/GKE, Vault, PDPA/GDPR compliance	🔒 Proprietary
Delentia-Private-OS	Enterprise platform (private)	🔒 Proprietary
Delentia-Website	Marketing + docs site — Next.js, Vercel	🔒 Proprietary

---

License

Apache 2.0 — see LICENSE.

Copyright 2026 Ittirit Saengow (อิทธิฤทธิ์ แซ่โง้ว) — Delentia Labs
Made with ❤️ from Bangkok, Thailand 🇹🇭