WORKS WITH CLAUDE CODE, CURSOR, ANTIGRAVITY & AIDER

43% fewer agent turns. 37% faster completion.

The Local Context Engine — Measured Turn Reduction for AI Coding Agents

TZRO assembles relevant code, runs automatic verification, and delivers high-signal context locally — so your agent solves tasks in fewer model turns. Measured across 9 real coding tasks with independent grading and full evidence retention.

Install Free Read Docs

posix-sh — install

$ curl -fsSL https://get.tzro.ai | bash

# Output pipeline expectation:

➔ Downloading runtime binaries from secure s3 allocation...

✔ System architecture validated (x86_64 / arm64)

✔ Symlinked tzro binary wrapper to local user bin space.

Latest Release

What's New in v3.1

Multi-language context intelligence, predictive test selection, session pause/resume, and developer workflow integration.

CONTEXT INTELLIGENCE NEW

Multi-Language Adapters

Go · TypeScript · Python · Rust

› Tree-sitter AST adapters resolve references across 4 languages: TS barrel re-exports, Python relative imports, Rust crate:: paths.
› tzro context --symbol provides surgical, symbol-anchored context assembly with --file disambiguation.

TEST INTELLIGENCE NEW

Predictive Test Selection

tzro test --impact

› Analyzes blast radius of staged/unstaged changes and runs only affected tests across Go, Jest, Vitest, and pytest.
› Comment-only hunks filtered. Config changes trigger fallback to broader suites. Output is compacted automatically.

WORKFLOW INTEGRATION NEW

Pause, Resume & Hooks

Session · Shell · Git

› tzro pause / resume snapshots agent work with git drift detection and a resumption dashboard.
› tzro shell init captures terminal history. tzro hook install adds advisory pre-commit impact analysis.

Measured Turn Reduction Engine

How Tzro v3.1 Cuts Agent Turns

Tzro delivers relevant context and automatic verification locally, eliminating the exploration and scheduling turns that slow agents down. 63 model invocations instead of 111 — same 9 tasks, same correctness.

PHASE 1: INGRESS & KV-LOCK Intercepted

Transparent Proxy

Loopback Port 7878

› Agents send requests to localhost:7878. System instructions and tool schemas are pinned in deterministic byte order.
› Benchmarked at 70–99% prompt cache hit rates across 8 LLM providers, avoiding the 12.5x cache miss penalty.
› E2E benchmarks show kvlock normalization improves cache effectiveness by 5–10 percentage points over native provider caching.

PHASE 2: AST PRUNING & PROBING < 50MB RAM

Tree-Sitter Engine

On-Device Indexing

› Code reads are skeletonized: method bodies are elided into SHA-256 hashes (#hash) and stored in local SQLite.
› tzro probe scans codebases via ripgrep in <5ms, turning 10-turn discovery loops into single 500-token queries.

PHASE 3: STREAMING EGRESS Zero Limits

Cloud LLM

Claude 3.5 / GPT-4o

› The model receives dense, high-signal, cache-locked context without transient log bloat or secret leakage.
› SSE tokens stream straight back to your editor with sub-millisecond latency.

# stdout pipeline debug inspect ❯ Daemon compiling task graph locally. Local workspace search complete.

Measured, Not Claimed

43% Fewer Agent Turns — Instrumented Across 9 Real Tasks

We ran a full 3-condition comparison: Native agent (no Tzro), Simple helper (bulk-update script), and Guided Tzro — same 9 coding tasks, same model (Gemini gemini-3.8-flash-low), same frozen client, independent grading. All 27 executions passed.

Condition	Correct	Total Time	Model Invocations	vs. Native
Native (no Tzro)	9/9	201.07 s	111	—
Simple Helper	9/9	198.58 s	106	4.5% fewer turns
Guided Tzro	9/9	125.28 s	63	43.2% fewer turns, 37.7% faster 🟢

⚡

How Turn Reduction Works: Fewer Decisions, Same Correctness

Agent turns are the real bottleneck. Each model invocation adds latency, accumulates context, and risks wrong-turn recovery loops. Tzro eliminates unnecessary exploration and scheduling turns by delivering relevant context and verification locally.

Example: ts-function-rename — Native used 23 model invocations in 34.68s. Tzro completed the same task in 6 invocations in 20.55s. The agent received relevant code upfront instead of exploring file-by-file.

Without Tzro (Native)

The agent explores incrementally — 23 model turns to discover files, read implementations, plan the rename, execute edits, and verify. Each exploration turn adds latency and context accumulation.

With Tzro (Guided)

Tzro delivers relevant code and runs verification as part of the edit workflow — 6 model turns. The agent starts with context and ends with a verified result. 74% fewer turns on this task.

The Result: Tzro was faster on 7 of 9 tasks against Native and 8 of 9 against the Simple helper. It used fewer model invocations on 8 of 9 tasks against each control. All results independently graded with full evidence retention.

Local Context Engine & Turn Reducer

Core Execution Surfaces

Tzro provides relevant code, compact diagnostics, and automatic verification locally — eliminating the exploration turns that slow agents down. The optional Proxy Shield adds KV-cache prefix locking and secret masking for cloud API traffic.

Token Shield Proxy

TRANSPARENT

<50 MB RAM · Zero dependencies · Transparent loopback

token_shield — active

→ kvlock: prefix hash f9e6d77… locked (296 prompt tokens)

→ dlp: 3 secrets redacted (sk-…, ghp_…, AKIA…)

→ ast: skeleton 14 files → 78% token reduction

✔ proxy: cache_read_tokens=1920 hit_ratio=0.89 ✔

⚡ KV-Cache Prefix Lock Guard LIVE

🛡️ Zero-Cloud DLP & Secret Redaction LIVE

🧠 Tree-sitter AST Skeletonizer LIVE

🔄 Smart JSON Crusher + Stack Elider LIVE

💾 Content-Hash Store (SQLite FTS5) LIVE

CLI Discovery Engine

NATIVE

Sub-millisecond discovery · AST-aware · Zero cloud tokens

cli_discovery — ready

↑ context: 'implement rate limiter' → 1,850 tokens (budget: 2000)

↑ impact: pkg/context/context.go → 14 callers, 3 test suites

↑ search: 'token bucket' → 8 hits across code, ADRs, and docs

↑ session: save 'ratelimit' → schema v2 manifest (fresh git SHA)

✔ compact --run: 'go test' → exit 0, 10-line inline cap, artifact stored ✔

🧩 Task Context Packs (tzro context) LIVE

💥 Pre-Edit Impact Graph (tzro impact) LIVE

🔍 Unified Evidence Search (tzro search) LIVE

📋 Session Continuity Handoff (tzro session) LIVE

🩺 Diagnostic Doctor (tzro doctor) LIVE

📊 Signal Density Benchmark (tzro bench) LIVE

🎯 Discovery Engine (tzro probe) LIVE

🧬 AST Skeleton + Expand LIVE

📦 Log & Output Compaction (--run) LIVE

🔁 Tabular Data Ingest & Query LIVE

🧪 Predictive Test Selection (tzro test --impact) NEW

⏸️ Session Pause/Resume (tzro pause / resume) NEW

🐚 Shell Integration (tzro shell init) NEW

🪝 Git Hook Manager (tzro hook install) NEW

🌐 Multi-Language Context (Go/TS/Python/Rust) NEW

43% Fewer Agent Turns

37% Faster Completion

<5ms Discovery Latency

System Architecture

Every OS primitive, implemented for AI agents

tzro maps every classical operating system concept to an agentic equivalent. Click any block to explore.

Kernel

tzrod

Process Scheduler

Kahn Compiler

Processes

Tasks & Workflows

Virtual Memory

Context Compaction

Filesystem

SQLite

IPC

StreamBus

Device Drivers

CLI Tools

System Bus

Loopback Proxy

System Daemons

Agent Lifecycle Hooks

Permissions

Proactivity Ladder

CPU

Inference Backend

DMA / Offload

Cloud Escalation

Shell

CLI & Proxy

GUI / Window Manager

Generative Dashboard

Boot Loader

install.sh

Portable Disk

tzro.db

Get Started

One command. Zero config.

Install TZRO with a single command. It detects your system, downloads the right binary, and symlinks it to your PATH.

Terminal

$ curl -fsSL https://get.tzro.ai | bash

Under the Hood

What else ships inside the jumpdrive

Six more proprietary subsystems — all implemented, tested, and shipping.

🛡️

Zero Syntax Failures

GBNF Grammar + Semantic Validator

The Local Model generates high-speed XML under shallow GBNF structural constraints, then a deterministic Semantic Validator coerces it into strict JSON tool parameters. Type coercion, default imputation, fuzzy matching — all in one boundary seam. 0% syntax failure rate for tool arguments.

⚡

Zero Chat Latency

Priority KV Cache Preemption

When a user sends a chat message, the OS dumps the running background task's KV attention state to disk, erases the slot, and processes the chat instantly — sub-450ms time-to-first-token. When chat completes, background state restores from disk without re-evaluating historical tokens.

🧠

Pure Local Memory

Hybrid Vector Search & Knowledge Graph

Zero cloud dependencies for long-term recall. SQLite FTS5 keyword pre-filtering → ONNX cosine similarity ranking → Neighborhood Multi-Hop traversal across a relational knowledge graph. Rich, contextual subgraphs injected directly into the model.

🔄

Self-Improving Inference

Dual Micro-Skill Extraction

Successful trajectories synthesize Procedural Micro-Skills. Failed-then-succeeded pairs extract Corrective Micro-Skills — teaching the local model to self-correct on specific failure patterns without weight updates. The OS gets better the more you use it.

👁️

Background Intelligence

Observer + Sentinel + Attention Scheduler

Three background agents form an autonomous nervous system. The Observer reflects on completed tasks. The Sentinel proactively correlates workspace activity. The Attention Scheduler enforces preemption, safety gates (L0–L4), and resource budgets.

🖥️

Generative Dashboard

Agent-Composed Observability

The dashboard isn't a static monitoring page — it's a Generative UI surface where the Local Model analyzes system state and composes the layout from 15 primitives. The agent decides panel ordering, emphasis, and which tasks deserve spotlight attention.