4-Layer Radial Session Dial, Core Health HUD & Daily Telemetry Highlights
Four concentric radial rings encode the Model, Harness, Coordination, and Environment layers across 48 time sectors over Oct 20 – Oct 27, 2026 with anomaly tripwires.
The Local-First Flight Recorder, Causal X-Ray & Operational Intelligence Studio for AI Coding Workflows.
Six open agent terminals look productive—even when four are waiting on a handoff and two are trapped in a ping-pong rework loop. Written in Rust and powered by an embedded columnar DuckDB engine, Dendro reconstructs existing local session logs out-of-band into an instrument-grade causal X-ray across sessions, actors, harnesses, and tools—with zero prompts, zero secrets, and zero cloud exfiltration.
cargo install --git https://github.com/smota/dendro.git dendro-cli
When engineering teams deploy autonomous coding agents across multiple terminal panes, isolated Git worktrees, or multi-actor topologies, execution becomes an opaque black box. Dendro replaces guesswork with retrospective causal truth.
active, waiting_on_human, idle_with_work (Handoff Wait), idle_without_work (Cleanly Parked), and unknown (Stalled / Rework / Unobserved).I09): Trace spawn, delegate, handoff, return, and retry edges across sessions and harnesses.| Dimension | Cloud LLM Tracers (LangSmith, Arize, Helicone, Datadog) | Raw Local Logs (JSONL files, grep, jq, bash) |
Dendro Local-First Studio |
|---|---|---|---|
| 1. Data Privacy & Storage | Transmits prompts, outputs, and proprietary code to third-party cloud servers. | Local on disk, but unindexed, unredacted, and sprawling across hidden directories. | 100% Local-First DuckDB. Zero prompts, thoughts, or secrets ever persisted or transmitted. |
| 2. Execution Overhead | Sits in the live runtime network path; adds 30–120ms proxy latency per prompt. | Zero runtime latency (passive file append). | Zero runtime overhead. Out-of-band passive flight recording; never touches the prompt wire. |
| 3. Multi-Agent Lineage | Truncates at single LLM spans; blind to terminal handoffs, queues, and worktrees. | Manual cross-referencing of UUIDs and timestamps across disparate files. | Full Causal Graph (I09). Multi-hop sub-agent lineage, queue wait (I12), and return loops. |
| 4. Cross-Layer Breadth | Model layer only (tokens and latency). Blind to OS resources, sandboxes, and tools. | Unstructured; requires brittle ad-hoc scripts to join across harnesses. | 4-Layer Unified Stack: Model + Harness + Coordination + Environment & Security. |
| 5. Query & Slicing Speed | Rate-limited cloud dashboards with multi-minute aggregation lag. | Slow linear jq scans taking minutes over gigabyte session logs. |
Sub-15ms local queries via vectorized columnar DuckDB, Ratatui TUI, and 12 Nao views. |
| 6. Loop & Anomaly Physics | Post-facto billing alerts after token budgets have already been exhausted. | Discovered only when a terminal freezes or rate limits trip. | Pre-Loop Distance Tripwires (I22) & structural Schema Drift gel-strips (I23). |
| 7. Cost & Licensing | $500–$3,000/mo per-user cloud SaaS subscriptions plus per-trace ingestion fees. | Free license, but high recurring engineering toil. | Free for Internal & Team Use (FSL-1.1-Apache-2.0) — converts to Apache-2.0 after 2 years. Runs on your own hardware forever. |
Inspect your entire AI workflow at a glance: four concentric radial rings encode the Model, Harness, Coordination, and Environment layers across 48 time sectors, while anomaly markers pinpoint exact failure and rework events. Scrub across any time window or click a preset below to inspect the Core Health HUD.
Hover or click any concentric layer band, hatched null slice, or anomaly tripwire (I07, I08, I19, I23) to inspect its telemetry.
Each radial band corresponds to one canonical layer of the AI execution stack. Quiet or unobserved intervals are rendered with diagonal hatch lines (url(#container-hatch))—honoring the Null ≠ Zero rule so missing coverage is never mistaken for idle actors.
Ratio-of-sums cache read efficiency across 5 disjoint token parts separates warm prefix reuse from uncached input bleed.
Tracks turn pacing and message density across Claude Code, OpenAI Codex, Google AGY, xAI Grok CLI, and Pi.
7-day column strip reporting daily trajectory stability across 1,127 trajectories: clear convergence vs. action retry clusters.
Press ⌘E (or toggle below) to lift flat 2D swimlanes into an exploded 3D isometric stack. Vertical cubic Bezier threads trace temporal correlation from a Model token burst, through a Harness tool retry loop, into a Coordination queue wait, down to the OS process RSS footprint.
5-Part Token Breakdown (input_uncached, cache_write, cache_read, output, nested reasoning), 96.9% cache read yield, and Counterfactual Routing (I25).
Capability Funnel (I06), Context Window Pressure (I07), Tool Execution Loops (I08), Trajectory Vortex (I22), and Schema Drift (I23).
Sub-Agent Lineage Graphs (I09), Work Duration & Concurrency (I10), Queue Wait Friction (I12), 5 Disjoint Activity Bands, and Acceptance Yield (I19).
OS Process CPU Deltas & Max Sampled RSS (I14), Sandbox Isolation (I16), Secret Scrubbing (I18), and 8-Hop Authority Blast Radius (I24).
Dendro classifies every agent action through its 5-Layer Capability Matrix—mapping execution across 10 Behavioral Tool Families, native harness primitives, MCP server tools, lifecycle guardrails, and the FUNNEL I06 Declared → Loaded → Verified Invoked Skills funnel.
I06)
54.5k built-in verbs (Bash, Read, Edit, Write, Grep, Glob, Task).FUNNEL I06): Separates skills merely declared in config from skills loaded into context and skills effectively invoked.Embedded across the Hub and all 12 views. Click any dimension to preview the rollup structure:
Every console pairs empirical DuckDB evidence with explicit mathematical guardrails—clearly distinguishing observed fleet telemetry from counterfactual simulations across arbitrary sliding windows (?window=7d or YYYY-MM-DD..YYYY-MM-DD).
Spot when an agent stops converging and starts spiraling—plotting multi-turn trajectories in an elliptical phase space (FLOAT[32] cosine distance and turn-transition dynamics) so runaway tool retry loops pull orbits outward before token budgets burn. A vortex trip is an empirical alert, not a proved root cause.
Track structural metadata shifts across Claude Code, Codex, AGY, Grok CLI, and Pi updates as a biological DNA gel-strip—measuring VARIANT envelope L1 distance (keys_added, keys_removed, keys_retyped) across daily cohorts so silent harness upgrades never blindside your pipelines. Structural drift is not a compatibility verdict.
Trace how far a revoked permission, failed tool call, or compromised credential propagates across multi-hop sub-agent delegation chains—walking evidenced session_edges and security_facts authority scopes up to an 8-hop ceiling. Dependency exposure does not grant or imply inherited authority.
Test "what-if" model routing policies against your real workload history before changing a single production setting. Evaluates pinned pricing tiers and SIMULATED TIER TOTAL (COUNTERFACTUAL) fast-tier envelopes in normalized token units against a 128k context-pressure threshold. Simulation proxy, not a live routing mutation or financial guarantee.
Explore how handoff return rates, token burn per mission, and engineering review loops interact across your active actors. All calculations run locally in your browser from your explicit slider inputs—never a synthetic ROI guarantee.
Epistemic Boundary (Scenario Calculator ≠ Predicted ROI): All values above are direct arithmetic projections of your operator-supplied slider assumptions. Dendro never injects hidden cloud averages, synthetic productivity multipliers, or guaranteed savings claims.
Install via Cargo or build directly from Git checkout. Point Dendro at the local session transcripts already on your disk—nothing ever leaves your machine.
# Path A: Install via Cargo (dendro on PATH)
cargo install --git https://github.com/smota/dendro.git dendro-cli
dendro cockpit
# (or from local checkout: cargo install --path crates/dendro-cli --locked)
# Path B: Or build and run from Git checkout (current)
git clone https://github.com/smota/dendro.git
cd dendro && cargo build --release --locked
./target/release/dendro cockpit
# Serve the Connected Web Studio on loopback (127.0.0.1:4242 only)
dendro dashboard --serve 127.0.0.1:4242 --site-dir ./site
# Run headless loopback daemon, pre-flight advisor & Nao semantic queries
dendro serve 127.0.0.1:4242
dendro advise
dendro ask "which handoff pairs had the highest return rate this week?"
Inspect exported multi-agent runs in a single zero-dependency HTML file, or integrate with Dendro's open JSON schema.
dendro cockpit (6-Screen Ratatui TUI): Pure-Rust terminal interface with 6 keyboard-driven screens (Overview, Layers, Handoffs, Capabilities, Consoles, Inspection) and full L0–L3 insight drill-downs.dendro serve & dendro dashboard (127.0.0.1:4242): Binds strictly to local loopback (refusing non-local interfaces), streaming live SSE updates (/api/events) and DuckDB JSON queries (/api/query).dendro advise & dendro ask: Sub-15ms pull-only pre-flight health oracle and deterministic in-process Nao semantic router across 12 canonical SQL views (zero LLM query hallucination).An unobserved interval or unmaterialized table is null (rendered with diagonal hatch marks or insufficient_evidence), never zero. Five exclusive status badges govern every view: ok, partial, insufficient_evidence, refused, and not_applicable.
High token volume never implies high engineering output—a 20M token session may be a stuck rebase loop. Token accounting is strictly framed as 5-part cost and cache yield attribution.
Vertical Bezier threads in the 4-Layer Stack X-Ray represent recorded temporal and structural correlation across Model, Harness, Coordination, and OS spans—never claiming mathematical proof of causation.
Consoles I22–I25 clearly distinguish observed telemetry from counterfactual simulation models, explicitly labeling SIMULATED TIER TOTAL (COUNTERFACTUAL) as a simulation proxy rather than a live router mutation.
The Capacity Scenario Calculator is an Operator Assumption Explorer with transparent arithmetic formulas—never a vendor ROI promise or invented "developer hours saved" claim.
Prompts, model responses, chain-of-thought, tool arguments, and error payloads are never persisted in DuckDB. Secret prefixes (sk-, ghp_, gho_, xai-, Bearer tokens) are scrubbed before storage.
Execute parallel coding tasks inside isolated Git worktree sandboxes with Meshloop, then inspect repair turns, sub-agent lineage, and process RSS in Dendro.
Define engineering role boundaries and human acceptance gates with AgentFlow, and measure first-pass acceptance yield (I19) and handoff wait times in Dendro.
Ground coding and executive agents in local, reviewable context with Holoself while Dendro verifies 100% local-first privacy and zero secret persistence across every session.
Built by Samuel Mota · Move the Needle
Open source · FSL-1.1-Apache-2.0
See where time, handoffs, rework, capabilities, and token budget actually go across your multi-agent AI coding sessions—using verifiable local DuckDB evidence instead of vanity productivity claims.
Six open terminals look busy even when four agents are stalled on a handoff and two are looping. Dendro turns raw local session history into a 4-layer causal X-ray of where time, handoffs, and budget actually go.
Reconstructs local session logs out-of-band across Claude Code, Codex, AGY, Grok CLI, and Pi (plus optional multi-agent orchestration adapters) into 4 architectural layers, 5 capability funnels, and 25 deterministic DuckDB insights.