tmai - Interface Tátil para Multi-Agentes
trust-delta/tmai
Orquestre múltiplos agentes Claude com memória persistente e despacho de workers
Ver no GitHubPlataforma de orquestração e supervisão para executar múltiplos agentes Claude (produtor + workers) em paralelo, gerenciando continuidade, memória de projeto e decisões entre sessões. Oferece substrato sempre ativo, observabilidade em tempo real e controle fino sobre workers em tmux, permitindo que o produtor se concentre apenas nas decisões irreducíveis.
Instalação
npx convez-ai trust-delta/tmai1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Desenvolvimento paralelo de múltiplos projetos com um agente produtor por projeto
- Supervisão e inspeção de trabalho de agentes workers em segundo plano
- Manutenção de contexto cross-project e histórico de decisões entre sessões
- Automação de tarefas mecânicas enquanto concentra decisões humanas no essencial
Veredito

tmai é uma solução arquitetural madura para o problema real de executar agentes long-running com memória e continuidade. Excelente para quem precisa orquestrar múltiplos projetos em paralelo sem perder contexto, mas requer compreensão profunda de workflows de agentes.
README
A tradução para o português deste README ainda está na fila.
tmai
Tactful Multi Agent Interface — the exoskeleton a Producer agent uses to run multi-project development, and the console you support and observe through.
You talk to one agent per project — the Producer. It remembers your past decisions, tracks what changed (CI, PRs, in-flight work), dispatches a worker when implementation would crowd the conversation, and brings you only the decisions that genuinely need a human. tmai is what makes that possible: the continuity layer, the worker spawn/steer surface, the always-on substrate, and the window you watch through.
日本語版: README.ja.md
This is the tmai monorepo and release hub. The UI clients (
clients/react/,clients/ratatui/), the wire contract (api-spec/), the installer, and the release pipeline live here; only the engine source stays private intmai-core.
What tmai is for
Run several coding projects in parallel: one Producer per project — a Claude Code session you talk to — and workers under it, one bounded-and-report-back agent per repo. The Producer is read-mostly: it holds the project's memory and current decisions, watches what changed, does the mechanical things itself, dispatches a worker when the implementation would crowd the conversation, and routes only the irreducible decisions to you — densified, so your scarce review attention goes to the true bottleneck and nothing else.
The bet: a strong model doesn't need a tool to make its decisions for it — but a called LLM agent is still episodic (it can't run forever), amnesiac (it doesn't learn across sessions), blind inside the workers it spawns, and bounded in context. tmai supplies exactly those structural pieces:
- continuity — a fused baseline (cross-project memory ⊕ project decisions ⊕ in-flight handoff) composed and handed to the Producer at session start, so re-entry costs ~0
- real workers — spawn a Claude Code session in a repo's worktree with a proper brief, run it, get it back; inspect and steer it
- an always-on substrate — a supervisor that outlives episodic sessions, so an event that lands at 3am has somewhere to go
- observability — the human's out-of-band window into what a worker is actually doing, which the Producer's summary can't give you
What tmai is not
- Not an orchestration feature. tmai does not decide what to launch, when, how to integrate it, or what architecture to use — that's the Producer's reasoning, in an agent's context where it can flex, not calcified into tmai's code. tmai routes; it doesn't build.
- Not single-project fan-out. The rate limiter is your review attention, not agent compute — five agents finishing in an hour just queues five hours of review onto your desk. The parallelism that's real lives across projects, not inside one.
- Not a substitute for your judgment. tmai surfaces the decisions that need you and tracks whether the Producer's confidence was calibrated; it doesn't override the model, and it doesn't pretend a glance-and-approve is a real review. (A thin statement of intent — "this is the contract boundary, push back if it doesn't fit" — is a different thing, and a good one.)
What tmai requires of you
tmai is opinionated, and the opinion is the product. Adopt it and you adopt a discipline it won't let you quietly skip:
- Purpose and means stay apart. What you commit to — the outcome you bear — is a decision. How you're currently chasing it — the mechanism — is an approach, kept cheap to change. They're separate records on purpose: a means dressed up as a commitment is the failure mode, not a shortcut.
- Only you accept a decision. The Producer drafts it, argues it, runs the means under it — but it never accepts it for you. The one act that binds the project stays a human act, by construction. There is no "the agent decided."
- Your attention is rationed, not spent. tmai brings you the decisions that actually need a human, and refuses to pass a glance-and-approve off as a review.
Why force this instead of just going faster? Because the scarce thing is your judgment, not agent compute — and a tool that makes the wrong workflow effortless (approve-all, fan out forever, let the agent bless its own work) burns the scarce thing exactly where it should be guarded. The discipline is the floor that keeps you bearing the commitments while the agent carries the mechanism.
This is a worldview, and it's the whole point — not a setting to turn off. If what you want is to maximize how much an agent does while you're not looking, tmai is the wrong tool, deliberately. It keeps a seam where you stay in the loop, because that seam is the value: remove it and what's left isn't tmai. Better to know that before you install than to discover it by friction.
The shape
- You (episodic) — talk to one Producer per project; decide the irreducible.
- The Producer — one per project (a Claude Code session). Holds the baseline, triages what changed, does the mechanical things itself, dispatches workers, writes briefs. Read-mostly: proposes architecture, doesn't decide it; routes, doesn't build.
- tmai — the exoskeleton the Producer runs on (continuity, worker spawn/steer, always-on substrate) and the console you support and observe through (WebUI, TUI, mobile remote).
- Workers — one per repo: bounded, contract-anchored, report-back Claude Code sessions. A worker never spans repos; tmai does not auto-orchestrate them — coordination across a project's repos is the Producer's reasoning, not tmai's code.
A "project" is a single repo, or the smallest group of repos that share a contract surface toward a common goal (e.g. engine + spec + WebUI). One Producer per project, whatever its repo count.
Install
Prebuilt bundle tarballs are attached to this repo's Releases. Pick the installer that fits your workflow — all three land the same bundle:
Curl (portable)
# Latest release into $HOME/.local (default prefix):
curl -fsSL https://raw.githubusercontent.com/trust-delta/tmai/main/install.sh | bash
# Pinned version + custom prefix:
curl -fsSL https://raw.githubusercontent.com/trust-delta/tmai/main/install.sh \
| bash -s -- --version 3.2.0 --prefix /usr/local
Homebrew (macOS + Linux)
brew tap trust-delta/tmai
brew install tmai
cargo binstall (Rust users)
cargo binstall tmai
Reads the [package.metadata.binstall] stanza on the tmai crate and pulls the matching platform tarball from Releases.
What lands on disk
$PREFIX/bin/tmai
$PREFIX/bin/tmai-ratatui
$PREFIX/share/tmai/webui/ # served automatically by tmai (binary-relative fallback)
$PREFIX/share/tmai/api-spec/ # OpenAPI + CoreEvent JSON Schema reference
Supported platforms: Linux x86_64, Linux aarch64, macOS arm64. For other platforms, build from source in tmai-core (requires repository access).
Quick start
# One-time setup: register Claude Code hook receivers in ~/.claude/settings.json
tmai init
# Start the engine + operational dashboard TUI (engine health, activity, logs, UI launcher)
tmai
# Open a Producer session for a project (or repo group), with the fused baseline handed in
tmai producer <unit>
# Browse the decision store
tmai decisions
tmai serves the bundled WebUI automatically — open the URL it prints. For WebUI development (Vite HMR against a tmai backend), see CONTRIBUTING.md.
What's shipped today
- Engine (
tmai-core, private) — HTTP/SSE API server (/api/*,/api/events); MCP host (the Producer's tools for dispatching and steering workers, inspecting agents, driving PRs/CI, and acting on prompts — over stdio JSON-RPC 2.0); hook-based agent detection (attention: started | halted | completed | null, driven by Claude Code hooks — no polling); and the workbench:tmai producer <unit>composes the fused baseline and hands it to a Producer session,tmai decisionsbrowses the decision store,tmai handoffis the in-flight work-state store. - React WebUI (
clients/react/) — the operator surface today: agent list, live preview via xterm, prompt/approve, multi-pane display modes, mobile remote withAskUserQuestionsupport. On a graduation path toward tmai's own surface — across multiple projects, check project state while conversing with the Producer — not an operator dashboard, but a window onto what the Producer sees. - Ratatui TUI (
clients/ratatui/) — andtmai's default mode is a dashboard TUI: engine health, activity, detections, UI registry, logs, and launching the UI clients. A health viewer + launcher, not an agent-conversation surface. - Wire contract (
api-spec/) — OpenAPI 3.1 + CoreEvent JSON Schema + MCP tool snapshot. UIs integrate via three standard surfaces: HTTP REST (/api/*), the SSE event stream (/api/events), and MCP (tmai mcp). The spec follows SemVer independently of the engine; UIs must tolerate unknown event variants and optional fields. - Git surface — PR / CI / issue integration via
gh, worktree CRUD. - Install & release —
install.sh, the Homebrew tap, thecargo binstallmetadata stub, and the release workflow that assembles per-target bundle tarballs.
Direction
The Producer model is being built out, core-first:
- bottom-up feedback — a worker that completes a task but noticed "this works, but a different approach would be better" writes that down; the Producer periodically synthesizes the accumulated notes and brings tradeoff proposals to you. The channel that keeps the methodology from calcifying — distinct from "I'm stuck, decide" (which the Producer catches in real time).
- idle-gated synthesis — when you're away, the always-on supervisor wakes the Producer in a retrospective mode; you come back to a dense digest of just the decisions that need you. Preemptible — your session takes priority.
- the WebUI graduation above.
The previous "orchestration as a feature" model — auto-approve, cron-scheduled launches, automatic CI-event handling — was removed across v3.0.0–v3.x: a tool that makes the wrong workflow easy is worse than no tool. The design records for all of this live in tmai-core (private).
Structure
| Repo | Visibility | Role |
|---|---|---|
trust-delta/tmai (this repo) | public | Release hub + monorepo. Holds the React WebUI (clients/react/), ratatui TUI (clients/ratatui/), wire contract (api-spec/), installer, and docs. Publishes the bundled tarball. |
tmai-core | private | Core engine — HTTP/SSE API server, MCP host (the Producer's dispatch/steer tools), hook-based agent detection, the workbench. Ships per-target binaries via core-v* Releases; generated spec + types flow here via bot PRs. |
tmai-api-spec / tmai-react / tmai-ratatui | archive | History-only. Content merged into this repo on 2026-04-23. |
Contributing
UI / contract / docs / packaging changes happen right here — file issues and PRs against this repo:
- React WebUI behaviour →
clients/react/ - Ratatui client behaviour →
clients/ratatui/ - Wire contract (REST endpoints, CoreEvent variants, error taxonomy) →
api-spec/(generated — edits flow fromtmai-corevia bot PRs) - Installer / release workflow / docs → root
Engine-only changes (the MCP host, HTTP/SSE implementation, agent detection, the workbench, the Producer's dispatch tools) happen in the private tmai-core. If you need an engine change, open an issue here and we'll triage it through.
The previous sub-repos — tmai-api-spec, tmai-react, tmai-ratatui — are archived as of 2026-04-23. Please don't file issues or PRs there.
See CONTRIBUTING.md for the local development setup (Vite HMR + tmai backend), the bot PR recovery flow, and PR conventions. Security reports go through SECURITY.md (GitHub Private Vulnerability Reporting).
Screenshots
History
tmai started as a single monorepo (through 2026-04-18), then briefly split into four repositories (tmai-core + tmai-api-spec / tmai-react / tmai-ratatui). On 2026-04-21 the UI layer and wire contract were consolidated back here under clients/ and api-spec/; the three sub-repos were archived on 2026-04-23. The last pre-split commit is 88bab7d; the re-consolidation shipped as v2.0.0.
From v3.0.0 (2026-05) tmai inverted: it stopped trying to be the orchestration layer ("a smart layer over many agents, supplying what each one lacks") and became the exoskeleton a Producer agent uses — the orchestration locus moved from tmai's code to the Producer's reasoning. v3.0.0–v3.x removed the old-premise subsystems (auto-approve, cron scheduling, automatic CI-event handling) and the Producer workbench landed as the new center.
The tmai crate on crates.io now exists as a thin installer-metadata stub: 1.7.0 is the last "real" crate-packaged release (not yanked), 1.7.1 was a deprecation marker, and 2.0.0+ carry the cargo binstall metadata + stub binaries that print a pointer at the real installer if invoked via cargo install tmai. Use any of the install paths above instead.
License
MIT — see LICENSE.