LiveAgent, the Repo: A Desktop AI That Refuses to Phone Home

A Name Collision and a Niche

Search for “LiveAgent” and you will find a Slovakian help-desk SaaS that has occupied the name since 2003, complete with Instagram accounts, G2 review pages, and enterprise pricing tiers. LiveAgent the company is not Stack-Cairn/LiveAgent the repository. The latter is an open-source desktop AI agent client built in Tauri, React, and Rust, and it arrives at a moment when the phrase “AI agent” is being attached to everything from chatbots to full-stack automation platforms. The naming collision is unfortunate, but it also underscores how crowded the branding space has become. To find the repo, you have to know what you are looking for: a local-first, model-agnostic operator that lives on your machine rather than in a browser tab.

Local-First in a Cloud-Agent Era

The current wave of desktop AI agents is bifurcating into two philosophies. On one side are cloud-hybrid systems like Manus My Computer and the various Copilot integrations Microsoft is embedding into Windows and Office 365, which treat the local machine as an extension of a remote brain. On the other side are tools that insist the brain—or at least the keys, the file system access, and the execution context—stay on the hardware you own. LiveAgent is firmly in the second camp. Its documentation states unequivocally that API keys are stored locally on the desktop side only; the optional remote Gateway is a pure protocol relay that never touches the file system or stores credentials. This is a direct answer to the trust problem that haunts cloud-native agents: giving a remote service shell access to your laptop is an exercise in faith that many developers and security-conscious users would rather avoid.

The Stack as Security Boundary

The architecture is itself an argument. The desktop client is built with Tauri 2, React 19, and a Rust backend, compiled to native binaries for macOS, Windows, and Linux. Tauri’s webview-based approach keeps the bundle lighter than Electron while still supporting streaming Markdown, KaTeX math, Mermaid diagrams, and Monaco code preview in the frontend. The choice of Tauri is not incidental; the framework now underpins thousands of public repositories and has become a mature option for developers who want web technology without shipping an entire browser engine. The Rust backend, running on Tokio, is the actual security boundary: it handles file reads and writes, bash execution with configurable timeouts, long-running process supervision, and sub-agent delegation with worktree isolation. SQLite provides local persistence for memory and conversation history, while gRPC via tonic handles communication with the optional Gateway. This split—web UI for rendering, Rust for system access—is pragmatic. It means the dangerous parts run in a compiled systems language with strong sandboxing potential, while the interface remains a modern web stack.

Then there is the Gateway: a separate Go service that exposes the local agent to any browser via gRPC and WebSocket. The Gateway is deliberately optional. The desktop app works fully standalone; deploy the Gateway only if you want to control your local machine from a phone or browser elsewhere. The documentation is careful to note that the Gateway is a pure relay, and it includes provisions for bounded sequence-window replay after short disconnects. It is a concession to convenience, but a well-engineered one.

MCP, Skills, and the Extensibility Bet

LiveAgent does not attempt to build every tool itself. It natively bridges the Model Context Protocol, allowing external tool servers to plug in via stdio or HTTP. This is a bet on an emerging standard rather than a proprietary plugin format. The documentation also advertises a Skills system with progressive disclosure and on-demand loading, plus a ClawHub ecosystem. The relationship between Skills and MCP servers is not fully explained in the provided materials—there is a plausible overlap—and the ClawHub marketplace is referenced without a populated catalog in the sources. Still, the intent is clear: the project wants an open extension model rather than a walled garden. This mirrors the broader MCP ecosystem, where servers are proliferating for everything from browser automation to database access, including dedicated MCP tooling for Tauri development itself.

The Agent Primitives

The market is saturated with chatbots rebranded as agents. LiveAgent’s definition is more operational. It reads, writes, edits, and deletes files; executes bash commands; supervises long-running dev servers via ManagedProcess; delegates work to isolated sub-agents that run in parallel and merge their results; and schedules cron-like tasks that execute bash, HTTP, or prompt jobs in the background. It also compacts conversation history using Segment + Summary Checkpoints to avoid the context-window cliff that plagues long sessions. These capabilities map neatly onto the definition of a true AI agent offered by industry surveys: perception (file search via Glob/Grep), decision (multi-turn reasoning with sub-agent delegation), and action (file edits, process spawning). The sub-agent feature is particularly notable; by spawning isolated workers with their own worktrees, the system can parallelize research or coding tasks without polluting the main session state. Whether it genuinely adapts over time through feedback loops—as opposed to simply executing scripted workflows—is harder to verify from the documentation alone, but the scaffolding is there.

The Optional Gateway and Its Tensions

The Gateway is LiveAgent’s most interesting compromise. A local agent that only works when you are sitting at the keyboard is useful; one you can reach from a browser while traveling is far more useful. But exposing a local agent to the internet, even through a self-hosted Go relay, reintroduces the attack surface that local-first design tries to eliminate. The documentation acknowledges this by providing Nginx reverse-proxy configurations and emphasizing TLS. The bounded sequence window for disconnect recovery is a nice engineering touch. Yet the feature remains a tension: users who deploy it are trading the purity of local isolation for accessibility. It is a reminder that local-first is often a spectrum, not a binary.

The Field and the Fork

LiveAgent enters a field that is rapidly professionalizing. Manus My Computer offers hybrid cloud-to-local orchestration with a polished consumer interface. Claude Code and ChatGPT Agent lean on their respective ecosystems and closed models. LiveAgent’s pitch is different: it is open-source under MIT, model-agnostic (supporting Claude, Codex, and Gemini protocols, plus custom base URLs for third-party relays), and free to modify. It is also, notably, a desktop GUI application rather than a CLI tool, which lowers the barrier for users who want visual feedback but raises questions about whether a webview app can match the raw efficiency of a terminal-native workflow. In the broader landscape described by Microsoft’s Azure AI agent strategy, where enterprise agents are expected to collaborate across cloud services and APIs, LiveAgent represents the open-source, individualist counter-current: one user, one machine, one agent.

What Remains Unclear

The project is not without ambiguity. The ClawHub ecosystem is referenced but not demonstrated in the sources. The Skills packaging format is described, yet the documentation does not clarify how it differs from an MCP server or why both systems coexist. The sponsorship from API relay providers PackyCode and RightCode—services that resell access to Claude, Codex, and Gemini—suggests the project was developed and tested against relayed endpoints rather than direct provider keys, which is pragmatic but worth noting. And the name collision with the established LiveAgent help-desk software is a genuine discoverability handicap; search engines will conflate the two, and the repo’s README does not acknowledge the older trademark.

LiveAgent is best understood as an architectural manifesto rendered in Rust and TypeScript. It argues that the future of AI agents should look like native desktop software—fast, offline-capable, and cryptographically local—rather than browser tabs wrapped around remote APIs. Whether it can build the ecosystem to match its ambition is an open question. The ClawHub marketplace must populate, the Skills format must prove distinct from MCP, and the project must survive the confusion of its own name. But the technical choices are coherent. In a landscape where AI agent increasingly means cloud service that logs into your computer, LiveAgent offers the counterpoint: an agent that logs into nothing, because it already lives on your machine.