Crush 0.74.1 Fixes the Shell Hang That Makes Autonomous Coding Look Amateur
Autonomous coding agents do not usually fail in cinematic ways. They fail because a command opened Vim in a headless shell, a pager swallowed the output, a provider adapter guessed the wrong API shape, or a background process waited forever while the product UI politely pretended everything was fine.
That is why Crush 0.74.1 is more interesting than its patch-release shape suggests. Charmbracelet did not ship a grand new agent metaphor here. It shipped a fix for the kind of terminal edge case that makes “autonomous coding” look unserious the first time it meets a real repository.
The release sets safer non-interactive defaults for shell executions, fixes Qwen3.7-Max through OpenCode by routing it through the Anthropic Messages API path the model actually requires, and continues stabilizing Crush’s experimental client-server mode. The headline is not a benchmark. The headline is runtime hygiene.
The terminal still thinks a human is sitting there
The core fix comes from PR #3025, which sets a handful of environment variables for shell commands when the caller has not already provided them: TERM=dumb, GIT_EDITOR=true, EDITOR=true, VISUAL=true, PAGER=cat, and GIT_PAGER=cat.
That list looks mundane until you map it onto the failures agents hit every day. git rebase -i HEAD~3 wants an editor. git commit without -m wants an editor. git log often wants a pager. A human sees that and acts. An unattended coding agent launched through a shell tool may just hang, because the command is waiting for a terminal interaction that will never arrive.
Charmbracelet’s test plan calls out exactly those cases: interactive rebase should no longer hang, commit-without-message should exit immediately instead of opening an editor, and git log should emit output without blocking in a pager. Just as important, the patch preserves explicit caller intent by not overriding an already-set EDITOR. That is the correct line: make the default safe for agents, but do not seize control from users who deliberately configured the environment.
This is one of those places where the industry’s agent demos are misleading. Demos show the model editing code and running tests. Production use involves all the weird inherited behavior of Unix tools, Git defaults, pagers, editors, wrappers, hooks, aliases, and half-remembered local configuration. The model may be novel. The substrate is old and opinionated.
Failing explicitly beats waiting forever
There is a trade-off here. Setting EDITOR=true does not magically make interactive operations semantically correct. Some commands will exit without doing the intended edit. Others will fail because required text was never supplied. That is still better than a hung run.
For agents, “failed fast with an exit code” is useful information. “Sat inside an editor prompt for twenty minutes” is not. A model can recover from a clear failure by choosing a non-interactive path: pass -m for a commit message, use GIT_SEQUENCE_EDITOR with a scripted plan, avoid interactive rebase entirely, or ask the human for intervention. It cannot recover from a tool call that never returns unless the harness has separate timeout and cancellation logic.
This is the practitioner lesson: do not confuse non-interactive defaults with capability. They are guardrails, not intelligence. If an agent needs to rewrite commit history, the safe implementation is not “let it open an editor and hope.” The safe implementation is a deterministic workflow with visible plan, explicit commands, tests, reviewable diff, and a rollback path. The environment variables prevent deadlocks. They do not replace review.
The pager defaults matter for similar reasons. Agents inspect history, logs, diffs, test output, and build failures constantly. If output is routed into a pager, the agent may receive nothing, a partial screen, or a stuck process depending on the wrapper. PAGER=cat and GIT_PAGER=cat make output boring. Boring output is underrated when the next model decision depends on it.
Provider adapters are part of the runtime, not glue code
The other notable fix in 0.74.1 is PR #3040, which fixes Qwen3.7-Max when used through OpenCode. The release notes say the model only works through the Anthropic Messages API. That detail is easy to skim past and expensive to ignore.
Agent runtimes now sit on a messy compatibility matrix: provider protocol, model naming, tool-call format, structured output support, reasoning behavior, context-window limits, image handling, cache semantics, and SDK quirks. “OpenAI-compatible” is not a universal solvent. “Anthropic Messages-compatible” is not just branding. A model can exist behind a provider path and still fail if the harness assumes the wrong request shape.
This is where agent engineering starts looking less like prompt craft and more like systems integration. Good coding-agent runtimes need explicit provider adapters, capability detection, and useful errors. Optimistic string matching works until the model appears to run but silently loses the tool format, rejects a reasoning option, or behaves differently in a resumed session. Crush’s Qwen/OpenCode fix is a small example of a larger truth: model routing is infrastructure.
The release also mentions client-server reliability fixes for crush run under the opt-in CRUSH_CLIENT_SERVER=1 mode, plus a scrollbar track-position fix. The client-server direction is worth watching. Separating UI/client from execution/session state can unlock better background runs, remote control, and multi-client workflows. It also raises the bar for cancellation, process ownership, audit trails, and state synchronization. A shell hang is annoying in a local terminal. In a detached or remote execution model, it becomes operational debt.
Audit the shell wrapper before you trust the agent
Crush had roughly 24,806 GitHub stars, 1,757 forks, and 458 open issues at collection time, with the 0.74.1 release published at 2026-05-29T20:45:24Z. Those numbers matter less than the category of fix: a widely used agentic terminal tool is patching the boring boundaries between model intent and process reality.
If you are evaluating coding agents, this is the checklist hiding inside the release. Does the shell wrapper disable editors and pagers by default? Does it preserve explicit environment overrides? Does it time out quiet commands? Does it surface the exact command, working directory, environment assumptions, exit code, stderr, and elapsed time? Can you distinguish “command failed” from “command waited for a human forever”? Can the user cancel a stuck process from every surface where the agent can be launched?
Those questions are not secondary to model quality. They are how model quality reaches production. A brilliant model trapped in vim is not an autonomous engineer. It is a very expensive terminal session with stage fright.
The broader agentic-coding market is currently obsessed with bigger context windows, more parallel subagents, and stronger reasoning modes. Fine. Those matter. But the tools that win daily developer trust will also be the ones that handle Git, shells, pagers, provider protocols, client-server state, and cancellation like they expect to run unattended at 2 a.m. Crush 0.74.1 is a small patch in that direction. Small patches are often where the product becomes real.
Sources: GitHub — Crush v0.74.1, Crush v0.74.0, PR #3025 — set non-interactive env vars in shell, PR #3040 — fix Qwen3.7-Max on OpenCode