zot Coding Agent
A lightweight coding agent harness written in Go: one static binary with 30+ built-in providers, a TUI, background subagent swarms, and a Telegram bridge for full agentic coding workflows in your terminal.
Docs describe jail sandbox, tool allowlists, permission modes, auth. 0600, so least privilege and sensitive-data handling are documented; but the default runs tools freely, confirmation exists only via --no-yolo and is ignored in non-interactive modes — deducted; external effects (bash, telegram, GitHub downloads) are README-only claims without code in scope; no file rollback mechanism; dependencies pinned but no vuln scanning or security policy; third-party OAuth client-ID reuse risk is honestly disclosed.
Failure paths are well described (token refresh failures, PowerShell errors, silent changelog skip); however CI pins Go 1.23 while go.mod requires 1.25.0 — a concrete self-inconsistency, deducted; dependencies are publicly available.
Audience/scenarios (interactive/print/JSON/RPC/embedding), capability boundaries (jail is not a security boundary, zotfiles limitations), and trigger precision (mode auto-selection, flag precedence) are adequately documented; multi-platform fit (Linux/macOS/Windows, arm64) is evidenced.
Install notes cover four channels with checksum verification — full marks; LICENSE complete; docs well organized with honest limitations (OAuth ToS risk, bash 3.2, jail limits); but versions are auto-bumped by CI with no CHANGELOG file, and maintenance is single-author with no support commitment — deducted.
Output formats (streaming, NDJSON, stats) and multi-provider marginal value are clear, single-binary positioning is coherent; but cost-benefit is asserted without benchmarks — deducted.
The README separates facts, notes, and risk warnings well; however the supplied evidence contains no tool/sandbox implementation code, so most core claims cannot be traced or corroborated, and the project self-describes as 'vibe-slopped' — deducted.
- By default tools (bash/write/edit) execute without per-call confirmation; use --no-yolo or jail explicitly for safety, but jail is an accident-prevention guardrail, not a security boundary.
- Non-interactive modes (print//rpc) ignore confirmation settings; constrain the tool set yourself when scripting.
- auth. is executable configuration: anyone who can modify it can run programs as your user via api_key_command; protect its permissions.
- Subscription login reuses OAuth client IDs from official CLIs and may violate their terms of service or be revoked at any time.
- CI Go version (1.23) conflicts with go.mod (1.25.0); the test matrix may not cover the target Go version.
- Running a zotfile from GitHub executes third-party code with no official review or allowlist; run only trusted sources.
What does this agent do, and when should you use it?
zot is a lightweight coding agent harness written in Go, delivered as a single static binary with releases for Linux, macOS, and Windows on amd64/arm64. It ships adapters for more than 30 providers — Anthropic, OpenAI/Codex, Google Gemini/Vertex, Kimi, DeepSeek, GitHub Copilot, Bedrock, Azure OpenAI, Ollama local models, and more — with both API-key and subscription OAuth login paths. The agent runs built-in tools (read, write, edit, bash, glob) and supports interactive TUI, print, stream, JSON, and RPC run modes; `zot rpc` exposes a newline-delimited JSON protocol for embedding zot in apps written in any language. Sessions persist as JSONL transcripts with resume, fork, tree view, and portable .zotsession export, and standing or reusable instructions come from AGENTS.md and SKILL.md files. Extensions run as subprocesses speaking JSON-RPC in any language, and the product also includes /swarm background subagents, a /jail cwd sandbox, and a Telegram bot bridge.
zot runs an agent loop in your working directory: the model invokes built-in tools — read, write, edit, bash, and glob — to inspect and modify files and run shell commands, capped at 50 iterations by default (--max-steps). Launch zot for the interactive TUI, zot -p "prompt" for final-text output, zot -- for NDJSON events, or zot rpc as a long-lived subprocess for third-party embedding. Credentials resolve in order: --api-key flag, provider env vars (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.), then $ZOT_HOME/auth., with OAuth tokens refreshed automatically. /login offers browser-based subscription sign-in for Claude Pro/Max, ChatGPT Plus/Pro, Kimi Code, SuperGrok, and GitHub Copilot. zot run owner/repo downloads a public GitHub repository archive to a temporary directory, validates it, and runs it as a packaged zotfile agent. /swarm spawns parallel background subagents, /compact condenses context, /jail confines tools to the cwd, and /telegram forwards DMs into the running session.
- Terminal-first developers who want a vendor-neutral coding agent they can point at Claude, GPT, Gemini, DeepSeek, or local Ollama models in any repo.
- Engineers with a Claude Pro/Max or ChatGPT Plus/Pro subscription who want to reuse it via browser OAuth login instead of buying API keys.
- Teams embedding an agent in their own tooling, using the Go SDK (packages/agent/sdk) in-process or the cross-language
zot rpcNDJSON protocol. - Users who want to prompt a long-running session from their phone via the built-in Telegram bridge, which refreshes OAuth tokens per turn so multi-day bots keep working.
- Developers parallelizing side tasks with /swarm — e.g. one subagent drafting a migration while another writes tests — while continuing in the main thread.
- Migrants from Claude Code, moving CLAUDE.md content into AGENTS.md and reusing skills under .claude/skills/.
What are this agent's strengths and limitations?
- One static Go binary across Linux/macOS/Windows (amd64/arm64) with no runtime dependencies — extremely low deployment cost.
- 30+ built-in provider adapters plus subscription OAuth login (Claude Pro/Max, Codex, Kimi Code, SuperGrok, Copilot) and a model-rescue picker on provider failures, minimizing vendor lock-in.
- Strong embedding story: the Go SDK and the cross-language NDJSON RPC share one event schema, making integration into existing pipelines straightforward.
- Fine-grained session management: JSONL persistence, resume, fork, tree view, portable .zotsession export, and automatic context compaction.
- Subscription login reuses OAuth client IDs published in Claude Code, Codex CLI, and other official tools; the README explicitly warns this may violate provider terms of service and can be revoked at any time.
- /jail is an accident-prevention guardrail, not a security boundary; swarm subagents edit the host working directory directly with no per-agent worktree, so parallel edits require your own git worktree setup.
- Extensions ship none by default and require explicit
zot ext installor--ext; DeepSeek and Google Gemini support only API-key auth, with no subscription path. - This profile is based on a truncated README; details after the Vertex AI section (zotfile permissions model and limitations) could not be verified here and require docs/zotfiles.md.
How do you install or deploy this agent?
One-liner (macOS/Linux): curl -fsSL https://www.zot.sh/install.sh | bash — the script verifies the SHA-256 against checksums.txt and installs into /usr/local/bin, ~/.local/bin, or ~/bin. Windows (PowerShell): iwr -useb https://www.zot.sh/install.ps1 | iex. Via Go: go install github.com/patriceckhart/zot/cmd/zot@latest (requires Go 1.25+). From source: git clone https://github.com/patriceckhart/zot && cd zot && make build. Prebuilt archives for Linux/macOS/Windows on amd64/arm64 are on the GitHub Releases page.
How do you use this agent?
- Run
zotand type/loginin the TUI to authenticate via browser — API key or subscription (Claude Pro/Max, ChatGPT, Kimi Code, SuperGrok, GitHub Copilot) — or set an env var such asANTHROPIC_API_KEY,OPENAI_API_KEY, orDEEPSEEK_API_KEY. 2. Basic invocation:zot(interactive TUI),zot "fix the failing test",zot -p "list all go files"(print mode),zot -- "refactor main.go"(NDJSON events),zot --continueto resume the last session. 3. Pick provider/model with--provider anthropic --model <id>; browse withzot --list-models. 4. Optional guardrails:/jailto confine tools to the cwd,--no-yoloto confirm every tool call,/swarm new <task>for background subagents,/studyto have the agent read the project first. 5. Run packaged agents:zot run ./my-agent.zotorzot run owner/repo.
How does this agent compare with similar options?
The README self-describes zot as "Yet another coding agent harness" and repeatedly contrasts it with Claude Code: zot does not read CLAUDE.md (its only Claude compatibility is skills under .claude/skills/), and its subscription logins reuse the Claude Code and Codex CLI OAuth flows — positioning it as an open-source, multi-provider alternative to those closed CLIs.
FAQ
Do I need to buy API keys?
Will the agent modify my files directly, and how do I control risk?
How do I integrate zot into my own application?
zot rpc as a subprocess and exchange NDJSON commands/events over stdin/stdout — reference clients live under examples/rpc/.