useagent README

The project's README from github.com/useagenthq/useagent. As one markdown file: README.md.

useAgent

The open-source AI coworker for your team.
Your agents. Their own computer. Finished work you can use.

Status: alpha License: AGPL-3.0 Runtime: bun Documentation

Watch the demo · Quick Start · Self-hosting · Documentation · Architecture

useAgent gives Claude Code, Codex, OpenCode, and Pi a shared workspace with repositories, a terminal, a browser, and your team's tools and context. Ask for research, a website, a spreadsheet, or a code change. Follow the work in the thread, step in when needed, and open the files it produces.

Watch useAgent in action: an agent session with a live timeline, terminal, and workspace panes

Watch the 63-second product tour →
Real product footage. No sign-in required. The recorded UI may differ from your release.

Alpha software. useAgent is under active development: expect rough edges, and APIs/schemas may change between releases. It already runs real daily workloads, but pin a tag if you need stability.

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 →

 An agent reads browser sources while its tool activity and research stream into the thread

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 →

 Browse reusable skills and the team's knowledge from the shared workspace

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 →

 The memory hub with separate organization and personal views, shown in dark and light themes

Also in the workspace:

Supported agents

Claude Code   Codex   OpenCode   Pi

One session UI and event contract across engines. Connect a supported provider account or API key; available models, login methods, and tools depend on the adapter and your self-hosted configuration. See the engine guide.

Integrations

Work arrives from anywhere and tools stay behind the gateway:

Surface What's connected
Channels in Web app, Slack, REST API, 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 handled by the broker, tokens sealed server-side
Workspace surfaces Knowledge base, team memory, skills and playbooks, scheduled automations

Quick Start

Clone the public repository:

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

Requires bun and Postgres 16+ with the pgvector extension (stock Postgres images do not include it). No Postgres handy? One container does it:

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 + orchestration on :3201
bun run dev:frontend   # UI on :3400 (proxies /api/* to the backend)

bun run typecheck covers every package.

The database example is for local development. See the setup guide for provider credentials and sandbox configuration before running a real agent task.

Self-hosting

useAgent runs on any Linux host - AWS, Google Cloud, Azure, Hetzner, or bare metal. See infra/self-host/ for the full guide, including the one-command Hetzner 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 pluggable: Daytona (managed service - pairs with a host on any cloud, easiest start) or CubeSandbox (self-hosted runtime on your own hardware - full data locality). Production deploy lanes are documented in infra/self-host/; the provisioning is provider-agnostic and addresses the host over SSH.

Architecture

useAgent architecture: entry channels feed a self-hosted control plane (Run API, Postgres event log, engine adapters, session UI); adapters spawn an isolated cloud sandbox per thread; every integration crosses the trusted gateway; finished work comes back as editable artifacts

Three properties do the heavy lifting:

  1. The engine is a plug. Claude Code, Codex, OpenCode, and Pi all speak one canonical event contract through the engine adapters - swap engines and your threads, artifacts, and memory stay.
  2. Every run is an event log. Postgres is the source of truth: runs survive backend restarts, replay exactly, and stay inspectable after the fact.
  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 live only 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, canonical engine events, workpieces, renderers
docs-site/ Documentation site: concepts, architecture, API, operations
infra/self-host/ Self-hosting on any provider + Hetzner reference Terraform
memory/ Optional team-memory service

Deeper reading: the documentation site and the interactive request-flow diagram.

The additive immutable-container release lane is documented in docs/operations/immutable-releases.md.

Community and contributing

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 useAgent under the AGPL.

If you want to embed useAgent into proprietary software, distribute it without AGPL obligations, build an OEM or white-label product, or obtain different terms, 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.

useagent (useagenthq/useagent)

Searching Database…

366 ·GitHub
Useagent
What is this?useAgent is an open-source alternative to Devin: it gives coding agents like Claude Code, Codex, OpenCode, and Pi a shared cloud workspace with a terminal, a browser, and your team's tools, so they can do real work like research, code changes, or documents.
Is this an app I install, or a platform I self-host?It's a self-hosted platform made of a frontend web app, a backend control plane, and pluggable sandbox runtimes (Daytona or CubeSandbox) that actually run the agent's isolated workstation; you deploy the whole stack on your own Linux host or cloud account.
How do I get it running?Clone the repository, then run it with bun and a Postgres 16+ database that has the pgvector extension enabled; one container can spin up that Postgres instance if you don't already have one, and bun run typecheck checks every package before a real deploy.
Which coding agents does it support, and do I need accounts for them?It supports Claude Code, Codex, OpenCode, and Pi through one shared event contract; you connect each with a provider account or API key, and the available models, login methods, and tools depend on that engine's adapter and your self-hosted config.
How stable is it right now?It's labeled alpha software: expect rough edges and breaking changes to APIs and schemas between releases, though it already runs real daily workloads if you pin a release tag.
Where do my credentials and API keys go?They never enter the agent's sandbox; every integration call crosses a trusted gateway as a typed tool, and the keys live only on your own control plane.
What can an agent actually produce in the workspace?Documents, spreadsheets, presentations, PDFs, images, and videos, called workpieces, with revisioned edits and native exports.
Can I run tasks from Slack instead of the web app?Yes, you mention an agent in Slack, send attachments, and get the finished artifacts back in the thread, alongside the web app, REST API, and schedules as entry points.
What are skills and playbooks?Skills are procedures you import from GitHub and pin to a task; they're versioned, so every run records exactly which version it used, letting a team reuse what already works.
Which third-party tools can it connect to?Gmail, Linear, Notion, and HubSpot via OAuth connectors, with a broker handling auth and sealing tokens server-side so agents never see raw credentials.
What are similar projects?open-swe, moyai, ruflo, qm, claude-code, nocobase, hive, Aperant
Which topics is it in?computer-use, slack, bun, vector-database, autonomous-agents, opencode, oauth, sandbox, github, browser-automation, agpl, postgresql
Creator
useagenthq
Size
44.9 MB
Stars
366
Updated
CommitOct 18Releasenative-runtime-e23fb6e2e7ecOct 11
Age
1mo
Commits · 90 Days