Ultracode

reasoning_effort: ultracode is the highest setting on the effort dial. It is not an additional API effort value — Anthropic's Messages API only accepts up to xhigh/max on the wire. Ultracode is a mode, mirroring Claude Code's "Ultracode" level:

xhigh reasoning + a standing prerogative to orchestrate multi-agent workflows.

It is delivered through prompt engineering (a standing-consent system instruction) rather than a new wire parameter, and it is reliable only on claude-opus-4-8 and the Claude 5 family (claude-opus-5, claude-fable-5-1) — the orchestration half is backed by Anthropic's mid-conversation system messages, which ship on those models. On any other model ultracode degrades gracefully to plain xhigh.

See Anthropic's reference: Effort and Build an orchestration mode.

What the runtime does

When a node declares reasoning_effort: ultracode, iterion:

1. Sends xhigh on the wire. The value is remapped via model.wireEffort before it reaches the provider, then coerced to what the model accepts (xhigh on Opus 4.8/4.7, high on OpenAI, etc.). The literal ultracode never reaches an LLM API.
2. Grants the orchestration prerogative. A ## Workflow Orchestration section is appended to the system prompt giving standing consent to decompose substantial work across parallel subagents (via the agent tool) and to verify findings adversarially — without asking first. The section is backend-neutral: how a subagent's report comes back is the backend's to state.
3. Makes the subagent tool available. On the claw backend, the agent subagent tool is added to the node's allowlist when the node restricts its tools (an unrestricted set already exposes the claw builtins) — and claw serves it: a child conversation needs a host-wired subagent runner, and iterion wires one at both hosts (in process and in the sandbox container), so the dispatch returns the child's real answer (#1940). The child runs SYNCHRONOUSLY, within the node's own effective tools, permission policy and step budget, and its spend is debited to the node — an ultracode claw node orchestrates for real, and pays for its subagents out of its own ceiling. agent is withheld from the child, so a decomposition is one level deep — and so is the ask channel: the child holds no ask_user/ask_user_async/await_answers, since a question raised from inside a tool call would pause the run unattributed, with no child conversation persisted for the resume (#2812); the child reports the question to its parent, whose own channel is intact. The policy's ask VERDICT takes the same route (#2877): an ask rule matching a tool the child holds degrades to a refusal naming the rule at the delegation's gate, instead of pausing the run from inside the parent's tool call. Holding agent also reads the node as MUTATING to the parallel-branch workspace-safety guard: that the shipped runner bounds the child to the node's own list is the host's wiring, which the guard's name reading cannot see, so an ultracode claw node shares no worktree unless it declares readonly: (#2811). An embedding that wires no runner earns the typed refusal backend "claw" cannot serve the agent tool (subagents) instead, and the ## Workflow Orchestration grant says what to do with it where it grants the dispatch: a refused agent call is final, so the model keeps the decomposition and runs the parts in its own thread instead of retrying. The claude_code backend orchestrates through its native Agent tool, and every subagent runs in the foreground: each spawn sets CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1 (unless the operator asks for background work, ITERION_CLAUDE_CODE_BACKGROUND_TASKS=on), so an Agent call returns the agent's report as its tool result. To parallelise, the model puts several Agent calls in one message; they run concurrently. A ## Subagents in this session section states this on every spawn that keeps the tool, ultracode or not. The session is one-shot, so a background agent's report could only arrive while the turn was still running: a model that ended its turn to wait for one would end the session with it, and lose the findings. With background work on, a background agent is waited for instead — the background lifecycle keeps the session open until its report is delivered — and a ## Background work in this session section says so. The multi-agent Workflow tool is withheld from every node, ultracode included, whether background work is on or not: a workflow fans out agents of its own, whose cost and scope the node never declared (see backends.md).
4. Warns off Opus 4.8. Compiling ultracode on a model that isn't claude-opus-4-8 emits diagnostic C089 (a warning, not an error): the orchestration half won't be reliable and the node runs as plain xhigh.

Adaptive thinking comes from the claw backend's model profile — adaptive across the Opus 4.8/Claude 5 lines, required on claude-opus-5-5 (thinking: {type: "adaptive"}), so ultracode gets extended thinking without extra configuration.

Usage

agent implementer:
  backend: "claude_code"
  model: "anthropic/claude-opus-4-8"
  reasoning_effort: ultracode
  system: build_system
  user: build_task

Ultracode fits implementer/agent nodes that benefit from spawning helpers for independent sub-parts. It is wasteful on judges, routers, and simple read-only nodes — use high or xhigh there, and keep cheap LLM routers on a small model such as anthropic/claude-sonnet-4-6.

The value is also settable dynamically from an upstream node:

plan_router -> implementer with { _reasoning_effort: "ultracode" }

and via env substitution, which is resolved (and re-validated) at runtime:

  reasoning_effort: "${ITERION_EFFORT:-ultracode}"

Relationship to other dials

• Effort vs. cursors. Effort (including ultracode) controls compute and the orchestration prerogative. Cursors are qualitative framing dials (ambition/depth/rigor/autonomy) appended under ## Calibration. They are orthogonal and compose freely.
• Ultracode vs. routers. Routers (fan_out_all, llm) orchestrate at the workflow graph level — the author wires the branches. Ultracode lets a single agent node orchestrate dynamically at run time by spawning subagents it decides it needs. Use both together for deep fan-out.

Studio

The effort selector offers ultracode only when the node's model is claude-opus-4-8 or a Claude 5 model (the /api/effort-capabilities endpoint gates it server-side, complementing the C089 compile warning). The EffortBar renders it full-bar in a distinct accent tone, reading as "beyond max".