Agenvoy

Agenvoy is an open-source, self-hosted AI agent harness built in Go and released under the Apache 2.0 license. It runs entirely on your own machine, routes tasks across ten LLM providers through a single interface, and automatically builds missing tools on demand. The project is built in Taiwan by 邱敬幃 Pardn Chiu and is available on GitHub.

What It Is

Agenvoy is a local agent harness — a single binary daemon that accepts natural-language requests, dispatches them to the best available model, and executes the result using a sandboxed tool library. When no existing tool covers a request, the agent writes a new script, tests it in an OS-native sandbox (bubblewrap on Linux, sandbox-exec on macOS), and registers it for future reuse by any connected agent. It also acts as both an MCP server (exposing its tool library to Claude Code, Codex, and other MCP clients) and an MCP client (connecting to external MCP services).

Architecture: One Binary, Many Roles

Agenvoy ships as a single Go binary that handles every role simultaneously:

• Agent daemon — processes sessions, dispatches tasks, manages memory
• MCP server — exposes all sandboxed tools to external agents via stdio
• MCP client — connects to third-party MCP servers via stdio or HTTP/SSE
• Scheduler — runs cron and one-shot tasks with fsnotify hot-reload
• Local HTTP API — OpenAI-compatible chat completions endpoint plus management routes
• Web dashboard backend — connects to web.agenvoy.com, which runs in the browser but talks only to the local daemon; nothing leaves the device

The dispatcher LLM routes each task to the best-fit worker model, with per-model cooldown and automatic fallback when a provider fails.

Tool Self-Extension and Sandboxing

The defining capability of Agenvoy is its auto-tool-generation loop. When a user request requires data or an action that no existing tool covers, the agent searches for a public API, writes a script with a JSON schema, runs it through the sandbox to verify it works, and registers it permanently. The same tool is then instantly available to all connected MCP agents. Tool failures are stored in cross-session error memory with a 90-day TTL, and the agent rewrites and retests failing tools automatically. Every file touched by a tool is snapshotted, enabling per-version or per-task rollback.

Memory and Knowledge System

Agenvoy implements a three-tier memory architecture:

• Context window — rolling incremental summary with timestamp cursoring and a 24-message recent history window, sized to each model's context window via an in-run compaction pipeline
• Semantic vector search — keyword and semantic dual-track search over a personal knowledge base via optional KuraDB integration (registered as an MCP server)
• Full-text SQLite archive — cross-session error memory and reasoning guides pulled in by topic via reasoning_guide(topic=...)

Integrations and Reach

The same agent session is reachable from multiple surfaces simultaneously:

• TUI — interactive terminal with slash commands and session switching
• Web dashboard — browser UI at web.agenvoy.com, connects to the local daemon
• Telegram — OTP-authenticated bot with HTML output and voice (Gemini TTS, OGG/OPUS)
• Discord — guild-verified bot with native select menus and modals
• REST API — OpenAI-compatible chat completions endpoint

Ten LLM providers are supported behind one Agent.Send() interface: Anthropic, OpenAI, Gemini, GitHub Copilot, NVIDIA NIM, xAI Grok, DeepSeek, Mistral, OpenRouter, and Cloudflare Workers AI. Any OpenAI-compatible /v1 endpoint (Ollama, LM Studio, vLLM, self-hosted) also plugs in.

Update: v0.33.1

The latest release is v0.33.1, published on 2026-08-28, with the repository last pushed on the same date. The GitHub project was created in February 2026 and has been actively developed since, with the web dashboard demo video referencing v0.28.0 as a recent milestone. The project appears on Trendshift's daily Go repository rankings. The 25 built-in tools use a lazy-loading schema strategy — only five ship with full schemas at startup, with the rest loading parameters on first use to keep the initial payload at roughly one-third of the full registry size.