useAgent: The Open Source AI Coworker

Four days after its first public commit, useAgent had 275 stars and a pricing page. That combination tells you most of what you need to know: this is an open source AI coworker with a company attached, shipped as AGPL-3.0 source you can run yourself and as a hosted early-access product you can join with an email address. The README calls itself alpha in bold, twice.

What it does is narrower and more interesting than "another agent platform". useAgent doesn't build you a new agent. It takes the coding agents your team already runs, gives each one a Linux machine of its own, wires in your tools and your company context, and hands back finished work rather than a transcript.

Which agents it actually runs

Codex, Claude Code, and OpenCode sit behind one provider-neutral event contract. Codex authenticates either with an API key or with a ChatGPT subscription. The useagent.org homepage adds two more to the row that the README doesn't mention: Pi, and a plain Chat mode. The docs are the place to check that list, since a four-day-old project will move faster than any write-up of it.

That framing matters. Most self-hosted agent projects want to be the agent. This one wants to be the room the agent works in, which is a smaller claim and a much easier one to keep. Swap the engine and the timeline, the approvals, the artifacts and the audit trail all stay put.

Every thread gets a real workstation

This is the load-bearing design decision. Each thread in useAgent opens an isolated Linux workstation with a terminal, cloned repositories, a browser, and a visible desktop over noVNC that records to MP4. Two sandbox backends, Daytona and Cube, sit behind a single contract, so the platform isn't married to either.

The recording detail is easy to skim past and shouldn't be. A desktop session captured to MP4 means that when an agent does something surprising in a browser, you can watch it happen rather than reconstruct it from a tool log. Anyone who has tried to work out why a scraping run returned an empty table will recognise how much time that saves.

Credentials never enter that sandbox. Knowledge, memory, skills, GitHub access, web search, desktop control and artifact publishing are all typed tools served by the backend, which means a compromised run can't walk off with your GitHub token because the token was never in the room. For anyone who has watched an agent cat an .env file into a log, that architecture choice is the difference between a demo and something you'd let near production.

Runs are event-sourced into Postgres. A backend restart doesn't kill work in flight; recovery re-probes live sessions and adopts whatever finished rather than failing it. Every turn stays inspectable afterwards through one session grammar, no matter which engine produced it.

Skills, memory, and the approval card

Skills come from GitHub as SKILL.md files, imported as versioned objects with auto-resync, then ranked into each turn. If your team already keeps a skills repo for Claude Code, that repo is the input; nothing needs rewriting. We've covered how that file format spread across tools in our piece on what agent skills are and where they came from.

Alongside that sits org-scoped retrieval with citations, a wiki, and a human-reviewed learning lane, so the things a team teaches the agent don't live in one person's chat history.

Then the approval card. Destructive tools pause and surface a card in the web app or in Slack; approving it resumes the run with a one-shot, argument-bound capability. Not a blanket "yes, this agent may run shell commands" toggle. One action, one grant, bound to the arguments it was approved for. That's the sort of thing that reads as unnecessary until the first time an agent decides git push --force was implied.

Work arrives through whatever door your team already uses

Channels in are the web app, Slack, a REST API, and schedules, and every one of them enters through the same run door. That sounds like a plumbing detail; it's the reason the audit trail is worth anything. A task kicked off by a cron schedule at 3am produces the same event-sourced timeline as one somebody typed into the composer, so "what did the agent do last night" has one answer instead of four.

Slack gets the deepest treatment: mention-to-run, threaded replies, attachments, artifacts, and approvals resolved inside the thread. Nobody has to open a second tool to say yes. GitHub is native too, with App-based auth, clones and pull requests, while Gmail, Linear, Notion and HubSpot arrive through a connector broker that handles OAuth and keeps tokens sealed on the server side.

The thing an open source AI coworker has to get right, and most don't, is that the work does not start in the agent's interface. It starts in a thread someone was already having. useAgent's answer is to meet it there and normalise it afterwards.

What it costs, and what "free" covers

The pricing page is refreshingly short. Early access is open, no card, leave an email. Self-hosting the platform is free because it's AGPL-3.0. Model spend bills to you, since you supply your own provider credentials. Enterprise, in the site's own phrasing, "is a conversation".

So the honest cost of the self-hosted route isn't licence fees. It's the standing infrastructure: bun as the runtime, Postgres 16 or newer with the pgvector extension compiled in (stock Postgres images don't ship it, and the README hands you a docker run line for pgvector/pgvector:pg16 because that trips people up), plus a Daytona or Cube account behind the sandbox contract, plus somewhere for all of it to live that stays awake.

That last item is where the promise and the practicality diverge. useAgent's core pitch is that an agent should have its own computer, which is exactly right; the catch is that self-hosting means you're now the one operating that computer, its database, its sandbox provider and its uptime. MoClaw sells the finished version of the same idea, a cloud AI computer that's already up, so the thing you evaluate on Tuesday is the thing you use on Wednesday.

The AGPL question your legal team will ask

AGPL-3.0 is the sharpest edge here and useAgent isn't hiding it: the badge sits in the README's first block. The clause that matters is section 13, which extends copyleft to network use. Modify the platform, expose it to users over a network, and you owe those users the corresponding source of your modified version.

Run it internally, unmodified, and this is uneventful. Fork it and build something customer-facing on top, and you've taken on an obligation most product teams haven't planned for. That's not a knock on the licence, which is doing precisely what its authors intended; it's a reason to route the decision through counsel before the fork, not after. Our self-hosted agent comparison walks through the same trade-off across several projects.

Where this lands for most teams: an open source AI coworker is a great thing to run inside your own walls, and a complicated thing to build a product on top of. MoClaw sidesteps that entirely, since a hosted service carries no copyleft obligation into whatever you build with it.

Should you run it yet?

The alpha warning is not decoration. The README says APIs and schemas may change between releases and tells you to pin a tag if you need stability, while also claiming it already runs real daily workloads. Both of those can be true; the repository is four days old in public and there were no open issues when I checked on 2 September 2026, which usually means early rather than perfect.

Two things push in its favour. The integration list is unusually complete for week one, with Slack and GitHub native, plus Gmail, Linear, Notion and HubSpot through an OAuth broker that keeps tokens sealed server-side. And artifacts are first-class: DOCX, XLSX, PPTX and PDF with revisioned editing and native renderers, rather than markdown you paste somewhere else.

Two things push against. Alpha software plus AGPL plus a bun-and-pgvector stack is three unfamiliar things at once for most infrastructure teams. And the hosted early access, the path with no setup at all, is a waitlist rather than a signup.

If you want to see whether the shape works for your team before committing to any of that, the cheapest experiment is to run the same task against a hosted machine first. MoClaw gives an agent a real computer with no database to stand up, which tells you within an afternoon whether "hand off the work, get the result back" fits how your team actually operates, and the answer transfers whichever platform you land on. Compare notes with our rundown of agent platforms worth knowing in 2026 once you have it.

Where it stands

As an open source AI coworker, useAgent is four days old in public, AGPL-3.0, 275 stars, alpha by its own admission, and clearer about its architecture than projects five times its age. The sandbox-per-thread model, the credential gateway, and the one-shot approval capability are all decisions I'd expect to see copied. Accurate as of September 2026; on a repository this young, check the README again before you plan around any of it.

FAQ

Is useAgent free?

The source is AGPL-3.0 and self-hosting costs nothing in licence fees. Hosted early access is free while it lasts, with no card required. You pay your model provider directly, and you pay for whatever infrastructure the self-hosted version runs on.

Can I self-host useAgent?

Yes, and that's the primary path. You'll need bun, Postgres 16+ with pgvector, and a sandbox backend through Daytona or Cube. The README's docker run pgvector/pgvector:pg16 one-liner covers the database if you don't already have one.

Does AGPL-3.0 affect commercial use?

Using it internally is fine. The network clause bites when you modify the platform and offer the modified version to users over a network, at which point those users can ask you for your source. Ask your own counsel before building a product on a fork.

Which AI agents does useAgent support?

Claude Code, Codex and OpenCode per the README; the homepage also lists Pi and a plain Chat mode. Codex works with an API key or a ChatGPT subscription.

Is it production-ready?

Its own README says alpha, warns that APIs and schemas may change between releases, and suggests pinning a tag. It also says it runs real daily workloads. Treat it as promising and young rather than settled.