App Privacy Policy
Last updated: November 16, 2026
This page describes the Tamekoshi app, service by service. The website and the waitlist are covered by the Privacy Policy.
1. Who is responsible
Tamekoshi is published by Tamekoshi (“we”). Contact: hello@tamekoshi.com.
2. Data we collect
There is no telemetry, crash reporting service, advertising identifier or analytics SDK, and we run no account system, catalog or token broker for the app. Ordinary app use does not send data to a server we operate; the only exception is the optional update notice below.
Update notice (optional, Windows/Linux, off by default): when you turn it on in Settings, the app requests https://tamekoshi.com/version.json right away, then about 90 seconds after each start and once a day. The request carries no identifier, cookie or query string; like any web request it reveals your IP address, and its user agent names the app version. Our website host may record this ordinary request metadata. The app only tells you that a newer version exists, with a link to tamekoshi.com; nothing is downloaded or installed.
3. Data stored on your computer
GIFs in chat (Windows/Linux, optional): GIFs need a GIPHY API key you add yourself, kept in your system credential vault. With a key, opening the GIF picker requests trending GIFs, and your search words and any words your companion searches for go to api.giphy.com; your device loads the GIFs from GIPHY's media servers, which can see your IP address. GIPHY handles this data under its own privacy policy. A chat stores the GIF's address, title and size, not the media, and the GIF's title is sent to the companion's AI provider as part of the conversation. Without a key, the app sends no search to GIPHY; GIFs already in a chat are still loaded from GIPHY's media servers when shown.
Workspace sidebar (Windows/Linux): pinned, unread and hidden bot flags, section names and assignments are saved locally in the workspace WebView's localStorage. These interface preferences contain bot identifiers, never credentials or conversation contents, and are not sent to a service. Hiding a bot preserves its conversations; it can be shown again from Hidden bots. The workspace also keeps there the companion, group or room you last opened, pane widths and small blurred thumbnails of each bot's computer and browser screens.
Bot computers (Windows/Linux, optional): a bot's own computer is an InstaBox machine by default, or a local Docker/Podman container if you choose it. Its non-secret enablement and backend choice are stored in a private local computers.db. With InstaBox, the account's API key is kept in the OS credential store (an INSTABOX_API_KEY environment variable is also accepted). The machine itself — its Linux desktop, files and /data disk — belongs to your InstaBox account and is reached over HTTPS at api.instabox.sh (InsForge AI, Inc.), which receives the machine operations, commands, typed input and screenshots this bot's computer needs, a one-way digest of the companion's internal ID as machine metadata (machines created by earlier versions keep the plain ID until you recreate them) and the small driver script Tamekoshi uploads into the machine. Machines are created with a 30-minute auto-suspend. Tamekoshi publishes no port and creates no desktop viewing link for it. The machine and its disk remain in your InstaBox account until you delete them there. With the local container, creating its desktop explicitly downloads the pinned Cua XFCE image from Docker Hub (registry-1.docker.io, Docker authentication and distribution hosts) and desktop packages from Debian repositories (deb.debian.org, security.debian.org). Each bot has a separate local runtime volume containing its Linux home, files and any credentials you enter inside that desktop. Tamekoshi does not mount your personal folders, credential store or runtime socket into it. Desktop previews and human input pass through the native backend without publishing guest network ports. With either backend, when the bot uses its computer in chat, screenshots, terminal output and tool results are sent to the AI provider selected for that companion and can become part of its local conversation history. Files never move between your computer and the bot's. Commands inside the desktop contact the destinations you or the bot request. An unused computer is put to sleep after two minutes. Turning access off stops new bot actions and attempts to suspend its container; files remain in the runtime volume. Deleting Tamekoshi or its settings does not delete Docker/Podman volumes; remove those separately through your container runtime. This capability is independent of Computer Use on your own desktop.
Bot phones (Windows/Linux, optional): a companion can also own an Android phone: an emulator from your own Android SDK, with its device files in a phones folder private to the app, reached only through the app's own adb server on this computer (port 5137). Your own emulators, devices and adb server are not used. Screenshots and screen contents the bot reads are sent to the companion's AI provider as tool results, and apps or pages the bot opens in the emulator contact their own destinations.
The companion's browser (Windows/Linux, optional): opening a bot's browser in the workspace starts its own Camoufox on this machine — an anti-detect Firefox shipped with the app, held in a per-bot child process with a persistent profile and one device profile drawn per bot, under the app's own private data directory (profile and identity file). The app also starts a shared “reader” browser of the same kind, without opening a pane, when web search or reading a page needs a real browser (see Public web research). The browser talks to the app over a pipe and opens no network port. No remote service is involved in browsing unless you set a proxy for a companion's browser: all its traffic then goes through that http, https or socks5 proxy, whose address is saved in that browser's folder and whose password is kept in the OS credential store. Pages contact the destinations the person or the bot navigates to, and the tool's page reads follow the same selected-provider tool-result path as any other tool result; when a browser decision model is set, the page details listed under Quick decision models also go to that model. On the browser's first open, Tamekoshi fetches one fixed, checksum-verified data file (the fpgen machine-distribution model, delivered by GitHub releases) into the app's private data folder, shared by all bots; later launches do not fetch it again. A browser no longer in use quits after two minutes (twenty while a chat turn holds it), and closing the workspace ends it. Bot logins typed into that browser stay in its profile on your computer and are never returned to the chat, a log or a tool. Deleting Tamekoshi does not remove these folders; delete them with the app's data folder.
Skills: imported SKILL.md instructions, supporting text files, activation, companion selections and revisions stay in the local skill library (private connector SQLite storage on Windows/Linux; a private JSON library on macOS). On macOS, a starter installed with Install original from GitHub also keeps the repository and folder it came from, so the editor can name its origin; that install is the only skill action that contacts a service (see GitHub below). Importing a skill from a file does not run its scripts or contact a registry. On Windows/Linux, Settings reads the names and descriptions of skills found in ~/.claude/skills, ~/.claude/plugins and ~/.codex/skills so you can import them, and companions can create, edit and delete their own skills with a skill tool during a conversation. Selected names and descriptions, and instructions or resources explicitly read during a conversation, enter the chosen companion's AI-provider context. Skills do not grant tool or credential access; private-context turns do not supply skills.
Learning from conversations (Windows/Linux): after an ordinary chat turn — in the app, or from you in a paired messaging channel — states a lasting rule (“always…”, “from now on…”, a correction), the app records that line in a private local signal table. When a lesson is waiting, or when you run /learn, one extra request goes to the companion's configured AI provider with the waiting lessons (up to eight), an index of that companion's skills, the full text of up to two candidate skills, their recent usage counts and test summaries, and a bounded digest of the recent conversation (with /learn, also the start of your request). The provider drafts or updates a SKILL.md. By default a new skill waits as a proposal until you accept it; updates to an existing skill apply directly. Learned skills are marked with a badge and assigned to that companion; they are ordinary skills. Each review's summary, token counts and cost are kept locally. Private turns, Vault shares and @meetings requests are never captured or sent; a turn with an attachment is not captured as a lesson and the attached file is never sent, though the text typed in that turn can appear in the digest. The local notes stay until the local app data is removed.
Paid research apps (Windows/Linux and direct macOS: Context.dev, Firecrawl, Exa, Litescrape, Hunter, Apify, Search1API, MrScraper, AnyAPI, TinyFish, DataForSEO, akta, cloro, Ploid, TikHub, Apollo, ContactOut): nothing is sent to these services until you connect one with your own account or key. Connecting a provider that uses OAuth reads its sign-in metadata, may register a client and opens its consent page. After that, each operation sends its arguments, such as search terms, page addresses, company names or people's names, to mcp.context.dev, mcp.firecrawl.dev, mcp.exa.ai, mcp.litescrape.com, mcp.hunter.io, mcp.apify.com, mcp.search1api.com, mcp.mrscraper.com, api.getanyapi.com, agent.tinyfish.ai, mcp.dataforseo.com, mcp.akta.pro, mcp.cloro.dev, api.ploid.com, mcp.tikhub.io, mcp.apollo.io, contactout.com, under that provider's own terms and billing. Operations that can be billed ask for your approval first; lookups the app lists as free (such as searching an API catalog or listing countries) run without asking. Responses may enter the selected companion's AI-provider context. Keys and tokens stay in the OS credential vault.
Notion and 1Password apps (Windows/Linux and direct macOS): Notion sign-in discovers OAuth metadata and registers a client with mcp.notion.com, opens the provider's browser consent page and stores issued tokens in the OS credential vault. Authorized MCP operations send their arguments to mcp.notion.com; responses may enter the selected companion's AI-provider context. Connecting 1Password stores a service-account token in the OS credential vault and supplies it only to the installed official 1Password CLI through its child-process environment. The CLI contacts the service account's 1Password region (1password.com, 1password.eu or 1password.ca). This adapter runs only vault/item listing commands and returns IDs, names, titles and categories; passwords and secret fields are excluded. Connecting runs one listing to check the token, and every later 1Password read asks for your approval. No requests to either provider occur before you choose to connect or use that app.
In the direct macOS app, the Integrations Hub stores account names, provider definitions, enabled state, per-agent tool grants, binding fingerprints and credential revisions in ~/Library/Application Support/Tamekoshi/Integrations/accounts.json, with a private lock file in the same directory. API keys are stored separately in Keychain under com.kumanaya.tamekoshi.integrations, and OAuth tokens for Notion and other remote MCP apps you sign in to under com.kumanaya.tamekoshi.connector-oauth; they are absent from that JSON file and are never returned to the Hub or AI agents. The Hub contacts a connected remote MCP server to list its tools. Disconnect revokes account access before attempting to remove its key; a locked vault can require another cleanup attempt. Approval requests hold account/agent identifiers, the operation and its arguments in process memory and expire after 100 seconds; they are discarded on decision, cancellation or app shutdown. Only an explicit Allow once click can approve a queued request; no approval is saved or reused.
Connected tools in direct macOS companion chats execute natively inside the app. The selected AI provider receives the allowed tool names, input schemas, provider/account descriptions, arguments requested by its model and redacted results. Tool exchanges are retained with the local conversation in companion-api-threads.json, under the existing companion data directory; raw integration credentials are excluded. Conversations marked by a Vault share, an attachment or a message starting with @private do not receive integration or web-search tools on that turn or later turns. This marker is local metadata and is not sent to the AI provider. A stopped tool turn may already have performed an operation; Tamekoshi does not replay it automatically.
Earlier versions kept phone-number metadata for Saperly tools (number IDs, numbers, country/type) in connectors.db or the macOS accounts.json. Current versions no longer create it; any left over is removed when you disconnect that account. It never contained API credentials.
Quick decision models (optional, Windows/Linux and direct macOS): when enabled and a model is selected for a purpose, Tamekoshi sends bounded request text or metadata to that configured provider: your request (up to 3,000 characters) with candidate tool/skill/companion names and descriptions for routing; recent tool names for continuation advice; a new message together with the request already running, to decide whether it can run as a separate background task; Windows/Linux channel message text for priority, and a channel message with up to 2,000 characters of earlier conversation for reply decisions; the call transcript and previous utterance for call turn-taking; or — for the Windows/Linux companion browser — the active tab's title, URL, visible text excerpt, link text/URLs and its form fields with their current values (up to 120 characters each; password, file and hidden fields are left out) when a browser task asks for a next step. On Windows/Linux, a clear match can be settled by a local ranker with no request; it uses the shared-memory semantic model if you enabled it. On Windows/Linux, call audio is transcribed on your computer; on macOS it is transcribed on the Mac when macOS supports the language on-device, and otherwise by Apple's speech recognition service. Only text is sent to the decision model. Private Vault turns are excluded. On macOS, OpenRouter's decision catalog is contacted only when you click Refresh catalog; on Windows/Linux, opening the decision-model settings refreshes it at most once a day while an OpenRouter key is configured. OpenRouter and TypeSafe keys stay in the OS credential store. Requests can incur provider charges. These outputs cannot grant tool access, approve actions or bypass existing permissions; they choose among options already allowed — a confident routing answer can start the message as a background task, and a browser step the model picks can be carried out. Settings, active models and purpose routes are stored locally; the browser route falls back to the first active model when none is chosen.
| What | Where | Why |
|---|---|---|
| AI provider API keys entered in Settings (Anthropic, Google AI and OpenAI on macOS; every API-key provider and custom gateway on Windows/Linux) | macOS Keychain, Windows Credential Manager or Linux Secret Service; on Windows/Linux a key can instead be a 1Password op:// reference | To call these services on your behalf |
| Decision-provider API keys (OpenRouter and TypeSafe) | macOS Keychain, Windows Credential Manager or Linux Secret Service | Optional decision-model requests and catalog refreshes |
| OAuth logins started for AI providers (Windows/Linux) | Access and refresh tokens are stored in Windows Credential Manager or the Linux Secret Service; Tamekoshi's backend reads them for provider requests and renewal | To authenticate the provider selected for a companion |
| Desktop messaging channel connections (Windows/Linux) | Credentials (bot tokens, app tokens, server passwords and access tokens) in Windows Credential Manager or the Linux Secret Service; connection names, provider, companion routing, non-secret settings, cursor state, approved sender IDs, pairing codes, pending replies, the time of each chat’s last message, the messages a companion started, the tags and notes a companion keeps on a person, the consent basis and evidence for anyone a companion wrote to first, and who asked for no messages in the private channels.db; channel chat history in memory.db | Connect a channel directly to a companion, require approval for new senders, and keep channel conversations separate |
| Preferences (sound, delays, active pill selection, chat provider and model, shortcut) | App preferences on your Mac (the decision-model cache in ~/Library/Application Support/com.kumanaya.tamekoshi); settings.json in %APPDATA%\Tamekoshi on Windows or ~/.config/tamekoshi on Linux | To remember your settings |
| Companion names, appearance, instructions, private notes, per-companion chat histories, rooms and group chats, and requested discussions | Private companions.db and memory.db in the app configuration directory on Windows/Linux; companions.json, companion-chats.json, companion-chat-sessions.json, companion-api-threads.json and companion-exchanges.json in ~/Library/Application Support/Tamekoshi on macOS | Keep identities and conversations separate, restore them after a restart, and display each participant's words in the originating chat. Notes are sent as context to that companion's selected AI provider when it responds. |
| Companion memory facts | User-stated facts and preferences with companion and source-conversation IDs in private memory.db on Windows/Linux or companion-memory.json in ~/Library/Application Support/Tamekoshi on macOS | Recall relevant statements in later chats with the same companion. Saved preferences are sent with every message to that companion's selected AI provider, and other matching facts are sent as context when relevant. The companion can also save, change or remove an entry during a chat, based on your own words. Vault turns, attachments, and meeting requests are excluded from automatic capture; deleting a conversation or companion removes its associated facts. |
| Shared harness memory (optional; off by default) | Private shared-memory.db in the Windows/Linux app configuration directory; private SharedMemory/state.json under the macOS app support directory | Keep explicitly authorized, project-scoped episodic, semantic, procedural and temporary facts, source references, versions, permissions, synchronization checkpoints and an operation audit. Discovery inspects installation/configuration metadata only after consent. On Windows/Linux, turning on the single General shared-memory switch authorizes every supported harness's standard local transcript folder and the workspaces those sessions record, and a harness installed later adopts its standard folder automatically; there is no per-harness or Advanced folder control. On macOS, Settings has a switch per harness and lets you authorize source and workspace folders. Extraction runs locally and excludes recognized credential/private-content patterns. Relevant excerpts reach a harness's configured AI provider only when context injection and the required sharing/query grants are enabled. Facts expire after the retention period (90 days by default). Disabling preserves facts; separate confirmed deletion removes facts and derived indexes. Non-content source/turn fingerprints remain to prevent deleted history from being imported again. This store does not import the companion's existing private memory. |
| Check-backs a companion sets for itself (Windows/Linux) | What to look at, when it is done, the wake time or event (and, for a connected-app watch, the operation, its input and the item IDs already seen), the last report and the check count, in the private routines.db, which also holds the routines you create; ended check-backs are deleted after 30 days. The tool call that set one is kept so its chat line can cancel it. | Let a companion look again later by itself until something outside it is done. Each look runs in the background on that companion's selected AI provider with these fields and the companion's connected apps; what an event or app returns is sent as context. A finished watch raises one check-in. Secrets are refused in the stored text. Turn it off or cancel any watch in Settings → Control; deleting a conversation or companion cancels its watches. |
| User-created coding goals (Windows/Linux) | Objective, optional verification command, status, and progress in the private memory.db, scoped to one chat conversation. Running command output is held in memory and bounded. | Resume a goal after restarting and verify work before marking it complete. The objective, progress, and tool results may be sent to the selected AI provider as chat context. |
| Background tasks, usage receipts, check-ins and wiki (Windows/Linux) | Background tasks with their title and full prompt in tasks.db; per-reply cost receipts, monthly limits and subscription windows in usage.db; check-ins in checkins.db; wiki pages as Markdown files in wiki with a wiki.db index; all in the private app configuration directory | Resume work after a restart, show costs and limits, and keep pages for later. They are not sent anywhere by themselves. |
| Daily backups (Windows/Linux) | Once a day, a copy of every local database except shared-memory.db in backups/YYYY-MM-DD in the app configuration directory; the seven newest days are kept, plus the copy saved before a restore | Restore your data after a problem, only after you confirm in Control. Deleted conversations, facts and notes can remain in these copies for up to seven days. Secrets are not in these files. |
| Vault logins, API tokens, cards, identities, and secure notes | Encrypted vault.enc in the app's private configuration folder; the random encryption key is in macOS Keychain, Windows Credential Manager, or Linux Secret Service. | Keep private items on this device. A selected item is sent to the active companion's AI provider for one chat request only after you choose Use in chat; including secret fields and notes requires a separate choice. Chat replies may contain details from that item and are saved in chat history. Tools and web search are unavailable during that request. For a user-requested authenticated API action on Windows/Linux, the companion may receive matching credential metadata; Tamekoshi attaches authentication only to the exact saved HTTPS origin and gives the companion the API response, never the credential. |
| MCP server definitions (Windows/Linux) | mcp.json in the app configuration directory. Environment variable and 1Password op:// references are stored, but their values are not. | To reconnect the servers you enabled for chat and show their tools in Settings. |
| Companion connector access (Windows/Linux) | Connection identifiers in companions.db; no credentials. | Chat connects only to servers selected for the acting companion. New companions and connections have no access until selected. Settings connection checks remain explicit configuration diagnostics. |
| Native API connections (Windows/Linux) | Names, fixed endpoints, imported API descriptions, account policies and per-companion tool permissions with configuration fingerprints and revisions in private connectors.db. Credentials stay separately in Windows Credential Manager or Linux Secret Service. | Expose only selected connections to a companion. Settings can edit configuration and report credential presence, but cannot retrieve a stored credential. |
| Interfaces from MCP Apps | Interface documents returned by connected tools, in mcp-apps in the app configuration directory (Windows/Linux) or in ~/Library/Application Support/Tamekoshi/mcp-apps (macOS) | Draw a tool's own card again in the chat. |
| Approval decisions (Windows/Linux) | Tool kind, redacted target and detail (such as the first line of a command or a file path), decision, rule, reason, timestamp and the companion, conversation and tool-call IDs in a private approvals.jsonl in the local data directory, started afresh when it reaches 1 MB. Remembered Allow and Ask-first rules and the selected approval mode are in settings.json. No chat content or credentials are stored. | Explain why an action ran, asked or was denied, and remember a narrow decision without asking again. |
| Coding-agent CLI folders (Windows/Linux) | Private codex-home and opencode-home folders in the local data directory; codex-home holds a copy of your Codex login (auth.json) taken from ~/.codex; per-turn token files in cli-turns, deleted after the turn | Run a companion on your CLI login without your own CLI settings or MCP servers. |
| Files you drop on the notch | A copy in the app’s inbox folder (~/Library/Application Support/NotchBuddy/inbox on Mac, %LOCALAPPDATA%\Tamekoshi\inbox on Windows, ~/.local/share/tamekoshi/inbox on Linux), deleted after 7 days | So you can ask a question about them or attach them to an email |
| Claude Code session events (project name, current step, permission requests) | In memory only | To show them in the notch |
| Computer audio and microphone audio explicitly captured for a meeting, source-labelled live transcripts and inline translations (Windows/Linux) | Live text stays in memory between the island and transcript window. Finalized audio passages waiting for local speech recognition are temporarily queued as 16-bit PCM in the app WebView's IndexedDB storage and removed after recognition; leftovers from an interrupted session are cleared when the island starts again. Takenote capture also records the audio to private temporary files in meeting-audio under the app's local data directory; unsaved ones are removed after 24 hours. When you click Save in Meeting Notes, the finalized transcript, translations, labeled AI reply suggestions and your written note are stored in a private meetings.db under the app's configuration directory, and the recorded audio is mixed into a WAV file with a waveform file, kept with that note until you delete it; target language stays in preferences. | Local speech transcription, playback and translations you explicitly request. Saved notes can be reopened, searched, played back, edited and deleted. Meeting audio is not part of chat history. The meeting microphone is separate from chat dictation. |
| Unfinished Takenote transcript draft (Windows/Linux) | Finalized text and translations are written to alternating private meeting-draft-a.json and meeting-draft-b.json files in the app configuration directory. | Restore recognized passages after an unexpected exit. The draft is deleted when you save or clear that meeting; raw audio is not in these files. |
| Meeting folders, pins, generated summaries, and cross-meeting search (Windows/Linux) | Stored alongside saved transcripts in the private meetings.db. Exports are downloaded to the location chosen by your browser or system. | Organize and export saved meetings. A summary is saved only after you click Generate summary. Saved meeting excerpts are added to a chat request only when you begin it with @meetings. |
| Local speech model files (Windows/Linux) | Persistent private speech-models folder (recognition, voice-detection and end-of-turn models, and the local call voices Supertonic 2 and, for Portuguese, Kokoro) and the native Parakeet v3 GGUF in speech-native under the app's local data directory; on Windows, the espeak-ng program in espeak-ng there; selected model, speech language and each companion's call voice in preferences | Reuse downloaded public models across launches; no audio or transcript files are stored there |
| Optional speaker diarization files and labels (Windows/Linux) | A verified NeMo-Speech.cpp runtime shared with native speech recognition and Nemotron 3 GGUF in the private local diarization folder; the opt-in preference in settings; speaker numbers alongside saved transcript passages in meetings.db | Identify speakers locally. Model files are prepared at app startup; speaker identification runs only when enabled. |
| Diagnostic log (event and tool names, project names, HTTP status codes and error messages, and short labels such as background-task titles taken from your request, routine names, file paths written by coding tools and channel or app account names — no API keys) | nb.log and tamekoshi.log in ~/Library/Logs/NotchBuddy on Mac (App Store: same path inside the container); tamekoshi.log in %LOCALAPPDATA%\Tamekoshi on Windows or ~/.local/share/tamekoshi on Linux. Each file starts afresh at about 1 MB. Never leaves your computer. | To help diagnose connection issues between agents and Tamekoshi |
You can delete current provider keys in Settings. Credentials saved by older versions for removed service integrations stay in the OS credential store until you remove them there. To delete other local data on macOS, delete the app and its folders ~/Library/Application Support/NotchBuddy, ~/Library/Application Support/Tamekoshi, ~/Library/Application Support/com.kumanaya.tamekoshi and ~/Library/Logs/NotchBuddy (or the app’s container for the App Store version). On Windows: uninstall Tamekoshi from Settings → Apps, then delete %APPDATA%\Tamekoshi and %LOCALAPPDATA%\Tamekoshi. On Linux: delete ~/.config/tamekoshi, ~/.local/share/tamekoshi and ~/.cache/tamekoshi. These folders include the daily backups. Hooks the app added to agent settings files are removed from the app's settings, not by deleting these folders.
4. Services you connect yourself
Managed MCP connections (Windows/Linux) store transport configuration and tool policies in connectors.db. Named environment/header secrets remain separately in the OS credential vault. Only selected connections start for a companion; explicitly inspecting a configured connection in Settings also starts its MCP client. A configured stdio process receives its environment credentials, while a remote server receives HTTP authentication and tool arguments. Responses are bounded and configured credentials are redacted. Remote MCP OAuth discovery reads the server's challenge, protected-resource metadata and authorization-server/OpenID metadata without transmitting stored credentials. Discovery contacts only the configured server and public HTTPS metadata URLs it declares. Review the discovered issuer, resource and scopes before signing in. The direct macOS app also discovers OAuth metadata, can register a client and signs in through the browser for remote MCP apps.
Native connector OAuth (Windows/Linux) uses the configured authorization, token, discovery and optional client-registration endpoints. Sign-in opens the system browser and receives a local loopback callback with PKCE. Access tokens, refresh tokens and client secrets remain in the OS credential store; renewal and client-credentials requests happen on demand. Settings receives connection status only.
The local Integrations Hub (Windows/Linux) executes admitted tools natively through the app's own MCP and CLI routes. Stored credentials remain in the OS vault; during an authorized invocation the native backend resolves the required credential in memory only. That credential is not returned to Settings or AI agents, and is not saved in configuration or logs. API arguments and authentication go only to the configured service; redacted tool results may enter the selected AI provider's chat context.
Tamekoshi talks directly to the services you configure and, when a feature you use needs them, to the public services listed below (DuckDuckGo and the public pages a companion reads, weather and map services, model downloads). Those services process your data under their own privacy policies:
- Bundled service selection (Windows/Linux Settings) — choosing a recipe fills the local editor without contacting a registry or icon service. Binary API uploads send only the explicit bytes supplied to the admitted tool, after its approval policy is checked.
- Your native API connections (Windows/Linux) — a companion with access to a connection sends operation arguments to its configured API endpoint after the operation policy is checked. The backend attaches any stored authentication; it never returns that credential to the companion. Tool descriptions, arguments and redacted API results are part of the selected AI provider's chat context. Redirects are not followed. API writes request approval by default; email sending requires an explicit click.
- Anthropic (Claude API) — when you chat using Anthropic or ask about a file or a window, the text you type, the conversation so far, the file content and/or the window context you chose are sent to Anthropic, together with the companion's context (its instructions, your notes for it, relevant memory and its skills). On macOS, these chats can use Anthropic's own web search tool, so search queries are run by Anthropic. When you open the chat, a companion's editor or Settings, the list of available models is also fetched from the Anthropic API using your key. Anthropic privacy policy.
- Google AI (Gemini API) (macOS) — when you chat using Google AI, the text you type, the current conversation and the same companion context are sent to Google's Gemini API. If you attached a window, the app name, title and URL are also sent. If you attached a file, only its name is sent (file content is only sent to Anthropic). The list of available models is fetched when you open the chat or a companion's editor. Google privacy policy.
- OpenAI (macOS) — when you chat using OpenAI, the text you type, the current conversation and the same companion context are sent to the OpenAI API. If you attached a window, the app name, title and URL are also sent. If you attached a file, only its name is sent (file content is only sent to Anthropic). The list of available models is fetched when you open the chat or a companion's editor. OpenAI privacy policy.
- Other AI providers (Windows/Linux) — Settings also offers many other API providers (such as OpenRouter, Groq, Mistral, xAI, DeepSeek, model hosts and gateways), local servers (Ollama, LM Studio, llama.cpp, LiteLLM, vLLM) and a custom gateway at an address you set. The provider selected for a companion receives its chat requests with the conversation and the companion's context. For each configured provider, the app fetches its model list (kept for an hour), and Test sends one authenticated request to check the key. A local server processes requests on your own computer. Each provider's own privacy policy applies.
- Coding-agent CLIs as chat engines (Windows/Linux) — a companion can run on your own Claude Code, Codex, OpenCode or Gemini CLI login. Each turn sends the conversation's summary, its recent dialogue and the current request to that CLI, which sends them to its own service (Anthropic, OpenAI, OpenCode or Google) under your CLI account. The CLI runs without your own CLI settings or MCP servers; its only tools are the companion's own, under Tamekoshi's approvals.
- OAuth chat providers (Windows/Linux) — after you choose and sign in to an OAuth provider, Tamekoshi opens the provider's authorization page, receives the callback or polls a device code, stores tokens in the OS credential vault, and sends the companion's chat request and relevant context directly to that provider. Tamekoshi refreshes tokens locally. The selected provider's privacy policy applies to the request.
- Mixture of Agents / Council (Windows/Linux) — only when a companion uses the Council provider. On each user turn by default (or every round, or every few rounds, as the council is set), every enabled voice receives a fixed advisor instruction, instead of Tamekoshi's system prompt, and the newest part of the stored conversation (about 16,000 characters): the text of each user and assistant message (up to 4,000 characters each, which can include the text of a small attached text file), the names of tools the companion called and the first 700 characters of each tool result. Images, PDFs and other non-text content are left out; a message with nothing else becomes “[user sent non-text content]”. Tool schemas, the companion's notes, memory and shared memory, and a Vault item itself (it is placed only in that one request's instructions) are not sent. Private turns kept in the conversation never reach the voices: a Vault-share message, a private reply, a live meeting or screen turn, its tool rows and the companion's answer are all left out, as are the messages the app writes internally for goals. The voices' advice is then added to the speaker's normal request, which goes to the speaker's provider. The council's Privacy setting only masks what the app shows and stores: Advice previews redacts the advice previews and the council record saved with the chat, and Previews and guidance also redacts the advice the speaker reads. Masking replaces private-key blocks, email addresses, JWTs, common API-key prefixes, database URLs with credentials and phone numbers written with separators; it does not change what the voices receive. Each provider's own privacy policy applies to its request.
- Desktop messaging channels (Windows/Linux) — only after you configure and enable a channel, Tamekoshi connects to that service with the credentials you supplied and exchanges private messages with the selected companion: Telegram (Bot API long polling), Discord and Slack (their message gateways), Matrix (homeserver sync), Mattermost (REST and WebSocket), IRC and Twitch (their chat networks), BlueBubbles (a server on your Mac), Signal and SimpleX (helper daemons you run locally), Email (your IMAP and SMTP provider), Home Assistant (state-change events; replies become persistent notifications), ntfy (the topic you choose), WhatsApp Cloud, LINE, Microsoft Teams, Google Chat, Microsoft Graph, WeChat Official Accounts and WeCom apps (webhooks from those services, plus their send APIs), Twilio SMS and voice (Twilio transcribes the caller's speech), DingTalk, Feishu/Lark, WeCom bots, QQ Bot, Yuanbao, Weixin (Tencent iLink), Zalo and Zalo ClawBot, Nextcloud Talk, Synology Chat, Nostr relays, Tlon (your Urbit ship), Buzz, ClickClack, Reef and the Hermes relay (the servers you name), WhatsApp (a WAHA server you run), Zalo personal (the zca tool you run), Photon (its sidecar), iMessage (the command you configure, such as imsg over SSH to your Mac) and Raft (its CLI). Unless you name other servers, Nostr uses
relay.damus.ioandnos.lol, and ntfy usesntfy.sh. Webhook channels and the Webhook, API server, WebChat and A2A endpoints are served by a small listener on 127.0.0.1 (port 47390 by default) that runs only while such a channel is on; it is reachable from the internet only through a tunnel you set up yourself, or from your local network when you connect Synology Chat or open WebChat to the local network. A new sender receives a pairing code; messages reach the companion only after you approve the sender in Settings. Message text and that channel's conversation history go to the companion's selected AI provider, with the companion's instructions; your notes for the companion are added to your own messages only, never to a guest's. Your own messages as the owner reach the same companion as in the app — its memory, skills and tools, including control of this computer — and can teach it skills; an approved guest gets skills and web search only, plus tools that ask for your approval at each step. Vault items and meeting content are not added to channel requests. Disabling a channel stops its connection. Signal, SimpleX, WhatsApp (WAHA), Zalo personal, Photon, iMessage and Raft deliver through helpers you run yourself, which follow their own documentation; Tamekoshi never downloads or installs them. - Companion discussions — only when you ask one companion to discuss with another, the question, a short excerpt of the originating chat and the participants' replies are sent to each participant's configured AI provider. Each participant's private notes are sent only to their own provider. On macOS, up to three rounds and a conclusion are generated. On Windows/Linux, each companion gives its view, the invited companion can add one correction, and a conclusion follows; the invited companion also receives up to six recent messages of its own chat, and both can use their tools during the discussion.
- Vault sharing — when you explicitly choose an item for chat, that item's non-secret fields and your next message are sent to the active companion's selected AI provider. Secret fields and notes are included only if you choose that option. The item is not added to the stored chat request or shared with tools or other companions.
- Authenticated API actions from Vault (Windows/Linux) — the general secrets tool lists credential metadata. When you request an API action, web_fetch sends a GET, HEAD, POST, PUT, PATCH or DELETE request with locally resolved Basic or Bearer authentication only to the exact HTTPS origin saved with that credential. Write requests carry the JSON payload chosen for the requested change and follow the configured app approval policy. The selected AI provider receives the API response, including requested record details or comments, not the token. Authenticated redirects are never followed. There is no dedicated Jira tool or automatic Jira request on macOS.
- Public web research (Windows/Linux desktop chat) — when a companion uses web search, the search query first goes to the AI provider already serving that chat, when it offers its own search. Otherwise it is sent to DuckDuckGo's search page without an API key, through the shared reader browser on this machine or directly. When it reads a result, Tamekoshi requests that public page over HTTPS (plain http addresses are upgraded); if the page refuses a plain request, it is opened in that reader browser on this machine, and then its address may be sent to that same AI provider to read; a PDF or other non-text address is sent to the provider directly. Titles, snippets and limited page text are sent to the selected AI provider as tool results; result previews and URLs are saved with the chat reply. Tamekoshi does not automatically attach Vault fields, meeting content or files to these web requests.
- Weather and places cards (Windows/Linux, on unless you turn them off) — when a companion uses its weather or places tool, the place name it chose goes to Open-Meteo's geocoding service (
geocoding-api.open-meteo.com), the place's coordinates and time zone go toapi.open-meteo.comfor the forecast, place searches (with the start point you gave, as coordinates) go to Photon (photon.komoot.io), route start and end coordinates go torouting.openstreetmap.de, and map tiles are fetched fromtile.openstreetmap.org. These requests carry no key or account. You can turn either card off in Settings; the tool is then never offered. - Remote media in Tame UI (Windows/Linux and macOS direct) — when a reply uses the
ImageorImageGallerycomponent, the WebView loads that exact https URL from its host with no referrer; aVideocomponent on Windows/Linux loads its https URL with no referrer too. There is no Tamekoshi proxy, so the host sees the request; small inlinedata:images need no request, and a local file or anasset:URL is never accepted from model output. Clicking an image opens its address in your browser. The browser'sread kind: "images"only reads image URLs already present on the companion browser's current page. OpenUI supplies the language, not the media. - MCP Apps interfaces (Windows/Linux and direct macOS) — when a connected tool returns an interface of its own (a
ui://resource), Tamekoshi saves that vendor document locally and draws it in a sandboxed frame cut off from the app. That frame can load scripts and media from, and connect to, the hosts the vendor declares, directly from your device; what it sends there is decided by the vendor's code and the result it displays. - Hugging Face (Windows/Linux speech model) — at app startup, Meetings downloads and caches the transcription model in use from
huggingface.coand its file-delivery hosts: Parakeet v3 by default, or the model automatic mode picks for your speech language (Qwen3-ASR 0.6B for languages outside Parakeet's European set, Whisper large-v3-turbo when the native engine is unavailable). Whisper and Qwen3-ASR also download when you choose them in Settings → Speech. The first call also downloads the small Silero voice-detection model and the Smart Turn v3 end-of-turn model. Removing a model in Settings deletes its files. The first companion call downloads and caches the local voice model (Supertonic 2, including the chosen voice file) from the same hosts; for Brazilian Portuguese, also the Kokoro voice model when the GPU is used and, on Windows, the official espeak-ng 1.52.0 package from GitHub, checksum-verified and unpacked without being installed (Linux uses an installed espeak-ng). The call's audio and text stay on your computer. Native Parakeet also downloads a verified NeMo-Speech.cpp runtime from GitHub. Audio is processed on your computer, not uploaded. Hugging Face privacy policy. - Hugging Face (optional Windows/Linux shared-memory semantic model) — only when shared memory and its optional semantic-model preference are enabled, a semantic request downloads the pinned
Xenova/paraphrase-multilingual-MiniLM-L12-v2q8 model fromhuggingface.coand its file-delivery hosts. Model files remain in the Settings webview's browser cache for offline reuse; the WASM runtime is bundled with the app. Sentences and vectors are processed locally, never sent to Hugging Face or Supermemory. Revoking consent terminates semantic work but does not erase cached public model files. macOS uses available on-device NaturalLanguage embeddings instead. - NVIDIA model on Hugging Face and NeMo-Speech.cpp on GitHub (optional Windows/Linux speaker identification) — app startup prepares a verified Nemotron 3 Diarization model from Hugging Face and a verified native runtime from GitHub. Identification runs only when enabled. Meeting audio stays on your computer; only these public files are downloaded.
- GitHub releases (Windows/Linux companion browser) — the first time a companion's browser opens, Tamekoshi fetches one fixed, checksum-verified data file (the fpgen machine-distribution model that draws the bot's browser fingerprint) from that release, and caches it in the app's private data folder. Later launches do not fetch it again. Pages the browser visits contact only the destinations the navigation itself requests.
- InstaBox (Windows/Linux bot computers) — when a bot's computer uses the InstaBox backend, Tamekoshi calls
api.instabox.sh(InsForge AI, Inc.) with the API key you saved to create, start, pause and delete that bot's own machine, upload its driver script, run commands over its API and read screenshots back; a one-way digest of the companion's internal ID is attached to the machine as metadata, never the ID itself (machines created by earlier versions keep the plain ID until you recreate them). The machine lives in your InstaBox account under that provider's terms (instabox.sh); nothing from your computer is mounted into it, and Tamekoshi publishes no port and creates no viewing link for it. - Your configured AI provider (Windows/Linux translation) — only when you click Translate, the current transcript and target language are sent directly to the provider/model selected in Settings. No audio, chat history or tools are included. A local provider processes this request on your own computer.
- Application language (Windows/Linux) — the complete Brazilian Portuguese interface catalog ships with the app and works offline. For other supported languages, only packaged interface strings and the selected language may be sent to your configured AI provider to prepare labels; chat, documents, audio and meeting content are never sent by this route. Those translations may be cached in
interface-<locale>.jsonin the private app configuration folder. The language preference is stored insettings.json. New meeting summaries and assistance use that language; ordinary chat follows the conversation. - Your configured AI provider (Windows/Linux smart notes and meeting memory) — clicking Generate summary sends the saved transcript and meeting title to the provider/model selected in Settings, without audio, chat history, or tools. A chat request beginning with
@meetingssends the matching saved excerpts (which can include your notes and saved summaries) and their source identifiers, plus up to twenty recent passages of a meeting in progress, alongside that chat turn. Ask Tame in the meetings library sends your question with that meeting's transcript (up to 60,000 characters) and your note to the chat provider selected in Settings; the answer is not stored. Meeting assistance can, when you ask, capture a screen you choose and send it with recent passages; opt-in Auto Answer uses computer audio only. These images and passages are used for that request and not saved in chat. Retrieval runs locally; a local provider keeps generation on your computer. - Your configured AI provider (Windows/Linux skill learning) — when an ordinary conversation (in the app, or from you in a paired channel) states a lasting rule, or when you run
/learn, one request sends the waiting lessons, a bounded digest of the recent conversation and the companion's skill entries to the provider/model selected for that companion to draft or update aSKILL.md. Private turns, Vault shares and@meetingsrequests never reach this route, and attached files are never sent. - GitHub (macOS Skill library) — choosing Install original on a starter that names an upstream repository fetches that public repository's file list from
api.github.comand its text files fromraw.githubusercontent.com, without credentials. Nothing is downloaded until that click, and the fetched skill stays a draft you review and assign. Hidden files are skipped; files that are not UTF-8 text or exceed 64 KB, and packages beyond 64 files or 512 KB, are refused. GitHub privacy statement. - Your configured MCP servers (Windows/Linux chat) — opening the MCP section of Settings, clicking Check connections (including for an unsaved draft) or saving connects to every enabled server and requests its tool list; a chat turn connects only to the servers selected for the acting companion. When the chat uses a tool, its arguments are sent to that server after the configured approval policy is applied. Tool descriptions and results are also sent to your selected AI provider as part of the chat turn. Environment variable and 1Password
op://references inmcp.jsonare resolved when a server starts, including for these checks, and passed to that server. Settings can import server definitions from~/.claude.json,~/.cursor/mcp.json,~/.codex/config.tomland OpenCode's configuration, moving any secret written there into the OS credential store. A remote MCP server can process this data under its own policy; a local server runs on your computer.
Connected service requests go directly to those services; no Tamekoshi server sits in between.
5. Claude Code, Gemini CLI, Antigravity, Cursor and Codex hooks
If you install the agent hooks, the agents send session events to Tamekoshi through a local connection on your computer: Claude Code, Gemini CLI and Antigravity on macOS; Claude Code, Cursor and Codex on Windows/Linux. These events never leave your computer through Tamekoshi. Before installing hooks in a settings file (~/.claude/settings.json, ~/.gemini/settings.json and ~/.gemini/config/hooks.json on macOS; ~/.claude/settings.json, ~/.cursor/hooks.json and ~/.codex/hooks.json on Windows/Linux), Tamekoshi makes a dated backup and shows you the changes (on macOS, the resulting file; the App Store version lists the files it will change). On Windows/Linux, the optional Claude Code status line is also written to ~/.claude/settings.json when you turn it on. Removing the Claude Code hooks on macOS rewrites that file without making a new backup.
6. Email
On macOS, when you send a file by email, the message is created and sent by your own Mail app after your click. On Windows/Linux, if you connect the Email channel, the companion replies to approved senders through your own IMAP/SMTP account without a click for each reply, and a companion writing first to someone always waits for your approval card. Tamekoshi never sends email through a server of its own.
7. System permissions
Depending on the version and the features you use, macOS may ask you to allow Automation (Mail, to send a file you chose; Safari, Chrome, Arc, Firefox or Edge, to read the address of the tab you attach), Accessibility (to read the title of the window you attach), and the Microphone and Speech Recognition (for calls with a companion). These are only used for the feature you triggered and can be revoked at any time in System Settings → Privacy & Security. The Windows and Linux versions install for the current user and need no administrator rights. They use the microphone only for features you start (dictation, calls, meetings), subject to the system's microphone privacy setting, and capture the screen, computer audio or mouse and keyboard only for features you turn on (meeting capture and assistance, Computer Use).
8. Children
Tamekoshi is a developer tool and is not directed at children.
9. Your rights
We hold no account or other personal data about you. For data held by a connected service, contact that service. You may also contact your data protection authority (in France: the CNIL).
10. Changes
If this policy changes, the new version will be published on this page with a new date.