I open-sourced UseAgent: turn Claude Code, Codex or OpenCode into a coworker with its own computer

#ai #opensource #devtools #showdev

I open-sourced UseAgent this week. Built it over the last few months to run my own daily work.

👉 https://github.com/useagenthq/useagent

Short version: it takes Claude Code, Codex, or OpenCode and gives each one a real cloud computer. What comes back is finished work. PRs, spreadsheets, decks, PDFs, screen recordings of it clicking through a browser. Not a chat transcript.

There's a live demo with no signup: https://demo.useagent.org. The demo itself is the most interesting engineering artifact here, but I'll get to that.

🖥 Hand it work, watch it work

You send a task from the web app or Slack. It gets a sandbox: terminal, files, a visible desktop. You can watch it open a browser and click around. Or ignore it and scrub the recording later.

It plans, then checks things off as it goes:

🔁 The engine is a dropdown

Every agent speaks its own dialect. Codex has its app-server RPC. Claude Code has its own agent protocol. OpenCode is an HTTP/SSE server. Pi has its own RPC. Wire your product straight to one of them and you've married it: your threads, your storage, your UI quietly take that agent's shape.

So the rule in UseAgent is that nothing downstream knows which engine is running. Each engine gets an adapter that speaks its native protocol and translates it into one canonical event stream. There is an ACP adapter too, for agents that already speak it, but the native drivers are the real path. The UI, memory, artifacts, Slack - they only ever see canonical events. Switching Claude Code to Codex is a dropdown. Your threads and files don't move.

The interface is small. The translation fidelity is the hard part: every harness has different ideas about tool-call boundaries, streaming, what "done" means. The adapters own that mess in one place.

🧾 The important part: runs are event logs

Most agent tools treat a run as a live process. Close the tab, lose the plot. Backend restarts mid-run, gone.

In UseAgent a run is an append-only log of canonical events in Postgres. The UI never renders a live process. It renders the log. Every tool call, every file change, every status flip is a row, in order, forever.

That one decision pays for everything else. Runs survive backend restarts. You can reconnect from another device and the thread rebuilds from a cursor. You can audit what an agent did last Tuesday, tool call by tool call.

And here's the receipt: the demo at demo.useagent.org is a static site. No backend. No database behind it. Every session you click through is a real event log replaying in your browser: timelines, artifacts, the multi-agent runs, all of it. If runs weren't event-sourced that demo could not exist. I didn't build the demo as a marketing asset, I exported the logs and they just worked. That was the moment I knew the architecture was right.

📄 Real files back

Deliverables land as actual files you open and edit in the browser. Spreadsheets with formulas, PDFs, decks, code.

🔐 Keys never enter the sandbox

The agent's computer is disposable. Slack and GitHub credentials stay on the control plane behind a typed tool gateway. The agent calls the tool, the gateway holds the token.

🚀 Try it

git clone https://github.com/useagenthq/useagent && cd useagent
# needs bun + Postgres with pgvector (README has a one-line docker for it)
bun run dev:backend    # :3201
bun run dev:frontend   # :3400

Cold clone to running app was under a minute on my machine.

It's alpha. It runs my daily workloads. Real runs, real sandboxes, Slack in and out. APIs still move between releases though, so pin a tag if you need stability. Approval gates exist in the UI and aren't wired to the backend yet. That's next.

If something breaks in your first ten minutes, tell me. That's exactly the feedback I want.

⭐ Repo: https://github.com/useagenthq/useagent
🌐 Site: https://useagent.org
🧪 Demo: https://demo.useagent.org
🐦 X: @useagenthq
😺 Product Hunt: https://www.producthunt.com/products/useagent