# Talkio puts several models in one group chat and keeps the keys out of local storage

> A local-first Tauri 2 application where several models share a conversation, each with its own persona, temperature and top-p. The interesting parts are the ones a feature list skips: two lockfiles committed for one dependency set, a Rust whitelist in front of every git command, and backups that deliberately leave your provider keys behind.

**llt22/talkio** — Local-first multi-AI group chat desktop app — pull gpt, Claude, Gemini, DeepSeek into one conversation. Tauri 2 + React 19.

- Repository: https://github.com/llt22/talkio
- Stars: 338 · Forks: 41
- Language: TypeScript
- License: MIT
- Published: 2026-09-14 · Updated: 2026-09-14 · Language: en
- Canonical page: https://hysenlabs.com/projects/llt22-talkio

## Two lockfiles at the root, and the documented path only covers one

The install path is npm, and the whole thing is two commands once your prerequisites are in place.

```bash
npm install
npm run tauri dev
```

Production bundles come from `npm run tauri build`. The prerequisites are Node.js 18 or later, a Rust toolchain installed through rustup, and the system dependencies listed in the Tauri setup guide for your platform, so nothing is installed on your behalf. What is worth noticing is that the root carries both package-lock.json and pnpm-lock.yaml, which means two package managers have a resolution tree committed for the same dependency set while only one of them is documented. Every script in package.json assumes npm. Formatting and linting run through biome, check pairs biome with tsc --noEmit, tests are vitest, and end to end runs are playwright. Which lockfile wins on your machine is not something the documentation decides for you, and a divergent tree shows up as a version skew between two developers rather than as an error.

## Group chat is the product, and each seat carries its own settings

The centre of the design is a conversation with more than one model in it. Unlike a one to one chat, several models enter the same thread, they can see what the others have said, and the stated intent is that they think independently instead of simply agreeing with each other. You address a specific participant with an @ mention, or you let everyone take turns. Each participant can be bound to a persona, which is a name plus a system prompt, and the persona carries its own temperature, its own top-p and a reasoning effort control, so a debate opponent and a translator in the same thread are not running the same decoding settings. One model can hold a different persona in a different conversation, which is the part that makes a library of roles practical rather than decorative. A group level system prompt sits above the individual ones and steers the direction of the discussion. The roles given as examples are translator, code reviewer, debate opponent and a word chain player.

## Keys live in the OS credential store, and backups leave them there

Conversations and settings are stored locally in SQLite through tauri-plugin-sql, and no cloud service of the project's own runs anywhere in that path. API keys are the part with real care in the design. On desktop they are written to the operating system credential store, meaning macOS Keychain, Windows Credential Manager or Linux Secret Service, and explicitly not to the application's own local storage. On Android they sit in the app private WebView storage instead. Keys are used only to reach the provider you configured, with nothing routed through a Talkio service. The boundary shows up most clearly in backup. Settings and the complete chat history export as JSON and can be restored on another device, and that export deliberately excludes provider and speech API keys, so restoring on a new machine means re-entering credentials by hand. One thing does leave the machine regardless: chat messages are sent to the provider you configured, which the documentation names as the condition under which the feature works at all.

## MCP tools reach you over SSE, and stdio only on the desktop

External tool servers connect through the Model Context Protocol, with the SDK pinned at 1.30.0. Two transports are supported and the split between them is not even. SSE covers remote servers, stdio covers local ones, and stdio is marked as desktop only. That is the constraint to plan around, because a local tool server is the interesting case for filesystem or shell work and it is precisely the one you cannot attach on the Android build. The listed uses include system capabilities such as calendar, location and reminders as well as custom tool servers you supply, and the model decides by itself when a tool is worth calling, which means a badly described tool shows up as a model that never reaches for it. A .mcp.json file sits at the root of the repository, which suggests at least part of that server configuration is meant to live beside the code rather than only inside the app settings.

## Four wire protocols behind one adapter directory

The provider list is long, and the reason it works is that the protocols behind it are not the same. Presets ship for OpenAI, Anthropic, Google Gemini, Azure OpenAI, OpenRouter, DeepSeek, Groq and Ollama, and the app speaks four distinct request shapes: Responses, Chat Completions, Anthropic Messages and Gemini Generate Content. The directory structure keeps that split contained, with a provider-adapters folder for protocol adaptation, a provider-profiles folder for presets and the model catalogue, and a runtime folder described as a unified streaming runtime. The dependencies are built on the AI SDK with separate packages for Anthropic, Google, Groq and OpenAI, plus an openai-compatible package that catches everything else, which is what makes a preset for Ollama possible without a bespoke adapter. Reasoning output is handled as a separate concern again, since `reasoning_content` and `<think>` tags from models such as DeepSeek and Qwen arrive in a shape the four protocols do not agree on, and the renderer has to show a chain of reasoning without freezing the stream.

## File and git access pass a Rust whitelist and a confirmation dialog

Bind a local project directory to a workspace and the model can read, search and edit files in it, with a per file preview and an explicit confirmation before a write lands. Git access is narrower on purpose. Status, diff and log can be run from inside the conversation, and the safety story is given in two parts: a whitelist in the Rust layer plus a confirmation dialog in the interface. Whitelisting the verbs rather than the paths is the part that limits the damage, because the model can read a diff it has no way to push, and the Rust layer matters here because these commands run in the application process rather than in a sandboxed sidecar. File parsing covers PDF, Word, Excel and a range of text formats, and images arrive by drag and drop or by pasting from the clipboard. Voice input rides on Whisper compatible speech to text services from Groq or OpenAI, with push to record.

## v1 was Expo, v2 is Tauri 2, and the bundle is about 20 MB

The move from React Native to Tauri 2 is explained with four reasons rather than a slogan. Rendering was the first: the React Native bridge bottlenecked long conversations, streaming output and large message lists, whereas Tauri uses the native WebView so the front end runs against a standard DOM and heavy Markdown, Mermaid and KaTeX rendering stays smooth. Coverage was the second, with Windows, macOS and Linux desktops plus Android through a WebView, which is one codebase instead of two. Size was the third, roughly 20 MB against 100 MB or more for an Electron build, with no Chromium bundled and startup to match. The fourth is the Rust plugin ecosystem for SQLite, filesystem and HTTP work. On the front end the stack is React 19 with Vite, Zustand for state, TailwindCSS v4 with shadcn/ui over Radix, Stackflow for mobile navigation, react-markdown with Mermaid and KaTeX for output, and Framer Motion for animation.

## Agent config files are committed next to the chat interface

Several files at the root have nothing to do with chatting: a .mcp.json, a .windsurf directory and claude-code-rules.md, which together say the repository is set up to be worked on by coding agents and not only run as an application. Tooling is centralised in biome.json, which owns both formatting and linting, and the check script pairs biome with tsc --noEmit. Tests come in three shapes, vitest for units, playwright for end to end against its own config file and an e2e directory, and a live provider test that runs a single named file under src/services/runtime/ai-sdk against real endpoints. A sync:model-catalog script regenerates the model catalogue from a development source, which is worth knowing before you hand edit a provider profile. The release rhythm over the last two months is steady: v2.15.0 on September 3, 2026, v2.16.0 on September 17 and v2.16.1 on September 28, with package.json carrying 2.16.1 and the most recent push to main dated September 28, 2026. Two open issues sit against 338 stars and 41 forks, under an MIT licence in a LICENSE file at the root.

## Conclusion

Talkio is worth the setup cost if what you want is a room where several models argue about the same question rather than a single assistant you prompt in isolation, because the persona system and the mention mechanism are built for that and nothing else in the category is quite the same shape. It costs you more than a web client, since you supply your own keys across up to eight provider presets and you are the one running npm install against a Rust toolchain. Before you commit, check four things: which lockfile your setup actually resolves from, since both a package-lock and a pnpm-lock sit at the root; whether your tool servers need stdio, which is desktop only; whether the backup file you plan to rely on includes credentials, which it does not; and whether the model catalogue sync script is going to overwrite a profile you edited by hand. Nothing here needs an account, and nothing here needs a server you did not start yourself.

## FAQ

### What is Talkio?

Talkio is a local-first desktop and mobile application built on Tauri 2 and React 19 that puts several AI models into one group conversation. Each participant can be bound to a persona with its own system prompt, temperature, top-p and reasoning effort, and you can address one model with an @ mention or let everyone take turns.

### Is Talkio safe with my API keys?

Keys are kept out of application local storage on desktop, going instead into macOS Keychain, Windows Credential Manager or Linux Secret Service, and on Android into app private WebView storage. Keys are used only to reach the provider you configured, and the JSON backup deliberately excludes provider and speech keys. Chat messages themselves are still sent to that provider.

### What do I need to build Talkio from source?

Node.js 18 or later, a Rust toolchain installed through rustup, and the system dependencies listed in the Tauri environment setup guide. Then run npm install followed by npm run tauri dev, and use npm run tauri build for a production bundle.

### Does a Talkio backup file include my API keys?

No. Settings and the full chat history export as JSON and can be restored on another device, but provider and speech API keys are left out of the export on purpose and stay in the operating system credential store.

### Why did Talkio move from React Native to Tauri?

Four reasons are given: the React Native bridge bottlenecked long conversations, streaming and large message lists; one Tauri codebase covers Windows, macOS, Linux and Android instead of two; the bundle is about 20 MB against 100 MB or more for Electron with no bundled Chromium; and the Rust plugin ecosystem covers SQLite, filesystem and HTTP access.

## Sources

- [Issues](https://github.com/llt22/talkio/issues)
- [License: MIT](https://github.com/llt22/talkio/blob/main/LICENSE)
- [llt22/talkio on GitHub](https://github.com/llt22/talkio)
- [README](https://github.com/llt22/talkio/blob/main/README.md)
- [Releases](https://github.com/llt22/talkio/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/llt22-talkio