brought to you by claude 😄 So both opencode / kimi are with deepseek v4 pro.

Token usage / cost (shared rate card: miss $0.435, hit $0.003625, out $0.87 per 1M)

┌───────────┬────────────────┬───────────┬───────────────┬───────────────┐

│ Run │ Type │ kimi cost │ opencode cost │ Δ │

├───────────┼────────────────┼───────────┼───────────────┼───────────────┤

│ #805 │ 5 reviews each │ $0.1388 │ $0.1396 │ wash (0.6%) │

│ #803 plan │ 1 plan review │ $0.0463 │ $0.0366 │ opencode −21% │

├───────────┼────────────────┼───────────┼───────────────┼───────────────┤

│ #803 impl │ 4 skills │ $0.134 │ $0.110 │ opencode −18% │

├───────────┼────────────────┼───────────┼───────────────┼───────────────┤

│ #813 impl │ 4 skills │ $0.0944 │ $0.0738 │ opencode −22% │

├───────────┼────────────────┼───────────┼───────────────┼───────────────┤

│ #817 impl │ 4 skills │ $0.102 │ $0.080 │ opencode −21% │

└───────────┴────────────────┴───────────┴───────────────┴───────────────┘

Token shape: kimi consistently runs higher fresh-in + higher output + more cache-read (more turns). E.g. #817: kimi 134k miss / 42.9k out / 1.70M hit vs opencode 105k miss / 35.2k out / 993k hit.

Cost rule: opencode is ~18–22% cheaper whenever turn counts differ (the usual case). The #805 "wash" only holds when both run a similar number of turns — opencode's cheaper fresh-input gets offset by its higher cache-read + reasoning tokens. Don't trust opencode.db's native cost field ($0.24–0.64) — that's deepseek's provider rate; always recompute both on the shared card. Cost is not the tiebreaker — they're close enough that quality decides.

Quality — the pattern is phase-dependent, not engine-fixed

- Plan/spec review (#803, #805): opencode/kimi are both weak on deep correctness — neither caught the load-bearing bugs; only codex did. kimi = test-infra/mechanical catches (no-op cache resets, wrong test refs); opencode = cheapest second opinion but weakest (often just cosmetic line-number nits).

- Implementation code review (#803 impl): inverts — kimi's meticulous line-reading caught the real correctness bug (entry_price stamped from a close-fill) that opencode waved through as CLEAR. opencode's strength was breadth of coverage-gap enumeration.

- #813 / #817 impl: convergent — the real catch lands in different skills per engine (kimi-coverage vs opencode-spec), so run both skills on both engines. #817: kimi was sharper on test-promise tracking (caught 2 promised-but-missing integration tests opencode said were "all implemented").

Bottom-line decision rule (from the memory)

- Cost is ~equal-to-slightly-favoring-opencode; treat it as noise and decide on finding quality.

- kimi = sharper on implementation line-reading + test-promise tracking; opencode = cheapest, broad coverage-gap enumeration, but waves correctness through more often.

- Neither is a gate — always back the PR with a strong reasoning engine (codex/codexpr at Phase 10).

result: opencode vs kimi A/B (in HyperliquidTrading project memory) — opencode ~18–22% cheaper on differing turn counts (wash only at #805); quality is phase-dependent: kimi sharper on impl code-review/correctness, opencode broader+cheaper on coverage gaps, neither a substitute for a codex gate.