useagenthq/useagent

useAgent – an open‑source AI coworker

What it is

• A self‑hosted platform that lets large‑language‑model agents (Claude Code, Codex, OpenCode, Pi) work inside a full‑featured computer environment. Agents can browse the web, run commands in a sandboxed Linux VM, edit files in your repositories, and interact with the tools your team already uses (Slack, GitHub, Gmail, Notion, etc.).
• The UI shows a timeline of the agent’s actions, a terminal, a browser pane and a workspace where the generated artifacts (code, docs, spreadsheets, images…) are stored.

Key concepts

Concept	What it gives you
Computer per thread	Each agent runs in an isolated sandbox (Daytona or CubeSandbox) with its own screen‑recorded desktop and terminal, so you can watch the work in real time or take over manually.
Skills & playbooks	Reusable, version‑controlled procedures imported from your GitHub repos. A playbook can be pinned to a task so the same workflow is applied every run.
Knowledge & memory	A shared wiki‑style knowledge base plus optional “team memory” that persists across runs. Facts can be inspected, corrected, and kept separate for personal vs. organization use.
Artifacts	Files produced by the agent (code, PDFs, images, spreadsheets) are stored with revision history and can be exported directly.
Integrations	Incoming work can come from a web UI, Slack mentions, a REST API, or scheduled jobs. Outbound actions (GitHub PRs, Gmail sends, Linear tickets, etc.) go through a gateway that never exposes credentials to the sandbox.
Event log	Every run is recorded in PostgreSQL (with pgvector for embeddings). The log survives restarts, can be replayed, and provides an audit trail.

How it works (high‑level architecture)

• Frontend (frontend/) – React UI that displays sessions, skills, memory, and artifacts.
• Backend (backend/) – Control plane handling authentication, run orchestration, sandbox provisioning, engine adapters, and connector gateways.
• Engine adapters – Thin layers that translate a canonical event contract to the specific API of Claude Code, Codex, OpenCode, or Pi.
• Sandboxes – Isolated Linux workstations (Daytona or CubeSandbox) where the agent’s “computer” lives; they record screen/video for the UI.
• Postgres event store – Source of truth for runs, memory, and artifact metadata; enables durable sessions and replay.
• Connectors – OAuth‑secured bridges to external services (GitHub, Slack, Gmail, Linear, Notion, HubSpot, etc.).

Quick start (local development)

# Clone and enter repo
git clone https://github.com/useagenthq/useagent.git && cd useagent

# Run a PostgreSQL container with pgvector extension
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

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

# Start backend API (port 3201) and frontend UI (port 3400)
bun run dev:backend
bun run dev:frontend

After that, open http://localhost:3400 to interact with the UI.

Self‑hosting

• Runs on any Linux host (cloud VM, bare metal, etc.).
• Provided Terraform scripts and a deploy-app.sh helper provision the control plane, PostgreSQL, and sandbox infrastructure on the chosen provider.
• Choose between a managed sandbox service (Daytona) for quick starts or a self‑hosted CubeSandbox for full data locality.

Typical use cases

• Automated research & reporting – Ask the agent to browse the web, summarise findings, and output a markdown report.
• Code generation & review – Provide a repository, a change request, and let the agent edit files, run tests, and open a PR.
• Team knowledge assistant – Store internal docs in the knowledge base; the agent can retrieve and cite facts during a session.
• Scheduled automation – Define recurring tasks (e.g., nightly data export) that run in the background and produce artifacts.
• Human‑in‑the‑loop workflows – Watch the agent’s live terminal; intervene whenever a decision is needed, then let it continue.

License & commercial options

• Code is released under the GNU AGPL‑3.0, meaning you can run, modify, and redistribute it as long as you keep the same license.
• A separate commercial license is offered for OEM or proprietary embedding.

Where to learn more

• Full docs: https://useagent.org/docs/
• Demo video (no sign‑in required): https://useagent.org/#demo
• Architecture diagram: https://github.com/useagenthq/useagent/blob/main/docs/architecture/request-flow.html

---

All information above is taken directly from the repository’s README; no additional features have been inferred.