Skip to main content

Mellions Coxen

Turn frontier coding agents into engineers who stay on the job.

Mellions Coxen is an engineering responsibility and reliability layer for frontier coding agents: continuity, ownership, falsification, coordination, and disciplined completion.

Integrated with the engineering tools you already use

  • Claude Code
  • Codex
  • GitHub

Stop managing every prompt.

A capable coding agent can still leave you choosing every next task, re-explaining context, approving obvious follow-up work, and checking whether “done” actually means done. Mellions Coxen reduces that management load.

Developer carrying engineering work across a long-running project
  • Own the whole responsibility

    Established defects inside the active code path are carried through root cause, implementation, and verification instead of handed back as another approval request.

  • Try to prove the answer wrong

    Passing tests are evidence, not automatic proof. Consequential conclusions are challenged with mutations, comparisons, and checks that can genuinely fail.

  • Continue across interruptions

    Assignments and current repository state preserve the responsibility across restarts, compaction, handoff, and parallel engineering lanes.

Frontier-model judgment. Deterministic mechanisms where they earn their keep.

The coding runtime keeps its native reasoning, tools, permissions, worktrees, subagents, sandboxing, and model choice. Mellions supplies the durable engineering layer around that capability.

  1. 01

    Establish reality

    Read the running system, source, history, tracker, and governing contracts before treating the task description as truth.

  2. 02

    Carry the work

    Proceed autonomously on ordinary engineering decisions and escalate only the judgments that genuinely belong to a person.

  3. 03

    Falsify completion

    Verify the original obligation, neutralize important fixes, and make sure the claimed proof turns red for the intended reason.

  4. 04

    Leave durable state

    Keep the issue, pull request, assignment, and handoff aligned so another session can continue from evidence rather than replaying a conversation.

Stronger completion, with evidence you can inspect.

Mellions Coxen is developed through production use, controlled same-model comparisons, and deterministic replay. Its public record separates observed behavior from retrospective estimates instead of presenting one case study as a universal coding benchmark.

Defect ownership
Without Mellions Coxen

Finds another real defect, then asks whether to fix it.

With Mellions Coxen

Establishes whether the defect belongs to the active responsibility and owns it when it does.

Verification
Without Mellions Coxen

Treats a green test suite as the stopping point.

With Mellions Coxen

Actively tries to disprove consequential conclusions.

Continuity
Without Mellions Coxen

Leaves most session state inside the conversation.

With Mellions Coxen

Carries durable responsibility across interruption and handoff.

Coordination
Without Mellions Coxen

Lets parallel agents unknowingly duplicate work.

With Mellions Coxen

Makes active responsibility and overlapping work visible.

Install the CLI and plugin together.

After checkout, one make install command builds the Go CLI and registers the Mellions plugin with supported coding runtimes already present on the machine.

Supported today: source installation

A one-click installer or hosted marketplace install is not published today. Requires Go 1.26.1 or newer, Git, an authenticated GitHub CLI, Claude Code and/or Codex, and macOS or Linux.

Read the complete installation guide
git clone https://github.com/LetA-Tech/mellions-coxen.git
cd mellions-coxen
make install

mellions config init
mellions doctor