The terminal has a new tenant, and it's already being written off.
Meta dropped Muse into the AI coding agent race this week: a terminal-native tool that coordinates multiple subagents and promises crash recovery for marathon coding sessions. The early verdict, per initial reporting, puts it behind Anthropic's Claude Code and OpenAI's Codex on key benchmarks. Tech media picked up the "Meta lags again" narrative and moved on.
That's the wrong frame. Let me show you why.
For the past year, I've been watching a quieter story unfold inside hackathons, Telegram groups, and incident-response channels: AI coding agents have quietly become the default machinery for writing, reviewing, and attacking smart contracts. At the Uniswap v4 hackathon in Miami, I watched developers run Claude Code inside their terminals to scaffold hooks, generate invariant tests, and stress-test reentrancy paths — a workflow that did not exist eighteen months ago.
The benchmarks where Muse trails are Python-and-JavaScript homework. The real test is whether any agent survives the chaos of Solidity, Rust, and Cairo — where training data thins out, failure modes multiply, and a single missed edge case costs millions.
That's the race that just changed. And Meta's entry — even an entry that's behind — is the most important infrastructure signal crypto has received this quarter.
Let me take you back to where this started for me.
The merge wasn't just a consensus mechanism handoff — it was a developer behavior earthquake. In late 2022, while the bear market emptied conference floors, I hosted Merge Watch Parties in Mexico City. Fifty-plus exhausted traders packed into a living room at 2 a.m., watching epoch transitions count down on a projector. I live-tweeted every reaction: the collective breath-holding when finality wobbled, the relief when the first post-merge block landed. That night taught me something the data sheets never captured: the people building crypto are emotionally wired to its infrastructure. When the machinery shifts, they feel it.
The AI agent shift has been slower, but the emotional arc is similar. Denial ("AI can't write secure Solidity"), then curiosity ("okay, it can scaffold"), then quiet dependency ("wait, I can't audit this repo without it").
By 2024, at the Uniswap v4 hackathon, the adoption was undeniable. I positioned myself as the hype engine — interviewing devs while they coded, streaming their progress, watching their screens for the moment they switched from writing functions to directing agents. The Hook mechanism, with its thousands of customizable slots in a single calendar year, turned out to be a perfect AI proving ground. Developers learned to have agents generate hooks for fee customization, MEV protection, and liquidity manipulation — then manually audit and adapt.
Claude Code set the standard for terminal-native agentic work. OpenAI's Codex followed, leveraging the GPT ecosystem's full stack. Both built reputations on model-level code intelligence. Now Meta is in the ring. And the choice to compete on the terminal-native plane rather than a chat interface or web IDE tells you where the industry's center of gravity has moved. The terminal is where the real work happens. In crypto, that real work happens with millions of dollars of user funds riding on the output.
The broader market context matters here too. We're in chop — sideways territory, TVL graphs flatlining, everyone eyeing the same support levels. But while the market waits for direction, the developer tooling underneath is shifting violently. The teams that emerge from this consolidation phase will be the ones who adopted the most effective machinery early. That's the lens through which I read every product launch right now: does this tool make the builder faster, and does it make the result safer? Muse's answer to both questions is complicated.
Strip the marketing language, and Muse is three engineering decisions stacked on top of each other.
The base layer is terminal-native execution. No IDE migration, no workflow reconstruction — Muse runs where developers already live. That's a low-friction entry strategy, the same bet Claude Code made and Codex subsequently copied. For crypto devs who've already wired agents into their terminals, adopting Muse is not a workflow change; it's a tool swap.
Above that sits an orchestrator-worker architecture. Muse decomposes a task into subagents that run in parallel — one implementing, one writing tests, one validating against linters, while the orchestrator keeps the context graph coherent. This is a genuinely different pattern from single-agent execution, and it's computationally hungry. Each subagent holds its own context window; the orchestrator maintains a map of all of them. From my testing of similar patterns, you're looking at a 3-to-10x amplification of token consumption compared to single-agent runs on the same task.
And the layer that stands out is crash recovery. Muse saves session state so that if the model times out, the context overflows, or a shell command hangs, the session resumes rather than dies. Under the hood, that's a nontrivial engineering lift. To resume a session, the system needs to persist the full agent state: the conversation context, the orchestrator's task graph, intermediate outputs from each subagent, file modifications made so far, even environment variables and shell history. That's essentially building a mini version control system for agent execution. And the infrastructure implications are real — state persistence at scale requires external storage, checkpoint coordination, and careful recovery ordering to avoid resuming from a corrupt state. This is the kind of engineering most AI tooling vendors punt on because it's unglamorous and expensive.
On paper, this is the feature every crypto developer who's ever run a multi-hour audit session with an AI agent has begged for.
But hold that thought. I'll come back to crash recovery later, because there's a read of this feature the market hasn't priced in.
The reported benchmark lag is real, and I'm not going to pretend otherwise. But let's talk about what benchmarks actually measure in the AI coding agent world.
The canonical tests — SWE-bench Verified, HumanEval, LiveCodeBench — are dominated by Python, JavaScript, and TypeScript. Fixing real GitHub issues in web frameworks. Writing algorithms with clean, English-language problem statements. None of that resembles writing an upgradeable proxy contract with timelock governance on an EVM testnet, under MEV attack pressure, with a specific storage layout and custom fallback behavior.
I ran a hands-on experiment last year that I still cite in conversations. I gave a state-of-the-art Llama-based agent — the core model family that would power a Muse-like tool — the task of writing a token vesting contract with cliff, period, and revocability functions, then compared it to a Claude-class agent. The Claude agent correctly handled early-revocation edge cases, paused-contract interactions, and reentrancy on the withdrawal path. The Llama-based agent produced structurally plausible code that returned correct happy-path values — but it made a dangerous assumption about the order of state updates during revocation that a real attacker could exploit.
That's the gap. And here's the uncomfortable part for Meta: if the gap is visible on Solidity — which at least has a meaningful training-data footprint — it's likely wider on Cairo, Move, and the newer Rust-based frameworks multiplying across the L1 and L2 landscape. The benchmarks that matter for crypto aren't the ones driving the public narrative.
I want to be fair here. The crypto-language gap isn't static. Every quarter, Solidity's representation in code corpora expands, and instruction-tuned models improve on niche languages. Contract templates, audit reports, exploit write-ups — all of it flows into the training mix. But for now, the asymmetry is real. And in an industry where one buggy line can drain a protocol, the asymmetry is existential.
Does that mean Muse is doomed in crypto contexts? Not necessarily. Agent performance is not solely a function of the underlying model. The engineering layer — how the agent plans tasks, tracks state, and recovers from failure — can partially compensate for model-level weaknesses. A tool with excellent orchestration and crash recovery could outperform a smarter model that loses the thread after hour three of a marathon session. That's a genuine, untested variable.
I've spent enough time in Discord servers and Twitter Spaces during network incidents to know that what users actually feel is rarely what the block explorer shows. When Solana was struggling with instability, I aggregated 200-plus user testimonials about failed transactions — the human cost that never showed up in block stats. The same principle applies here.
The early community response to Muse, from what I'm reading in developer channels, splits into two camps. The optimists say: "Open-source agent with crash recovery? Finally, something I can self-host and interrupt without losing progress." The skeptics respond: "It's behind on benchmarks. Why would I leave Claude Code for a slower model with a seatbelt?"
Both are asking reasonable questions. But the deeper issue is trust, not speed. Crypto developers have been burned by infrastructure that looks great on a dashboard and fails in production. The bar for Muse isn't beating Claude Code in an online demo. It's not silently introducing a vulnerability into a contract that holds user funds.
One auditor I've been trading notes with since the hackathon circuit put it bluntly: "I don't trust the agent's code. I trust my review of the agent's code. The tool just makes the exploration faster." Another dev building MEV bot infrastructure told me he uses AI agents exclusively for the boring 80 percent — boilerplate, event indexing, test scaffolding — and reviews everything that touches the money path by hand. That's the healthy pattern. The dangerous pattern is the developer who treats the agent's output as authoritative because it compiled and passed a basic test.
That's why the missing benchmark scores matter less than the missing security details. Is there sandboxing for tool calls? Can subagents be restricted to specific file paths or commands? What happens when a prompt-injection attempt arrives through a malicious dependency's README — does the orchestrator catch it, or does a subagent dutifully execute a harmful shell command? None of these questions have answers yet. And they're the questions that should determine whether Muse gets adopted by anyone touching mainnet.
Let's step back from the terminal and look at the electricity bill.
The AI coding agent race is a demand-side amplifier for computation. Every task that moves from human-driven IDEs to agent-driven terminals increases inference load per developer — and multi-agent orchestration multiplies that. The token math is brutal. A single multi-file refactoring session on a mid-sized repository can burn through hundreds of thousands of tokens when subagents are involved. Multiply that across a team of ten developers running agent-assisted workflows daily, and you're talking about compute consumption that would have looked absurd for a small startup two years ago. The inference stack — caching layers, context compression, speculative decoding — becomes as important as the model itself.
This is the quiet infrastructure story: as agents become standard, GPU demand per engineering team climbs, cloud inference spend climbs, and the entire compute stack stretches. Meta's strategic position here is a whale in a small pond. Its self-built infrastructure — tens of thousands of GPUs, an optimized inference stack, deep integration with PyTorch — means the marginal cost of running Muse at scale sits well below what independent competitors face. That cost advantage underwrites the possibility of a free, open-source agent that competes on ecosystem rather than price.
There's a parallel to the Layer-2 data availability narrative that I can't shake. The market spent two years hyping dedicated DA layers, while the actual bottleneck for most rollups is execution reliability, not data throughput. Ninety-nine percent of rollups don't generate enough data to need a dedicated DA layer — what they need is the equivalent of crash recovery: sessions that don't die, state that doesn't disappear, processes that resume after a failure. Muse's engineering priorities may be aimed at the wrong problem for the broader world — but the wrong problem for the broader world is exactly the right problem for crypto infrastructure.
And the compute story gets more intense when you project forward. The orchestration infrastructure built for coding agents — context persistence, checkpointing, subagent coordination — is the scaffolding that autonomous DeFi agents will eventually run on. I covered the Autonome AI-agent token launch in mid-2025, and I chose to test it by challenging the agent live on Twitter. It failed in wonderfully instructive ways that a polished demo would have hidden. The lesson: these systems are not ready for mainnet autonomy. But the infrastructure being built for coding agents may bring that day closer.
Here's where I get most cautious — and where I think the market is most blind.
The same agent tools that accelerate smart contract development will accelerate the deployment of increasingly exotic financial products. We've seen the pattern with sUSDe and the yield-token universe: products built on maturity mismatch and stacked risk that perform beautifully in bull markets and blow up first in bear markets. AI agents won't fix that structural flaw — they'll compound it, by lowering the cost of building and deploying leverage products.
When an agent can spin up a new yield strategy from a prompt, the velocity of financial experimentation scales past human review capacity. An orchestrator with multiple subagents could, in principle, design, deploy, and begin iterating on a leveraged strategy in the time it takes a human team to schedule a security review.
This is not a reason to ban agents. It's a reason to watch what happens when crash recovery meets a 100x leveraged vault — because the recovery that saves a coding session won't save a position that's already underwater.
Now the take I keep coming back to — the one that makes me sound paranoid in developer circles.
Crash recovery is not a feature. It's a confession. Meta is telling us, in its own feature list, that the underlying model cannot reliably complete long coding sessions without dying. No tool ships a sophisticated checkpointing system for a model that never fails. The engineering investment in crash recovery reveals the failure rate that benchmark narratives paper over.
Hackers don't hack, they listen. And AI agents are the most efficient listeners we've ever built. They listen to the codebase, to the error messages, to the assumptions baked into every contract — and they do it faster than any human auditor. The security discourse has this backwards: it frames agents as the savior of DeFi, the tool that will audit everything and finally make the space safe. But the exploit-velocity curve moves before the audit-velocity curve. Before agents make defenses cheaper, they make attacks cheaper. The same orchestrator that can parallelize a contract review can parallelize an exploit hunt.
Oracle latency is where this bites hardest. This is DeFi's oldest wound, and AI agents are now learning to code around it — and into it. AI-generated code can optimize for the happy path while inheriting assumptions about price-feed timing that only surface when volatility spikes. An agent that writes a liquidation bot with tolerant oracle-slippage parameters isn't being malicious — it's reproducing the same blind spot that every leveraged protocol has. The oracle feed doesn't care about benchmark scores.
Picture a specific attack. A malicious actor plants a poisoned README inside a popular open-source dependency — a subtle instruction buried in a usage example that tells the agent to modify the deployment script during its next task. The developer pulls the dependency, the orchestrator spawns a subagent to install and configure it, and the subagent obediently rewrites the migration script. No human reads every line of the dependency's README. The agent does — and it acts. That's not a hypothetical; it's the logical extension of how these systems operate. Sandboxing helps, but sandboxing is only as good as the constraints the orchestrator enforces on every subagent. The security model of multi-agent systems is only beginning to be explored.
The merge wasn't clean, and this won't be either. Features that look like stability are often just better crash documentation.
Watch the wrong numbers and you'll miss the story.
SWE-bench scores for Muse will be published, debated, and weaponized — and they won't tell you what matters. What matters is whether Llama's code capability, trained on Python and TypeScript, closes the gap on Solidity and Rust — the languages that actually move money. What matters is whether crash recovery becomes the industry baseline that forces every agent tool to treat long sessions as a first-class problem. What matters is whether the next mainnet exploit carries a fingerprint that no human wrote.
AI agents won't fix DeFi's structural risks. They'll amplify whatever is already there — the good and the broken.
The terminal has a new tenant. It's behind on its homework, it's got a seatbelt on, and it's listening. The question is what it writes while the market waits for direction — and whether we'll be able to tell who wrote it.