Agendo

Agendo is a locally branded, multi-provider fork of MoonshotAI/kimi-code. It keeps the upstream architecture, package names, compatibility paths, documentation links, author metadata, and MIT license while presenting Agendo in the terminal UI.

The supplied robot-and-cape artwork is the canonical product mark. Its charcoal, white, and amber colors now drive the browser UI and terminal theme (#F5A900 on dark surfaces and #A95000 on light surfaces). The application UI is English-only: the Chinese locale, language selectors, and other Chinese user-facing strings were removed. Tests may retain Unicode fixtures. Upstream Kimi references remain where they describe package compatibility, vendor-specific OAuth, authorship, or licensing.

Agendo maintains a persistent local SQLite catalog for six team routes: Kimi K3, GPT-5.6 Sol, DeepSeek V4 Pro, DeepSeek V4 Flash, GLM 5.2, and MiniMax M3. The catalog keeps model and provider provenance, subscriptions, immutable price snapshots, specialties, objective run evidence, and learned route scores. OpenCode Zen/free models can also be added to the normal model selector.

Run agendo, then use /model inside the CLI to switch the root conversation. Run agendo --team to make that root conversation a non-coding team lead which delegates through catalog-selected, model-pinned specialists.

Provider credentials stay in the trusted launcher/provider layer and are removed from config writes and delegated environments; Agendo does not save provider keys or Codex access tokens to config.toml.

The trusted provider layer holds credentials, while delegated Bash processes receive a separate, minimal allowlist. Do not enable verbose HTTP logging while provider credentials are present, and keep unrelated secrets out of the Agendo launch environment.

Quick start

The repository requires Node.js 24.15.0 and pnpm 10.33.0.

cd kimi-code
nvm install
nvm use
npm install --global pnpm@10.33.0
pnpm install
pnpm build:kimi-cli
cd apps/kimi-code
npm link

npm link installs the command into the active Node version. With nvm, repeat it if you switch to a different Node installation.

Start Agendo from any project directory:

cd /path/to/your/project
agendo

The startup line lists the detected models:

Agendo models: DeepSeek V4 Pro, Codex subscription: gpt-5.6-sol. Use /model to switch.

Inside the CLI:

/model

Choose the initial model without opening the selector:

AGENDO_DEFAULT_MODEL=deepseek agendo
AGENDO_DEFAULT_MODEL=deepseek-flash agendo
AGENDO_DEFAULT_MODEL=codex agendo
AGENDO_DEFAULT_MODEL=glm agendo
AGENDO_DEFAULT_MODEL=minimax agendo
AGENDO_DEFAULT_MODEL=opencode agendo

The last option is available only when an OpenCode Zen key is configured. Kimi subscription models come from the saved Kimi login and remain selectable with /model. Agendo publishes only the agendo executable.

Adaptive team mode

Plain agendo keeps the upstream single-conversation behavior. Team mode is explicit:

agendo --team

The selected root model becomes the team lead. Its profile has no direct Write, Edit, or unrestricted Bash tool; for non-trivial work it delegates implementation and judges the resulting evidence. Each worker conversation is pinned to one resolved route for its lifetime, including retries and fixes.

Role	Responsibility	Default catalog bias before learning
Planner	Architecture, requirements, and risk	Strong reasoning
Consolidator	Reconcile three independent plans	Strong reasoning
Frontend	UI, accessibility, responsive behavior	Kimi K3
Backend	API, data, security, integrations	GPT-5.6 Sol
Coder	General implementation and repairs	Quality/cost-ranked
Assets	Image generation and visual integration	Image-capable route
Research	Current primary-source evidence	Research-ranked route
Reviewer	Independent Git-diff review	Review-ranked route
Verifier	Programmatic, Playwright, and visual acceptance	Verification-ranked route

TeamTask enforces plan → implement → programmatic checks → independent verification and review. It captures Git and protected-file state both before implementation and after validation, and permits only a bounded number of fixes. A task cannot pass on prose alone or after a validator changes the workspace.

For genuinely difficult decisions, the lead can invoke PlanningCouncil. Three isolated planner conversations receive the same question independently; a separately routed consolidator challenges and combines them. This is a deliberate side track, not overhead added to every turn. ResearchTask similarly provides one bounded, read-only research delegation.

Model catalog and objective learning

The default database is local to the user; inspect its resolved path and contents with:

agendo catalog path
agendo catalog status
agendo catalog list routes --enabled
agendo catalog list subscriptions
agendo catalog list scores --role frontend
agendo catalog explain frontend

Pin or unpin a role, change the user's real subscription cost, and calculate one request without mixing actual, provider-derived, theoretical, and allocated cost meanings:

agendo catalog set-role frontend --route kimi-k3-subscription
agendo catalog set-role frontend --clear
agendo catalog set-subscription opencode-go-subscription --monthly-cost-usd 10 --active
agendo catalog cost deepseek-v4-pro-official \
  --input-tokens 250000 --cached-read-tokens 200000 --output-tokens 12000 --json

Definitions can be safely edited through strict, credential-free JSON records:

agendo catalog show route deepseek-v4-pro-official --json
agendo catalog upsert provider ./provider.json
agendo catalog upsert model ./model.json
agendo catalog upsert subscription ./subscription.json
agendo catalog upsert route ./route.json
agendo catalog upsert price ./new-immutable-price-snapshot.json
agendo catalog export > agendo-catalog-public.json

Unknown fields and secret-bearing values are rejected. Price snapshots are append-only. Sanitized show/export output omits credential references. Use --database /absolute/path/catalog.sqlite on catalog commands to manage a separate catalog.

Agendo records deterministic runtime facts—checks, errors, retries, iterations, elapsed time, token buckets, and distinct cost meanings—and learns only from comparable objective cohorts. It does not ask another LLM to grade the work. Manual scores can be locked; learned scores remain unset until their sample/confidence gates are met:

agendo catalog learn --min-samples 3 --min-confidence 50
agendo catalog set-role reviewer --route codex-gpt-5-6-sol-subscription \
  --manual-score 95 --lock-score
agendo catalog set-role reviewer --unlock-score

Use agendo catalog --help and each subcommand's --help for the complete list/show/record filters.

Kimi K3 subscription

Sign in through Agendo's inherited Kimi login flow, then choose K3 with /model:

agendo login
agendo

The team catalog route is kimi-k3-subscription, with inference attributed to Moonshot AI. The subscription's request-level cash cost remains unknown unless the account exposes coverage or overage evidence; the catalog keeps official API list pricing only as a separate theoretical comparison.

DeepSeek V4 Pro

Prefer a dedicated provider file outside both this repository and every project delegated to Agendo:

DEEPSEEK_API_KEY=YOUR_KEY

KIMI_PROVIDER_ENV_FILE="$HOME/.config/agendo/providers.env" agendo

Agendo configures:

• Model ID: deepseek-v4-pro
• Display name: DeepSeek V4 Pro
• Endpoint: https://api.deepseek.com
• Protocol: OpenAI Chat Completions
• Context declaration: 1,000,000 tokens
• Default thinking effort: high

Test the legacy single-provider launcher without making a model request:

pnpm agendo:deepseek -- --check

Run one prompt:

pnpm agendo:deepseek -- -p "Reply with only: DeepSeek works"

Override thinking effort:

KIMI_DEEPSEEK_THINKING_EFFORT=max agendo

Codex subscription

Install the official Codex CLI and sign in with ChatGPT:

codex login
codex login status

Agendo finds the Codex executable in common nvm and Herd Node installations, asks the official codex app-server to refresh the login, and reads the resulting short-lived access token and account ID from Codex's own auth.json. The refresh token is never copied.

Defaults:

• Model ID: gpt-5.6-sol
• Display name: Codex subscription: gpt-5.6-sol
• Endpoint: https://chatgpt.com/backend-api/codex
• Protocol: OpenAI Responses
• Context declaration: 272,000 tokens
• Default thinking effort: medium

Test the profile:

pnpm agendo:codex -- --check
pnpm agendo:codex -- -p "Reply with only: Codex works"

Override the model or effort:

KIMI_CODEX_MODEL=gpt-5.6-terra \
KIMI_CODEX_THINKING_EFFORT=medium \
agendo

If Codex is not on PATH, set KIMI_CODEX_BINARY to its absolute path. Set CODEX_HOME if Codex stores its state somewhere other than ~/.codex.

Codex bridge limitation

OpenAI officially supports ChatGPT plans through the Codex CLI, but does not document the ChatGPT Codex backend as a general third-party provider API. This bridge may need adjustment when Codex authentication, headers, model names, or response schemas change. Use the official codex CLI directly if that happens.

Agendo sets KIMI_MODEL_MAX_COMPLETION_TOKENS=0 because the current ChatGPT Codex backend rejects the otherwise standard Responses field max_output_tokens.

OpenCode Go subscription

Sign in with the official OpenCode CLI:

opencode auth login
opencode auth list

Agendo reads the stored opencode-go login at startup without copying it into its own config. You can also provide OPENCODE_GO_API_KEY through the protected provider environment. Two routes are added:

• opencode-go-glm-5-2: GLM 5.2 over OpenCode Go's OpenAI-compatible endpoint, frozen at high reasoning because the gateway does not publish a broader effort contract.
• opencode-go-minimax-m3: MiniMax M3 over the documented Anthropic-compatible endpoint. OpenCode's public route/model metadata caps context at 512,000 tokens and output at 128,000 tokens; Agendo asserts no price beyond that context ceiling.

OpenCode identifies the Go gateway but not its underlying serving infrastructure, so Agendo records the inference provider as undisclosed. The $10 monthly plan can be stored for allocation reporting, but included requests do not become a fabricated $0 actual cost without request-level coverage evidence.

OpenCode free models

OpenCode currently lists several limited-time free models. Availability can change.

Use an OpenCode model inside Agendo

Kimi's provider abstraction needs an OpenAI-compatible API key. Create an OpenCode Zen key and add it to .env:

OPENCODE_API_KEY=YOUR_OPENCODE_ZEN_KEY

OPENCODE_ZEN_API_KEY is also accepted. Agendo then adds the selected Zen model to /model.

KIMI_OPENCODE_FREE_MODEL=ling-3.0-flash-free agendo

The legacy launcher can list its allowlist:

pnpm agendo:opencode-free -- --list-free-models
pnpm agendo:opencode-free -- --check

Use OpenCode's stored login directly

An OpenCode CLI login is not an exportable Zen API key. Without a Zen key, use the official OpenCode CLI; this still allows free-model testing but does not place that model in Agendo's /model selector:

opencode run --pure \
  -m opencode/ling-3.0-flash-free \
  "Reply with only: OpenCode works"

The currently observed free-model list on July 27, 2026 was:

• deepseek-v4-flash-free
• laguna-s-2.1-free
• ling-3.0-flash-free
• mimo-v2.5-free
• nemotron-3-ultra-free
• north-mini-code-free

big-pickle was also listed by OpenCode but was not marked with the -free suffix.

Model identity and response language

Agendo injects the actual resolved model ID and display name into both v1 and v2 system prompts. After startup or /model, the agent can accurately distinguish the Agendo runtime from the LLM currently powering it.

Live checks used during this implementation returned:

DeepSeek V4 Pro (deepseek-v4-pro)
Codex subscription: gpt-5.6-sol (gpt-5.6-sol)

The language rule uses the user's recent messages only. Repository files, AGENTS.md, source text, tool output, provider defaults, and system locale must not make an English conversation switch to Chinese or another language.

Sandbox, bounded context, and layered configuration

Agendo defaults every local agent session to an OS-enforced workspace-write sandbox. On macOS it uses Seatbelt (sandbox-exec); on Linux it uses Bubblewrap (bwrap). If the native backend is not available, startup fails closed. Direct KAOS file writes use the same canonical-root policy and reject .. and symlink escapes. Child-process network access is off by default; model-provider and built-in web requests run in the trusted parent process and are unaffected.

Global settings live in ~/.kimi-code/config.toml (or $KIMI_CODE_HOME/config.toml):

[sandbox]
mode = "workspace-write" # read-only | workspace-write | danger-full-access
network_access = false
writable_roots = ["../shared-output"] # resolved relative to the session cwd

danger-full-access is the only explicit opt-out. Permission approval and sandboxing are separate: approving a tool call does not silently widen its OS sandbox.

Configuration precedence is deterministic:

built-in defaults → user config → .kimi-code/config.toml → .agendo/config.toml → environment

Project config is ignored until its canonical repository root is trusted. Permanently trust a root in the user config:

[workspace_trust]
trusted_roots = ["/absolute/path/to/project"]

Or trust project config for one invocation only:

AGENDO_TRUST_PROJECT_CONFIG=1 agendo

Use the SDK getConfigDiagnostics() call to inspect ignored layers, warnings, and the effective source of each changed setting. A project file cannot add itself to the trust list.

Dynamic model context is typed by source and provenance, then allocated by priority under a hard 64 KiB budget (including separate caps for project instructions, skills, directory listings, and additional directories). The fully rendered system prompt has an absolute 128 KiB ceiling. Truncation is UTF-8 safe, marked inside the prompt, reported in session warnings, and exposed as modelContext in the agent/profile config data.

Tetris model comparison

All three models received the same prompt: build one self-contained, accessible DOM-based Tetris game with no external runtime resources and stable browser-test hooks.

The complete benchmark—including first-pass and final feature coverage, recorded token usage, session timing, actual cost, repair history, artifact fingerprints, and Agendo icon candidates A–F—is published at Agendo Tetris Model Comparison.

Build	Execution path	Verified URL
DeepSeek V4 Pro	Agendo/Kimi harness	Play DeepSeek Tetris
Codex gpt-5.6-sol	Agendo/Kimi harness	Play Codex Tetris
OpenCode ling-3.0-flash-free	Official OpenCode CLI stored login	Play OpenCode Tetris

Each stable deployment was downloaded and compared byte-for-byte with its validated local HTML. The final 16-check Playwright audit passed against all three deployed URLs on desktop and at 375×812. It checks:

• exactly one of every required data-testid element;
• a 10×20 board rendered as 200 DOM cells, with no canvas;
• Start, pause/resume, restart, keyboard movement, rotation, and hard drop;
• visible and working touch controls;
• live, defensively copied window.__TETRIS_TEST__.getState() data;
• no horizontal overflow, browser errors, or runtime asset/network requests.

Codex passed without repair. DeepSeek needed one repair turn. The successful OpenCode Ling path needed three repair prompts after the free-model selection attempts. Those differences and the DeepSeek direct-API cost calculation are documented in the published report. The shared prompt, smoke verifier, and deeper feature audit are under .tmp/tetris/ in this workspace.

Signal Yard model benchmark

Signal Yard is the harder follow-up task: a deterministic railway-dispatch puzzle with four switches, colored trains and depots, collisions, lives, scoring/combo, three levels, pause/restart, two speeds, persistence, keyboard/touch controls, accessibility, and a synchronous browser-test contract. Every model received the same prompt in an empty isolated workspace through the Agendo harness. The 13-model leaderboard uses OpenRouter; a second six-run sweep calls DeepSeek directly; and an eight-model provider rematch uses OpenCode Go/Free, official author endpoints, or an explicitly pinned alternate provider.

The expanded screenshot-backed report includes all 13 models, the full 24-check acceptance matrix, code-quality measurements, native token/cache counts, timing, provider evidence, failure diagnoses, actual costs, the official DeepSeek reasoning sweep, the canonical logo, and icon explorations A–F: Agendo Signal Yard Benchmark.

Rank	Model	Complete	Bugs	Quality	Input / output / reasoning / cached	First file / wall	Actual cost	Observed provider	Artifact
1	xAI Grok 4.5	24/24	0	79	428,659 / 24,752 / 4,394 / 377,344	3:03 / 5:52	$0.364345	xAI	Play
2	Z.AI GLM 5.2	24/24	0	71	3,867,828 / 64,373 / 43,250 / 3,678,464	n/a / 20:00	$1.453504	Z.AI + CoreWeave	Play
3	Qwen3 Coder Next	23/24	1	78	14,615,004 / 59,654 / 0 / 0	1:18 / 20:00	$7.412799	Alibaba	Play
4	MoonshotAI Kimi K3	22/24	2	85	610,737 / 32,527 / 23,755 / 567,296	13:15 / 20:00	$0.788417	Moonshot AI	Play
5	DeepSeek V4 Pro	15/24	9	77	1,677,315 / 45,819 / 31,755 / 1,115,904	n/a / 20:00	$0.499773	StreamLake	Play
6	NVIDIA Nemotron 3 Super Free	14/24	10	72	1,949,181 / 69,588 / 3,327 / 1,294,720	1:09 / 20:00	$0	Nvidia	Play
7	Xiaomi MiMo V2.5	10/24	14	81	2,158,655 / 60,691 / 46,841 / 2,069,312	n/a / 20:00	$0.035296	Xiaomi	Play
8	Mistral Small 4	3/24	21	33	319,762 / 11,232 / 853 / 285,920	1:03 / 20:00	$0.016104	Mistral	Inspect
9	NVIDIA Nemotron 3 Ultra Free	0/24	24	0	188,150 / 5,722 / 5,528 / 0	none / 20:00	$0	Nvidia	No file
10	DeepSeek V4 Flash	0/24	24	0	0 / 0 / 0 / 0	none / 20:00	$0	No completed generation	No file
11	ByteDance Seed 1.6 Flash	0/24	24	0	22,766 / 6,782 / 1,558 / 0	none / 0:46	$0.003742	Seed	No file
12	Tencent HY3	0/24	24	0	165,434 / 140,565 / 140,502 / 107,136	none / 20:00	$0.085449	Tencent	No file
13	MiniMax M3	0/24	24	0	161,019 / 98,668 / 90,242 / 131,082	none / 20:00	$0.135248	Minimax	No file

Grok 4.5 was the follow-up-cohort winner and the only new model to reach 24/24. Kimi K3 had the highest static quality score, but failed seeded determinism and high-score persistence. Qwen reached 23/24, but its official Alibaba route returned 96 rate limits across 268 requests; repeatedly sending the growing uncached context produced 14.62 million input tokens and $7.412799 in cost. Nemotron Super shows the tradeoff behind a free route: it wrote a playable file after 69 seconds at zero inference cost, but ended with ten functional failures and one simulation path that could block Chromium.

Official DeepSeek API: off vs high vs max

These six runs used https://api.deepseek.com directly with the same prompt, 20-minute cap, and 24 Playwright checks. OpenRouter was bypassed. DeepSeek documents only high and max reasoning effort; low and medium map to high, so thinking disabled is the real lowest-compute condition. Each model/effort cell is one observed run. Jobs overlapped within the vendor's documented account concurrency limits, so timing is an execution measurement rather than a universal latency guarantee.

Model / reasoning	Complete	Bugs	Quality	Input / output / reasoning / cached	First file / accepted or wall	Requests	Cost	Artifact
V4 Pro / off	24/24	0	83	1,680,067 / 33,461 / 0 / 1,637,504	2:21 / 8:16	29	$0.053562	Play
V4 Pro / high	24/24	0	53	2,332,231 / 60,699 / 34,671 / 2,289,920	4:27 / 12:49	30	$0.079514	Play
V4 Pro / max	24/24	0	68	1,629,910 / 59,261 / 39,082 / 1,587,584	4:42 / 13:42	21	$0.075724	Play
V4 Flash / off	24/24	0	73	2,732,865 / 72,273 / 0 / 2,679,040	1:03 / 17:34	32	$0.035273	Play
V4 Flash / high	24/24	0	68	2,741,947 / 71,637 / 45,496 / 2,694,656	4:27 / 11:07	32	$0.034224	Play
V4 Flash / max	0/24	24	0	87,760 / 131,072 / 131,072 / 65,664	none / 20:00	5	$0.039977	No file

Use thinking off for V4 Pro: all three settings reached 24/24, but off was fastest, cheapest, and scored highest on the deterministic quality metric. For V4 Flash, use high for speed/cost; off scored five quality points higher but needed another 6:27. Flash/max produced four consecutive 32,768-token reasoning-only responses ending with finish_reason=length; its fifth request was still running when the harness timed out.

The direct sweep cost $0.318275. DeepSeek's API returns usage rather than a dollar total, so each cost above is vendor-reported cache-hit input, cache-miss input, and output usage multiplied by the official V4 rates. The reasoning-mode behavior comes from DeepSeek's thinking-mode documentation.

Provider rematch: OpenCode and pinned endpoints

The failed or partial models received a controlled second chance. MiniMax moved from its author-pinned OpenRouter route to OpenCode Go's documented Anthropic-compatible /messages endpoint with reasoning off. MiMo and HY3 moved to the signed-in OpenCode Go gateway's OpenAI-compatible endpoint with low reasoning. Nemotron Ultra moved from Nvidia through OpenRouter to OpenCode Free with reasoning off. Mistral and Seed remained hard-pinned to their official author endpoints on OpenRouter, with runtime fallbacks and reasoning disabled. Qwen3 Coder Next received a second sample on Parasail's healthy BF16 endpoint with reasoning and runtime fallbacks disabled.

Model	Rematch gateway / observed serving provider	Reasoning	First → rematch	Bugs	Quality	Input / output / reasoning / cached	Wall	Actual cost	Metered value	Artifact
MiniMax M3	OpenCode Go / not disclosed	off · Anthropic API	0 → 24/24	0	83	3,414,056 / 61,671 / 0 / 3,339,422	14:25	$0*	$0.296761	Play
NVIDIA Nemotron 3 Ultra Free	OpenCode Free / not disclosed	off	0 → 15/24	9	60	313,271 / 30,302 / 0 / 235,008	20:00	$0	$0	Inspect
Xiaomi MiMo V2.5	OpenCode Go / not disclosed	low	10 → 14/24	10	79	146,084 / 22,850 / 15,287 / 99,840	20:00	$0*	$0.013152	Inspect
Mistral Small 4	OpenRouter / Mistral official	off	3 → 11/24	13	90	1,083,864 / 17,091 / 0 / 1,030,336	1:44	$0.033739	$0.033739	Inspect
ByteDance Seed 1.6 Flash	OpenRouter / Seed official	off	0 → 2/24	22	54	82,164 / 7,750 / 0 / 0	1:12	$0.008487	$0.008487	Inspect
Qwen3 Coder Next	OpenRouter / Parasail BF16	off	23 → 15/24	9	70	15,951,023 / 66,608 / 0 / 15,817,888	20:00	$1.176515	$1.176515	Inspect
Qwen3.7 Max	OpenCode Go / not disclosed	off · Anthropic API	new → 20/24	4	67	182,333 / 19,896 / 0 / 86,528	20:00	$0*	$0.431997	Inspect
Tencent HY3	OpenCode Go / not disclosed	low	0 → 0/24	24	0	44,524 / 65,536 / 65,536 / 22,016	20:00	$0*	$0.041933	No file

* OpenCode Go added no per-run charge under the existing $10/month subscription. Metered value applies OpenCode's published per-token rates to observed usage for comparison; it is not an extra charge. OpenCode identifies its Go or Free gateway, but does not expose the underlying serving infrastructure in the response, so the observed inference provider is recorded as not disclosed.

The original MiMo, MiniMax, HY3, Mistral, Seed, and Qwen runs were already routed to Xiaomi, Minimax, Tencent, Mistral, Seed, and Alibaba respectively, with fallbacks disabled. Nemotron was the genuine provider failure: its first Nvidia route returned repeated ResourceExhausted and idle-timeout errors, while OpenCode Free produced a 15/24 artifact. MiniMax exposed a protocol issue instead: OpenCode's documentation assigns MiniMax M3 to the Anthropic-compatible /messages API, while MiMo and HY3 use the OpenAI-compatible /chat/completions API. A provisional MiniMax retry on the accepted but wrong API dialect produced an unusable 32,768-token thinking block. With the correct adapter, MiniMax wrote its first file in 2:00 and repaired it to 24/24 in 14:25. The downloaded public build independently re-passed all 24 checks. The remaining diagnoses held across gateways:

• HY3 returned two successful HTTP 200 completions, but each spent all 32,768 completion tokens on reasoning and ended with finish_reason=length, even at low reasoning.
• MiMo made clean tool calls and gained four checks, but its two main generations took 365 and 189 seconds, leaving too little repair time.
• Nemotron gained 15 checks despite six Streaming response failed server errors on the free route.
• Turning reasoning off raised Mistral from 3 to 11 checks in 104 seconds. Seed wrote a file, but a JavaScript syntax error left only two checks passing.
• Qwen's Parasail BF16 rematch reduced HTTP 429s from 96 to 3 and cost from $7.412799 to $1.176515 (-84.1%), with 99.17% of input reported as cached. It also fell from 23 to 15 checks and from quality 78 to 70. The rerun removes most provider noise but is not a better implementation sample, so both observations remain visible.
• Qwen3.7 Max used OpenCode Go's documented Anthropic-compatible endpoint with reasoning off. Three initial requests returned 503 Inference is temporarily unavailable; the first file arrived after 14:45 and the final artifact reached 20/24 before the 20-minute cutoff. Its subscription run added no incremental charge; $0.431997 is the metered value of its observed token/cache mix at published Go rates, not another bill.

The API dialects, included model catalog, context limits, and published token rates come from the OpenCode Go documentation. OpenCode does not identify the serving infrastructure behind its gateway responses, so this benchmark does not infer an underlying vendor.

Run the rematch from a signed-in OpenCode Go account plus OPENROUTER_API_KEY:

SIGNAL_YARD_CONCURRENCY=4 pnpm benchmark:signal-yard:second-chance
pnpm benchmark:signal-yard:audit-second-chance

China's six AI Tigers

The commonly cited “six AI Tigers” are Zhipu AI, Moonshot AI, MiniMax, StepFun, Baichuan, and 01.AI; DeepSeek and Alibaba/Qwen are important Chinese labs but are not members of that specific six-company group. Four are now executed in Signal Yard, while the final two direct official adapters are ready but credential-blocked. Sources: TIME's six-company roster, Baichuan's official API, and 01.AI's official API.

Company	Tested model / route	Complete	Bugs	Quality	Input / output / reasoning / cached	Wall	Actual cost	Status / artifact
Zhipu AI	GLM 5.2 / OpenRouter	24/24	0	71	3,867,828 / 64,373 / 43,250 / 3,678,464	20:00	$1.453504	Play
Moonshot AI	Kimi K3 / Moonshot AI	22/24	2	85	610,737 / 32,527 / 23,755 / 567,296	20:00	$0.788417	Play
MiniMax	MiniMax M3 / OpenCode Go	24/24	0	83	3,414,056 / 61,671 / 0 / 3,339,422	14:25	$0*	Play
StepFun	Step 3.7 Flash / official StepFun, high reasoning	9–10/24	14–15	68	572,867 / 104,239 / 0 / 449,920	13:41	$0.162461	Inspect
Baichuan	Baichuan4 Turbo / direct official API	—	—	—	—	—	—	Awaiting BAICHUAN_API_KEY; no current OpenRouter/OpenCode route
01.AI	Yi Large FC / direct official API	—	—	—	—	—	—	Awaiting YI_API_KEY; no current OpenRouter/OpenCode route

StepFun's route was pinned to the healthy official stepfun/fp8 provider with fallbacks disabled. The run wrote its first artifact after 9:08 and exited voluntarily at 13:41. The controller saw 10/24; an independent repeat against the exact deployed bytes saw 9/24 because the implementation seeds itself with Date.now(). The displayed 9–10 range preserves that nondeterminism instead of choosing the better sample. Two earlier diagnostics are not leaderboard rows: high reasoning produced no artifact for $0.059073, while low reasoning reached 23/24 for $0.315189.

The Baichuan and 01.AI modes bypass aggregators, enforce reasoning off, verify the required key before launching Playwright, and record official-list pricing. Add the two keys to the parent workspace .env, then run and audit the frozen six-company sweep:

SIGNAL_YARD_CONCURRENCY=3 pnpm benchmark:signal-yard:china-six
pnpm benchmark:signal-yard:audit-china-six

Why Grok's $0.364 run cost less than the old DeepSeek $0.500 run

Headline token prices do not determine the bill by themselves. The old DeepSeek leaderboard attempt made 54 requests versus Grok's 11, sent 3.9× more total input, billed 10.9× more uncached input (561,411 versus 51,315), and generated 1.9× more output. It ran for the full 20 minutes, incurred retries/browser-repair loops, and was served by StreamLake rather than DeepSeek. Grok completed the task in 5:52 with 88% of its input reported as cached. Its higher unit prices were therefore applied to a much smaller workload.

The clean vendor result reinforces this: official V4 Pro/off reached 24/24 for $0.053562, 89% below the old StreamLake-routed attempt. The old $0.499773 is an observed routing-and-agent-loop outcome, not DeepSeek V4 Pro's intrinsic cost.

The selected 13 OpenRouter runs cost $10.794677 and consumed 226.6 aggregate model-minutes. The selected runs shown in the public visual report cost $13.207574. Including the two earlier paid StepFun diagnostics described above, total observed experiment spend was $13.581836. The existing OpenCode Go subscription is not counted a second time as per-run spend. Free-route inference charges reported as exactly zero remain included as $0; failed attempts are not hidden.

Why models failed

• DeepSeek's official OpenRouter endpoints were cataloged as healthy, but corrected official-only Pro and Flash retries returned 404 No endpoints available matching your guardrail restrictions and data policy. The selected Pro result is therefore the original StreamLake fallback run; it also received 30 rate limits and spent 20 shell calls trying to repair the agent-sandbox browser. Direct DeepSeek calls later removed this OpenRouter guardrail from the comparison.
• The initial GLM artifact passed 24/24, but the process reached the cutoff after 56 browser-repair shell calls. MiMo made 24 similar calls and stopped at 10/24.
• Nemotron Ultra received seven NVIDIA upstream 504 idle timeouts before it could write a file.
• DeepSeek V4 Flash/max repeatedly exhausted the 32,768-token completion budget entirely on reasoning; off and high both produced independently verified 24/24 builds through the direct API.
• HY3 hit the per-response output limit four times while reasoning and never invoked the write tool. MiniMax showed the same symptom in its initial OpenRouter run, but its successful OpenCode Go rematch established that the provisional retry's API dialect—not MiniMax's tool-use capability—was the decisive integration fault.
• Seed returned a complete HTML implementation as chat text in 45.6 seconds for $0.003742, but never called the write tool, so there was no deliverable.
• Mistral wrote a file with a JavaScript syntax error, then waited in a shell loop for 24/24 instead of reading the controller's listed failures and editing the artifact.

Model selection and provider policy

The follow-up cohort added models with a specific differentiator: Kimi K3 for open frontier-scale agentic work, Grok 4.5 for coding/agentic performance, Qwen3 Coder Next for an open coding agent with only 3B active parameters, Seed 1.6 Flash for speed and low cost, Nemotron 3 Super for free open hybrid-MoE inference, and Apache-2.0 Mistral Small 4 for hybrid instruct/reasoning/coding. Primary references: Kimi K3, Grok 4.5, Qwen3 Coder Next, Nemotron 3 Super, Mistral Small 4, and Seed models.

As of July 28, 2026, Qwen3-Coder-Next remains the newest dedicated Qwen Coder release. It is an 80B-total / 3B-active Apache-2.0 MoE model with a native 262,144-token context and non-thinking operation. Qwen's provider guide calls it the experimental coding model; the newer Qwen3.7 family is general-purpose rather than a newer Coder-branded release. OpenCode Go currently lists Qwen3.7 Max, Qwen3.7 Plus, and Qwen3.6 Plus, but not Qwen3-Coder-Next. Sources: official Qwen3-Coder-Next model card, Qwen Code provider catalog, and OpenCode Go model list.

Follow-up routes were pinned to the official Moonshot AI, xAI, Alibaba, Seed, NVIDIA, and Mistral inference providers whenever those endpoints passed preflight discovery. Runtime fallbacks were disabled. Qwen's additional sample deliberately pins Parasail BF16 as a healthy alternate. The initial cohort is retained unchanged for reproducibility, so GLM's first run includes one CoreWeave request and DeepSeek Pro uses StreamLake. This distinction is visible in the report.

The frozen specification, prompt, runner, verifier, quality formula, and report verifier live in benchmarks/signal-yard/. Run one model after setting OPENROUTER_API_KEY:

node benchmarks/signal-yard/run-one.mjs grok-4-5

Run the direct DeepSeek sweep after setting DEEPSEEK_API_KEY:

SIGNAL_YARD_CONCURRENCY=3 node benchmarks/signal-yard/run-deepseek-official.mjs

Run just one direct configuration:

SIGNAL_YARD_INFERENCE=deepseek-official \
SIGNAL_YARD_REASONING=high \
node benchmarks/signal-yard/run-one.mjs deepseek-v4-pro

Run the Qwen alternate-provider sample with the exact healthy endpoint pinned and fallbacks disabled:

SIGNAL_YARD_INFERENCE=openrouter \
SIGNAL_YARD_REASONING=off \
SIGNAL_YARD_RUN_LABEL=parasail-bf16-off \
SIGNAL_YARD_PROVIDER_TAG=parasail/bf16 \
node benchmarks/signal-yard/run-one.mjs qwen3-coder-next

The verifier loads a project-local playwright package when available, then checks common nvm/Herd global installations. Set SIGNAL_YARD_PLAYWRIGHT_MODULE=/absolute/path/to/playwright/index.mjs for another installation layout.

Available slugs are deepseek-v4-pro, mimo-v2-5, deepseek-v4-flash, hy3, glm-5-2, nemotron-free, minimax-m3, kimi-k3, grok-4-5, qwen3-coder-next, qwen3-7-max, step-3-7-flash, seed-1-6-flash, nemotron-super-free, and mistral-small-4. Run a bounded concurrent batch (Qwen3.7 Max is opt-in because it uses OpenCode Go rather than OpenRouter):

SIGNAL_YARD_CONCURRENCY=3 node benchmarks/signal-yard/run-batch.mjs \
  kimi-k3 grok-4-5 qwen3-coder-next

The current rematch protocol v2.4 preflights Playwright before any paid request, watches for a stable index.html, writes acceptance feedback to .agendo-verification.txt, stops on the first 24/24 artifact, and terminates a browser-blocking verifier after 45 seconds. The temporary feedback file is removed at the end. The Agendo agent remains sandboxed throughout.

Audit every available artifact, capture screenshots, diagnose logs, and combine the frozen original cohort with the six-model expansion:

node benchmarks/signal-yard/audit-all.mjs
SIGNAL_YARD_INFERENCE=deepseek-official node benchmarks/signal-yard/audit-all.mjs
SIGNAL_YARD_INFERENCE=second-chance node benchmarks/signal-yard/audit-all.mjs
node benchmarks/signal-yard/diagnose.mjs
node benchmarks/signal-yard/combine-results.mjs

Each failed acceptance criterion counts as one bug. The 0–100 quality score applies deterministic deductions for syntax errors, unsafe evaluation/writes, inline handlers, innerHTML, console calls, complexity, long functions, and duplicate five-line windows. OpenRouter provider routing uses order, only, and disabled outside fallbacks as documented in the provider-routing guide. Actual cost and native token/cache counts come from the generation usage API.

OneShotShopLight storefront benchmark

benchmarks/one-shot-shop-light/ contains the frozen brown-field successor experiment. Every candidate starts from the same Next.js 16, Tailwind CSS 4, and SQLite shop workspace with a complete protected HTTP API. The contestant implements only the customer storefront; the controller enforces a two-hour cell-work deadline and records provider, token, cache, timing, actual-cost, and theoretical-cost evidence. Campaign preflight and final aggregation are timed separately from contestant cells.

The completed historical v1 cohort used GPT-5.6 Sol medium, Grok 4.5 high, DeepSeek V4 Pro high, GLM 5.2 high, MiniMax M3 with reasoning off, and DeepSeek V4 Flash high. Those results remain frozen and are not silently mixed with the adaptive experiment.

Prepare and run a fresh contestant directory:

pnpm benchmark:one-shot-shop-light:prepare gpt-5-6-sol-medium
pnpm benchmark:one-shot-shop-light:run gpt-5-6-sol-medium

Then run the protected-integrity gate and headless acceptance suite:

pnpm benchmark:one-shot-shop-light:qa \
  /private/tmp/agendo-one-shot-shop-light/gpt-5-6-sol-medium/workspace

The six prepared-API checks are non-scoring preconditions. The 42 storefront criteria determine feature completeness; a separate GPT-5.6 Terra reviewer at medium effort confirms failures, partial credit, bug count, and detected stack. SonarQube Community Build supplies LOC, code smells, technical debt, and duplication.

The completed 2026-07-28 experiment is published at agendo-one-shot-shop-light.vercel.app. GLM 5.2 won with 41/42 criteria, followed by Grok 4.5 with 39/42 and GPT-5.6 Sol with 38/42. The full reproducible summary, cost accounting, independent bug review, and immutable deployment URL are in benchmarks/one-shot-shop-light/RESULTS.md.

Adaptive v2 experiment

The new pre-registered matrix compares six routes—Kimi K3, GPT-5.6 Sol, both DeepSeek V4 variants, GLM 5.2, and MiniMax M3—across four cells each:

1. legacy-single/pilot-r1 — one model performs the whole task.
2. homogeneous-team/pilot-r1 — the enforced team workflow uses that same candidate for every role.
3. adaptive-team/pilot-r1 — a fresh catalog uses its curated priors and cost forecasts.
4. adaptive-team/learned-r1 — every cell receives an identical frozen catalog learned once from the disclosed homogeneous training cohort.

That is 24 isolated workspaces. Complete runs require the full automated and independent-review evidence. An honest model failure, two-hour timeout, or protected-workspace violation remains reportable after the controller finishes a valid matching integrity receipt and a distinct Terra-medium terminal adjudication, with unavailable measurements kept null. Terminal rows require an application screenshot or explicitly typed controller-rendered failure evidence. Protected violations count as contestant failures/bugs; missing, duplicate, unexpected, malformed, tampered-controller, or controller-incomplete cells still block publication.

Use the v2 aliases to plan and run one cell; model calls remain dry-run by default and require the explicit cost acknowledgement:

pnpm benchmark:one-shot-shop-light:v2:prepare -- \
  gpt-5-6-sol-medium legacy-single pilot-r1

ONESHOTSHOPLIGHT_AGENDO_ALLOW_MODEL_CALLS=I_UNDERSTAND_COSTS \
  pnpm benchmark:one-shot-shop-light:v2:run -- \
  gpt-5-6-sol-medium legacy-single --repetition=pilot-r1 --execute

After homogeneous cells finish, preview and then freeze the objective-only learned policy:

pnpm benchmark:one-shot-shop-light:v2:learn -- \
  --source /private/tmp/agendo-one-shot-shop-light-v2 \
  --target /private/tmp/agendo-one-shot-shop-light-policy

pnpm benchmark:one-shot-shop-light:v2:learn -- \
  --source /private/tmp/agendo-one-shot-shop-light-v2 \
  --target /private/tmp/agendo-one-shot-shop-light-policy --apply

Use repeatable --candidate <id> only when deliberately excluding a failed training candidate; the included candidate and source-run IDs are frozen into every learned result and the public report. Complete protocol details are in benchmarks/one-shot-shop-light/README.md.

The adaptive campaign is mechanically ordered: the frozen six-model Tetris ladder runs first, Signal Yard runs only after its explicit gate, and OneShotShopLight accepts only the independently revalidated post-ladder handoff. See Gated serial campaign in the benchmark README for the exact dry-run, resume, and execute commands. Direct shop execution without both staged evidence roots is rejected before a build or model request.

Timing boundaries are explicit. The zero-model-call campaign preflight runs before, and outside, every per-cell clock. Once a cell starts, one controller-owned absolute deadline covers planning, model work, verification, and attempt closure. After that deadline, only bounded safety cleanup may continue; it is not presented as on-budget model work. Final campaign-ledger aggregation is post-cell bookkeeping and is not charged to any candidate's cell time.

Environment lookup

Provider values are merged in this order, with later sources taking priority:

1. The cloned repository's parent .env.
2. The current working directory's parent .env.
3. The current working directory's .env.
4. The file named by KIMI_PROVIDER_ENV_FILE.
5. Existing shell environment variables.

For delegated/team runs, keep provider credentials in a dedicated file outside every delegated workspace and select it explicitly:

KIMI_PROVIDER_ENV_FILE="$HOME/.config/agendo/providers.env" agendo

Agendo passes only the absolute paths of successfully loaded source files—not their contents—to the runtime. Those paths are removed from delegated process environments and mechanically masked from both shell processes and direct filesystem tools. danger-full-access fails closed whenever a provider source file was loaded because that mode cannot guarantee the boundary.

Automatic repository/working-directory .env lookup remains for compatibility, but a workspace .env will consequently be protected from agent reads and writes. Prefer the external KIMI_PROVIDER_ENV_FILE layout above, keep every credential file out of Git, and check git status before committing.

Development and verification

Run the focused checks:

pnpm test:provider-launcher
pnpm --filter @moonshot-ai/agent-core exec vitest run \
  test/config/env-model.test.ts \
  test/harness/runtime-provider.test.ts \
  test/profile/default-agent-profiles.test.ts
pnpm --filter @moonshot-ai/agent-core-v2 exec vitest run \
  test/app/agentProfileCatalog/profile-shared.test.ts
pnpm --filter @moonshot-ai/kimi-code exec vitest run \
  test/tui/components/chrome/welcome.test.ts \
  test/tui/components/dialogs/model-selector.test.ts
pnpm build:kimi-cli

Run broader upstream checks when carrying the fork forward:

pnpm typecheck
pnpm lint
pnpm test

Upstream attribution and license

Agendo is based on MoonshotAI/kimi-code. The upstream LICENSE remains unchanged and applies to this fork. Moonshot AI's authorship, repository metadata, compatibility names, and upstream documentation links are intentionally preserved.

See the upstream Kimi Code documentation and original source repository for the base project.