Evot

Same quality. Up to 78% less cost.

Fewer tool calls. Less context waste. More work per token.

News · Benchmark · Why · Dashboard · Install · Quickstart · Commands · Dev

• 2026-07-24 [REPL] /share securely shares or imports complete sessions through one command.
• 2026-07-24 [Memory] /clip saves the latest assistant reply verbatim; /clip all distills the whole session into the memory vault.
• 2026-07-22 [Memory] Persistent markdown memory and semantic /resume <query> recall.
• 2026-07-16 [REPL] Prompt queue — queue follow-ups and manage them with Ctrl+B.
• 2026-07-09 [REPL] /log shot — export the last assistant markdown turn as an HTML/PNG snapshot matching the TUI.
• 2026-07-03 [REPL] /copy — copy the last agent message's Markdown source to the clipboard.
• 2026-06-16 [REPL] Shift+Tab cycles reasoning effort; persisted per session.

Same task and eval environment, across three agents and three models. The matrix shows how both choices affect cost, tool usage, and concurrent work.

Cost and tool calls: lower is better. Parallelism: higher means more concurrent work.

Task: Fix a real bug in serde_json (issue #979) — investigate root cause, apply fix, write regression test, verify all tests pass.

All nine runs produce correct, passing code. Compared with Claude Code, evot costs 72–78% less and uses 23–38% fewer tool calls. It also uses fewer tool calls than pi on every model, while costing less on GPT 5.6 and Claude Opus 4.8.

Give the LLM less context, but higher-quality context. Where other agents burn extra tokens and time managing context, evot leans on cheap, deterministic machinery first:

• Algorithmic compaction — a Rust pipeline runs in microseconds between turns: spent tool results are reclaimed, and old turns are evicted into a compact structured summary while recent work stays intact.
• Provider-native compaction — on GPT/Codex models (OpenAI Responses API), evot uses server-side compaction automatically: the endpoint returns an opaque item that replays with far higher recall than a text summary. Zero config — any failure falls back to local summarization silently.
• Spill to disk — large tool results write to disk with a short preview. The model re-reads on demand instead of carrying megabytes in context.
• Compaction markers — structured metadata (files modified, conclusions, environment state) survives compaction, so progress is never lost.

Every gain is earned under a rigorous trace + eval framework, not guessed at. Each engine change is measured against live traces and a reproducible benchmark pipeline — the same real-world tasks run against Claude Code and Codex (latest versions) — before it ships. Token usage, cost, time, and success rate must improve or hold. Relentless trial and iteration, where the numbers decide what stays. Continuous improvement, no regression.

Evot ships with a built-in web dashboard for real-time observability: server resource usage, all connected sessions, and per-session detail — token usage, tool call sequences, and span-level traces.

Overview — server metrics & sessions	Session detail — usage & tool traces

curl -fsSL https://evot.ai/install | sh

git clone https://github.com/evotai/evot.git
cd evot
make setup && make install
evot

1. Set your API key

Create ~/.evotai/evot.env:

# Anthropic (default)
EVOT_LLM_ANTHROPIC_API_KEY=sk-ant-...
EVOT_LLM_ANTHROPIC_BASE_URL=your-anthropic-base-url
EVOT_LLM_ANTHROPIC_MODEL=claude-opus-4.8
# Multiple models: EVOT_LLM_ANTHROPIC_MODEL=claude-sonnet-5.0,claude-opus-4.8,claude-fable-5

# Or OpenAI Chat Completions
# EVOT_LLM_OPENAI_API_KEY=sk-...
# EVOT_LLM_OPENAI_BASE_URL=your-openai-compatible-base-url
# EVOT_LLM_OPENAI_MODEL=gpt-5.6-sol
# EVOT_LLM_OPENAI_PROTOCOL=openai

# Or OpenAI Responses API (official OpenAI GPT/Codex models)
# Using the official endpoint enables provider-native "remote compaction":
# context is compacted server-side with far higher recall, taking priority
# over the local algorithmic path (auto — falls back to local on any failure).
# EVOT_LLM_OPENAI_API_KEY=sk-...
# EVOT_LLM_OPENAI_MODEL=gpt-5.6-sol
# EVOT_LLM_OPENAI_PROTOCOL=openai_responses

# Or DeepSeek (Anthropic-compatible)
# EVOT_LLM_DEEPSEEK_API_KEY=sk-...
# EVOT_LLM_DEEPSEEK_BASE_URL=https://api.deepseek.com/anthropic
# EVOT_LLM_DEEPSEEK_PROTOCOL=anthropic
# EVOT_LLM_DEEPSEEK_MODEL=deepseek-v4-pro

# Or Kimi Coding (Anthropic-compatible)
# EVOT_LLM_KIMI_API_KEY=sk-...
# EVOT_LLM_KIMI_BASE_URL=https://api.kimi.com/coding
# EVOT_LLM_KIMI_PROTOCOL=anthropic
# EVOT_LLM_KIMI_MODEL=kimi-for-coding

2. Run

evot                 # interactive TUI
evot -c              # continue latest session in cwd

In the TUI: /help lists commands, Shift+Tab cycles the reasoning effort.

One-shot: evot -p "..." · resume by id: evot -r <id> · model override: --model provider:model

/help lists everything. These are the ones unique to evot and worth knowing:

Context compaction is automatic — evot compacts between turns as context fills, with no setup. On the official OpenAI Responses API, provider-native (remote) compaction takes priority; everything else uses the local algorithmic path. Use /compact only when you want to force it early.

make setup        # install Rust toolchain, git hooks
make test         # all tests (engine + CLI)
make install      # compile standalone binary to ~/.evotai/bin/evot

Apache-2.0