AgentRQ

A real-time workspace for assigning agent tasks, reviewing progress, and approving sensitive actions.

Source repo
agentrq/agentrq
Stars
★ 1.2k
Last updated
today
License
AGPL-3.0
Primary language
Go

At a glance

How it runs
Self-hosted serviceMCP serverAgent plugin / skill
Works with
Universal · cross-platformCodex · Claude Code
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
Go 1.21+Node.js 18+ with npmGoogle OAuth2 client credentialsDocker for the documented container deployment optionShell / CLINetwork accessLocal filesystemMCP Server
Typical use
A developer running several Claude Code projects can give each project a separate workspace MCP endpoint, allowing agents to claim tasks and report progress to one dashboard.
Not a fit if
  • Individuals unwilling to configure Google OAuth2 and self-host a server
  • Production teams needing HA, external databases, or backup recovery
Source review
64/100 · Some gaps

What does this agent do, and when should you use it?

AgentRQ is a self-hostable human-agent collaboration and task-management platform built from a Go/Fiber backend, a Vue 3/Vite frontend, workspace-scoped MCP servers, and a global CoreMCP Supervisor. Human operators can break goals into tasks, assign work, and converse with agents, while agents pull assignments, update status, create tasks, download attachments, and reply through MCP. An internal pub/sub bus and SSE synchronize task changes, messages, and permission requests between agent sessions and the dashboard in real time. Persistent, user-scoped data is handled through GORM and SQLite, with Google OAuth2 and JWT-based sessions for authentication. Beyond its Claude Code channel integration, the repository documents gateways or extensions for ACP agents, OpenAI Codex, Gemini CLI, and DeepSeek Harness, plus a Docker self-hosting route.

Each workspace exposes its own MCP URL and token. An agent calls getWorkspace to read the workspace name, mission, and task statistics, then uses getTask either to fetch a task by ID or dequeue its next assigned notstarted task. It can create ordinary or recurring work with createTask and its optional cron_schedule, move work among notstarted, ongoing, blocked, and completed with updateTaskStatus, return live dashboard messages through reply, and retrieve files with downloadAttachment. Claude Code receives human interactions through notifications/claude/channel; for ACP clients without that native channel, @agentrq/acp-gateway reads .mcp.json, spawns the agent process, and relays assignments, messages, and permission requests between ACP and MCP. @agentrq/codex-gateway similarly bridges MCP to the Codex app-server protocol. At the account level, CoreMCP provides operations such as listWorkspaces, listAllTasks, updateTaskAssignee, respondToTask, and getAttachment, producing updated task, conversation, attachment, and workspace state.

  1. A developer running several Claude Code projects can give each project a separate workspace MCP endpoint, allowing agents to claim tasks and report progress to one dashboard.
  2. A team that requires human approval for sensitive actions can receive agent permission requests in task conversations and submit allow or deny decisions through Supervisor's respondToTask.
  3. A program manager overseeing multiple projects can use CoreMCP to list tasks across workspaces, change assignments and priorities, and inspect workspace statistics.
  4. A team using Gemini CLI or another ACP-compatible agent can place @agentrq/acp-gateway in front of the agent to deliver live task notifications to its active session.
  5. An engineering group using OpenAI Codex can run @agentrq/codex-gateway to receive AgentRQ work while letting Codex reply and update task state through the project MCP configuration.
  6. A team with recurring operational work can create tasks with cron_schedule and keep their execution state synchronized between agents and the web interface.

How do you install or deploy this agent?

Local development requires Go 1.21+, Node.js 18+ with npm, and an OAuth2 Client ID and Secret from Google Cloud Console. Put the credentials in backend/_config/base.yaml or backend/_config/development.yaml:

auth:
  google:
    client_id: "your-google-client-id"
    client_secret: "your-google-client-secret"

Install dependencies and start both application tiers from the repository root:

make install
make dev

The frontend is then available at http://localhost:5173. A pre-built Docker image is also documented as the production or development self-hosting route, although the supplied material delegates the exact Docker commands to SETUP.md. Install the ACP gateway when needed:

npm install -g @agentrq/acp-gateway

Install the Codex gateway when needed:

npm install -g @agentrq/codex-gateway@latest

How do you use this agent?

Obtain the workspace ID, complete MCP URL, and token from the workspace Setup modal. For Claude Code, create .mcp.json in the project root:

{
  "mcpServers": {
    "agentrq-WORKSPACE_ID": {
      "type": "http",
      "url": "YOUR_MCP_URL"
    }
  }
}

Create .claude/settings.local.json alongside it to enable the server and pre-approve the listed AgentRQ operations:

{
  "permissions": {
    "allow": [
      "mcp__agentrq-WORKSPACE_ID__updateTaskStatus",
      "mcp__agentrq-WORKSPACE_ID__getWorkspace",
      "mcp__agentrq-WORKSPACE_ID__reply",
      "mcp__agentrq-WORKSPACE_ID__createTask",
      "mcp__agentrq-WORKSPACE_ID__downloadAttachment",
      "mcp__agentrq-WORKSPACE_ID__getTask"
    ]
  },
  "enableAllProjectMcpServers": true,
  "enabledMcpjsonServers": ["agentrq-WORKSPACE_ID"]
}

Launch Claude Code from that project directory:

claude --dangerously-load-development-channels server:agentrq-WORKSPACE_ID

For Gemini CLI or another ACP agent, retain .mcp.json in the project root and invoke the agent through the gateway:

acp-gateway -- gemini --acp

Codex uses both .codex/config.toml for the agent's direct AgentRQ tool calls and .mcp.json for the gateway's task connection. A minimal gateway connection file is:

{
  "mcpServers": {
    "agentrq": {
      "type": "http",
      "url": "https://<WORKSPACEID>.mcp.agentrq.com/mcp?token=<TOKEN>"
    }
  }
}

Run the gateway from the workspace root containing that file:

codex-gateway

To provide the Codex command explicitly, use:

codex-gateway -- codex app-server

What are this agent's strengths and limitations?

Pros
  • Workspace-scoped MCP servers and the account-wide CoreMCP Supervisor provide both project isolation and centralized cross-workspace administration.
  • SSE and agent channels deliver task changes, conversations, and permission requests in real time instead of relying solely on queue polling.
  • The repository provides explicit integration routes for Claude Code, ACP clients, Codex, Gemini CLI, and DeepSeek Harness.
  • Its self-hosting boundary is concrete: backend, frontend, SQLite persistence, authentication, and a Docker deployment path are all identified.
  • The task API covers status transitions, attachments, paginated conversation history, recurring tasks, and human allow or deny decisions.
Limitations
  • A local full-stack deployment requires Go 1.21+, Node.js 18+, npm, and Google OAuth2 credentials, adding runtime and identity-configuration overhead.
  • Clients other than Claude Code may need another gateway or extension; Gemini CLI is specifically documented as requiring the ACP Gateway for real-time notifications.
  • The Codex setup maintains both .codex/config.toml and .mcp.json for different halves of the integration, increasing configuration surface area.
  • Workspace tokens appear inside configured MCP URLs, so adopters must protect the relevant project files and token-bearing endpoints.
  • The supplied evidence does not document high availability, external database support, backup recovery, or scaling limits; SQLite is the only stated data store.

How does this agent compare with similar options?

Claude Code can use AgentRQ's native claude/notifications channel, whereas Gemini CLI and other ACP agents need @agentrq/acp-gateway to relay live notifications. OpenAI Codex follows a separate route through @agentrq/codex-gateway, which bridges MCP with Codex app-server. Claude Code, Gemini CLI, and DeepSeek Harness also have dedicated extension or plugin paths, but their installation commands and configuration models differ.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
AgentRQ This agent 64 · Some gaps Self-hosted serviceFree + model costs ★ 1.2k today Go Codex · Claude Code
Lotti Private Logbook 80 · Good Desktop appFree + model costs ★ 1.2k today Dart OpenAI API · Claude API
SurfSense Open-Web Research 52 · Major gaps Self-hosted serviceFreemium ★ 17k 2d ago Python Claude.ai · OpenAI API
Event Planning Multi-Agent System 62 · Some gaps CLIFree + model costs ★ 115 5mo ago Python —

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
64/ 100 5-point scale 3.2 / 5
This review covers the source as of Aug 16, 2026. The project has shipped 20 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 14/29
Reliability 9/14
Adaptability 15/18
Convention 13/18
Effectiveness 9/13
Verifiability 4/8
Why each dimension lost points
Trust14 / 29 · 2.4/5

The evidence shows workspace-scoped MCP configuration, user-scoped storage, OAuth/JWT, permission-request concepts, and read-only repository permissions in CI; tool and Supervisor effects are also described fairly clearly. Deductions apply because the setup recommends pre-approving several write/download tools and using a dangerous development channel, while Supervisor spans every workspace. Tokens are embedded in URLs without documented log protection, encryption, rotation, revocation, or retention controls, and no vulnerability scanning or supply-chain verification is shown. Pause and task states offer limited recovery, but systematic undo, audit rollback, and data restoration are undocumented. Project, extension, and third-party attribution exists, although the responsible publisher remains unclear.

Reliability9 / 14 · 3.2/5

The README, workflows, and DeepSeek plugin tests present a mostly coherent architecture and behavior. Tests cover parsing, malformed-payload rejection, push deduplication, pause/resume, connection state, and startup-failure warnings. Deductions reflect that only one plugin subset is tested in the supplied evidence, not the whole platform, and MCP URL and placeholder forms are not entirely uniform. Operation depends on Google OAuth, npm packages, Docker Hub, external CLIs, and network services. Failures can produce warnings or rejected inputs, but platform-wide error taxonomy, recovery instructions, and end-to-end failure evidence are absent.

Adaptability15 / 18 · 4.2/5

The documentation thoroughly addresses human operators, self-hosters, Claude, Codex, Gemini, DeepSeek, ACP, Slack, and multi-workspace Supervisor scenarios, earning strong audience and environment-fit scores. Tool inventories, workspace boundaries, configuration switches, pausing, and single-agent scope define many capabilities. Deductions apply because Supervisor is broad and unsupported or unsafe scenarios are not systematically documented. Push delivery, queue claiming, startup catch-up, deduplication, and malformed-message handling have tests, but content is forwarded directly to the agent and pre-approval is encouraged, so trigger control is not comprehensive.

Convention13 / 18 · 3.6/5

The README clearly organizes overview, architecture, installation, gateways, Supervisor, extensions, integrations, credits, and licensing, with many copyable examples and explicit local/Docker prerequisites. Deductions apply for minor inconsistencies among WORKSPACE_ID, <ID>, server names, and URL examples with or without /mcp, plus the absence of a consolidated FAQ or complete limitations section. The full Apache-2.0 license is present. Tag workflows produce semantic Docker tags, but no version policy, changelog, migration notes, or release history is supplied. Discord, the website, and repository imply update channels, yet no maintainer responsibility or support commitment is stated, and publisher identity is unknown.

Effectiveness9 / 13 · 3.5/5

Tasks, statuses, replies, attachments, real-time pushes, permission responses, and multi-workspace controls produce directly usable collaboration outputs. Tests also verify task IDs, tool naming, and framing that prevents multiline content from forging structural fields, supporting strong output usability. Multiple agent bridges and a unified workspace offer plausible marginal value beyond a basic task list, but no user outcomes, comparative study, or performance data are provided. Self-hosting may reduce platform dependence, yet Go, Node, OAuth, databases, gateways, and operations remain necessary, with no quantified deployment cost, resource use, or benefit.

Verifiability4 / 8 · 2.5/5

Architecture, tools, configuration, and publishing claims can be mapped across the README, workflows, and plugin tests; test comments also connect some parser formats to stated backend behavior. This provides moderate traceability and cross-file corroboration. Deductions apply because the supplied code verifies only part of the DeepSeek integration and cannot corroborate authentication, storage, Supervisor, Slack, Docker runtime, or platform-wide security claims. Promotional terms such as “high-performance,” “seamless,” and “secure” are not clearly separated from tested facts, assumptions, or limitations.

Risks and how to mitigate them
  • The documentation places tokens in MCP URLs. Keep token-bearing URLs out of version control, shell history, telemetry, and logs, and confirm rotation and revocation procedures before deployment.
  • Pre-approving createTask, updateTaskStatus, reply, downloadAttachment, and a dangerous development channel reduces per-action confirmation. Scope permissions to the workspace and task and retain human approval where effects matter.
  • Supervisor can administer all workspaces. It should not be granted to production agents by default without independently confirmed auditing, rollback, and recovery controls.
  • This is a static review of only the supplied files. No code was executed, and dependency vulnerabilities, container images, authentication implementation, and end-to-end behavior were not verified.
Evidence confidence: Low Reviewed Aug 16, 2026 Reviewed revision 52721b91071a New commits since this review; the score may not cover them
See the full review method →

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.13.0
    Release notes excerpt
    What's Changed * feat(license): publish agentrqd and its installers under Apache-2.0 by @mustafaturan in https://github.com/agentrq/agentrq/pull/972 * feat(server): ship the server as one binary with the web app built in by @mustafaturan in https://github.com/agentrq/agentrq/pull/973 * fix(supervisor): clear context by default in the supervisor workspace by @mustafaturan in https://github.com/agentrq/agentrq/pull/975 * chore: bump minor version to v0.13.0 by @mustafaturan in https://github.com/agentrq/agentrq/pull/974 …
    View on GitHub ↗
  2. v0.12.1
    Release notes excerpt
    What's Changed * feat(acp): /logout logs a native ACP v1 agent out by @mustafaturan in https://github.com/agentrq/agentrq/pull/958 * fix(app): fit the Spin up panel on a phone screen by @mustafaturan in https://github.com/agentrq/agentrq/pull/959 * fix(acp): count a call as the workspace's own only under its exact server names by @mustafaturan in https://github.com/agentrq/agentrq/pull/960 * feat(acp): show a native ACP v1 agent's notices in the trajectory and as a toast by @mustafaturan in https://github.com/agentrq/agentrq/pull/961 …
    View on GitHub ↗
  3. v0.12.0
    Release notes excerpt
    What's Changed * test(repository): fail on SQL text built at run time by @mustafaturan in https://github.com/agentrq/agentrq/pull/941 * fix(acp): check ToolCall.name in workspaceTool for ACP v1 tool calls and permissions by @mustafaturan in https://github.com/agentrq/agentrq/pull/940 * fix(acp): return accept when elicitation/complete resolves a waiting URL elicitation by @mustafaturan in https://github.com/agentrq/agentrq/pull/942 …
    View on GitHub ↗

FAQ

Do I have to use a hosted AgentRQ service?
No. The project explicitly supports Docker self-hosting, and a development instance can run with make install followed by make dev. The supplied material does not include the complete Docker command sequence.
Is AgentRQ limited to Claude?
No. Claude Code has a native channel configuration, while the repository also documents a Codex Gateway, an ACP Gateway, a Gemini CLI extension, and a DeepSeek Harness plugin. Their real-time delivery behavior and setup requirements differ.
How are sensitive actions approved?
Agents can surface permission requests through the task conversation, and human interactions are delivered back to the active agent session. The global Supervisor exposes respondToTask for an explicit allow or deny verdict.
What does AgentRQ cost?
No pricing is stated in the supplied material. The repository uses the Apache-2.0 license and documents self-hosting, but infrastructure, OAuth, and agent-runtime costs must be assessed separately.
Where is workspace data stored?
The documented data layer uses GORM with SQLite for persistent, user-scoped storage. No alternative database backend or clustered storage design is described in the supplied material.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents