Technical Architecture & Mechanics

Intent to execution.

Explore the layers behind your agents. See how human directives, Rust execution, private memory, and approval gates connect in one inspectable runtime.

⚙️

Sovereign Protocol Core Stack

Click any component below to inspect runtime specs, data flows, and code contracts.

Version 1.1 Series Reference

📜

Directives SOP

Layer 1: Instruction Set

INPUT_LAYER

The entry point of the sovereign engine. Directives are authored in Markdown and YAML, ensuring business logic is human-readable and machine-executable.

Key Engineering Specifications

Parsing EngineTree-sitter / YAML-rs

ValidationSchema-Strict

Hot-ReloadInstant (FS-Watch)

Control MappingDeployment-Dependent

Architecture Code Contract

struct Directive {
  id: Uuid,
  sop_version: String,
  parameters: HashMap<String, Value>,
  constraints: Vec<Constraint>,
}

All Architecture Layer Specifications

📜

Directives SOP

Layer 1: Instruction Set

The entry point of the sovereign engine. Directives are authored in Markdown and YAML, ensuring that business logic is human-readable but machine-executable. The engine parses these into a directed acyclic graph (DAG) of tasks.

Parsing EngineTree-sitter / YAML-rs

ValidationSchema-Strict

Hot-ReloadInstant (FS-Watch)

Control MappingDeployment-Dependent

🧠

Agent 99 Router

Layer 2: Intelligence Orchestration

The brain of the operation. Agent 99 evaluates the Directive and routes the request to the optimal model slot. It manages the Swarm Hierarchy, deciding when to spawn sub-agents or call for human intervention.

Routing LogicSemantic Intent Mapping

Fallback ChainTri-Slot Redundancy

ConcurrencyTokio Multi-threaded

State MgmtRedis / In-Memory

⚙️

Rust Core Engine

Layer 3: High-Performance Runtime

Built with Axum and Tokio, the execution engine handles asynchronous task processing using Rust's memory-safety model. Throughput depends on hardware, workload, model latency, and tool configuration.

RuntimeTokio Async

Web FrameworkAxum 0.7

ThroughputBenchmark per Deployment

MemoryZero-Copy Deserialization

🛡️

Sapphire Shield

Governance & Security

The zero-trust gatekeeper. Sapphire Shield intercepts any high-risk tool calls (e.g., file deletion, fund transfer) and triggers a WebSocket event to the Human-In-The-Loop (HITL) dashboard for cryptographically signed approval.

Auth ProtocolMerkle-Proof Signed

Gate TypeHard Privacy Gate

Audit LogOBLITERATUS Ledger

LatencyEnvironment-Dependent

💾

LanceDB GraphRAG

Long-Term Sovereign Memory

A serverless vector database that combines Graph structures with RAG. It allows the swarm to remember preferences, historical outcomes, and complex entity relationships across millions of documents.

IndexingIVF-PQ

Embeddings768-dim (text-004)

Query SpeedBenchmark per Index

StorageDisk-native / S3

Role Analysis

Operational Perspectives

Select a role to see how AI-Tadpole-OS transforms security, governance, operational control, and daily execution.

Zero-Trust IT Security

Air-Gapped Local Security & Merkle Audits

IT departments define execution boundaries. When configured for air-gapped operation, the Hard Privacy Gate can disable external network access while tool activity is recorded for audit review.

Zero Cloud Data ExfiltrationAir-Gapped Mode

Active Documentation Guard (ADG)Symbol Gate Enforcement

Audit Ledger IntegrityOBLITERATUS Cryptographic Trail

Operational Governance

Continuous Telemetry & Human-In-The-Loop

Managers gain visibility over multi-agent workflows with10Hz MessagePack telemetry streams and WebSocket HITL gates. High-risk capabilities such asshell:execute and budget:spend require management approval.

Swarm Pulse Frequency10Hz Binary Stream

Sapphire Shield InterceptWebSocket HITL Prompt

Enterprise Control

Sovereignty as the Ultimate Enterprise Advantage

Deploying Tadpole OS on organization-controlled hardware can reduce API dependency and keep proprietary context within the security boundaries selected for that deployment.

Local

Configurable Data Boundary

Optional

External Model Access

Supercharged Workforce

Transition from Manual Drudgery to Swarm Director

Operators turn routine SOPs into executable Markdown directives in directives/, supporting scaled work while maintaining human oversight over execution outcomes.

One Operator, Multiple Governed Workflows

Ingest playbooks, coordinate parallel reviews, and synthesize findings with operator oversight.

Dynamic Redundancy Engine

Tri-Slot Model Routing Architecture

AI-Tadpole-OS decouples model selection from application logic. The engine can route prompts across three fallback slots to improve resilience when a provider or model is unavailable.

Slot 1: Primary

Local Ollama Engine

Local qwen2.5-coder / llama3.3 models running air-gapped on hardware GPU/NPU acceleration.

Latency: Local-direct | Cost: No metered API charge

Slot 2: Secondary

Groq Ultra-Speed LPU

Ultra-fast cloud inference fallback (high-throughput streaming) for complex multi-agent reasoning tasks.

Latency target: deployment-dependent | Fallback configured

Slot 3: Tertiary

Google Gemini 3 Flash / Pro

Massive 2M token context window slot for large document ingestion & deep architectural synthesis.

Context: 2M Tokens | Sovereign Backup

Core Protocol Performance Metrics

Representative runtime targets for the Rust server-rsand Tauri desktop builds.

Component / Subsystem

Target Specification

Runtime Performance

Swarm Pulse Telemetry

MessagePack over WebSockets

10Hz Stream (100ms interval)

Vector Search (LanceDB)

768-dim text-embedding-004

Direct Vector Indexing

Active Doc Guard (ADG-01)

Symbol Gate Static Analysis

Symbol Gate Validation

Governance Authorization

Sapphire Shield HITL Gate

Zero-Trust Merkle Proof

Ready to Deploy Sovereign Swarms?

Clone the runtime repository and start building autonomous, privacy-first multi-agent systems on your own hardware.

Clone Runtime Repo Launch Mission Demo ➔