Smart Enough

Every few weeks someone asks who is winning the AI race, and the question usually means one thing: whose model is smartest. The assumption underneath is simple. Build the smartest model, build the best products, win the market.

In September that assumption got awkward. Meta’s new personal agent, Muse, reached No. 1 on the US App Store within a week of launch, ahead of ChatGPT, Gemini and Claude. Meta’s models have trailed OpenAI’s and Anthropic’s on several key benchmarks. Others have already explained the climb well: Meta’s built-in audience, a pitch about doing tasks rather than answering questions, and a free tier that made trying an agent cost nothing. Product engineering plus distribution at enormous scale. I’m concerned about Instagram and Facebook brain-rot, but from a strategy perspective Meta have made exactly the right play with Muse.

Three weeks later OpenAI answered with Dots: persistent agents, each with its own cloud computer, running on GPT-6 Astra, OpenAI’s flagship model.

Same product category, opposite bets. Meta leads with good-enough intelligence and billions of users. OpenAI leads with its best model, gated behind a premium tier.

The horse race and White House memes are fun. But the question I keep coming back to is a different one: how smart does the model have to be before something else becomes the bottleneck?

It isn’t a new question. Ethan Mollick has been arguing for a while that you can’t judge AI by the model alone: the model, the app and the harness around it all matter. Muse is that idea arriving in the mass market. My own small project is the same idea under a microscope.

I Thought the UX Was Polish

For the past few months Claude and I have been building Marlow, my own personal assistant. It’s basically a reaction to the security nightmare that is OpenClaw, as well as a way for me to stay technical. It runs on a private server, talks to my phone, reads my email and calendar, keeps a memory, and runs scheduled jobs. Under the hood it drives Claude Code as its agent runtime. Its users are me and a few friends and family.

I’m not telling you about Marlow because I think you should use it (it’s not released yet, and may never be). But it’s a small, fully instrumented agent where we can see exactly why things go wrong. You can’t do that with Muse or Dots from the outside. We have 500+ commits, design notes, telemetry and session transcripts that record every wrong turn.

I thought the interesting work was the plumbing and the raw capability: memory, tools, permissions, scheduling. The everyday UX felt like polish we’d get to later. Then I noticed that, despite building my own assistant, I kept opening ChatGPT for quick questions. That defection is what started us fixing things. Muse pushed us much further. Seeing it made me realize how much a clunky UX was holding Marlow back, and it took Marlow from a research project to a product I’m proud of. Replies appear quickly, it shows what it’s doing while it works, and a few UI tricks make it feel snappier. I’m using it far more as a result.

I still drift back to ChatGPT sometimes. But Muse taught me something I should have known already: Muse is winning because it’s a coherent, well-engineered product, not because Meta found a smarter model.

Marlow Is Not Slow. Marlow Is Long.

When I noticed myself defecting to ChatGPT, I assumed the problem was raw speed. The model was too slow, or the infrastructure was. But when Claude looked at the telemetry, reply time tracked reply length almost exactly. Short replies took a few seconds; long ones took over thirty. We were already on a fast configuration of the LLM: a mid-tier model at low reasoning effort.

The fix was to change Marlow’s instructions — Claude noticed that we had prompted Marlow to “be detailed” and this was nudging it towards longer (slower) answers. Instead, we told Marlow to answer at the size it was asked, and deleted the line inviting technical depth.

But the verbosity wasn’t just slow; it was burying specific “Marlow knows Mike” information in the middle of several paragraphs of general knowledge that I could have gotten anywhere. A faster, more concise Marlow was also more obviously useful to me.

A later measurement found the next bottleneck: conversational turns that used tools were much slower to show anything. The fix was to change which tools Marlow could see, excluding dozens that had nothing to do with a personal assistant, which also freed up context on every turn.

The Model Routes to Whatever It Can See

When we went back through Marlow’s history, one pattern kept recurring. Almost none of the failures were intelligence problems. They were ‘legibility’ problems. The model failed because it couldn’t see its own world accurately.

Two examples:

• The feature it was never told about. We added scheduling directly in the harness instead of relying on cron. Tests passed and the deploy was verified. But Marlow’s instructions still said scheduling wasn’t its job. When I asked for a reminder, it tried a Claude Code built-in skill that didn’t work in the harness, then tried sleep 300. It was following its outdated instructions. The commit message for the fix put it well: forgetting to add a new capability to the agent’s instructions is not neutral, because the model routes to whatever it can see. Now a change to the harness isn’t finished until Marlow’s instructions describe it.
• The instruction it kept ignoring. We told it explicitly not to use cat to read files, and why. It used cat anyway, twice. We assumed a trained habit we’d have to coach out. The real cause: the file-search tools had never been in its tool list. When we asked what tools it had, it confidently listed one that wasn’t there.

Muse has its own version of this. One user asked it to summarize a saved Instagram workout video and found it could only see the first frame. Meta owns the model, the agent and Instagram. The agent still couldn’t see the video.

Look at what Meta and OpenAI converged on, too. Both run tasks on isolated cloud computers, keep saved passwords away from the model, and ask permission before critical actions. That’s most of Marlow’s commit history. The labs are spending serious engineering exactly where I spent my weekends.

Where the Model Still Matters

This isn’t an argument that models don’t matter. I deliberately use stronger models when I need better reasoning. Marlow’s history shows two places where the model clearly matters.

The model can’t be trusted to explain itself. One evening a nightly job reminded me about a plan that was three days stale. When I asked what went wrong, Marlow gave me two confident explanations. Both were false, and one got written into its own memory. The real cause was a flaw in the job’s prompt. Our working rule now is: don’t believe Marlow about its own harness.

A smarter model might confabulate less. But the fix that worked lived outside the model. At Muse’s scale, that matters. If an agent with access to your email and payments can’t reliably explain its own failures, auditability has to live in the harness, not in the model’s account of itself.

Building is not running. We never fixed a runtime problem in Marlow by switching to a bigger model. A mid-tier model at low effort is fine for an assistant. But when we build Marlow, I route design work to the most capable model I have, because less capable coding agents make mistakes I can’t live with.

So the answer to my opening question, how smart is smart enough, depends on the task. For running errands, today’s mid-tier models are already there, and the harness is the bottleneck. For engineering the harness itself, extra intelligence still pays off. Frontier intelligence may be most valuable for building the systems that let good-enough intelligence suffice.

And there’s a reliability question I can’t answer from my own small sample. Going from an agent that works 90% of the time to one that works 99.9% of the time may need more intelligence, not just better orchestration. If so, the frontier labs’ advantage comes roaring back.

Renting the Harness

Marlow doesn’t call a model API directly. It drives Claude Code, which means I’m renting Anthropic’s harness as well as its model. That gave us a huge head start: tools, connectors to my email and calendar, sessions, caching, a permission system. It also came with costs we only found by probing: instructions we couldn’t see, defaults that silently drifted, tools we couldn’t separate, and caching we had to reverse-engineer.

So should Marlow own its harness? We costed it. Running the same workload on per-token API pricing would cost significantly more than I pay today.

The lock-in, it turns out, isn’t technical. It’s economic.

That’s the strategic point for the labs. A better model alone won’t keep customers, because good-enough models are available elsewhere. So OpenAI and Anthropic are building products people come to depend on: Claude Code, Codex and now Dots. It works on me. What keeps Marlow on Claude Code isn’t that Claude is the smartest model; it’s that the runtime is good and cheap to rent. Having the best model is like making the fastest chip: valuable, but most of the value goes to whoever owns the customer relationship.

Back to the Race

So who wins? It might be being scored on the wrong metric.

For everyday personal tasks, several models are already smart enough. We’re seeing the critical differences shift elsewhere: what the agent can see, what it remembers, how it asks permission, how quickly something appears on screen, and who already has your attention. Meta is very strong on the last of those. OpenAI is betting that capability will still decide things. Both may be right for different tasks.

There are real reasons the thesis could be wrong. A big enough capability jump could reset the market overnight. Everything Meta built around Muse can be built around a stronger model too. And Meta is asking people to hand an agent their messages, money and identity, which is a lot of trust to ask of Meta.

“We have the smartest model” is still a great asset. But Muse is the clearest sign yet that the market has caught up with what builders have been saying for a while: the model is one part of the system, and increasingly not the part that decides who wins.