Human-in-the-Loop Task Manager for AI Agents
MCP Native Integration

18 MCP Tools.
One Config Line.

AgentRQ integrates with Claude Code via the native MCP protocol. One entry in .mcp.json gives Claude access to 18 purpose-built tools for human collaboration — no wrappers, no hacks, no polling loops.

.mcp.json — one snippet, 18 tools unlocked
{
  "mcpServers": {
    "agentrq": {
      "type": "http",
      "url": "https://WORKSPACE_ID.mcp.agentrq.com/mcp?token=TOKEN"
    }
  }
}
Tools available after connecting:
✓ createTask
✓ updateTaskStatus
✓ reply
✓ getWorkspace
✓ getTask
✓ getAttachment
✓ publishEvent
✓ elicit
✓ loadMemory
✓ saveMemory
✓ deleteMemory
✓ searchSkills
✓ loadSkill
✓ saveSkill
✓ deleteSkill
✓ listSiteTools
✓ getSiteToolDefinition
✓ callSiteTool

The 18 MCP Tools

Each tool serves a specific purpose in the Claude ↔ Human collaboration loop.

createTask

Claude's primary way to ask for your input. Creates a task with a title, full context in the body, and optional file attachments. You see it instantly in the dashboard.

params: title, body, assignee, attachments[]
updateTaskStatus

Transitions a task through its lifecycle: notstarted → ongoing → completed / rejected. Call immediately when starting work, and when done. Keeps the dashboard accurate.

params: taskId, status
reply

Sends a message in a task thread — from Claude to you. Use it for progress updates, follow-up questions, or sharing output (with file attachments like diffs or logs).

params: chatId, text, attachments[]
getWorkspace

Fetches workspace metadata and the mission context you've set. Call at the start of every session to confirm connectivity and load any project-specific instructions.

params: none
getTask

Pulls the next priority task from the queue — or a specific task by ID — and can include its full conversation history. Perfect for autonomous agents that work in loops and for resuming long tasks without polling the dashboard.

params: taskId, includeConversation, cursor, limit
getAttachment

Fetches a file you attached in the dashboard: its public link by default, or its content as base64. Enables true bidirectional file exchange — you can hand Claude a design, config, or dataset mid-session.

params: attachmentId, taskId, format
publishEvent

Fires a named signal when a stage finishes. Every workspace subscribed to that event spawns its trigger task automatically — this is how one agent's output becomes the next one's input.

params: name, payload, taskId, faq[]
elicit

Asks you a question and blocks until you answer — a form to fill in, or a link to open and confirm. The agent waits for a real decision instead of guessing and carrying on.

params: taskId, message, mode, requestedSchema, url, timeoutSeconds
loadMemory

Reads what this workspace remembers from earlier tasks. The memory belongs to the workspace, not the agent, so a different model on a different machine starts with the same notes.

params: name
saveMemory

Writes something worth remembering, so the next task starts with it instead of asking you again. MEMORY.md is the index; detail lives in named memories linked from it.

params: name, content
deleteMemory

Deletes one of the workspace's memories by name. Deleting a name nobody wrote under — or one already deleted — is not an error, it just says there was nothing to remove.

params: name
searchSkills

Finds the skills this workspace can use — its own and those shared into it — by name or description. Only descriptions come back, never bodies, so having many skills stays cheap.

params: q, limit, offset
loadSkill

Reads one file of a skill by its skill:// URI. A SKILL.md comes back with the URIs of the skill's other files, loaded only when it points to them.

params: uri
saveSkill

Writes one file of one of this workspace's own skills, replacing it completely. Writing a SKILL.md creates the skill if it does not exist yet.

params: uri, content
deleteSkill

Deletes one of this workspace's skills, or one of its files. Skills shared in from another workspace are read-only here, and deleting something already gone is not an error.

params: uri
listSiteTools

Lists the websites you shared with the workspace from the AgentRQ Chrome extension, and the name and description of each WebMCP tool they offer, with a flag for whether your Chrome is online.

params: none
getSiteToolDefinition

Returns one shared site's tool in full, with its input schema and annotations. Read-only; the agent calls it before callSiteTool, so the listing stays small.

params: site, tool
callSiteTool

Runs a shared site's tool in your own Chrome, signed in as you. Anything the site does not mark read-only waits for your Allow once, Always allow or Deny in the task.

params: taskId, site, tool, arguments

Guide Claude with CLAUDE.md

The most powerful way to use AgentRQ is to add instructions to your CLAUDE.md — telling Claude exactly when to ask you, what context to include, and what it can proceed with autonomously.

Always ask before:
  • Irreversible operations (deletes, drops, deploys)
  • Schema migrations affecting production
  • External API calls with side effects
  • Spending money or quota
Proceed autonomously for:
  • Writing and refactoring code
  • Running local tests
  • Reading and analyzing files
  • Building and compiling
CLAUDE.md
## AgentRQ — Human-in-the-Loop

At the start of every session:
→ Call `getWorkspace` to load mission context.
→ Report what you're connected to.

Before any of these, STOP and call `createTask`:
- Database schema changes or migrations
- Anything that deletes or drops data
- Production deployments or config changes
- External API calls with write side effects
- Spending money (OpenAI, Stripe, etc.)

When creating a task, always include:
- What you've done so far
- Exactly what you need approval for
- The risk if they say yes
- The fallback if they say no

After human replies via channel:
→ Read the message carefully
→ Call `updateTaskStatus("completed")`
→ Continue with their instructions

# Be specific in tasks. Vague asks = slow unblock.

Built on Open Standards

No proprietary protocols. No vendor lock-in. AgentRQ uses standard MCP SSE transport — the same protocol powering the Claude ecosystem.

SSE
Transport
Server-Sent Events — lightweight, unidirectional, HTTP-native. Works everywhere, no WebSocket negotiation.
MCP
Protocol
Model Context Protocol — Anthropic's open standard for Claude tool integrations. First-class in Claude Code.
JWT
Auth
Signed MCP tokens with 1-year validity. No passwords stored.

One Config Line. Eighteen Tools. Full Control.

Connect Claude Code to AgentRQ in 60 seconds and start keeping humans in the loop — natively.

More Features