Core Design Philosophy

AI To Local keeps cloud reasoning and local execution as separate trust domains. ChatGPT, Gemini, and Claude interpret requests in their respective cloud services; the native Go daemon on the user's computer performs only the local tool calls that the user has enabled and authorized.

The Go core is designed for a footprint below 30 MB of RAM during typical idle operation and has no Node.js or Python runtime dependency. The local guard applies workspace and tool policy at the point of execution, while the chosen AI provider remains responsible for model reasoning.

End-to-End System Topology

Remote MCP traffic reaches the local daemon through an encrypted Cloudflare Tunnel, either managed by the service or supplied by the user. The daemon evaluates each tool request before passing an approved operation to the local resource boundary.

+------------------+     +---------------------------------------+
|   Web AI Client  |---->| HTTPS / MCP Streamable HTTP + OAuth 2.1 |
+------------------+     +--------------------+------------------+
                                               |
                                               v
                         +---------------------------------------+
                         | Encrypted Cloudflare Tunnel           |
                         | Managed or BYO                        |
                         +--------------------+------------------+
                                              |
                                              v
                         +---------------------------------------+
                         | AI To Local Daemon (native Go)         |
                         +--------------------+------------------+
                                              |
                                              v
                         +---------------------------------------+
                         | Permission Guard Engine                |
                         +----------+---------------+-------------+
                                    |               |
                      +-------------v--+   +--------v---------+
                      | File System     |   | Controlled Shell |
                      +----------------+   +------------------+
                                    |
                                    v
                         +--------------------+
                         | Local audit.log    |
                         +--------------------+

OAuth establishes the client authorization flow; TLS protects network transport. Workspace policy and local command controls remain enforced by the daemon regardless of which tunnel mode is selected.

Immutable Shell and Versioned Core Separation

V3 separates the small platform launcher from the versioned Go core. On macOS, the native Swift shell remains in the signed application bundle, preserving its codesign identity across core updates. On Windows, the C# launcher manages the core process through a Job Object with kill-on-close behavior.

Core binaries live under versions/<build>/. An atomic current.json pointer records the active and previous builds plus validation state. After an update, the shell checks process liveness and probes http://127.0.0.1:18926/api/health. If the new core fails to become healthy within 15 seconds, the launcher stops it, restores the previous pointer, and restarts the last known good version.

Multi-Agent Concurrent Slots

V3.2 can serve multiple AI agents concurrently. Each agent slot receives an isolated local port beginning at 18928, its own workspace whitelist, and file write-lock coordination to prevent conflicting edits.

Slots can share the primary managed tunnel or use dedicated secondary tunnels configured with the user's Cloudflare account. Per-agent workspace policy remains distinct in either topology, so adding another model client does not implicitly expand its folder access.

Zero-Redundancy Data Privacy

AI To Local does not index or crawl local files and does not upload them in the background. A file is read only when an authorized tool call requests it. The operation returns the specific requested content through the active connection to the AI provider selected by the user.

That requested snippet travels over TLS as part of the tool exchange. The provider's own retention and data-use terms govern content after it reaches that provider. Local audit records stay on the device.