Closed Beta

The Heavy Lepton of AI Agents

Rust-native terminal agent. 75+ providers. Native vision. Local embeddings. Privacy by default.

macOS only • Linux & Windows coming soon

tau — ~/projects/webapp

Files

▸ src/

─ main.rs

─ lib.rs

▸ tests/

─ Cargo.toml

Usage

12.5K tokens

$0.024

❯ tau "Add authentication to the API"

● Analyzing codebase (4,203 files)...

● Found 12 API endpoints

✓ Created src/middleware/auth.rs

src/middleware/auth.rs

pub fn verify_token(req: Request) -> Result {

let token = req.headers().get("Authorization")?;

jwt::decode(token, &SECRET_KEY)

}

✓ Applied to 12 files

✓ cargo nextest: All tests passing

[B][V][T]claude-opus-412,450 tokens$0.024

The Standard Model

Elementary Particles of AI Development

Just as tau leptons carry more mass than electrons, TAU carries more capability than traditional agents. Full terminal control. Native vision. 75+ model providers.

"TAU is the best option for agentic development. Unlike CLI-apps or AI IDEs, it's designed from the ground up for terminal-first workflows."

Early Adopter

Staff Engineer

The Multi-Provider Advantage

75+ providers. Zero lock-in.

Switch providers mid-conversation. Use Claude Opus for reasoning, GLM-4.7 for code, Gemini for design. Your choice, always.

Anthropic

Claude Opus 4.5

OpenAI

GPT-5.2

Google

Gemini 3 Pro

xAI

Grok 4.1

DeepSeek

V3.2

MiniMax

M2.1

Z.ai

GLM-4.7

Ollama

Local

+65 more

providers

Use Your Existing Subscription

Connect Claude Code, GitHub Copilot, Gemini CLI, or Codex — no extra API costs.

claude-code

github-copilot

gemini-cli

<2s

Cold start

75+

Providers

5-layer

Caching

Local

Embeddings

5-Layer Intelligent Caching

Prompt

Provider-native caching (Anthropic/Google)

Embedding

LRU cache for vector ops

Tool

Memory + disk persistence

Semantic

Jaccard similarity matching

Permission

LRU for user decisions

Real-time savings shown in TUI • Up to 90% cost reduction with prompt caching

Full Terminal Use

Real shell, real control

Full PTY support means real shell sessions, not mocked outputs. Interact with REPLs, debuggers, and any CLI app.

✓ Interactive shell sessions (PTY)
✓ DAP debugging (6 languages)
✓ Process supervision & timeout

❯ tau "Debug the auth test"

Launching debugpy...

(Pdb) break test_api.py:42

Breakpoint 1 at test_api.py:42

(Pdb) continue

> test_api.py(42)test_auth()

→ assert response.status_code == 200

✓ Found issue: missing auth header

localhost:3000

→ browser_screenshot_describe

Native Vision

See what you see

Built-in Vision MCP gives any model image understanding — even those without native vision. Local MLX-powered VLM on Apple Silicon, or cloud providers for complex analysis.

✓ browser_screenshot_describe
✓ file_describe_image (local)
✓ 9 browser automation tools

Recursive Language Models

Analyze 10M+ token codebases

Traditional approach: send entire document to LLM → context overflow, high cost, quality degradation.
RLM approach: document stays local, only small chunks reach the LLM.

Your Query

"Find all security issues"

TAU (Opus 4.5)

Orchestrates analysis

~$0.30 for 4 turns

Final Report

Synthesized findings

LOCAL (FREE)

Python REPL

●Document loaded: 1,000,000 tokens

●Chunked into: 20 × 50K

●Searchable via: regex, AST, semantic

→ Document never leaves your machine. No API cost for storage.

API (~$0.02)

Sub-LLM Calls (Haiku 4.5)

subcall_1: auth_module.rs✓

subcall_2: api_routes.rs✓

subcall_3: database.rs✓

... 17 more subcalls ...

→ Each subcall processes ~5K tokens. 20 calls × $0.008 = $0.17

Traditional: Send Everything

500K tokens$2.56

1M tokens$5.06

5M tokens— exceeds context

Cost scales linearly with Opus 4.5. Quality degrades with context size.

✓ RLM: Smart Decomposition

500K tokens$0.47

1M tokens$0.47

5M tokens$0.47

Fixed cost. Opus orchestrates, Haiku analyzes chunks.

Load

Document loaded into sandboxed Python REPL

Plan

Opus writes Python code to chunk & navigate

Analyze

Haiku 4.5 processes each chunk in parallel

Synthesize

Opus combines findings into final answer

read, grep, code_searchallow

write, editask

bash (rm -rf, /etc/*)deny

Safety

Autonomy, under your control

Pattern-based permission rules. Risk levels from None to Critical. Every action logged and auditable.

Built-in Tasks MCP

Project management that understands your code

Not another Jira clone. A knowledge graph that links tasks to commits, decisions, and code. Track who did what, when, and why — human or AI.

Tasks, Epics, Problems

Atomic work units, grouped initiatives, bug tracking

Full Audit Log

Every change tracked: who, what, when, old→new values

Knowledge Graph

Link tasks to commits, files, decisions, and concepts

tau tasks

❯ task_create "Implement dark mode"

id: task_x7k2m
status: open
created_by: ai:claude:sess_abc

❯ task_update --status in_progress

started_at: 2026-01-15T14:32:00Z
started_by: ai:claude:sess_abc

❯ kg_link_commit abc123 "feat: dark mode"

✓ Linked to task_x7k2m

❯ kg_what_was_i_doing --minutes 30

Working on: Implement dark mode
Files modified: 3
Commits: 1

human:andrei

Track human contributions with full attribution

ai:claude:sess_123

AI agent work tracked per session

system:github

Webhooks and integrations tracked

State Of The Art

Everything you expect from a modern agent

Dynamic Tool Selection

TAU doesn't flood the context with all tools. It lazily selects only relevant ones, saving 20-30% tokens on every request.

Skills & Subagents

8 specialized agents working together

TAU uses a pipeline of subagents — each specialized for a specific task. Skills customize the pipeline based on your intent via semantic matching.

Planner

Coder

Reviewer

Tester

Documenter

Refactorer

Verifier

→Semantic skill matching with embeddings

→Custom pipelines per skill (stages, tools, models)

→Project-specific skills in .tau/skills/

# .tau/skills/debug/SKILL.md

---
name: debug
description: Debug failing tests or errors
tools: read, bash, grep
model: claude-opus-4-5
stages: [planner, coder, tester, verifier]
---

Systematic debugging approach:
1. Reproduce the issue
2. Identify error source
3. Form hypothesis
4. Implement fix
5. Verify fix works

# Matched by:

"fix this failing test"

"debug the login error"

"why is this crashing?"

Under the Hood

Built with serious technology

Not another Electron wrapper. Native Rust performance with deep system integration.

DAP

Debug Adapter Protocol

Full debugging integration. Set breakpoints, inspect variables, step through code.

PythonNode.jsRustGoPHPJava

LSP

Language Server Protocol

Real code intelligence. Hover docs, go-to-definition, find references, completions.

RustTypeScriptPythonGoC/C++JavaRubyVueSvelte

TUI

Terminal Interface

Ratatui-powered. 60fps rendering, syntax highlighting, OSC52 clipboard, themes.

RatatuiSyntectCrosstermLRU Buffers

IDX

Code Indexing

Hybrid search: BM25 + semantic vectors. Real-time re-indexing on file changes.

TantivyLanceDBTree-sitterRipgrep

MCP

Model Context Protocol

Dynamic tool selection for token economy. Built-in aggregator for external MCPs.

Lazy SchemasTool SelectionBrowserVisionWeb

Tasks MCP

Built-in project management. Tasks, Epics, Problems with full audit logging and knowledge graph.

TasksEpicsProblemsAudit LogKnowledge Graph

MLX

Apple Silicon Native

Local embeddings and VLM on M-series chips. No API calls for semantic search.

EmbeddingsVision VLMMetal GPUOffline

37+

Built-in Tools

LSP Languages

DAP Debuggers

Crates

Private and Secure

Your embeddings stay local.

Local Embeddings

MLX on Apple Silicon. Semantic search runs locally. Your codebase index never leaves your machine.

Zero Telemetry

No analytics by default. No data sent to external servers unless you choose.

Full Transparency

Open architecture. See exactly what the agent does at every step.

Ready to try Tau?

Join the closed beta and be among the first to experience the future of AI coding agents.

No spam. We'll only email you when your access is ready.