Tamekoshi

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.

Tamekoshi has no analytics, ads or tracking, and no Tamekoshi account is needed to use it. Your data stays on your computer except what is sent to the AI providers and services you set up, and to the public services listed below when a feature you use needs them. The only server we operate that the app contacts is tamekoshi.com, for the optional update notice, which is off by default.

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.

WhatWhereWhy
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:// referenceTo call these services on your behalf
Decision-provider API keys (OpenRouter and TypeSafe)macOS Keychain, Windows Credential Manager or Linux Secret ServiceOptional 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 renewalTo 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.dbConnect 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 LinuxTo remember your settings
Companion names, appearance, instructions, private notes, per-companion chat histories, rooms and group chats, and requested discussionsPrivate 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 macOSKeep 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 factsUser-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 macOSRecall 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 directoryKeep 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 directoryResume 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 restoreRestore 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 notesEncrypted 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 AppsInterface 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 turnRun a companion on your CLI login without your own CLI settings or MCP servers.
Files you drop on the notchA 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 daysSo 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 onlyTo 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 preferencesReuse 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.dbIdentify 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:

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.