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.

Arrival and offers

Arrival starts with your first companion and reuses the installation and provider connection steps. A companion without a connected model provider is not ready to answer. Your companions can work on projects you make available on your computer; this does not mean automatic project discovery or exclusively local processing.

The initial offer choice belongs to the workspace’s founding administrator, not every administrator. Joining an established company, including as an invited administrator, does not let you choose or replace its offer. A first administrator invited into a company prepared without an offer can make that initial choice. Once recorded, the choice is not changed through onboarding; later plan changes go through Softizy.

The offer chooser presents three working arrangements:

Free: one personal companion.
Pro: several personal companions that you work with.
Enterprise: an organization whose colleagues work with their companions, including external companions or a mix of colleagues and companions you create.

Pro and Enterprise display a 30-day free trial, followed by €19.99 excluding VAT per additional agent per month. The first agent is free; the reference terms apply equally to additional agents you create or invite. Model-provider usage is separate. Selecting an offer creates no companion and does not itself start a trial, subscription, or charge. Before confirming each additional agent, you are shown the commercial impact: to keep the agent after the trial, a bank card will be requested; otherwise that additional agent will be deactivated. These are the offer terms, not an active trial or an amount due: this release does not activate trials, collect cards, charge, or deactivate agents. An explicitly accepted creation can move a personal Free workspace to Pro, never Enterprise. Existing agents and their data stay unchanged. Examples illustrate possible teams, not agents already created or included in the offer. An invitation that has not been accepted remains pending.

Additional creation requires actual creation permission and explicit acceptance of the commercial terms. Older offers’ fixed included-agent ceilings no longer block authorized creation or team preparation; there is no need to archive a companion or upgrade merely to free an agent slot. Provider and technical resource limits still apply. In a personal Free workspace, confirming the additional agent after accepting those terms moves the workspace to Pro only if creation succeeds. Enterprise is available during an initial organization arrival, not as an upgrade from a personal workspace. Selecting the initial arrangement does not remove existing companions, conversations, or data. An organization invitation has its own joining path, not an offer purchase.

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.

Your personal work home

A new conversation opens with competence shortcuts above a neutral greeting. Your first home starts with available work methods. Add, remove or reorder shortcuts to make it yours; removing one never deletes the competence or changes anyone else's home. An empty customized home stays empty when new methods are published.

Your home is saved for you in the current work context and follows you across signed-in computers and companion switches. Different people and workspaces keep separate homes. Unsaved changes are shown explicitly; if another computer has saved a newer version, choose which version to keep rather than silently overwriting it.

Add a competence searches names and summaries in the authorized catalog. If nothing fits, continue with your companion to describe what you need. Shortcuts are not an execution allowlist: ordinary conversation can still use authorized methods that you have never pinned or have removed from your home.

Clicking a card prepares a request; it does not send it. Suggestions reflect current companion specialties. You can choose one or several recipients, see their specialties and the associated person's first name for other people's companions, and check the same selected set in the composer before sending. Suggestions do not grant access or certify that tools are configured. You can always start by writing freely, without a widget or a catalog match.

In a companion's home workspace, a preparation shortcut lets you resume unfinished setup or adjust completed preparation. It reopens the existing conversation without sending a message, creating resources or publishing rules. You can keep working without finishing preparation. This shortcut does not substitute personal setup for a client assignment's context.

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.

Families are ordered by their most recent message, and expanded descendants are ordered by their own most recent message. Only one family stays expanded at a time. Opening or closing an already selected family changes only the sidebar: it does not reload the conversation, and an explicit collapse remains in place while the list refreshes in the background.

Resolved conversations disappear from the daily list when resolved rows are hidden and return when Show resolved is enabled. Hiding a resolved family leader never hides active descendants: the newest visible descendant becomes the temporary leader until the canonical parent is visible again.

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.

Finding a message in a long conversation

Long-running conversations outgrow what scrolling can reach. Cmd/Ctrl+F opens a find bar scoped to the conversation you have open, and it searches the entire history — not just the recent messages currently on screen.

Results appear as excerpts with their author, counted in messages, listed from the top of the conversation down: 1 / 12 is the oldest match, 12 / 12 the most recent. Beyond 500 matching messages, only the 500 most recent are listed, still numbered against the full count — the first one reachable is then 501 / 1000, not 1 / 1000.
Picking a result — or pressing Enter — takes you to that message, in a read-only window of the surrounding history. The searched term is highlighted in the conversation, the match you are on stands out from the others, and the view scrolls to the term itself, even deep inside a long message.
The list then collapses into a position counter (2 / 12 messages) with previous/next steppers. Enter moves to the next match and Shift+Enter to the previous one; both wrap around from the last match to the first, so you can walk the matches without retyping.
Pressing Cmd/Ctrl+F again while the find bar is open selects the current query, so you can type the next search straight away.
While you are reading a search result in history, the live conversation keeps running untouched behind it. A return control stays visible for the entire historical view, identifies that you are viewing history, and takes you back to the latest message in one click.
If you simply scroll up in the live conversation, the same control stays visible while you are away from the bottom and tells you how many new messages arrived meanwhile.
Closing the find bar clears the query, the results and every highlight, but leaves you where you were reading. Returning to the live conversation is always a deliberate, separate action.

The search covers persisted message text. It does not cover the output of tools that were not persisted, text that only lives inside persisted structured blocks, or queries that span Markdown markup — the find bar states these limits itself when nothing matches.

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. Workflow progress is kept independently for each thread, so switching conversations never mixes their steps and reopening a thread resumes its own progress.
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. A sent image shows as a thumbnail in the conversation; click it to view it full size (Escape, the close button or a click outside closes the view).
Agent picker — with several companions in the workspace, choose who you're addressing per message.
Create a subthread — in an existing conversation, use the action beside Send or Stop to turn the current draft into the first message of a linked child conversation. The child opens immediately and its first answer begins by summarizing a bounded, authorized window of the parent before answering the transferred message. A failed creation or transfer keeps the parent draft available. If that parent context cannot be loaded or scoped, no answer is generated and the transferred child message remains retryable; an interrupted first answer is likewise retried with the same parent context instead of producing a duplicate child.
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 assignments 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. If you have not answered after a few minutes, the companion does not carry on without you: it ends its turn saying it is waiting for your answer. The question stays answerable: pick an option whenever you are ready, or reply in a new message, and your answer starts a new turn.

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 stay with their original thread, including attachments. Returning to a thread that is still working keeps its corrections pending. If a new turn starts while an outgoing correction is being prepared, the correction returns to that thread’s queue rather than being discarded; text you are still composing is kept separately.

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. When the companion explicitly opens a private child conversation with itself, that solo thread inherits this human-controlled setting; peer messages, integrations, and scheduled tasks do not. 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. The guest list is read-only: placement removal and company-memory permissions are managed through its link to web administration → Guests. Personal and provider-side assignment controls remain in the desktop. See Cross-workspace assignments for the complete flow and safety guidance.
MCP Servers — connect external tools, with per-server visibility (only me / your personal agents of this workspace on this computer / the company 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. The founding administrator chooses an initial offer before entering the app. The first administrator invited into a company that has not yet chosen an offer also makes this initial choice; other members skip that step. No orchestration to wire, no infra to babysit.

The companion's guided discovery opens in Conversations. Moving from discovery to synthesis removes the transition action immediately while the companion prepares its response. If Claude authentication has expired on that first turn, completing the sign-in resumes the introduction automatically instead of leaving an empty thread to restart by hand.

Invited as an employee

When a company invites you as an employee, the e-mail carries a link to a page on tamag0.ai. That page names the company, tells you that you are joining it as an employee, and offers three things: download the application, open it if it is already installed, and copy your invitation code. Your companion is created inside the company when you arrive; there is no personal space to create first. Joining an established team does not require an offer choice. If you are the first administrator invited into a company with no offer yet, you make its initial choice during installation. The page asks nothing of you and creates nothing on its own — a link opened by mistake, previewed by a messaging tool or scanned by a mail filter leaves the invitation intact. Keep that page open during the installation: it is what hands the invitation to the application.

The invitation code goes in the application's invitation field, never in the API-key field: it is an invitation, not a key. If the application refuses the code, update the application first, then open the invitation again — the invitation stays valid after such a refusal, within its normal expiry.

An invitation that has expired, been cancelled or already been used answers with a single message that does not say which; ask the person who invited you for a new one. The invitation code is the only credential this journey uses. The link that activates the observation dashboard is a different thing and never goes in the application. External collaborators — freelancers, contractors — are invited another way and arrive with their own companion; see Cross-workspace assignments.

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.