Evot

An agent engine that completes complex, long-running work with minimal tokens and maximum quality.

Every gain measured under a rigorous trace + eval framework — earned through relentless iteration, never guessed at.

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

• 2026-07-22 [Memory] /mem — archive session knowledge to markdown; /mem <terms> and /resume <query> recall semantically.
• 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, same eval environment, different models. evot completes the work with fewer tokens, less time, and lower cost — on both frontier and open-source models.

Claude Opus 4.6	DeepSeek V4 Pro

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

All agents produce correct, passing code. The difference is how they manage context.

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