FlowMux

Short overview

Parallel coding agents can reach the same product decision through different local tasks. FlowMux is a local semantic interrupt controller: it collects bounded decision contracts from 2–3 trusted Codex Sessions, discloses the exact compiler-bound bytes and SHA, asks an isolated GPT-5.6 compiler to propose an equivalence mapping, and lets the human confirm one choice for the exact calls. Each original turn receives its own declared local answer.

Inspiration

When several agents ask differently worded versions of the same owner question, the human repeats one decision while reconstructing each local consequence. A queue can organize interruptions, but it cannot prove that three questions mean the same thing or safely translate one choice back into each origin's language.

FlowMux treats human judgment as the scarce resource. It reduces duplicate semantic interruptions without suppressing uncertainty or weakening Codex's permission boundary.

What it does

Three real gpt-5.6-sol Sessions independently describe one retry-policy decision for customer copy, QA, and API behavior. The Workspace shows the exact non-editable compiler JSON and SHA. After the human reviews those bytes, GPT-5.6 may propose one canonical choice and a complete bijection to every local choice. Deterministic validation must pass before a confirmation card appears.

For Strategy 2, the shared policy is exactly:

At most three total attempts, including the initial attempt; therefore at most two retries, with increasing waits between attempts.

One confirmation maps that meaning to:

API PLAN — Allow no more than three total attempts with increasing delays
QA MATRIX — Assert at most three upstream attempts with increasing gaps
CUSTOMER COPY — Say recovery uses at most three total attempts with increasing waits

FlowMux atomically records all three local answers, and each MCP bridge can fetch only its own. The Workspace reports factual fetched/lost counts. The demo then shows all three original Codex turns continuing; the receipt alone is not presented as resume proof.

If a contract is missing, sensitive-looking input is detected, meanings differ, the model abstains, validation fails, or a request becomes stale, FlowMux returns the group to Review separately with zero answers. Permissions, publication, purchase, deployment, destructive actions, and secrets are never compilable.

How we built it

FlowMux is a dependency-free local Node.js prototype composed of:

a Codex plugin with the route-human-blockers Skill, typed ask_human MCP contract, and native lifecycle/permission Hooks;
an immutable allowlist for 2–3 trusted, live Codex Sessions;
deterministic exact-byte disclosure, conservative field scanning, proposal validation, scope/revision/hash consent, and atomic per-origin delivery;
an isolated subscription-backed gpt-5.6-sol compiler in a fresh empty directory with read-only sandboxing, ignored user config/rules, tools and risky features disabled, bounded I/O, a fixed schema, and a strict timeout;
a loopback-only Workspace that keeps compiler mappings and delivery evidence visible to the human.

State is local and in memory. Agent bridges use nonce-bound HMAC challenges and signed responses. Human UI mutations use a separate one-time session capability and same-origin checks. No hosted backend or general-purpose API key is required for the canonical judge path.

How GPT-5.6 is used

GPT-5.6 has two essential runtime roles:

Each origin understands only its local task, independently authors a bounded typed decision contract, waits for the returned local label, and turns that answer into an answer-dependent artifact.
A separate isolated GPT-5.6 compiler compares the disclosed local semantics and may propose a canonical decision plus complete mappings. It can abstain, but it cannot choose for the human.

Gate B preserved adverse results. A12 stopped when only 2/3 contracts were valid. A13 failed closed because “three retries” and “three total attempts” are not equivalent. A14 passed once after all three contracts independently used the exact total-attempt meaning. The successful compiler call took 25.237 seconds and emitted no tool events. This is PASS n=1, not a reliability claim.

How Codex is used

Codex was the primary engineering environment and is the runtime surface. During development it helped narrow the product, write the spec and binary kill gates, implement deterministic contracts with TDD, build the isolated compiler and Workspace, and preserve failed live attempts alongside the successful one.

At runtime Codex supplies real parallel Sessions, trusted per-call metadata, plugin discovery, stdio MCP calls, Hooks, subscription-backed GPT-5.6 execution, and continuation of the original blocked turns.

The primary core-build task completed Codex /feedback. Its returned Session ID is reserved for the dedicated submission field below and is not part of the public project description or video.

Challenges

The central challenge was proving semantic equivalence without allowing the model to invent authority. Origin contracts had to remain independent; trusted identity could not enter model-controlled fields; compiler disclosure had to be byte-exact and consent-bound; every canonical choice needed a complete bijection to declared local choices; and delivery had to remain exact under races.

The live failures were productive. A12 exposed contract-generation fragility. A13 showed that retry count wording changes meaning: three retries can mean four total attempts. FlowMux correctly returned NOT_SAFE_TO_COMPILE and delivered zero answers instead of smoothing over the mismatch.

Accomplishments

One human-confirmed decision produced three different origin-local answers.
Three exact MCP calls fetched only their own answers, and all three original GPT-5.6 turns visibly continued.
Exact compiler bytes and SHA are shown before any semantic model call.
Semantic mismatch and incomplete input fail closed with zero answers.
Native permissions remain separate and higher priority.
The canonical proof runs locally through Codex subscription access without an OpenAI API key or hosted backend.

Potential impact and next steps

FlowMux could help developers supervise several agents without answering the same owner decision repeatedly. No productivity or reliability percentage is claimed yet.

Next steps are broader pass^k evaluation, cleaner installation and restart flows, and only then carefully scoped durability or platform expansion.