tamux runs autonomous agents as first-class daemon processes. Spawn specialists, route tasks, govern safety, remember everything — all from a terminal-centric platform.
tamux treats autonomous agent execution as a core primitive alongside PTY management, session persistence, and workspace isolation.
Terminal multiplexer built for AI agents. Autonomous execution is a core primitive.
Managed commands pass through sandbox isolation, AST validation, and policy evaluation.
Binary Space Partition layout engine with resizable panels and automatic tiling.
Visualize agent tool-call chains as a directed acyclic graph.
Filesystem and process snapshots with rollback capabilities.
Browse, search, and replay historical transcripts with full-text search.
Drag, add unlimited terminals, snap, and rearrange on an infinite canvas.
tamux ships with three purpose-built agents that collaborate to run your terminal workflows — from casual task execution to fully governed autonomous operations.
The main orchestrator. Svarog manages terminal sessions, spawns subagents, routes tasks to specialists, and maintains the working memory context across your session.
Lightweight operational handoff agent. Rarog handles cross-agent coordination, fetches contextual data, and routes information between agents without disturbing the operator's main working context.
Safety and governance agent. WELES intercepts potentially destructive commands, enforces policy guardrails, manages approval workflows, and maintains the sandbox isolation layer.
Operators command Svarog. Svarog delegates to Rarog for handoffs, and routes safety-critical operations through WELES before execution.
The daemon owns all state — sessions, agent runtimes, task queues, and memory. Agents execute as long-lived daemon processes. UI clients are stateless renderers that attach over IPC. Agent workflows survive disconnects.
Built-in agents (Svarog, Rarog, WELES) plus specialist routing and divergent sessions.
SOUL, MEMORY, USER files + semantic, session, and onecontext search across all sessions.
WELES agent + sandbox isolation + AST validation + WORM audit ledger.
Gmail, Calendar, Slack, Discord, Telegram, and web search — all via plugin API.
tamux agents maintain persistent memory across sessions. SOUL defines who they are, MEMORY stores episodic and semantic knowledge, and USER tracks operator preferences — all searchable at runtime.
Agent identity file. Defines core persona, operational constraints, and communication style. Loaded at startup — shapes every agent response.
role: artisan-craftsman
cadence: solar-cycle
personality: strict but fair
Episodic and semantic memory. Stores workspace facts, project conventions, recurring corrections, and durable operator preferences.
workspace: ~/gitlab/cmux-next
lsp: rust-analyzer
operator: conservative risk
Operator profile. Backed by SQLite — language preference, CV path, interests, session rhythm, and known feedback patterns.
language: English
session: ~11:00 UTC
signal: intellectually rigorous
WELES is a dedicated governance agent that intercepts potentially destructive commands, enforces policy guardrails, and maintains sandbox isolation — before anything runs.
WELES intercepts every bash_command before execution. Destructive patterns (rm -rf, fork bombs, credential exfil) are blocked by policy.
Managed commands run in sandboxed environments. File mutations (cp, mv, rm) are blocked by WELES governance — use python_execute instead.
High-risk operations trigger human-in-the-loop approval. WELES presents blast-radius warnings and waits for operator confirmation.
All governance decisions are written to a WORM (Write Once Read Many) ledger. Immutable audit trail for compliance and forensics.
tamux agents interact with external services through a typed plugin API. Gmail, Calendar, Slack, Discord, Telegram, and web search — all accessible to agents as first-class tools.
Read inbox, search, send, trash, archive, star, mark read/unread, and view full threads.
List events, view details with attendees, create, update, delete, and manage multiple calendars.
Send messages to channels. Operators get notified when agents complete long-running tasks or need input.
Send to channels or direct messages. Human-in-the-loop approvals routed through Discord when configured.
Send to configured chat. Real-time agent notifications and approval requests via Telegram bot.
Agents search the web for real-time information. Results fed directly into agent reasoning context.
Connect to all major LLM providers out of the box. Anthropic, OpenAI, open-source models via Cerebras/Groq/Together, local Ollama, and more. Switch providers at any time from the Settings panel.
Multi-platform support for Linux, macOS, and Windows. Build from source or download pre-built binaries.
# Clone the repository
git clone https://github.com/mkurman/tamux.git
cd tamux
# Build Rust components
cargo build --release
# Install frontend dependencies
cd frontend && npm install# Install via npm (all platforms)
npm install -g tamux# Linux
curl -fsSL https://github.com/mkurman/tamux/releases/latest/download/tamux-0.2.10-linux-x86_64.zip
# macOS Intel
curl -fsSL https://github.com/mkurman/tamux/releases/latest/download/tamux-0.2.10.dmg
# macOS Silicon
curl -fsSL https://github.com/mkurman/tamux/releases/latest/download/tamux-0.2.10-arm64.dmg
# Windows
curl -fsSL https://github.com/mkurman/tamux/releases/latest/download/tamux-0.2.10-windows-x64.zipReact-based UI with split panes, agent panel, execution canvas, and more.
Terminal multiplexer built for AI agents. Open source under MIT License.