ultracodex 0.5.0

The agent is the unit of programming: agent() is a call with a typed, validated
return, plain JavaScript composes it, and the Executor Contract keeps it portable
across Codex, Claude, and OpenCode. v0.5.0 completes the picture — the same unit
now runs once (Workflow), runs until it's good (Loop), runs on a clock
(Scheduler), and remembers (Org).

Loops

• goal, packaged in the box: builder rounds against explicit criteria, gated
  by a skeptical verifier — and the criteria carry the stop condition, so
  completion goals ("the backlog is empty") work too. Strict-valid portable Agent
  Script; returns { done } so it composes with scheduling.
• run <name> resolves packaged workflows after project-saved ones; nested
  workflow('<name>') too.
• Loop observability — agents tagged with the round grammar
  (<loop>:<role>-r<N>, bare -r<N>, or Round N phases) fold into trajectory
  dashboards: verdict strip, converged-after-N, per-round token cost. New LoopView,
  a Loops home tab, and a LOOPS section in show.

Scheduler

• ultracodex schedule add|ls|pause|resume|rm — recurring runs via one tagged
  crontab line per schedule, fully owned (installed, rewritten, and removed
  without touching the rest of your crontab). There is no daemon.
• --until-done retires a schedule when its run returns { done: true };
  --max-runs caps repetition; --budget caps every scheduled run, and scheduling
  an unbudgeted run warns loudly.
• Missed-run nudges at startup, a doctor section for crontab drift, and a
  Schedules home tab (exec-history strips, next-fire countdowns, exec-now,
  pause/resume/remove, schedule-from-TUI with S). ULTRACODEX_CRONTAB_FILE makes
  every schedule operation testable against a file instead of your real crontab.

Orgs (experimental)

• ultracodex org init|tick|wake|send|ask|tickets|lint|status|audit|replay —
  filesystem-routed agent organizations. Each agent is a directory (role contract,
  memory files, inbox), woken by triggers (time, inbox, severity, dependency) and
  executed from inside its own directory so the sandbox enforces the single-writer
  rule. Superiors read one ≤80-line BRIEF per seat.
• Messages are routed contracts: NOTIFY never travels up your own chain, REQUEST
  opens tickets ancestor-to-descendant, replies ride the ticket. Violations are
  ledgered, the sender gets feedback, and one failed wake never aborts a tick.
• org audit verifies cited claims against their sources and delivers findings as
  inbox notifies (agents self-correct next tick); org replay re-lives ingested
  history with fault injection (--pristine for true counterfactuals).
• The org-creation skill designs an org with you — coverage, role templates,
  fetcher contract, audit cadence — and an Org home tab renders the live tree,
  an ops board, and a briefs reader.
• Ships experimental: the runtime is tested end to end, but the discipline is
  young — supervise early cycles; don't schedule them unattended yet.

Engine & TUI

• GPT-5.6 lineup, pinned against codex-cli 0.144.0: fable/opus →
  gpt-5.6-sol, sonnet → gpt-5.6-terra, haiku → gpt-5.6-luna; reasoning efforts
  max and ultra pass through natively.
• The TUI home is now four tabs — Runs · Loops · Schedules · Org — all pure
  folds over plain files, with a lightweight status line (default backend · model ·
  routed backends), contextual empty-state onboarding, and consistent keyboard nav.
• 603 hermetic tests (all three backends faked; no API keys in CI), plus a live
  pre-release gate that runs a real workflow against Codex and asserts the journal,
  not just the final JSON.

Receipts

Every number in the README traces to a committed artifact — a
four-model controlled comparison
(same script, one [route] line apart, raw journals included) and the
v0.5.0 fleet ledger
(14 runs, 72 agents, 1.26M output tokens, all on Codex). Every feature in this
release was built by ultracodex fleets running on ultracodex.

Compatibility & upgrading

npm install -g ultracodex && ultracodex doctor

• Agent Scripts are unchanged and remain byte-compatible with Claude Code's
  Workflow tool (validate --strict checks the portable subset).
• Shipped defaults moved to gpt-5.6 / codex-cli 0.144.0. On older codex
  binaries, doctor reports the drift; pin models via config if needed.
• A project .ultracodex/workflows/<name>.js now shadows a packaged workflow of
  the same name (goal, org-audit, org-lint-repair).

Full Changelog: v0.4.0...v0.5.0

ultracodex 0.4.0

The multi-vendor release. One [route] table now sends each agent in a workflow to the backend best cast for it — implementation on one vendor, gates on a second, adversarial review on a third, one journal for all of it.

OpenCode backend

Route any label to opencode and it runs on whatever provider your opencode speaks — hosted or local. The adapter drives opencode serve's HTTP API: synchronous turns, SSE activity + live usage ticks, graceful /abort, session-resume repair turns, and wire structured output (json_schema) that degrades to a prompt contract mid-call when a provider rejects it. Tested against opencode 1.16.2.

[route]
"impl:*" = "opencode"
"review:*" = "claude"
"*" = "codex"

[backends.opencode]
model = "deepseek/deepseek-chat"

Read the sandbox note before routing untrusted content here — opencode has no OS sandbox; ultracodex doctor now prints the full posture (docs/operations.md).

Executor Contract v1

The backend seam is now a documented, versioned contract — docs/executor-contract.md: every adapter declares a capability descriptor (schema / resume / interrupt / usage / activity / sandbox), the engine owns the degradation rules for whatever a backend lacks (journaled as warnings, never silent), and a shared 10-assertion conformance kit runs against every adapter via a scripted fake of its harness. All three backends pass. Want a fourth? The contract + kit are designed so you never read engine source — the OpenCode adapter was built exactly that way.

The kit caught three real bugs in the existing adapters on day one (an abort that leaked process trees, validation against the wrong schema form, a missing wire-rejection fallback). All fixed here.

Verified recursively

The acceptance test for this release was a run on this repository: OpenCode implemented doctor's new opencode section, Codex gated it with the full test suite, Claude adversarially reviewed it (found real issues, requested changes, approved the fix) — five agents, three vendors, one journal, green. Every build wave of the release was itself executed by ultracodex fleets.

Also

• ultracodex doctor: opencode section (binary + version pin + security posture) when a route targets opencode.
• Hardened dead-runner detection in ps-less sandboxes.
• 338 → 465 tests; suite stays hermetic (scripted fakes for all three harnesses, no API keys in CI).

Zero-config behavior is unchanged: without a config file everything runs on Codex, exactly as before.

ultracodex 0.3.0

The authoring release. v0.2.0 made workflows good to run; v0.3.0 makes them easy to write — by you, by Claude, or by any model you point at one document. npm install -g ultracodex

The authoring skill

• skills/agent-script-authoring/SKILL.md — one self-contained document (~4.7k tokens: the core contract up front, a craft reference behind) that teaches any capable model to author Agent Scripts.
• Evidence, not vibes. Given only this file plus a problem statement: GPT-5.5 authored scripts judged comparable-or-stronger than Claude-written references on 7/7 problems, first try. A 31B open-weights model (gemma-4-31b) went from 0/7 to 6/7 after one evidence-driven strengthening round (with real run-to-run variance — treat small-model output as usable-with-review). A reasoning model (deepseek-reasoner) served as a fuzzing adversary and surfaced 11 novel failure modes — every one hardened into the skill text and re-verified. Three rounds, three model families, every miss traced to a text fix rather than blamed on the model.

The example gallery

• examples/ — nine orchestration shapes distilled from a census of 58 real production workflows, ordered as a complexity ladder: the first three rungs run in minutes with no setup; the rest are reference implementations for real work.
• Every entry ships a self-contained problem statement (they double as authoring exercises), a mermaid diagram verified against the script's actual topology, and a reference workflow.js that passes validate --strict — portable across Claude Code's Workflow tool and ultracodex by construction.

Install the skills anywhere

• ultracodex sync-skills now installs both static skills — the run contract and the authoring skill — plus one relay skill per saved workflow. opencode picks them up too (it reads Claude-compatible skill paths).
• The repo doubles as a plugin, with progressive disclosure (~250 always-on tokens; full text loads on invoke):

  claude plugin marketplace add YuanpingSong/ultracodex
  claude plugin install ultracodex@ultracodex
  

  and the Codex CLI consumes the same marketplace natively: codex plugin add ultracodex@ultracodex.
• The full four-surface matrix (Claude Code, codex, opencode, raw prompt): docs/skills.md.

Docs

• README rebuilt around time-to-first-run: install → doctor → sync-skills → one prompt, above the fold, with the HD demo video inline.
• Zero config is now stated as such — the config examples were always the shipped defaults; the docs finally say so.
• docs/ split into user docs (skills · operations · architecture · agent-script-spec) and docs/internal/ (working papers, ADRs, research — public for transparency, written for ourselves). The spec was re-verified clause-by-clause against a live Workflow-tool snapshot (2026-07-06).

Built by fleets: the 58-script census, the gallery generalization (with privacy and fidelity gates), the 21-judgment parity program, and the diagram verification all ran as multi-agent workflows — over a hundred agents across three model families, adversarially checked at every stage.

Full changelog: v0.2.0...v0.3.0

ultracodex 0.2.0

Second release — the dogfooding release. Everything here came from actually using ultracodex to run real work (and to build itself). npm install -g ultracodex

TUI

• Phase navigation — the phase strip is now a tab bar. ←/→ filter the run view to one phase (All is the default); density tiers re-apply to the filtered list, so narrowing a big run to a small phase restores the rich card view. No auto-jump when a new phase starts mid-run.
• Fits any terminal — the full-screen run view no longer overlap-garbles when content is taller than the window (previously broke at 80×24, macOS's default). The agent list windows to available rows with ↑/↓ N more markers, keeping the selected agent on screen; the result pane caps to fit. Verified via pty at 80×24 / 100×32 / 120×50.
• Model per agent — every agent card shows backend·model even when the script doesn't pin a model. agent_start now journals the resolved model/effort (single-sourced with the executor, so the journal can't drift from what actually ran).

doctor

Now prints, beyond pass/fail checks:

• the execution profile agents actually run with (model · effort · sandbox · network · service tier · approvals),
• where that diverges from your interactive codex (~/.codex/config.toml — e.g. a service_tier = "fast" or approval policy the fleet doesn't inherit),
• MCP servers your interactive config loads into every agent thread (a hidden source of per-agent startup latency),
• a soft codex version-pin check.

Config & security

• network_access — first-class [backends.codex] knob for egress inside the workspace-write sandbox (file confinement retained). Off by default; documented sandbox escalation ladder and exfiltration warning in docs/OPERATIONS.md.
• extra_args for both backends; the claude backend defaults to --allowedTools Read Glob Grep so claude-routed judges can read the repo out of the box.

Release engineering

• pnpm release <patch|minor|major> — one command: live pre-release gate → version bump + tag → push → publish (npm trusted publishing via OIDC, with provenance) → registry verification.
• pnpm release:check — runs the demo-video haiku actor–critic loop live against real codex and asserts the run's intermediate state (journal events with resolved models, per-agent artifacts, schema'd critic outputs, token ledger), archiving each run as release provenance.
• --version now reads package.json at runtime (0.1.1 mistakenly self-reported as 0.1.0).

Docs

Parent-verify (results return to your Claude session for judgment) is now the headline pattern; the in-run claude backend is documented as an advanced feature (ADR-0002). Two ADRs added: loop-engineering extensions (0001) and claude-backend positioning (0002).

Fixes came from real use: a founder inspecting a live research run found the missing per-agent model in seconds; the pre-release gate's own verification caught the 80×24 layout bug before it shipped.

Full changelog: v0.1.1...v0.2.0

ultracodex 0.1.1

The demo-driven release: everything in it came from watching a first-time session drive ultracodex from Claude Code.

New

• General ultracodex skill — sync-skills now always installs .claude/skills/ultracodex/SKILL.md teaching Claude the full contract (authoring byte-for-byte for the Workflow tool, run --json --budget, verbatim relay). An ad-hoc multi-agent request becomes a one-line prompt: "…— actor–critic loop, 3 rounds. Run it with ultracodex."
• Demo video + GIF in the README: Claude authors an actor–critic essay workflow, Codex executes it in the full-screen TUI, the result lands back in Claude.

Fixed / improved

• validate no longer warns about unmatched meta.phases titles when any phase() call has a computed title — the warning was pushing authors (human and AI alike) to unroll perfectly good loops.
• Run view keeps 5 completed agent cards visible before collapsing (was 3).

347 hermetic tests · npm install -g ultracodex

ultracodex 0.1.0

First public release. npm install -g ultracodex

Run Claude Code workflow scripts, unmodified, on the OpenAI Codex CLI — fable plans, codex executes, fable verifies.

• Full Agent Script runtime with upstream Workflow-tool semantics: agent / parallel / pipeline / phase / log / args / budget / workflow, null-on-failure, output-token budgets, 1000-agent + 4096-item caps
• Codex executor over the codex app-server JSON-RPC protocol (one server per agent slot, per-turn token metering, graceful turn/interrupt), claude backend for judgment-routed agents, config-only routing
• Belt-and-suspenders structured output: wire-strict schemas where supported + ajv validation + same-session repair turns
• Full-screen Ink TUI (launcher, live run view, agent detail with codex resume copy, Gantt timeline), journal-as-spine CLI (run/ls/show/attach/pause/resume/skip/kill/logs/validate/sync-skills/doctor)
• Dual-runnability linting (validate --strict), Agent Script spec v0.1 draft, builder-verifier loop cookbook
• 346 hermetic tests against a scripted fake of the codex app-server — no API keys in CI

Validated by a clean-room rebuild: Codex agents, orchestrated by ultracodex itself from the spec alone, rebuilt the project across 3 staged workflows (22 agents, 125 tests green).