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
- FA score
- 64/100 · Some gaps
At a glance
- How it runs
- 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
- 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.
- 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.
- 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. - A program manager overseeing multiple projects can use CoreMCP to list tasks across workspaces, change assignments and priorities, and inspect workspace statistics.
- A team using Gemini CLI or another ACP-compatible agent can place
@agentrq/acp-gatewayin front of the agent to deliver live task notifications to its active session. - An engineering group using OpenAI Codex can run
@agentrq/codex-gatewayto receive AgentRQ work while letting Codex reply and update task state through the project MCP configuration. - A team with recurring operational work can create tasks with
cron_scheduleand 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 devThe 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-gatewayInstall the Codex gateway when needed:
npm install -g @agentrq/codex-gateway@latestHow 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_IDFor Gemini CLI or another ACP agent, retain .mcp.json in the project root and invoke the agent through the gateway:
acp-gateway -- gemini --acpCodex 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-gatewayTo provide the Codex command explicitly, use:
codex-gateway -- codex app-serverWhat are this agent's strengths and limitations?
- 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.
- 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.tomland.mcp.jsonfor 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?
Why each dimension lost points
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.
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.
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.
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.
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.
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.
- 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.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
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 ↗ -
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 ↗ -
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?
make install followed by make dev. The supplied material does not include the complete Docker command sequence.Is AgentRQ limited to Claude?
How are sensitive actions approved?
respondToTask for an explicit allow or deny verdict.