useagent

UseAgent gives Claude Code, Codex, OpenCode and Pi a shared workspace with repositories, a terminal, a browser and your team's tools. Ask for research, a website, a spreadsheet or a code change from the web app, Slack or the API. Follow the work live, step in when you need to, and keep the files it makes.

Why teams pick UseAgent

It runs on your server. Self-host the whole thing on any Linux box. Your code, prompts and files stay where you put them, which is what compliance teams ask for first.

Every run is on the record. Postgres stores each step, tool call and approval as an append-only log. Replay any run, see who approved what, and survive a restart mid-task.

Use the accounts you already pay for. Run Codex on your ChatGPT plan, or bring API keys for any engine. Keys live on your server and never enter the agent's sandbox.

Swap the agent, keep everything else. Claude Code, Codex, OpenCode and Pi share one event format, so threads, files and memory carry over when you change engines.

Alpha software. UseAgent runs real daily workloads, but APIs and schemas can change between releases. Pin a tag if you need stability.

UseAgent and Devin

	Devin	UseAgent
Source code	Closed	Open source (AGPL)
Where it runs	Cognition's cloud; enterprise plans can put the workspace in your VPC, the agent itself stays in Cognition's cloud	All of it on our cloud, your own servers, or your laptop
Which agent	Devin's own	Claude Code, Codex, OpenCode or Pi, side by side
Model bill	Paid through Devin	Your own keys, your ChatGPT plan for Codex, or free models
Record of the work	In Devin's app	Every step in your own Postgres, replayable

UseAgent is not a new model, and not a proven replacement for every Devin workflow. It is the workspace around the agents you already use: a computer per task, your team's tools and context, and a full record of what happened.

Use the hosted app

No install, no credit card. Start here:

1. Sign up at app.useagent.org with your email.
2. Start a thread from the home page and say what you want done: a website, a research report, a spreadsheet, a fix in one of your repositories.
3. Pick a model. Free models are always available. Choose one from the Free list in the model menu and go.
4. Bring the plan you already have. Open Settings → Provider connections and connect your ChatGPT account to run Codex on your own plan. In India, the free ChatGPT Go plan works too.
5. Add more models when you want them. Paste an API key in the same place. Keys are write-only and never enter the agent's sandbox.

Watch the agent work in its browser and terminal, answer it when it asks, and open the files it makes.

Features

A computer for every thread

Watch an agent research in a real browser, run commands, and work with your repositories. Open its desktop or terminal and take control when you need to. Daytona and CubeSandbox provide isolated Linux workstations with screen recording.

Computer use and sandboxes →

Teach it how your team works

Import skills from GitHub, pin a playbook to a task, and reuse the procedures that work. Skills are versioned, so a run records exactly what it used.

Skills and playbooks →

Context that carries forward

Keep knowledge, wiki pages, and optional team memory beside the work. Inspect recalled facts, correct them, and keep personal and organization memory separate.

Knowledge and memory →

Also in the workspace:

• Files you can use - documents, spreadsheets, presentations, PDFs, images, and videos. Supported workpieces have revisioned edits and native exports.
• Work from Slack - mention an agent, send attachments, and receive artifacts in the thread.
• Recurring work - schedule tasks, inspect their history, or run one immediately.
• Approval controls - gated tools pause for a decision and resume with a one-shot, argument-bound capability.
• Durable sessions - Postgres stores the event timeline; recovery re-probes live sessions after a restart.

Supported agents

One session UI and event format across engines. Connect a provider account or API key; the models, login methods and tools you get depend on the engine and your configuration. See the engine guide.

Integrations

Surface	What's connected
Where work starts	Web app, Slack, email, REST API, CLI and MCP, schedules. Every channel enters through the same run door
Native	Slack (mentions, threads, delivery), GitHub (App auth, clones, PRs)
Via connectors	Gmail, Linear, Notion, HubSpot. OAuth runs through the broker and tokens stay sealed on the server
Workspace	Knowledge base, team memory, skills and playbooks, scheduled automations
Open for contributors	Discord, Telegram, Microsoft Teams, webhooks, a GitHub Action

Get started

Hosted. Follow Use the hosted app above.

From source. You need bun and Postgres 16+ with pgvector. No Postgres handy? One container does it:

git clone https://github.com/useagenthq/useagent.git && cd useagent

docker run -d --name useagent-pg -p 127.0.0.1:5432:5432 \
  -e POSTGRES_HOST_AUTH_METHOD=trust pgvector/pgvector:pg16
export DATABASE_URL=postgres://postgres@localhost:5432/postgres

for workspace in \
  packages/agent-harness packages/artifact-workspace \
  packages/agent-client packages/artifact-formats packages/sandbox-contract \
  packages/conformance packages/cli \
  backend frontend; do
  (cd "$workspace" && bun install --frozen-lockfile)
done

bun run dev:backend    # API and orchestration on :3201
bun run dev:frontend   # UI on :3400 (proxies /api/* to the backend)

Running a real agent task also needs a sandbox provider key and a model key. The setup guide walks through both. bun run typecheck covers every package.

Self-hosting

UseAgent runs on any Linux host: AWS, Google Cloud, Azure or bare metal. infra/self-host/ has the full guide, a one-command reference host (Terraform) and the provider-agnostic deploy-app.sh:

SERVER_IP=<host-ip> PG_PASSWORD=... OPENROUTER_API_KEY=... \
  infra/self-host/deploy-app.sh /path/to/this/repo

Sandboxes are plugins: Daytona (managed, the easiest start), CubeSandbox (runs on your own hardware for full data locality) or Box. Docker Compose for a single machine is in docs/operations/compose-releases.md.

Architecture

Three properties do the heavy lifting:

1. The engine is a plug. Every engine speaks one event format through its adapter, so you can swap engines and keep your threads, files and memory.
2. Every run is an event log. Postgres is the source of truth: runs survive backend restarts, replay exactly and stay inspectable afterwards.
3. Credentials never enter the sandbox. The agent's computer is isolated. Every integration call crosses the trusted gateway as a typed tool, and the keys stay on your control plane.

Path	What it owns
frontend/	Product UI: chat, sessions, skills, playbooks, wiki, artifacts, automations, settings
backend/	Control plane: auth, runs, sandboxes, engines, knowledge, memory, artifacts, connectors
packages/	Shared contracts: thread events, engine events, sandbox providers, the CLI
docs-site/	Documentation site: concepts, architecture, API, operations
infra/self-host/	Self-hosting on any provider, with a reference Terraform host
memory/	Optional team-memory service

More in the documentation and the interactive request-flow diagram.

Hacktoberfest 2026

UseAgent is in Hacktoberfest. Pick an issue with the hacktoberfest label, comment that you're taking it, and open a pull request.

• New here? Start with good first issue.
• Want something bigger? The channel issues (Discord, Telegram, Microsoft Teams) build on the existing connector framework, with the email connector as a worked example.
• How it counts: merged, approved or hacktoberfest-accepted pull requests count. Low-effort pull requests are closed.

Read CONTRIBUTING.md before your first pull request.

Community

• Report a bug or request a feature
• Read the release notes
• Our sister project threads is an agent framework for TypeScript and Python built on the same idea: every run is a log you can replay.

License

UseAgent is free and open-source software under the GNU AGPL v3.0 (AGPL-3.0-only). You may use, modify and self-host it under the AGPL.

To embed UseAgent in proprietary software, distribute it without AGPL obligations, or build an OEM or white-label product, a commercial license is available.

Contributions are accepted under the CLA. The UseAgent name and logo are covered by the trademark policy, not the code license. Third-party components are listed in NOTICE; vendored and ported files carry per-file attribution headers.