Verbatim Reasoning Replay and MCP Elicitation: Octomind 0.64.0

With the chatgpt provider, Octomind sent your session's history back to the model on every request, and the copy it sent was not what the model had written. Reasoning went missing on text-only turns, was copied onto every tool call on others, and the order of the model's own output was lost. On a task with many steps, every request replayed that distorted copy of the model's earlier work.

Octomind 0.64.0 replays the provider's output items verbatim, in their original order. There was no 0.63.x post, so this one covers 0.63.0, 0.63.1 and 0.64.0 since the 0.62.0 post. The open-source update is available today.

Replay the model's output as it came back

The chatgpt provider uses your ChatGPT subscription through the OpenAI Responses API, in stateless mode (store: false) with encrypted reasoning. The server keeps nothing between requests, so Octomind sends the whole history every time. Until 0.64.0 it rebuilt that history from fields it had stored, and the rebuild lost four things:

• Message structure. An assistant message was flattened into one text, and each item's phase (commentary or final answer) was lost.
• Reasoning on text-only turns. Reasoning was kept only when a response had tool calls.
• Reasoning placement. On a response with tool calls, the same reasoning was stored on every call and replayed from the first one.
• Order. The order of the items the model produced was not kept.

In 0.64.0 the items stay as the API returned them. Octomind stores them on the assistant message, writes them to the saved session so --resume restores them, and replays them in their original order, as the Responses API asks of callers that keep history themselves. It replays them only when they came from the same provider and their function calls match the message's tool calls. Otherwise it rebuilds the message from its stored fields, without reasoning or phase, which is also what happens for messages in sessions saved before 0.64.0.

The status line the supervisor asks the model to end with is still stripped from what you see. The replayed copy keeps what the model actually returned. The stateful openai provider is unaffected.

MCP elicitation: answer a server's question mid-call

An MCP server can stop a tool call to ask you something: confirm a refund, pick an environment, fill in a missing detail, or open a sign-in page. MCP calls this elicitation. Until 0.62.0 Octomind declined every such question without asking anyone. 0.63.0 asks whoever is present:

• Interactive CLI (octomind run). A prompt in the terminal: one line per field with type checks, then Send? [Y/n]. Ctrl+C cancels. A URL question shows the full URL and its domain, and opens it only after you confirm.
• WebSocket (octomind server). The client receives an elicitation frame if it bound with the elicitation_v1 capability, and answers with an elicitation_response, as in the MCP elicitation example below.
• ACP (octomind acp). Octomind forwards the question as ACP elicitation/create when the client advertised clientCapabilities.elicitation with form support. A URL question also needs URL support.

{"type": "session", "request_id": "bind-1", "session_id": "my-session", "capabilities": ["elicitation_v1"]}
{"type": "elicitation", "session_id": "my-session", "id": "e1", "server": "forms", "tool_id": "call-1", "params": {"mode": "form", "message": "Pick a size", "requestedSchema": {"type": "object", "properties": {"size": {"type": "string"}}}}}
{"type": "elicitation_response", "session_id": "my-session", "id": "e1", "result": {"action": "accept", "content": {"size": "L"}}}

Your answer, whether accept with values, decline or cancel, goes back to the server unchanged. When nobody can answer, Octomind declines the question: piped and --format runs, subagents and background tasks, clients that did not opt in, and calls it cannot attribute to one session.

An open question ends as cancel when its tool call ends, when the session closes, or when the WebSocket client answering it disconnects and no other takes over. A late answer gets an error frame with "code": "elicitation_gone", so match the code, not the text.

While a question is open, timeout_seconds waits for you. The idle deadline restarts when the question closes, and the absolute cap of 20 times timeout_seconds moves out by the time the question stayed open.

Servers on MCP 2026-07-28 return the question as part of the call's result, so it always reaches the right session. Octomind offers older servers protocol 2025-11-25, the first with URL elicitation. Over stdio an older server does not say which call a question belongs to, so when calls from more than one session wait on the same server, Octomind declines the question rather than guessing. The MCP tools guide and the WebSocket server guide document every case.

Sign in to an MCP server only where a person can answer

MCP OAuth sign-in used to open a browser on the machine and wait for the callback, whether or not anyone was there. 0.63.1 sends the sign-in to whoever answers the session:

• Interactive CLI. Octomind always prints the URL, and the browser opens as well. Before, the URL appeared only in the error when the browser failed to open.
• WebSocket and ACP clients. They receive the sign-in URL as a URL question. If the answer is no, or the request fails, Octomind closes its callback listener.
• Runs with nobody to answer. Piped runs, startup health checks and clients without elicitation fail at once:

MCP server 'stripe' needs an OAuth sign-in, but nobody in this session can complete it — sign in once from an interactive octomind session

Octomind registers the terminal as the answerer before MCP servers start, so a sign-in needed during startup reaches it.

The code exchange and the token refresh were sent as JSON. RFC 6749 specifies form encoding, and strict servers reject JSON. Both now send application/x-www-form-urlencoded.

Missing keys: skip the tool, or list them all

• A capability with an unset key is skipped (0.63.0). If a capability listed in a tap agent's manifest has wiring that references an {{ENV:KEY}} that is unset or empty (server env, headers, command, arguments or URL), the agent used to stop and prompt for a key it might never need. Now Octomind skips the capability with its dependencies and servers, and the agent starts without that tool. Set the key and start a new session to load it.
• A non-interactive run names every missing value (0.63.0). Callers used to find them one failed run at a time. The error is now Missing required values A, B and this run is non-interactive., followed by where to set them: the environment the process starts in, or ./.env, for environment values; one interactive octomind run <role>, or ~/.local/share/octomind/inputs.toml, for {{INPUT:KEY}} values.
• ACP shows why an agent could not start (0.63.0). initialize now succeeds even when the role fails to start, and creating or loading a session returns the reason. Before, the client saw the pipe close.

The verify-gate checks harder, and the supervisor loses less

The verify-gate is the independent pass that checks a finished turn against your request.

• A failing check could still be handed back as done (0.63.1). The gate allowed two passes, and the first spent its re-run on its own findings and on the once-per-turn evidence requests. It now allows three, so a check the agent recorded failing after its first answer still sends it back.
• Passing a condition now takes a quote (0.63.0, 0.63.1). A condition counts as met only when the verifier quotes a verbatim excerpt of at least 12 characters that the runtime finds in its recorded evidence. Naming an action without quoting what its output showed no longer counts.
• Evidence requests are stricter (0.63.0, 0.63.1). When the verifier cannot settle a condition, the runtime asks the agent once per turn, on the first pass, for an observation that would come out differently if the condition did not hold. The agent cites a recorded one, makes a new one, or reports the condition unsatisfied.
• Failure lines survive condensation (0.63.0). When the supervisor condenses a long tool result, it now keeps reported failures and their nearby lines: FAIL headers, failure glyphs, failing counts, Rust's panicked at and Go's --- FAIL:. It still drops distant passing and listing lines.
• A status report no longer leaks into the answer (0.63.0). When a model wrote the supervisor's status report as bare JSON on the last line, or opened a <sup> tag and never closed it, the raw object reached you. Octomind now recognises that last line by its fields, an object with state and focus and no keys outside the report's own, and removes it. It leaves JSON you asked for alone.
• Large changes no longer crowd out command results (0.63.1). The verifier's view of the changes has its own budget now, so recent command tails and status lines stay visible when the changes are large.
• Large diffs are scored hunk by hunk (0.64.0). With the supervisor enabled and [decision] supervisor = true, the gate no longer truncates a diff larger than its size limit. The evaluation model scores every hunk, the verifier reads in full the ones the request's conditions depend on, as far as its input window allows, and the rest are shown only as their @@ header and a (hunk not shown: +A -B lines) line, so the verifier does not read them as absent changes. An unavailable answer falls back to the size cut.
• The reminder carries the whole checklist (0.64.0). Near the end of the context the supervisor repeats what the turn must satisfy. For a request it had turned into a checklist, the same conditions the verify-gate checks, it repeated keyword excerpts of the request. Excerpts are a subset, so the work drifted toward the lines that were repeated and the requirements that were not went unmet. 0.64.0 repeats the checklist whole, and compaction pins the same lines. A turn without a checklist still gets the request's explicit directives verbatim.

The other fixes since 0.62.0

• File ranges past line 10,000 (0.63.0). Compaction records the file ranges it wants reloaded, and file references can be written as path:start:end. Both refused a range ending past line 10,000, and one out-of-range entry rejected the whole compaction record. A range can now sit anywhere in a file. A single range still covers at most 10,000 lines.
• Less waiting at agent start (0.63.0). Reading every capability file of every tap takes seconds when the data directory is on a network mount, and a delegated agent has seconds to answer its parent's handshake. Octomind now reuses the capability list for 60 seconds and clears it when it changes a tap, and MCP start-up no longer waits for capability prewarming. GitHub taps are pulled automatically at most once every 15 minutes.
• A period in inline code no longer ends a sentence (0.63.1). When the supervisor splits your request into sentences, a version number inside inline code stays whole, with the clause that follows it.
• Cost estimates for more OpenRouter models (0.63.0). Models from makers without their own price table, such as xiaomi/, x-ai/, qwen/ and meta/, now get a reference rate for estimates made before a call. Billing still reads the cost the response reports. Truly unknown models still get none.
• A Xiaomi MiMo provider (0.63.0). Use xiaomi: models such as mimo-v2.6-pro with XIAOMI_API_KEY.

Before you update

• Retired Anthropic models are refused (0.63.0). Claude Sonnet 4.5, Sonnet 4, Opus 4.1, Opus 4 and Claude 3.5 Haiku are no longer in the supported list. A config that names one fails with Provider 'anthropic' does not support model '<name>', so change the model first.
• Claude API temperature and sampling settings are not sent (0.63.0). Octomind now sends Anthropic API version 2026-10-21 and omits temperature, top_p and top_k on every model. A temperature set for an Anthropic model has no effect.
• OAuth sign-in needs an interactive session or an eligible client (0.63.1). Sign in once from octomind run before using that server in piped or background runs.
• GitHub taps refresh at most every 15 minutes (0.63.0). A tap you just pushed to may take that long to appear.
• Saved chatgpt sessions carry the provider's output items (0.64.0). They include the encrypted reasoning.
• No config changes. These releases add no config keys, and your config.toml keeps its version.

Update to Octomind 0.64.0

On macOS and Linux:

curl -fsSL https://octomind.run/install.sh | bash -s -- --version 0.64.0
octomind --version

On Windows, in PowerShell:

$env:OCTOMIND_VERSION = "0.64.0"
irm https://raw.githubusercontent.com/muvon/octomind/master/install.ps1 | iex

Or run scoop update octomind. See the installation guide for other methods, the full changelog, and the 0.62.0 notes if you're coming from 0.61.

Then try it: connect an MCP server that asks for input, call one of its tools from octomind run, and answer the prompt.

— DK