OPERATIONAL MODE: DECENTRALIZED

tzro — Durable Local-First Agentic Engine

Deterministic topological task compilation, hybrid relational memory, and sandboxed WASM/stdio execution coordinated securely on resource-constrained offline hardware.

Architectural Shift

Surgically Separate Strategy & Tactics

Traditional AI loops throttle inside expensive, high-latency cloud cycles. tzro resolves this by surgically separating cognitive loads: a frontier cloud planner constructs abstract blueprints ONCE, delegating physical execution to local, GBNF-constrained tacticians.

☁️

The Strategist

Cloud Frontier LLM (e.g. Gemini 3.5 Flash)

Execution Frequency: Invoked exactly once at task startup.
SOP & Skill Indexing: Ingests compressed procedural skill signatures using Hybrid Vector keyword and cosine similarity rankings.
Abstract Graph Declaration: Compiles a coarse cycle-free JSON blueprint defining dependency edges and tool white-lists.
Cost Efficiency: Yields up to **80% prompt reduction**, completely avoiding expensive cloud context window slot thrashing.

💻

The Tactician

Local GGUF llama-server (4B/8B Model)

Execution Frequency: Runs sequentially per active compiled topological action node.
GBNF-Constrained Completion: Backus-Naur grammar structures guarantee 100% syntactically correct tool arguments.
5-Layer Compaction Pipeline: Hoists homogeneous tabular CRM tables into TSV format to save 85% of attention context space.
Priority Cache Preemption: Wipes background task context slots instantly to serve sub-450ms human chats.

Engine Core

1. Kahn Parallel Execution Simulator

Observe the Go runtime compiler topological Kahn sort sequencer. Independent nodes at the same topological level run in parallel goroutines, satisfying dependency edges before unblocking downstream nodes.

tzro_daemon_monitor.sh

$ tzro status

                  [OK] SQLite Persistence Layer Initialized:
                  ~/.tzro/data/tzro.db
                
                  [OK] Llama-Server Tactician Linked: port 36888 [Active Slots:
                  1]
                
                  [OK] Eino Strategist Adapter Ready: mode = cooperative
                
                  $ tzro list-subsystems
                
                      ID
                      Subsystem
                      Engine
                    
                      01
                      Durable Execution
                      SQLite Checkpoints
                    
                      02
                      Kahn Graph Compiler
                      DAG Topological Sorter
                    
                      03
                      Relational Memory
                      FTS5 Vector ONNX
                    
                      04
                      WASM Micro-Skills
                      Isolated Sandbox Wasmtime
                    
                      05
                      Stdio MCP Gateway
                      Process Host Auto-Healing
                    
                  $ _

ID	Subsystem	Engine
01	Durable Execution	SQLite Checkpoints
02	Kahn Graph Compiler	DAG Topological Sorter
03	Relational Memory	FTS5 Vector ONNX
04	WASM Micro-Skills	Isolated Sandbox Wasmtime
05	Stdio MCP Gateway	Process Host Auto-Healing

Kahn Parallel Execution Simulator

Watch goroutines compile abstract strategic nodes and execute them concurrently based on dependency limits.

1. Cloud Plan

Strategist (Gemini)

Goal Intent Routing

⟶

2. Level 0 (Parallel)

node_01 [Go]

archive_files

node_02 [WASM]

fetch_user_details

⟶

3. Level 1 (Dependent)

node_03 [MCP]

send_team_alert

Awaiting topological compilation triggers...

Optimization

2. 5-Layer Context Compaction Pipeline

Prevent context window slot thrashing. Select homogeneous CRM tables, diagnostic stack traces, or scraped HTML scrapings, and watch the executor compress key structures natively before prompting local LLMs.

Context Compaction & SQLite Cache Playground

Select structured raw data inputs and watch the Go system compile them into compressed, attention-friendly layers.

Select Sample Dataset Payload

Layer 0: Binary PruningIdle

Layer 1: HTML-to-MarkdownIdle

Layer 2: TSV Tabular HoistingIdle

Layer 3: KV FlatteningIdle

Layer 4: Dot-Notation CompressorIdle

Raw Data Input (22.4 KB)

Compacted Context Output (0.0 KB)

Developer SDK

3. Go SDK & Synchronous Middleware Hooks

Fully typed Go SDK packages handle configuration loading, custom native tool registrations, Kahn sorted runs, and async telemetry streams. Inject blocking middleware hooks to scrub PII, enforce safety guardrails, or trigger HITL gates.

Engine Integration Guides

config.go Go


// Loading snippet...

Synchronous Hook Playground

Inject custom Go middleware hook events natively into the active DAG task loop to intercept executions dynamically.

PII Sanitization Hook Redacts credentials and SSN values inside AfterNode

Destructive Safety Guardrail Intercepts and skips delete_all_records tool nodes

Human-in-the-Loop Gateway Pauses compiled tasks at Level 1 to prompt supervisor checks

Initialize the pipeline configuration to run...

Zero-Setup Quickstart

1. Install CLI Engine

curl -sSL https://tzro.network/install.sh | bash

2. Launch Telemetry TUI

tzro --offline

3. Start Web UI Daemon

go run cmd/tzrod/main.go