ChatCLI

One binary for AI everywhere you work:
the terminal, your editor, your chat apps and webhooks, a gRPC server and Kubernetes.

_{14 LLM providers · an autonomous coder agent · a seven-pattern quality harness
Mixture-of-Agents with cross-review · a live APM-style dashboard}

https://chatcli.edilsonfreitas.com
_{The official website: guides, cookbooks, configuration and the full reference for every feature, in English and Portuguese.}

Documentation · Quick start · Highlights · Security · Contributing · Português

Why ChatCLI

• Every major model, one interface. Switch provider or model mid-conversation; fail over automatically; keep cost, tokens and prompt-cache use in view.
• An agent that does the work. /coder reads, edits, runs and tests code under a security policy you control, with checkpoints you can rewind.
• Answers you can trust more. Self-Refine, Chain-of-Verification, Reflexion, RAG with HyDE and Mixture-of-Agents with cross-review cross-check what models say.
• The same brain everywhere. The terminal, a browser UI, editors over ACP, any MCP client, Telegram, Slack, Discord, WhatsApp, webhooks, a gRPC server and a Kubernetes operator share sessions, memory and tools.
• Built to run where it matters. Signed releases, fail-closed defaults, workspace trust, audit logs and a published security process.

Quick start

# Homebrew (macOS, Linux)
brew tap diillson/chatcli && brew install chatcli

# or Go
go install github.com/diillson/chatcli@latest

# or a signed binary from the releases page
# https://github.com/diillson/chatcli/releases/latest

Point it at a model, with an API key or an OAuth login:

export LLM_PROVIDER=OPENAI OPENAI_API_KEY=sk-...   # or CLAUDEAI, GOOGLEAI, BEDROCK, XAI, OLLAMA, …
chatcli                                            # then /auth login <provider> for OAuth

Then:

chatcli -p "Explain this repository"               # one-shot, pipeable
git diff | chatcli -p "Write the commit message"
chatcli                                            # interactive
  > /coder add tests for the utils package         # the autonomous coder
  > /moa --layers 2 Should we migrate to Karpenter? # several models, cross-reviewed
  > /dash                                          # watch everything live

ChatCLI keeps itself current with /update (Homebrew, go install or a signature-verified self-replace). Installation guide →

Highlights

🤖 Coder agent A ReAct loop with 46 builtin tools: files, search, shell, git, tests, LSP diagnostics, a real browser, Git forges, background processes. Every call goes through an allow/ask/deny policy; edits are checkpointed in a shadow repository; an optional OS sandbox confines commands. Coder mode →	🧠 Mixture-of-Agents with cross-review /moa asks several models at once. With --layers 2, each model reads the others' answers and revises its own, and the synthesis keeps a section on where they still disagree. The AI can call it too, as @moa. MoA →
✅ Quality harness Seven patterns, composable and observable: ReAct, Plan-and-Solve, Reflexion with a durable queue, RAG + HyDE, Self-Refine with semantic convergence, Chain-of-Verification and a cross-provider reasoning backbone. Harness →	📈 Live dashboard, like an APM /dash draws the whole runtime as a service map, across every ChatCLI process on the machine: who called whom, from the turn to the agent, the tool, the model and the host, with cost, latency, errors, policy decisions and fallbacks. Metadata only. Live dashboard →
👥 Squads and task graphs Specialist workers run in parallel under a dispatcher; @taskgraph turns an approved plan into a verified DAG where the engine runs each task's checks and a fresh reviewer gives the verdict. Task graph →	🔌 MCP, ACP and plugins An MCP client (stdio, SSE, HTTP with OAuth) and an MCP server that re-exports everything; an ACP server for editors; signed plugins; provider plugins that add a whole LLM provider; skills from several registries; slash commands compatible with nine other CLIs. Extensions →
💬 Chat gateway Telegram, Slack, Discord, WhatsApp and webhooks run the same agent, with voice notes transcribed offline and answered in voice, sender allowlists that fail closed and one conversation across channels. Gateway →	☸️ Kubernetes and AIOps A gRPC server with TLS 1.3, JWT and roles, and an operator with 17 CRDs that watches workloads, opens incidents, proposes and applies remediations behind approvals, and writes post-mortems. Kubernetes →
📄 Documents and media, on every provider PDFs and images reach every model, natively where it can read them and as text where it cannot; image generation, offline speech-to-text and text-to-speech, diagrams and an interactive knowledge graph. PDF input →	🗂️ Memory and context Long-term memory with a profile and facts, a knowledge base with keyless BM25 retrieval, reversible compression where nothing is lost (@recall pages long originals), and sessions that continue across surfaces. Context →
⏱️ Scheduler Durable jobs with cron, wait-until conditions and dependencies; a daemon keeps them running with the terminal closed; agents can park themselves and wake on a condition. Scheduler →	🧪 Evals chatcli eval runs YAML suites against the real binary in a sandbox, graded by deterministic checks and an LLM judge, with pass@k, baselines and CI-friendly exit codes. Evals →

Where it runs

Surface	Start it with
Interactive terminal	chatcli	chat, /coder, /agent, /moa, every slash command
One-shot and pipes	chatcli -p "…"	scripts, CI, git diff | chatcli -p …
Browser UI	/web or chatcli web	the same session as the terminal
Editors (ACP)	chatcli acp	Zed and other ACP clients
Any MCP client	chatcli mcp-server	every tool, the agent loops, skills as prompts
Chat apps	/gateway start	Telegram, Slack, Discord, WhatsApp, webhooks
Shared backend	chatcli server	gRPC with TLS 1.3, JWT and roles
Kubernetes	Helm chart chatcli-operator	AIOps operator
Live dashboard	/dash or chatcli dash	every ChatCLI process on the machine

Providers

14 built-in providers behind one interface, with a fallback chain, cross-provider reasoning control (/thinking) and prompt caching where the provider offers it. Provider plugins add more without rebuilding ChatCLI.

Provider	LLM_PROVIDER	Auth
OpenAI	OPENAI	OPENAI_API_KEY, or OAuth with /auth login openai-codex (Responses API)
OpenAI Assistants	OPENAI_ASSISTANT	OPENAI_API_KEY
Anthropic Claude	CLAUDEAI	ANTHROPIC_API_KEY, or OAuth with /auth login anthropic
AWS Bedrock	BEDROCK	AWS profile, SSO, aws login or the credentials chain
Google Gemini	GOOGLEAI	GOOGLEAI_API_KEY
xAI Grok	XAI	XAI_API_KEY
Z.AI (GLM)	ZAI	ZAI_API_KEY, including the GLM Coding Plan
Moonshot Kimi	MOONSHOT	MOONSHOT_API_KEY
MiniMax	MINIMAX	MINIMAX_API_KEY
OpenRouter	OPENROUTER	OPENROUTER_API_KEY
GitHub Copilot	COPILOT	/auth login github-copilot (device flow) or GITHUB_COPILOT_TOKEN
Ollama	OLLAMA	local, no key
StackSpot AI	STACKSPOT	CLIENT_ID and CLIENT_KEY
Devin (Cognition)	DEVIN	the local Devin CLI

Models, prices and context windows come from a live catalog: /switch --model lists what each account really serves. Supported models → · All settings →

Security

ChatCLI runs commands and holds credentials, so security is the default, not an option:

• Policy-gated tools: every agent action is allowed, asked or denied by a policy you control; unattended surfaces refuse instead of approving.
• Workspace trust: a project's .env, hooks and policy load only after chatcli trust.
• Fail-closed integrations: chat channels refuse to start without a sender allowlist; signed webhooks are verified with HMAC.
• Encrypted at rest by default: conversations, memory, contexts, attachments and credentials are sealed with AES-256-GCM, with the key in the OS keychain (macOS, Linux, Windows) or, in Kubernetes, in a Secret; OAuth uses PKCE. Save a recovery key with /config security recovery-key: without it, a lost keychain means the data cannot be opened.
• No telemetry: your data goes only to the providers and tools you configure; metrics leave the machine only if you point OTLP at your own collector.
• Signed supply chain: Ed25519-signed release checksums verified by chatcli update, Cosign-signed images, an SBOM, and Trivy, CodeQL, gosec and govulncheck on every change.

Report vulnerabilities privately: see SECURITY.md. What happens to your data → · Security overview →

Documentation

Get started	Installation · Quickstart · Basic usage
Agents	Coder mode · Squads · Task graph · Mixture-of-Agents · Harness
Context	Memory · Knowledge base · Compression · Sessions
Extend	Plugins · Provider plugins · MCP · Skills · Hooks · Slash commands
Run it	Server mode · Gateway · Kubernetes operator · Docker
Reference	Commands · Environment variables · Architecture · Releases

Community

• Contribute: read CONTRIBUTING.md for the setup, the conventions and what CI checks.
• Conduct: everyone taking part follows the Code of Conduct.
• Security: report vulnerabilities privately as described in SECURITY.md.
• Bugs and ideas: open an issue.

If ChatCLI is useful to you, a ⭐ helps others find it.

License

Apache License 2.0 © Edilson Freitas