Powerful agents.
Your rules.

Tau defines agents through named roles that you compose into multi-agent teams. Give implementers, reviewers, and researchers different models, reasoning effort, communication styles, prompt fragments, and required skills.

Share defaults across a role group, then specialize each role. Tool policy belongs here too: select tools by name, group, or tag. Agents delegate to these configured roles, and you can select one directly with :role reviewer.

Compose your setup from shared defaults, config fragments, and named profile overlays. Keep model selection, agent behavior, and extension configuration independently reusable instead of maintaining a separate config for every workflow.

Stack profiles at launch; later patches override earlier ones at the same scope. This example selects DeepSeek as the inherited model default and adds a reasoning adjustment. Explicit role-level model settings still win. Configure a provider named deepseek with the listed model first.

Connect ChatGPT/Codex accounts, OpenRouter, public OpenAI Responses endpoints, or compatible Chat Completions servers, including local servers such as llama.cpp.

Provider profiles and credentials live separately. Account quotas, API billing, and supported tools or modalities depend on the route — not every model supports every feature.

Layer project and user AGENTS.md instructions while keeping a large skill library searchable on demand. Discovery reads bounded metadata, not every skill body. Agents search names and descriptions, optionally search content, then load an exact skill.

Project skills advertise their names and descriptions by default; user skills stay out of the prompt until searched. Set advertise: false for less frequently used project skills too. The library can grow without putting its whole catalog or contents into every agent's context.

Tau ships with discoverable skills about its own architecture, configuration, tools, and debugging workflows. Agents load the relevant guidance on demand to help you configure the harness, investigate problems, or understand how a feature works.

When documentation is not enough, the source-code skill explains where to obtain Tau and keep a reusable local checkout. Agents can inspect the implementation rather than guess from behavior, then help you customize Tau for your needs.

Configure how agents communicate, reason about a task, and present their results. Named prompt fragments compose at the global, role-group, and individual-role levels, so shared preferences do not need to be copied into every role.

Use inline text for a short communication style, file-backed fragments for longer instructions, and Handlebars templates for context-dependent behavior.

Tau provides a rich multi-agent interaction toolkit: role-based delegation, asynchronous messages within and across sessions, progress watches, completion notifications, and waits. Configure the team through roles and its collaboration patterns through prompts and skills.

Coordination is optimized around push notifications. Separate agent contexts keep delegated work focused; background tools let independent work proceed while a command runs. Per-agent workdirs and cooperative directory locks coordinate shared files.

The status tool reports meaningful task names and working, waiting, blocked, or done states to the UI and watching agents. These states drive behavior, not just presentation: Tau challenges premature final responses while an agent still reports working or has not reported a status, at most twice per unresolved phase.

Separate loop safeguards help models that struggle to recover from repetitive responses or tool failures. Tau injects one prompt to change approach, then stops automatic continuation with a visible notice if that cycle recurs. Both safeguards are bounded recovery measures, not guarantees of task completion.

Enable session_list discovery and use message to communicate with agents in other live sessions. Cooperative local harnesses can connect teams whose tools run in different sandboxes, with a configured receiver role for incoming work. The example allows Tau to start that receiver when no eligible instance is available.

Control outbound discovery and messaging with project-root allowlists and denylists. Incoming and outgoing notices can explain each team's trust context and handling expectations. Notices are advisory: peer messages do not grant permissions, and this same-user IPC is not isolation between hostile peers.

Eligible long-running tool calls move into the background automatically, freeing agents to do independent work. Completion notifications and wait collect results; cancel requests cancellation when a call is no longer needed. Cancellation does not undo effects already performed.

Asynchronous prompt inputs use configurable delivery deadlines for user input, agent messages, external messages, and status updates. Tune idle and waiting behavior to favor responsiveness or coalesce notifications into fewer model turns. Inputs join the next eligible prompt, rather than interrupting an in-flight model response.

Sessions live in the harness daemon, independently of any one terminal UI. Detach while agents keep working, connect multiple UI instances to the same live session, or resume a stored session after its daemon stops.

Run tau serve under systemd or another supervisor for a headless, long-lived session you can attach to as needed. Interactive sessions shut down on the last ordinary UI quit unless you have used :detach; supervised sessions stay alive across UI disconnects.

Make the most of your terminal space with two major display modes: compact for daily use, and verbose for a richer, configurable view of agent activity and performance. Toggle between them with Ctrl+V. Verbose mode exposes extra detail—including reasoning summaries, tool activity, and turn statistics—to help you understand how your agents work.

Keybindings can run shell commands and insert their output into your prompt. Use fzf-based file and history selection, or the agent picker on Ctrl+B. Press Ctrl+O to edit the prompt in your text editor: $TAU_EDITOR takes precedence over $EDITOR, with further fallbacks when neither is set.

Prompt completion and local ! shell commands round out the terminal workflow. Customize keybindings, themes, mouse behavior, and display detail independently of agent configuration. Install fzf to use the optional pickers.

The bundled shell extension provides everyday coding tools and remembers a separate working directory per agent. Configure the shell command, environment, and wrappers to fit your development environment.

Match the editing interface to the model's familiar tool style: apply_patch, line-based editing, or exact-text replacement. Model-aware tool policies select the surface; role settings let you override it.

Optional directory locks serialize cooperating agents' modifications while read-only inspection and unrelated work continue. Use manual locks around a whole workflow and automatic locks for supported file edits. Locks coordinate participating tools; they are not a general security boundary.

Control compaction through named, composable policies with model-aware thresholds, reserved headroom, lifecycle triggers, and agent-status conditions. Compact after an agent finishes a task, before its next inference, manually, or through an agent tool; configure policies globally or specialize them per role.

Tau supports provider-native compaction and its own configurable summary fallback, with custom mechanisms implemented through provider extensions. Provider-inline compaction and overflow recovery have separate controls from standalone policies. This example adds a status-aware policy while retaining the default before-inference safeguard; the model route determines the available mechanisms.

Named alerts send configurable notices to an agent when provider-reported input-token usage exceeds a chosen threshold. Use plain text or a prompt template to guide its next steps. Set alerts globally or per role, with lifecycle and status conditions controlling delivery.

Unlike automatic compaction, a notice lets the agent decide how to respond. Within a running daemon, each alert fires once while usage stays above its threshold and rearms when usage falls back or context accounting resets. The example delivers after a successful response and any tool calls it starts.

Inspect resolved prompts and tool definitions, durable event journals, agent-message timelines, and saved tool artifacts. Trace a delegated workflow across its agents, export conversations, or examine provider request and response captures when diagnosing a model issue.

Performance traces expose token and cache usage, cost estimates, tool and wait lifecycles, and compaction activity. Use compact human-readable output or machine-readable exports for your own analysis. Debug captures are best-effort and private; inspect them before sharing.

Track estimated API spend per agent and across a delegated workflow. Live cost displays include both an agent's own spend and a recursive total for it and the agents it created. These totals follow delegation, not every peer an agent messages. Usage and pricing coverage determine the estimates; they are not a provider invoice. Include descendants in traces to analyze the wider workflow.

The bundled papercut tool lets agents record incidental harness, tooling, and environment problems without derailing their task. Review accumulated reports periodically to find recurring friction and improve the setup; reporting does not automatically analyze or fix problems.

Tau supplies managed secrets directly to authorized providers and extensions, rather than putting credential values in agent prompts or tool arguments. Declare secret names in configuration; keep the values in Tau's secret store or supply them through TAU_SECRET_* variables at startup.

Supervised extensions cannot browse the secret store, and Tau removes those startup variables before launching them. Credential delivery stays out of ordinary event logs and transcripts. Extensions that receive secrets remain trusted code: this is not protection against an authorized integration leaking or misusing its credentials.

Enable, replace, or wrap capabilities as ordinary supervised executables. Extensions can register tools and actions, subscribe to events, and receive declared secrets. Use your preferred language and configure process wrappers where needed.

The placeholder executable below must implement Tau's extension protocol. Configured extensions are trusted local code; require: false allows startup with a warning if this optional integration cannot initialize.

Enable bundled Rhai scripting for trusted event hooks and custom tools. Separately installed projects connect Tau to Slack, Telegram, Zulip, XMPP, email and calendars, Swarm coordination, and Rostra.

These are opt-in, not services activated by a default install. Each integration needs its own setup, credentials, and authority choices. The Rhai example enables execution of a trusted local script.