Desktop app

The tamag0 desktop app (macOS, Windows, Linux) is where humans and companions work together. This is a tour of the actual interface: the sidebar, the three thread tabs, the composer, the context panel, and every settings section.

Layout at a glance

Left rail — workspace avatars (one per company/agent connection), the Library destination, the eco-mode button, the language switcher, and settings.
Thread sidebar — three tabs (Conversations, Activity, Thoughts) with per-tab unread counters, search, and reading filters.
Main area — the active thread: streamed responses, permission prompts, the workflow progress dropdown, and the composer with its execution controls.
Right context panel — what the thread is working with: files and repos touched, linked threads, participants, and any background tasks the companion is running.
Status bar — live token usage and rate-limit state for the provider in use.

Language

The desktop app ships in English (default) and French. You choose it on the very first onboarding screen, and a language switcher sits in the left rail, just above settings — toggle either and the whole interface updates instantly, no restart. The choice covers everything you see: the chat, onboarding, settings, the Library, native surfaces (system-tray menu, notifications, dialogs), and the right-click edit menu. It is remembered per install. Agent responses follow your agent's own language preference, set on its profile — independent of the interface language.

Library

The Library button in the left rail opens your Library — one shared store of files reachable from every one of your companions, separate from the thread tabs since it isn't a conversation filter. Search across it, inspect an artifact's folder and processing status, download it, or drop new files in yourself through the native file picker (see Library).

Formatted and mathematical answers

Companion answers are rendered, not dumped as raw text: headings, lists, tables, and syntax-highlighted code blocks. Mathematical notation is typeset — inline expressions sit in the flow of a sentence, displayed equations get their own centred line, and the usual LaTeX notation works whichever delimiters your companion writes. Fractions, sums, integrals, matrices, Greek letters, and the standard operators all come out as real formulas rather than backslash soup, so a conversation about mathematics stays readable by both sides. This applies everywhere markdown is shown: the conversation, subagent results, the context panel, interactive question previews, and Library markdown artifacts. Code samples are left untouched — a formula written inside a code block stays literal.

Activity in a conversation

When a companion works through a task, tamag0 keeps the conversation readable: consecutive tool calls are collapsed into one expandable activity row that shows the action in progress in plain words, not a list of tools. Once the work is done, the row settles on how many actions it took and how long they ran. Open the row for the per-call detail — every call, not only the failed ones; interactive questions and visual results remain visible in the flow. Codex reasoning summaries follow that same activity row instead of becoming separate chat messages, so live progress and a reopened thread keep the same compact shape.

Threads: three tabs

Conversations — the threads where a human talks with a companion. Draft threads are only persisted on the first message; titles are generated automatically.
Activity — the companion's autonomous work: messages from other agents, scheduled-task runs, Slack traffic processed in the background. A live pulse shows when an autonomous thread is currently running. When a companion needs a human decision, the thread is escalated — it moves from Activity into Conversations so it lands in front of you (see Thread lifecycle).
Thoughts — the retained results of the companion's autonomous reflection: introspection, analyses, monitoring notes, and dream narrations that it chose to carry forward after reflection (see Continuous learning). It is an auditable record of what the companion chose to retain, not a dump of hidden model reasoning.

When one thread creates related work, the sidebar presents that family as a collapsible group inside each tab. The leader and every visible descendant stay aligned at one flat level; expanding the group reveals the rest without a nested tree. If the original parent is hidden or belongs to another tab, the first visible member leads that tab's group instead. A dot on the leader signals unread activity inside the collapsed group.

Grouping never overrides where an individual thread belongs. If one autonomous child starts waiting for you, that child alone moves from Activity to Conversations; its siblings stay where their own state puts them. Thoughts likewise remain Thoughts even when they have children.

Reading controls

Working with agents that act on their own means lots of threads — the sidebar is built for triage:

Hide read / show read — per-tab toggle (Activity hides read threads by default, so it behaves like an inbox).
Show resolved — in Conversations and Activity, read closed, resolved, abandoned, and archived threads are hidden by default. Unread terminal threads remain visible. Turning on this toggle adds terminal threads to the current view; Hide read and other active filters still apply.
Mark all as read — one click clears the current view.
Filters — by agent (when the workspace has several) and by domain, plus full-text thread search.

Deleting a thread that has descendants is scope-aware: the confirmation shows the current number of affected threads. If that family changes before deletion completes, nothing is deleted; the app refreshes the count and asks you to confirm the new scope again.

The composer

Lower bar under the composer — message actions (attachment, mention, and skill) stay on the left; execution, workspace, and agent state stay on the right. The current explicit model preference remains visible after a message is sent, while Auto leaves the choice to the companion.
Hierarchical execution menu — open the execution control to choose Model, Effort, Model size, and Permissions whenever each axis applies. Model starts with Auto, then lists every configured provider and the models in its live catalogue, including custom providers. Choosing a Claude or Codex model resets Effort to Auto; other providers use their catalogue defaults, and unsupported axes stay hidden.
Skills as slash commands — type / to invoke any skill; multi-step skills show a progress dropdown with the current step, and you can skip ahead.
Agent mentions — type @ to pick an available companion. Guests working in the workspace show their home workspace in the list (for example, Luc (Softizy)), so people with the same name stay distinguishable. The selected companion is addressed by its stable identity, not by the display name.
Attachments — drag-and-drop or paste images and files.
Agent picker — with several companions in the workspace, choose who you're addressing per message.
Mention a guest on assignment — type @ in a conversation, then choose the guest shown as Name (Home workspace). tamag0 inserts its stable routing identity, so same-named guests remain distinguishable. See Cross-workspace missions for the assignment lifecycle and access limits.
Interactive questions — when the companion needs a decision mid-task, it asks with structured options instead of guessing.

Automatic provider fallback

When the composer is on Auto, a recognized provider quota/session exhaustion or supported HTTP 429 can continue the same turn on the next configured provider. The composer remains on Auto while the live header follows the provider, model, parameters, effort, and attempt that are actually running.

Each accepted switch creates one durable notice in the conversation. If every configured provider is exhausted, the terminal card shows the final error and the ordered history of actual attempts; providers skipped during preflight or cooldown are not presented as attempts. The same status survives reopening the thread, and assistive technology announces each accepted attempt or terminal state once.

Fallback after partial work uses the existing conversation history plus one internal continuation instruction. Visible partial output stays in the conversation, while completed tool actions are never mechanically replayed. The same recovery behavior applies to direct conversations and background Hub-routed work without relaying or acknowledging an intermediate attempt.

An explicit provider or model choice is a pin, so it never switches automatically. A pinned failure offers Retry and Switch to Auto and retry. Retry makes one attempt with the selected provider, bypassing its cooldown once without starting a cascade; switching to Auto uses the configured priority order again. Authentication, network, timeout, HTTP 5xx, context-window, and unknown failures stop instead of switching providers.

You never wait for the agent

The composer stays yours even while the companion is thinking:

Queue while it works — press Enter during a response and the message is queued as pending; it's delivered automatically the moment the current turn finishes. Queue several — they arrive as one combined message.
Interrupt on your terms — the pending banner has a Send now action (also triggered by pressing Enter twice): it stops what the companion was doing and delivers your message immediately. Use it when what you just learned changes the task.
Edit mid-flight — a pencil icon on your last message lets you take it back while the companion is still responding: the response is stopped and your text returns to the composer for editing and resending.
Drafts and pending queues are kept per thread — switch threads freely, nothing is lost.

Context panel

Every thread has a context panel showing the files and repositories the companion touched, its actual parent and direct children (related work stays navigable after it finishes), and the participants — humans, local companions, and external agents taking part in the thread. Parent and child work is separated into clear sections; other informational relationships are not presented as family.

The panel also links out to the web. When the thread is waiting on an external event, it names what is being watched — a pull request, a CI run, a deadline — and one click opens that pull request in your browser. Repository entries work the same way: a click opens the repository on its remote, whether that is GitHub, GitLab, or a self-hosted forge. Anything with no page behind it — a repository with no remote, a plain deadline — stays plain text instead of becoming a dead link.

Background tasks

When a companion starts a long-running command in the background — so it can keep working while the command runs — that task appears in a Background tasks section of the context panel, live, the moment it launches. Each entry carries a status (running, done, or killed); clicking it opens a detail view with the exact command and the output collected so far. The section stays hidden when there are no background tasks to show.

Workspaces and eco mode

A workspace connects to a company and holds one or several agents — added by API key, by invitation, or provisioned automatically. Each agent has its own secure credentials, threads, and an isolated working directory per thread. Multiple workspaces (e.g. two companies) work side by side, with instant switching from the left rail.

Eco mode (the leaf button) mutes incoming agent-to-agent requests for two hours to save tokens — your companion stops accepting peer work but stays available to you. One click resumes normal service early.

Always-on by design

The app keeps companions reachable: messages from other agents, Slack, email, and scheduled tasks are processed in the background — ordered sequentially per domain, in parallel across domains, with automatic reconnection after network loss or OS sleep.

On Windows and Linux, closing the window doesn't quit the app — tamag0 minimizes to a system tray icon and companions keep working in the background. The tray menu offers Show tamag0, Hide to tray, and Quit tamag0; the first time the window hides, a one-time hint confirms the app is still running and offers a Quit completely shortcut. This is on by default — turn off Close to tray under Settings → General so closing the window quits instead. macOS has no tray: the Dock already owns show, hide, and quit.

Permissions and control

Sensitive actions (shell commands, file writes, outbound messages) surface as permission prompts with once / this-thread scopes; denials are visible, never silent.

If you trust a companion to act without interruptions, open the execution control under the composer, choose Permissions, then choose Bypass for the current conversation. The same bypass can be set as a global default in Settings; enabling that global default takes an explicit confirmation. Either way, every affected conversation shows a persistent banner. Choose Inherit to use that default or Ask to restore prompts. See Security.

Settings tour

Agent — the companion's profile: name, origin story, specialty; per-agent configuration when the workspace has several. This is also where you create a new agent or team.
Extra directories — per-agent read access to folders (and everything under them) outside the thread's working directory. Add a path (or pick one with a folder browser) and the companion can read there without a permission prompt each time — useful when you want it to analyze documents that live elsewhere on your machine. Writes still go through the normal permission prompts; the access is read-only, local to this device, and not synced across machines. See Security.
General — runtime selection with both Claude Code and Codex set up from the app; working directory; performance (how many agent workers run in parallel — one worker per active thread, whatever the runtime: Claude, Codex, or local models; size it to the number of conversations you expect to run at once); context compression (two independent stages you can toggle — see Performance); global CLI install so your companion follows you into the terminal; and — on Windows and Linux — the Close to tray toggle that decides whether closing the window minimizes to the system tray or quits.
LLM Providers — the model catalogue, custom providers and models, and the per-agent runtime priority order used for automatic failover. Priority choices follow your account across devices after restart while remaining usable offline.
Workspaces — add a workspace with an API key, switch, manage its agents, and — for workspace administrators — place an active companion on a temporary, revocable assignment in another workspace. The receiving workspace's administrator accepts the single-use invitation from Add agent; invited companions remain visibly identified by their home workspace. See Cross-workspace missions for the complete flow and safety guidance.
MCP Servers — connect external tools, with per-server visibility (just me / whole workspace) and per-tool permissions.
Integrations — Slack, Gmail, Calendar, Jira, and more (see Integrations).
Reflexes — the behavioral layer you can inspect and edit: golden rules, best practices, forbidden commands, and reminders, per agent or for all.
Skills — browse, create, and share skills (see Skills).
Scheduled Tasks — recurring jobs with their schedules and last runs (see Scheduled tasks).
Watchdog — the recent decisions of the thread watchdog, so autonomous supervision stays auditable.
Appearance — light/dark theme.
About — version and updates; the app auto-updates.

Status and usage

The status bar shows live token usage against the provider's rate-limit windows, with reset times — no surprise limits mid-task.

Onboarding in minutes

Pick your interface language (English or French) as the first step, connect with a company key or an invitation, name your companion, then check the local development tools it uses for projects: Git and GitHub CLI. On Windows, tamag0 can install those tools before model runtimes; on macOS and Linux it shows their status so you can install any missing tool with your system's usual method. You can continue without them and configure them later. Next, install/sign in to the model providers (Claude and Codex both set up out of the box; each skippable — signing in reuses your existing Claude or ChatGPT subscription, no separate API billing), pick a workspace folder — done. No orchestration to wire, no infra to babysit.

Download tamag0 Desktop

Download tamag0 Desktop for Windows, macOS, or Linux. The download page offers a direct Windows installer, separate Apple Silicon and Intel builds for macOS, and AppImage, .deb, and .rpm packages for Linux. It is available in French too; the latest public release remains available as a fallback for other architectures.