Korallis’s agent-stack is a large local orchestration system around OpenRig, Claude Code, Codex, and Jev. The interesting part is not the 27-seat “AI team” pitch. It is the concrete boundary around Jev: ordinary code gathers evidence and limits the choices; Jev makes a typed judgment; ordinary code validates, records, and decides whether that judgment is allowed to trigger an action.

I inspected the README, decision catalog, Jev engine, fallback and storage code, routing tests, evaluation runner, and latest public CI result. I did not install the stack or make paid Jev calls.

Jev gets bounded decisions, not open-ended control

  • The versioned catalog defines decisions such as task classification, seat selection, stuck-agent detection, context reranking, review triage, and merge-or-hold.
  • Callers must supply explicit candidates. The engine enforces minimum and maximum counts, rejects duplicate IDs, drops undeclared input fields, redacts likely secrets, and caps field and state size.
  • Responses are checked for the expected type, legal labels, finite probabilities, and probability sums close to one.
  • Confidence maps to act, review, or uncertain; designated labels such as none_fit force uncertainty even when selected confidently.

The merge gate keeps deterministic checks outside the model

  • Code first verifies required CI, an independent review, and a QA verdict tied to the exact commit.
  • The live Jev decision sees a bounded merge or hold choice only after that evidence is assembled.
  • A cached answer, fallback-model answer, stub, stale commit, or Jev answer below the act threshold cannot silently merge on its own.
  • The final GitHub command pins the merge to the reviewed head commit, closing the race where a branch moves after review.

Failure handling is explicit

  • The adapter has request budgets, retries, a local rate limiter, a circuit breaker, and short-lived cache keys that include decision version and model.
  • An uncertain or unavailable Jev result may go to a named reasoning-model fallback, then to a deterministic conservative default.
  • Logs record who actually decided—Jev, cache, fallback model, or code—plus the band, signals, model, latency, usage, fallback reason, and a hash of the redacted state.
  • The merge decision is stricter than the generic path: only live Jev may approve it, and the code fallback is hold.

Evidence and limits

  • The repository’s latest GitHub Actions run for the inspected commit succeeded; its commit message reports 815/815 tests. That is the maintainer’s test count, not a result I reproduced locally.
  • The included Jev evaluation report has only eight labeled status-update cases: raw Jev was correct on 7/8, with 6/8 in the act band and all six act-band answers correct. The full fallback system scored 8/8.
  • That tiny hand-labeled set is useful plumbing evidence, not a general accuracy benchmark. Its one adversarial case fooled raw Jev and was recovered by the fallback model.
  • The stack runs autonomous seats with permission checks disabled and can pool consumer subscriptions through a proxy; the README itself warns that this may violate provider terms. This is an operationally serious system, not a safe default install.

“Code gathers the facts and sets the bar; anything Jev isn’t sure about goes to the lead or to you.”

The reusable pattern is narrower than the whole project: make the model choose only among code-approved options, preserve uncertainty, and require deterministic evidence at the point where a semantic judgment becomes a real side effect.