xCoder

The autonomous SWE agent supervisor — wraps Claude Code, Cursor, Codex, OpenCode, and Zed with a deterministic FlowEngine and mechanical guardrails. Your agent stays on a feature branch, writes a conventional commit, opens a PR, and closes the loop. Without you watching.

What xCoder is

Coding agents are powerful but undisciplined. Left alone, they commit directly to main, ship without a PR, and skip the build. xCoder is the layer that makes them follow a real software engineering flow — without making them less capable.

Three pieces work together:

LayerMechanismWhat it does
HooksPreToolUse / StopBlock bad actions at the moment they're attempted (edit on main, commit without typecheck, finish session without a PR).
FlowEngine@xcoder/flow-engineDeterministic phase machine — refuses to advance from BRANCH without an issue, from COMMIT without a conventional message, from PR without a PR number.
Autopilotxc autopilotContinuous autonomous loop — picks the next roadmap item, drives a coding agent through the flow, and emits events you can text-message yourself.

Install

xCoder is in private alpha while we harden the kernel before public release. Access is invite-only; the npm-published binary lands with v1.

Request alpha access

Email hello@decoperations.com with a short note about your repo and the agent runtime you use. We respond within a business day.

Once you have access, the install is one command:

bash
# (after invitation — pinned install token comes with access)
$ npm i -g @xcoder/xcoder@alpha

$ which xc
/Users/.../bin/xc

Two CLI names, same binary

xc and xcoder are aliases — both resolve to dist/cli/index.js. Use whichever fits your typing reflexes.

Two primary modes

1. Interactive — xc i

Boots a coding-agent session in your current repo with xCoder's hooks, skills, and flow guards already wired. The agent is the same one you'd run directly (Claude Code, Cursor, Codex, …) — xCoder just constrains it.

bash
cd ~/code/your-project
xc i

2. Autopilot — xc autopilot

Continuous autonomous loop. xCoder analyzes the repo, builds a roadmap of work, and grinds through items — branching, implementing, verifying, opening PRs — for as long as you let it run.

bash
cd ~/code/your-project
xc autopilot start --goal "harden flow adherence and document everything"

Why this matters

Most "agent frameworks" are prompt frameworks. They tell the LLM what to do and hope. xCoder is structurally different:

  • Mechanical guardrails. The no-edit-on-integration policy intercepts git commit on main at the kernel level. The LLM cannot talk its way around it. A motivated user can override with a named, logged bypass — but the default is refused.
  • Deterministic state machine. The FlowEngine is xCoder TypeScript code, not LLM prompting. Phase transitions are gated by acceptance checks the engine evaluates itself. No prompt drift can move state forward without satisfying the gate.
  • Observable bypasses. Every override emits a flow.bypass event. You can audit exactly when and why the system was overridden — by you, by an agent, by CI.
  • Agent-agnostic. Hooks are Claude-Code-format JSON stdin/exit-code protocol; the FlowEngine is a separate npm package. Wrapping a different agent runtime (Cursor, OpenCode, Codex) is a driver-level concern, not a prompt rewrite.

Where to go next

Quickstart →

Install, boot a session, ship a PR — five minutes.

Mental model →

Phases, invariants, hooks, and how they compose.

FlowEngine →

The deterministic state machine and the 15-invariant contract.

Hooks →

no-edit-on-integration, branch-prefix-must-match, commit-must-reference-issue, typecheck-must-pass-before-commit (+ session-end-pr-backstop, hand-rolled until M0.6).

CLI reference →

Every xc subcommand with examples.

Configuration →

.claude/settings.json, .xcoder/merge-policy.yaml, .xcoder/supervisor.yaml.