For nearly every AI use case, I now prefer using coding harnesses like Codex, Claude Code, or Pi. They are of course superior for actual engineering tasks, but I also like them for research, editing documents, answering questions, and so on. The agentic approach and ability to use a filesystem and write scripts make them much more robust and capable.

But from a user experience standpoint, I mostly want something more like ChatGPT or Claude.ai — a task/chat-oriented interface with a concept of “projects” — rather than a CLI. The CLIs are great for engineering (especially via an interface like Superset), but they doesn’t feel quite right for non-engineering tasks. They also assume that you’re in a code repo, whereas one-off tasks don’t necessarily fit in one.

In some sense, Claude Cowork and ChatGPT Work are meant to fill this gap, giving you agentic capabilities across your computer. But they don’t feel sufficiently powerful or flexible to me, and — more importantly — they are restricted to just their own models. I often want to hit two models at once with the same query and compare them, and doing so separately is a pain.

So I built a product for myself called daegent. To the user, it looks very similar to ChatGPT or Claude.ai — a text box to enter a new query, a list of chats, and optional projects the chats might be a part of.

But under the hood, it runs on a spare computer in my closet and uses Codex and Claude Code (via my subscriptions, not API usage!) to handle tasks. Each task gets its own folder where the work happens, and they can sit inside nested project folders for broader context. I can access it remotely in my web browser (over Tailscale), or via a dedicated interface in my personal app Congruence.

daegent allows you to send the same request to multiple models or harnesses at once, and also allows for the answers to be compared and summarized if you do so. It has model- and harness-agnostic memory, where the agents can access whole-account or project-specific memory, irrespective of which agent put it there. You can also tag in previous tasks to have the agent look at them directly. And it supports /goal usage with a nice monitoring and usability layer above it.

On desktop, it can be driven entirely via keyboard and is way snappier than the ChatGPT/Claude web interfaces. You “tag” models in via autocompleted strings like @codex:gpt-6-astra:medium (for medium-level thinking), and projects with hashtags like #acme-corp.

So a task might look like:

@codex:gpt-6-astra:medium @claude:fable[1m]:medium go research some complex stuff and @compare it. you may want to reference Audit every TPS report before Friday #acme-corp

This would create a new task-specific folder within the /acme-corp project folder. Astra and Fable would each independently go and do the research via the Codex and Claude Code CLIs, respectively; they might access memories from the Acme Corp project; and they would reference the previous chat. Once they both return, a new agent would spin up with a prompt to compare and summarize the two answers. The user would get back all three — Astra, Fable, and the summary.

The agents can also link to “internal” files it creates or downloads that are stored in its filesystem, and the user can click to open or download these. And all the daegent work (conversations, files, etc.) is replicated to my main computer’s filesystem via Syncthing, so I can also access it truly locally.

I now use daegent for ~100% of my non-engineering AI usage, and perhaps 20% of my engineering usage too (typically when I’m firing something off remotely); the remaining engineering usage is still via the CLIs in Superset.

I built interface0 last year — still with a very happy userbase! — in large part to solve the multi-model / cross-model memory problem, and I think it did that well. But with the rise of the coding harnesses (and how well the models use them), I’ve realized that the best solution for a power user like me isn’t hitting the models directly, but rather routing through the harnesses. In some sense, daegent is interface0 for the harness paradigm.

In general, after building interface0 and daegent, my perspective is that the labs will end up building almost everything themselves, so if there’s a capability gap, it’s only temporary. But a plausible exception is the cross-model layer. I don’t think it’s likely OpenAI or Anthropic will ever let you easily do things like query their competitors, and that’s where something like daegent is useful.

The other thing the labs won’t likely ever do is build a product that is perfect for me, Andy Bromberg. This is the personalized software thesis. Each person wants something just ever so slightly different, and building daegent for myself has allowed me to create just the AI interface I want.

Looking for more to read?

Want to hear about new essays? Subscribe to my roughly-monthly newsletter recapping my recent writing and things I'm enjoying:

And I'd love to hear from you directly: andy@andybromberg.com