---
title: "MCP Integration — 7 Native Tools for Agents | AgentRQ"
url: https://agentrq.com/features/mcp-integration
description: "AgentRQ gives agents 7 native MCP tools for tasks, replies, attachments, events, memory, skills, shared websites and docs. One config line to connect."
---

Human-in-the-Loop Task Manager for AI Agents

[AgentRQ](https://agentrq.com/) / [Features](https://agentrq.com/features/)

MCP Native Integration

# 7 MCP Tools. One Config Line.

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

.mcp.json — one snippet, 7 tools unlocked

```
{
  "mcpServers": {
    "agentrq": {
      "type": "http",
      "url": "https://WORKSPACE_ID.mcp.agentrq.com/mcp?token=TOKEN"
    }
  }
}
```

Tools available after connecting:

✓ task

✓ memory

✓ skills

✓ workspace

✓ siteTools

✓ pano

✓ help

## The 7 MCP Tools

Each tool covers one part of the Claude ↔ Human collaboration loop, with a short list of actions.

`task`

Claude's way to work with you. It opens a task with full context and files, pulls the next one from the queue, moves it from ongoing to completed or blocked, posts replies you see in the dashboard, asks you a question and waits for the answer, and fetches the files you attach.

actions: create, get, updateStatus, reply, elicit, getAttachment

`memory`

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. `MEMORY.md` is the index; detail lives in named memories linked from it.

actions: load, save, delete

`skills`

The playbooks this workspace can use, its own and those shared into it. Search returns only names and descriptions, so having many skills stays cheap; load reads one file of a skill when the task needs it, and save writes back what the agent learned.

actions: search, load, save, delete

`workspace`

Reads the workspace's title and the mission you set, so Claude starts every session with the project's goals. publishEvent fires a named signal when a stage finishes, and every subscribed workspace gets its next task automatically.

actions: get, publishEvent

`siteTools`

The websites you shared from the AgentRQ Chrome extension and the WebMCP tools they offer. Claude finds a tool, reads its definition, then runs it in your own Chrome, signed in as you. Anything the site does not mark read-only waits for your Allow or Deny in the task.

actions: search, getDefinition, call

`pano`

Markdown docs shared by every workspace on your account: a release plan, a runbook, a handoff note. Agents write and read them, comment on them and attach files, so work in one workspace is visible from the next.

actions: save, read, comment, attach, delete

`help`

Explains everything else. With no payload it lists the tools; with a tool name it lists that tool's actions; with `task.create` it prints the exact payload and an example call.

actions: {}, {"action": "task"}, {"action": "task.create"}

Every tool takes an action and a payload. Claude calls `task {"action": "create", "payload": {"title": "…", "body": "…"}}`, and when it is unsure what an action needs, `help` tells it. Clients you already installed keep working: the old tool names, such as createTask and loadMemory, still answer.

## 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 `workspace get` to load mission context.
→ Report what you're connected to.

Before any of these, STOP and call `task create`:
- 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 `task updateStatus` with status "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. Seven Tools. Full Control.

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

More Features

[Real-Time Notifications Zero-latency push — your reply reaches Claude in <50ms](https://agentrq.com/features/real-time-notifications) [Task Board Visual command center — see every Claude request at a glance](https://agentrq.com/features/task-board) [Workspaces Isolated environment per project with dedicated MCP tokens](https://agentrq.com/features/workspace)