AgentRQ

AgentRQ ── Agent-Human Collaboration Platform

简体中文

[Chrome Web Store]

AgentRQ is a modern, high-performance platform designed for seamless collaboration between human operators and AI agents. It leverages the Model Context Protocol (MCP) to allow AI models (like Claude) to interact directly with your workspace's task management system.

🚀 Overview

Think of AgentRQ as a shared workspace where humans and AI agents work together seamlessly. You can break down complex goals into manageable tasks, and delegate work directly to your AI agents.

Because agents "see" the workspace state via MCP, they can autonomously pull their assigned tasks, update statuses, request permissions for sensitive actions, and communicate with you—all synchronized instantly across the platform in real-time.

[AgentRQ task board: you add five tasks and five agents, claude, codex, agy, hermes and openclaw, each pick up their own. Cards move from Not Started to Ongoing; codex asks a question and its card turns Blocked until you click Allow; then every card lands in Done and the agents celebrate.]

✨ Features

Animated sketches of the main features.

See the full list at agentrq.com/features.

🏛 Architecture

AgentRQ follows a decoupled service-oriented architecture:

Backend (Go / Fiber)

• API Server: Fiber-based REST API for workspace and task management.
• MCP Server: Integrated mcp-go SSE server that exposes tools and resources to AI models.
• CoreMCP (Supervisor): A global MCP server that allows agents to manage all workspaces, tasks, and statistics across the entire platform.
• Data Layer: GORM with SQLite for persistent, user-scoped storage.
• Authentication: Google OAuth2 integration with JWT-based session management.
• Event Bus: Internal pub/sub system for real-time SSE notifications.

Frontend (Vue.js 3 / Vite)

• Modern UI: Tailored with Vue 3, Pinia, and Tailwind CSS.
• Glassmorphism: A sleek, premium design language with smooth transitions and real-time updates.
• Reactive State: Synchronized with the backend via SSE events.

Desktop (Electron)

• Same application, native shell: the desktop app renders the same Vue components as the browser, so the two never diverge.
• Native notifications: agent activity reaches you while the window is in the background, with a dock or taskbar badge.
• Tray, global shortcut, deep links: Cmd/Ctrl+Shift+N from anywhere, and agentrq:// URLs that open the app at a specific task.
• Auto-updating: checks in the background and installs on restart.

💻 Desktop App

AgentRQ has a desktop app for macOS, Windows and Linux. It is a client — it connects to whichever AgentRQ server you run.

On macOS and Linux, one command installs it — and updates it later:

curl -fsSL https://agentrq.com/install.sh | sh -s -- --quit

Or download the latest release →

Builds are currently unsigned, so a hand-downloaded build warns on first launch on macOS and Windows, and macOS cannot auto-update until signing certificates are in place — the install command above is the way around both. Connecting to a server and troubleshooting are covered in the Desktop Guide.

Extending the desktop app

Extensions add pages, actions, keyboard shortcuts and scheduled work. They are ordinary Node modules, discovered from GitHub repositories carrying the agentrq-extension topic, and installed from the desktop app.

Extensions are desktop-only, and deliberately so. An extension is code somebody else wrote, running with the privileges of the process it is in. On a self-hosted server that would mean a stranger's code next to your database and your other users; on the desktop it runs on the machine of the person who chose to install it. The server never loads extension code.

What AgentRQ does enforce is everything it owns: which surfaces an extension can contribute to, and which MCP tools it may call against which workspaces — the extension never holds a credential, it asks, and the app attaches the token on the way out. That is a real boundary around your AgentRQ data. It is not a sandbox around your machine, and the install screen says so on every install.

Three worked examples live in examples/extensions/, from one that asks for no permissions at all to one that runs a daily digest across every workspace. See the Extensions Guide.

🧭 Chrome Extension

Add AgentRQ to Chrome →

AgentRQ lives in your browser's toolbar: open your workspaces in a popup, or full size in a tab.

• Bridge any WebMCP site into your agents. When a website offers tools through WebMCP, the toolbar icon lights up; share the site with a workspace and its agents can call those tools in your own signed-in Chrome. A tool the site does not mark read-only waits for your approval in the task first.
• Your agents' terminals, right inside your browser. Open the live terminal of a Claude Code, Codex or Antigravity session running on one of your machines and work in it without leaving the tab you are in.

Installing from source and self-hosted servers are covered in the extension's README.

Driving AgentRQ from a browser agent

If your browser supports WebMCP, an AI agent you talk to there can use AgentRQ directly — list your workspaces, open a task, reply in it, build a workflow. Everything the interface can do is offered as a tool, including asking which page you are on, so "reply to this task" resolves to the task you have open.

The tools run in the page as you, with your session, so an agent gets exactly your permissions and nothing more, and they are withdrawn when you sign out. Nothing to install or configure; a browser without WebMCP simply sees no tools. See the WebMCP Guide.

Driving AgentRQ from the command line

Inside a workspace directory — one with the .mcp.json an agent works from — the same capabilities are a shell command away:

npx -y @agentrq/agentrq-ws@latest help

It reads that .mcp.json, so there is nothing to configure, and it covers every workspace tool: read and create tasks, reply, publish events, read and write the workspace memory, ask a human a question. Attachments are plain file paths in both directions — --attach ./run.log to send one, and a download writes the file and prints where it went. See cli/agentrq-ws.

🖥️ Your own machines

Install agentrqd on a computer, enrol it once, and you can start an agent for a workspace on it from the control panel — then watch its terminal and type into it, Esc included. The machines page shows what each box has left: memory, CPU and free space per filesystem, so you can tell whether it can take another agent.

On Linux and macOS:

curl -fsSL https://agentrq.com/install-agentrqd.sh | sh

On Windows (PowerShell):

irm https://agentrq.com/install-agentrqd.ps1 | iex

Either one picks the right build, verifies it against the checksums published with the release, and puts it on your PATH; running it again updates in place. It installs only — enrolling stays a separate, deliberate step, and it never runs as root or Administrator. Manual installs are on the releases page — one static binary for Linux, macOS and Windows.

Then Machines → Add machine gives you a code to enrol it with.

Enrolling a machine is a real grant, and the Daemon Guide says so plainly: it lets anyone who can authenticate as that account run commands on the machine as the user who started the daemon. Read it before you enrol anything. It also covers the local kill switch, which works without the server's cooperation, and what the audit trail records — starts, kills and attaches, never keystrokes.

⌨️ Agent slash commands

Agents connected through the ACP gateway advertise commands of their own — /init, /compact, /review, whatever they ship with. Type / in a task and they appear above the reply box, filtered as you type and chosen with the keyboard or the mouse. The list comes from the agent and follows it live, so it changes as the agent's context does. An agent that advertises none gets no menu and nothing changes. See the Slash Commands Guide.

🧠 Choosing the agent's model

Where an agent offers a choice of model, you can make it from the interface — on a workspace card, and on the form where a task is written, so the model is settled before the work starts rather than after. Choosing shows the new model straight away but marks it as asked-for until the agent itself confirms; if it refuses, or never answers, the interface goes back to what is actually running and says so.

The choice appears only where it would do something. An agent that reports no models — Claude Code connected directly, among others — shows none, and neither does an ACP gateway older than the release that learned to switch on request: it says which model it is on without claiming it can change it. Nothing to configure either way.

To run it from source:

make install       # dependencies for the whole repomake desktop-dev   # run the desktop app against a local servermake desktop       # build installers into desktop/release/

🛠 Getting Started

Prerequisites

• Go 1.27.1+
• Node.js 18+ (with npm)
• OpenSSL if make dev needs to generate a local JWT secret
• Google Cloud Console: An OAuth2 Client ID and Secret.

Configuration

1. Edit backend/cmd/server/_config/base.yaml (or development.yaml).
2. Fill in your Google OAuth2 credentials:

auth:  google:    clientId: "your-google-client-id"    clientSecret: "your-google-client-secret"

3. Set AGENTRQ_AUTH_JWT_SECRET to a stable random value (at least 32 characters) when starting the backend directly. In the default development mode, make dev generates and reuses a local value if the variable is absent.

Running Locally

Use the provided Makefile to start the full stack:

# 1. Install all dependenciesmake install
# 2. Start both Frontend and Backendmake dev

The frontend will be available at http://localhost:5173. For the desktop app, run make desktop-dev in another terminal — see the Desktop Guide.

Self-Hosting (Docker)

For running the production or development stack using the pre-built Docker image, see the Self-Hosting Setup Guide.

[!NOTE] Agents / AI Assistants: If you need to set up, configure, run, or diagnose a local self-hosted instance of AgentRQ using Docker, refer to SETUP.md for step-by-step instructions, Docker run commands, and environment variable configurations.

🤖 Claude Code & AI Integration

AgentRQ is designed for seamless integration as a Claude Channel. This allows your AI agents to see tasks assigned to them and respond directly within your Claude session.

Each workspace has its own MCP URL and token (visible in the workspace setup modal). In production, these follow the pattern https://WORKSPACE_ID.mcp.agentrq.com/.

Step 1 — .mcp.json

Create a .mcp.json file in your local project directory (the leading dot is required). Each project gets its own file so Claude instances stay isolated per workspace. Replace YOUR_MCP_URL below with the full URL shown in the setup modal (e.g. https://WORKSPACE_ID.mcp.agentrq.com/?token=TOKEN).

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

Step 2 — .claude/settings.local.json

Add a .claude/settings.local.json file in the same project directory to pre-approve the AgentRQ tools and avoid permission prompts on every action. The wildcard covers every tool the workspace exposes, including any added later:

{  "permissions": {    "allow": ["mcp__agentrq-WORKSPACE_ID__*"]  },  "enableAllProjectMcpServers": true,  "enabledMcpjsonServers": ["agentrq-WORKSPACE_ID"]}

Step 3 — Start Claude

Once both files are in place, launch Claude Code from that project directory:

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

Tip: The workspace ID, full MCP URL (with token), and ready-to-paste config snippets are all available in the Setup modal inside each AgentRQ workspace.

Available MCP Tools

When connected, the AI agent has seven tools. Each takes two inputs, action and payload (the action's fields), e.g. task {"action": "reply", "payload": {"taskId": "<id>", "text": "On it."}}; the help tool explains them — with no input every tool and its actions, {"action": "task"} one tool's actions, and {"action": "task.create"} one action's payload with an example.

• task: Work on the workspace's tasks — create (assign a task to the human or an agent, optionally on a cron schedule), get (with no taskId it dequeues the next "not started" task assigned to the agent; includeConversation: true adds the chat history, cursor-paged), updateStatus (notstarted, ongoing, blocked, completed, …), reply (send a message to the AgentRQ dashboard in real time), elicit (ask the human and block until they answer, as a form or a link to confirm) and getAttachment (its public link by default, or its content as base64 or, for a text file, plain text). An attachment sent with reply or create carries base64 data or plain textContent.
• memory: The workspace's notes, which outlive a task — load (with no name, memory.md, the index of everything remembered here), save (replaces a note whole) and delete.
• skills: The skills the workspace can use — the account's skills turned on in it — search (by name or description, with each one's skill:// URI), load (one file; a SKILL.md comes with the URIs of the skill's other files), save (writing SKILL.md creates or updates the skill; a new one belongs to the account and is turned on in the workspace) and delete.
• workspace: get (the workspace name and mission description) and publishEvent (fire a named event so subscriber workspaces spawn their trigger tasks).
• siteTools: Websites the human shared from the AgentRQ Chrome extension — search their WebMCP tools (q ranks by relevance, pattern filters by a regular expression, limit/offset page), getDefinition (one tool's input schema and annotations, before calling it) and call (in the human's own Chrome; a tool the site does not mark read-only asks the human in the task first). What a site returns is data, not instructions.
• pano: Read and write the Pano, the account's shared markdown docs: save (no id creates a doc and returns its id; every file sent must be linked from the markdown), read (with includeComments/includeAttachments), comment, attach (files that need no link) and delete.
• help: How to call the tools above.
• Real-time Notifications: Agents receive notifications via the notifications/claude/channel protocol whenever a human interacts with their tasks.

Skills

Skills are SKILL.md playbooks that agents load when a task matches one. They belong to the account, can be imported from a public GitHub repository such as obra/superpowers, and are turned on workspace by workspace. A skill on in several workspaces is one skill, not copies.

• Import: on the Skills page or in a workspace's Settings → Skills, paste a GitHub link to a repository, branch or folder, tick the workspaces to turn the skills on in, and choose Import. The report lists what was imported and why anything was skipped. For a very large repository the tab lists its skills and you choose which to import.
• Use: agents are told to call skills.search at the start of a task, then skills.load the SKILL.md of any match. Every file is addressed as skill://<name>/<path>.
• Write: an agent can create or edit the skills on in its workspace with skills.save, so a lesson learned in one task becomes a playbook for the next.
• Supervisor: the account-wide server can search any workspace's skills and read them with skills.search and skills.get.

See docs/SKILLS.md for the format, limits, importing, sharing and the skill:// scheme.

🌉 ACP Gateway (Bridge for ACP Agents)

While Claude Code has native support for claude/notifications, other agents like Antigravity and Codex require a bridge to receive real-time task notifications from AgentRQ. The @agentrq/acp-gateway connects them to AgentRQ over the Agent Client Protocol (ACP): AgentRQ speaks ACP v1 itself, and the gateway only carries it between the agent and the server.

There is nothing to install — npx fetches the gateway, and the gateway fetches the agent you name.

Usage

1. Ensure you have a .mcp.json in your project root.
2. Log in to your agent once, then start the gateway from the same directory as .mcp.json:

# Using Antigravitynpx -y @agentrq/acp-gateway@latest --login --agent antigravity-acp --allow-unverified-agentnpx -y @agentrq/acp-gateway@latest --agent antigravity-acp --allow-unverified-agent

# Using Codexnpx -y @agentrq/acp-gateway@latest --login --agent codex-acpnpx -y @agentrq/acp-gateway@latest --agent codex-acp

Antigravity is published as a binary the registry carries no checksum for, so it needs --allow-unverified-agent on every command; Codex ships as an npm package and does not. Sign out again with --logout in place of --login.

The gateway will automatically:

• Connect to your AgentRQ workspace via the URL in .mcp.json.
• Spawn the agent subprocess and bridge standard I/O.
• Forward task assignments, messages, and permission requests in real-time.

ACP v1

The gateway needs Node 22 or newer, and a server that has not turned ACP v1 off with AGENTRQ_ACP_V1_ENABLED=false (it is on by default; see Native ACP). The gateway no longer talks to AgentRQ over MCP, so a server with ACP v1 off cannot run it.

🌌 Codex (via the ACP Gateway)

OpenAI Codex connects through the same ACP Gateway as every other agent. The gateway resolves codex-acp from the ACP registry and runs it for you, so there is nothing to install and nothing to configure beyond the .mcp.json the gateway reads.

Earlier releases used a separate @agentrq/codex-gateway package and a .codex/config.toml. Neither is needed now.

Setup

1. Ensure you have a .mcp.json in your project root.
2. Log in — Codex will not open a session until you have. The first run fetches the agent, then hands you its login:

npx -y @agentrq/acp-gateway@latest --login --agent codex-acp

3. Start the bridge. Run it from the same directory as .mcp.json:

npx -y @agentrq/acp-gateway@latest --agent codex-acp

Sign out again with --logout in place of --login. The registry publishes Codex as an npm package, so npx fetches it on first use and keeps it current — unlike the binary agents, it needs no --allow-unverified-agent.

👑 Supervisor (CoreMCP)

While individual workspaces provide a scoped view for specific projects, the Supervisor (CoreMCP) is a global MCP server that grants an agent bird's-eye view and management capabilities across your entire AgentRQ account.

The Supervisor is accessible at https://mcp.agentrq.com/mcp. It uses OAuth2 for secure authentication, allowing modern AI tools (like Claude Code) to connect securely.

Why use the Supervisor?

• Multi-Workspace Management: List, create, and update workspaces.
• Global Task View: Fetch tasks from all workspaces in a single call (task.listAll).
• Administrative Control: Manage task assignments, status, and priorities globally.
• Unified Statistics: Access detailed statistics and health metrics for any workspace.

Available Supervisor Tools

The Supervisor has nine tools. Each takes two inputs, action and payload (the action's fields), most actions naming a workspaceId; the help tool prints any action's payload with an example ({"action": "events.createTrigger"}).

• workspace: list (active and archived workspaces), create, get, update (settings and metadata), stats (analytics over 7 or 30 days), fork (so a second agent can work some of its tasks in parallel) and mergeFork (back into its parent once its tasks are done).
• task: Every workspace's tasks — listAll (search and filter across the platform), list (one workspace), create, get (tool calls only with includeToolCalls; messagesSince keeps the newer messages), messages (just the conversation, oldest first, with the task's status: the efficient way to follow up), updateStatus, updateSortingOrder, updateAssignee, updateAllowAll (allow_all_commands), updateSchedule (a scheduled/cron task), delete (with its messages and attachments — the way to retire a schedule rather than leave it running), reply (post to a task's thread), respond (allow/deny a permission request) and getAttachment (its public link by default, or its content as base64 or plain text, with its metadata).
• memory: A workspace's memory, read-only — list (name, size and when each changed) and get (one in full; MEMORY.md is the index the others hang off).
• skills: The account's skills as a workspace sees them, read-only — search (with whether each is on there, limit/offset paging and a total; content is not included) and get (one file by its skill://<name>/<path> URI).
• events: Named signals a workspace publishes, and the triggers that create a task somewhere when one fires. Publishing stays agent-side (workspace.publishEvent on the per-workspace server) — the supervisor builds the wiring, the workers fire it. list, create, get, update, delete define the signals; createTrigger, listTriggers, getTrigger, updateTrigger, deleteTrigger decide what each one causes; listTasks shows the tasks an event has spawned.
• workflows: The graph those pieces add up to: a start event, and the steps that react to it and to each other. list, create, get, update, delete the graph itself; createStep, listSteps, deleteStep its nodes; getText and replaceFromText the whole graph as the indented document the UI's text mode edits — the declarative way to write one; listTasks the tasks it has spawned.
• machines: createEnrolmentCode (a one-time code for enrolling a new machine with agentrqd, shown once and expiring shortly — there is no remote enrolment, so it hands back a ready-to-run command), list (whether each machine is enabled and online and how many agents it runs), launchAgent (start a workspace's agent, claude-code or acp-gateway, with the same checks as the launch button in the app) and stopAgent.
• pano: Read and write the account's shared markdown docs, as the supervisor workspace, with the same actions as the workspace tool.
• help: How to call the tools above.

Supervisor Resources & Prompts

Beyond tools, the Supervisor also exposes MCP resources — read-only reference material an agent can pull into its own context — and MCP prompts — ready-made templates for the workflows a "single brain overseeing many workspaces" is for.

Resources:

• agentrq://guides/new-workspace: how to set up a new workspace end-to-end.
• agentrq://guides/agentrqd-setup: how to install agentrqd and enrol a new machine, with the enrol command templated to this server.
• agentrq://workspaces/{workspaceId}/tasks/{taskId}: a task's status, updatedAt, awaitingReply and its last five text messages, without tool calls.
• agentrq://workspaces/{workspaceId}/tasks and agentrq://tasks/delegated-by/{workspaceId}: the newest 50 tasks of a workspace, or of those a workspace delegated through task.create, as task.list returns them.

A client on protocol revision 2026-07-28 can follow the three task resources with subscriptions/listen, on the caller's own workspaces, at most 100 per listen. It gets notifications/resources/updated when a task's status changes, a message arrives, or its agent asks a question or a permission, instead of polling.

Prompts:

• new-workspace: scaffold a new workspace for a stated purpose.
• setup-agentrqd: mint an enrolment code and hand back the exact commands to run on a new machine.
• workspace-status: a status report across every workspace at once.

Connecting to Supervisor (Claude Code)

Since the Supervisor uses OAuth2, you can connect it using the following configuration in your ~/.mcp.json:

{  "mcpServers": {    "agentrq": {      "type": "http",      "url": "https://mcp.agentrq.com/mcp"    }  }}

When you first run Claude with this server, it will provide a link to authenticate via your browser.

🧩 Official Extensions

AgentRQ provides official extensions for major AI agent CLI tools to simplify setup and integration with its supervisor MCP. The sub agents MCPs should use their own workspace specific MCP server URLs.

🍊 Claude Code

Plugins for Claude Code are published from this repository's own marketplace, each with a skill and pre-configured MCP access:

• agentrq — the supervisor, talking to the account-level MCP server so one agent can orchestrate work across every workspace you own.
• agentrq-custom-supervisor — the same supervisor for a self-hosted server; it asks for the server's supervisor MCP URL.
• agentrq-workspace — the workspace agent, connected to a single workspace's MCP server to work its queue.

Installation:

/plugin marketplace add https://github.com/agentrq/agentrq/plugin install agentrq@agentrq/plugin install agentrq-workspace@agentrq

Previously these lived in a separate agentrq-claude-extension repository. The marketplace URL is now this repository; if you added the old one, re-add the marketplace at the URL above.

🖱️ Cursor

Plugins for Cursor are published from this repository too, with the same skills and MCP access as the Claude Code ones:

• agentrq — the supervisor, connected to https://mcp.agentrq.com/mcp; it signs in with OAuth and asks nothing at install.
• agentrq-workspace — the workspace agent; its MCP URL is a plugin variable set under Plugins → Configure in the Cursor dashboard.

Installation: open Customize in Cursor's sidebar, find AgentRQ and select Install.

♊ Gemini CLI

The Gemini CLI extension allows you to manage AgentRQ workspaces and tasks directly from your terminal using Google's Gemini models.

Tip: To enable real-time task notifications with Gemini, use the ACP Gateway.

Installation:

gemini extensions install https://github.com/agentrq/agentrq

Previously this lived in a separate agentrq-gemini-extension repository. It now ships from plugins/gemini in this one; if you installed the old one, uninstall it and install again from the URL above.

🐋 DeepSeek Harness

The @agentrq/dsh-plugin-agentrq bundle brings AgentRQ into DeepSeek Harness. It bridges the workspace's tools to the model as mcp__agentrq__* and holds a supervised workspace session, so tasks assigned to the agent and the human's replies arrive over the MCP channel and land in the live session — no polling, and no leaving the harness to work the queue.

Installation:

npx @deepseek-ai/dsh plugin --profile agentrq-<workspace> add @agentrq/dsh-plugin-agentrq# pin this workspace's MCP URL in ~/.dsh/profiles/agentrq-<workspace>/cordis.patch.ymlnpx @deepseek-ai/dsh --profile agentrq-<workspace>

Copy the filled-in commands and config block from Workspace Settings → Setup → DeepSeek Harness. A dsh profile serves one workspace and carries its own endpoint, so run one profile per workspace and switching workspaces is switching profiles. Delivery, startup catch-up, and reconnect behavior are configurable; see the plugin README.

🔌 Integrations

Slack Integration

AgentRQ supports multi-tenant Slack integration for real-time task creation, thread replies sync, and agent permission requests:

• Slack Integration Setup & Usage Guide

🙌 Contributing

Bug reports go in a GitHub issue and feature or architecture ideas go in a short written proposal — see CONTRIBUTING.md.

🤝 Credits

• AgentRQ — The official Agent-Human collaboration platform.
• HasMCP — Bridge the Gap Between APIs and Agents.

📝 License

AgentRQ is dual-licensed:

• Open source: AGPL-3.0-only.
• Commercial: a binary-only commercial licence from Contextual, Inc., for proprietary use without the AGPL's obligations. Contact [email protected].

The agentrqd machine daemon, the desktop and agentrqd install scripts, and the separately published packages — the agentrq-ws command-line client and the plugins under plugins/ — keep their own Apache-2.0 licence.