Octomind 0.35.0: Your Agent Reads Too Much

Watch a coding agent work and count what it reads. A git diff when it needed three hunks. A 2,000-line build log when it needed the one error. A directory listing where one path mattered. Every one of those bytes goes into the context window, gets billed as input tokens, dilutes the model's attention — and most of it was never needed.

The industry answer is truncation: cut the output at N tokens and hope the useful part was at the top. That's not context engineering, that's a guillotine. 0.35.0 ships the Condenser — a Supervisor mechanic that reads every oversized tool output in the context of what the agent is actually trying to do, and passes through only what the task needs. The result, on the same model and the same benchmark we published for 0.33.0: success up from 87% to 93%, cost per solved task down 34%.

The Condenser: an editor between your tools and your model

When a tool round returns a result over a token threshold, one cheap-model call examines the round and returns a verdict per result:

A diff requested by a review task is the payload — keep. A test log where 30 lines of 2,000 are the actual failure — extract. A directory listing from a wrong guess — replace, with the one load-bearing fact ("not found") preserved.

The trick: selection, never summarization

Here's the part we're most pleased with. The Condenser never retypes content. It receives a line-numbered copy of the output and answers with line ranges — "keep lines 12–40 and 57–80" — and Octomind reconstructs those lines verbatim from the original bytes in memory. The condensing model physically cannot hallucinate a path, mangle a code span, or "helpfully" paraphrase an error message, because the only thing it produces is numbers. Its entire answer costs ~50 output tokens instead of thousands of retyped ones.

This is the approach the research converged on in the last year — FocusAgent's line-range pruning, ACON's objective-conditioned compression, Squeez's task-conditioned tool-output pruning for coding agents. We added one thing the papers leave out: losslessness. Before anything is condensed, the full original is spilled to a session file, and the condensed result carries the path. If the Condenser ever cuts something the agent turns out to need, the agent reads that exact span back from disk — one cheap recovery, never a dead end. And the hard token cap (mcp_response_tokens_threshold) still applies after, as the ceiling.

Every failure mode fails open: condenser error, unparseable response, no spill — the results pass through untouched. The Supervisor never blocks the agent.

The Condenser knows what your agent is for

Relevance depends on the operator. To a code-review agent, diff hunks are sacred; to a doc writer they're noise. The user's last message alone can't tell you that — the agent's system prompt can, but shipping a multi-thousand-token role prompt with every condense call would dilute the very attention we're trying to focus.

So the Condenser distills it once: the first call of a session includes the head of the agent's system prompt and asks for one extra field back — an agent profile, ≤150 words of "what this agent is for and which output it must never lose." That profile is cached for the session (keyed by a hash of the system prompt, so a mid-session skill injection re-distills it automatically) and conditions every later verdict for ~100 tokens a call. No extra API round-trip, no config. This is ACON's objective-conditioning, self-generated.

Measured: −34% cost per solved task, +6 points success

Same methodology as 0.33.0: octobench, SWE-bench-Live pilot, model held fixed (GLM), the instance's own tests as the oracle, provider flakes excluded by fresh-retry. HEAD vs the frozen 0.33.1 baseline:

Two details worth being honest about. First, one instance in the suite — jupyter-ai-1125 — had never been solved by any previous version. 0.35.0 solved it. Second, the median tokens per solved run actually went up, and that's the correct direction to read it: solving a hard instance adds an expensive run to the solved set, while the total spend across the suite dropped by a third because the money stopped going to failures and runaway exploration. Success rate is the guardrail, cost-per-solved is the score; medians are a diagnostic, not a headline.

This baseline is now frozen in the repo (bench/baseline.json) as the reference the next release must beat — the git history of that one file is our public trend line.

Also in 0.35.0

• Evidence ledger for the verify-gate — when the agent claims done, the gate now verifies against a deterministic ledger of what the agent actually did (mutations, checks, errors — identical successful repeats collapsed, errors never collapsed), instead of trusting the agent's own narrative of events.
• Round-based signal aggregation — Supervisor detectors now aggregate per tool round, so one parallel batch produces one prioritized steer instead of a pile-up.
• Gate iterations reset per task — every new user request gets a clean verification budget. The previous task's exhaustion doesn't carry over.
• Workflows: forced skills and capabilities — pin exactly which skills and capabilities a workflow step loads. Auto-activation is no longer the only path.
• Workflows: stderr capture on process failure — the actual error, not just an exit code.
• Stability pass — ACP race conditions fixed with per-session exclusion locks; scheduler overflow and infinite loops patched with checked arithmetic and a ~10-year duration cap; orphan tool processes now terminate when their future is dropped.
• File, storage, and webhook fixes — UTF-8 corruption in reference parsing fixed by slicing bytes instead of character counts; the learning backend now escapes newlines and special characters; the webhook listener survives transient accept errors; session matching requires an exact dash-delimited project segment; and session names restore correctly from compressed .jsonl.zst files.
• Lesson extraction reliability — exit-path extraction is now awaited with a 60-second timeout instead of fire-and-forget, so lessons aren't silently lost when the runtime drops.

Security

• Removed vulnerable plist and YAML dependencies. The syntect syntax-highlighting crate was reconfigured to disable plist and YAML-load features, eliminating transitive quick-xml vulnerabilities. Only bundled default syntaxes and themes are used.
• OAuth PKCE verifier is now cryptographically random. The PKCE code verifier was previously a constant value, defeating PKCE protection. It's now filled from UUIDv4 bytes (CSPRNG-backed), complying with RFC 7636.
• allowed_tools inverted-default fix. When a role's allowed_tools list is non-empty but no pattern matches a particular server, that server is now dropped entirely instead of being exposed with an empty tool list — which was previously read downstream as "expose all tools."

Config

The Condenser ships enabled, with the Supervisor's usual strict schema — add the section to your existing config (a missing key fails loudly by design; we don't do silent defaults):

[supervisor.condense]
enabled = true
# Per-result trigger (estimated tokens). 0 = off.
# Keep well below mcp_response_tokens_threshold — that cap is the
# blunt backstop; this is the smart path that fires earlier.
tokens_threshold = 5000
# The model that does the narrowing (cheap + fast recommended).
model = "anthropic:claude-haiku-4-5"

Token savings and condensed-result counts surface in /info, in the supervisor activity line — N condensed (saved X tok).

Fresh installs get it out of the box. Everything else in the release needs no config changes.

Upgrade

# Homebrew (macOS / Linux)
brew install muvon/tap/octomind

# or from crates.io
cargo install octomind

Prebuilt binaries for every platform are on the releases page.

0.33 made the argument that the framework around the model is the product. 0.35 applies it to the least glamorous part of the loop — the firehose of tool output every agent drinks from — and the scoreboard moved again: same model, more solved, a third cheaper. The tokens you don't send are the fastest ones.