Agenvoy

A Go AI agent framework with self-improving error memory, intelligent multi-provider routing, Python/JS/REST API tool extensions, and OS-native sandbox execution

The agent learns from past failures across sessions, routes each task to the right LLM provider automatically, and lets you extend its toolset by dropping a script or JSON file — all running inside an OS-native sandbox.

Terminal UI consolidating CLI, Discord bot, and REST API into a single local interface — filesystem browser, session content viewer, and live log stream.

• Architecture
• Features
• Dependencies
• Concepts
• Version History
• License
• Author
• Stars

Full Architecture

graph TB
    subgraph Entry ["Entry"]
        App["cmd/app · Unified TUI App"]
    end

    subgraph Engine ["Execution Engine"]
        Run["exec.Run()\nprefix detect → SelectAgent → Execute"]
        Execute["exec.Execute()\n≤128 iterations\nskill activates via select_skill tool"]
    end

    subgraph Providers ["LLM Providers"]
        P["Copilot · OpenAI · Codex · Claude\nGemini · Nvidia · Compat"]
    end

    subgraph Security ["Security Layer"]
        S["Sandbox · Denied Paths · Keychain"]
    end

    subgraph Tools ["Tool Subsystem"]
        T["File · Web · API · Script · Skill (select_skill)\nScheduler · Error Memory · Sub-Agent"]
    end

    subgraph Memory ["Memory Layer"]
        M["ToriiDB Store · Session Summary"]
    end

    App --> Run
    Run --> Execute
    Execute -->|"Agent.Send()"| Providers
    Execute -->|"tool calls"| Security
    Security --> Tools
    Tools -->|"results"| Execute
    Execute --> Memory
    Memory -.->|"inject"| Execute

make build · agen (unified CLI / TUI / Discord / REST API) · Documentation

Seven backends (Copilot / OpenAI / Codex / Claude / Gemini / Nvidia / Compat) behind a unified Agent interface, with a planner LLM picking the right provider per task.

Drop a tool.json + script.js/script.py to register a script tool, or a JSON file to wire any HTTP API as a tool — no Go code, no recompilation.

All commands run inside bubblewrap (Linux) or sandbox-exec (macOS), with path escapes and sensitive files blocked at the OS level.

Tool failures are SHA-256 indexed into a knowledge base that the agent recalls and reuses across sessions.

invoke_subagent spawns an isolated sub-agent directly inside the host process — independent session, optional model / system-prompt / tool overrides, forced self-exclusion to prevent recursion, and no HTTP hop.

First-party packages Agenvoy pulls in directly from its author's ecosystem.

A lightweight embedded key-value store that serves as Agenvoy's single persistence backbone. Session history, error memory, and web tool caches (fetch_page / search_web / fetch_google_rss) all live behind a thin internal/filesystem/store wrapper instead of scattered JSON files. This collapses per-subsystem file formats into one indexed, atomic store, lets search_conversation_history and search_errors scan sessions without walking the filesystem, and reduces cache invalidation to a single key delete.

A cross-cutting utility package providing the HTTP, browser, sandbox, keychain, and helper primitives Agenvoy builds on. go-utils/http supplies the generic GET[T] / POST[T] / PUT[T] / PATCH[T] / DELETE[T] client used by every provider (claude / openai / copilot / compat / gemini / nvidia) and every native API tool (yahooFinance / youtube / googleRSS / searchWeb). go-utils/rod owns the headless-Chrome stack behind fetch_page — stealth JS, listener-settle detection, viewport handling, typed FetchError{Status}, KeepLinks, and a process-singleton browser with idle-TTL eviction. go-utils/sandbox owns the OS-native process isolation wrapped around run_command and every script tool — macOS sandbox-exec seatbelt profiles, Linux bwrap bubblewrap with auto-probed --unshare-* namespaces, CheckDependence() auto-installing bubblewrap on Linux, and a one-time New(denyMapJSON) to seed sensitive-path denylists sourced from configs/jsons/denied_map.json. go-utils/filesystem/keychain powers credential storage (macOS security / Linux secret-tool / file fallback), and go-utils/utils.UUID() provides the shared ID generator.

An in-process cron runtime that makes recurring schedules a first-class primitive inside the agen binary — no system crontab, no systemd timer, no external daemon. internal/scheduler wraps goCron.New(...) behind a process singleton (once.Do) with a minimal schedulerCron interface (Start / Stop / Add(spec, action, args...) / Remove), so the same engine powers both the hourly summary cron and agent-created schedules. This is surfaced to the LLM as four pairs of tools — add_cron / list_crons / get_cron / remove_cron for cron-expression schedules, and add_task / list_tasks / get_task / remove_task for one-shot time.Timer-backed tasks — both persisted through internal/filesystem and reloaded on startup. Because everything runs inside the agent process, schedule state, tool availability, and execution context stay consistent across TUI / CLI / Discord / REST modes; stop the binary and every pending firing stops with it (Stop() cancels every timer and drains the cron via c.Stop()).

Two prior projects from the same author directly informed Agenvoy's architecture:

pardnchiu/go-faas is a lightweight Function-as-a-Service platform that accepts Python, JavaScript, and TypeScript code via HTTP, executes each function inside a Bubblewrap sandbox with full Linux namespace isolation, and streams results. Agenvoy's script tool subsystem (scriptAdapter) adopts this model directly: each script tool is a stateless function invoked via stdin/stdout JSON, isolated to its own process, with the agent acting as the caller rather than an HTTP client.

pardnchiu/cim-prototype argues that perfect memory is a cognitive burden — based on research showing multi-turn LLM performance drops 39% when full conversation history is replayed verbatim (LLMs Get Lost In Multi-Turn Conversation). The system maintains a structured rolling summary and retrieves relevant fragments via fuzzy search only when triggered, mirroring how humans selectively recall rather than replay. Agenvoy's session layer reflects this directly: trimMessages() enforces a token budget rather than replaying full history, summary is persisted and deep-merged across turns, and search_conversation_history provides keyword-triggered recall rather than injecting all past context.

• v0.19.0 — Add in-process sub-agent delegation (invoke_subagent) with isolated temp sessions, per-call model / system-prompt / tool overrides, and mandatory self-exclusion. Add three-pass concurrent tool-call dispatcher with a Concurrent registry flag, fan-out for fetch_page / invoke_subagent / calculate, and a batch-scoped stub-activation guard. Add same-payload retry circuit breaker for provider and tool calls; add prompt_cache_key to the Codex Responses API; switch search_web from html.duckduckgo.com to lite.duckduckgo.com/lite/ with new anchor/snippet parsing; drop DDG-unsupported sub-day time ranges; harden fetch_page soft-404 detection via err=404/403/410 query-param redirects; strengthen agent tier routing and memory-driven tool recovery.
• v0.18.0–v0.18.3 — Add vim-style TUI navigation keys and : command input mode. Migrate session history, error memory, and fetch_page / search_web / google_rss caches to the ToriiDB store. Replace per-request summary with an hourly cron running chunked multi-pass generation. Consolidate cmd/cli and cmd/server into a single cmd/app entry and rename the binary to agen. Replace internal keychain / HTTP client / fetchPage internals with go-utils packages. Add stub-tool handling and schema-derived required-arg validation.
• v0.17.0–v0.17.4 — Ship the full REST API layer (/v1/send with SSE + non-SSE, /v1/key, /v1/tools, /v1/tool/:name), unify Discord bot and REST API under cmd/app, and move the Copilot token into the system keychain. Add invoke_external_agent / cross_review_with_external_agents / review_result for external delegation and internal priority-model review, plus a model field on /v1/send to bypass agent selection. Add search_tools deferred tool loading (keyword fuzzy search + select:<name> direct activation), exclude_tools per-request filtering, and prompt caching across Claude / Gemini / Copilot providers. Add OpenAI Codex as a standalone OAuth provider (Device Code Flow), read_image for local image input, and restore Yahoo Finance as a native Go tool (fetch_yahoo_finance) with concurrent query1/query2 fetch. Refactor session message assembly into 4 fixed segments with reactive context trimming, scheduler into crons/ / tasks/ / script/ sub-packages, and rename browser → fetchPage.
• v0.16.0–v0.16.1 — Ship the script tool runtime (scriptAdapter): drop a tool.json + script.js/script.py into ~/.config/agenvoy/script_tools/ and it is auto-discovered as a script_-prefixed tool via stdin/stdout JSON that mirrors the API tool contract. Bundle Threads and yt-dlp script extensions with cross-platform install_threads.sh / install_youtube.sh. Add Copilot token 401 auto-relogin. Refactor toolAdapter into api/ and script/ sub-packages, move session management into internal/session, split filesystem into single-responsibility files, and fix Darwin sandbox keychain directory access.
• v0.15.0–v0.15.2 — Add Copilot Responses API support (GPT-5.4 and Codex models auto-switch endpoint), session-level token-budget message trimming, sensitive-path denial rules for macOS and Linux sandbox, and restore Linux bwrap --unshare-all namespace isolation. Fix Copilot Claude/Gemini image validation by decoding and re-encoding every upload as JPEG; split the summary regex into three independent patterns; move system prompts after history to strengthen instruction adherence. Add the analyze_youtube metadata tool, Discord Modal-based API key management, per-model token usage tracking via usageManager, configurable reasoning level across all providers, and browser iteration limits via MAX_TOOL_ITERATIONS / MAX_SKILL_ITERATIONS / MAX_EMPTY_RESPONSES.

This project is licensed under the Apache-2.0 LICENSE.

©️ 2026 邱敬幃 Pardn Chiu