---
title: "Task Manager for AI Agents and Characteristics | AgentRQ Guidelines"
url: https://agentrq.com/guidelines/task-manager-for-ai-agents/ai-agent-task-manager-characteristics-memory-skills-workflows-schedulers-tools
description: "Every characteristic a task manager for AI agents needs, from memory, skills and workflows to schedulers and Mesher tools, why it matters and what it unlocks."
---

Checked November 22, 2026 | [All Task Manager guides](https://agentrq.com/guidelines/task-manager-for-ai-agents/)

# Task Manager for AI Agents and Characteristics

A task manager for AI agents is the place where people hand work to agents, agents ask people for decisions, and both sides can trust what comes back. It is not a to-do list with a bot attached. An agent forgets everything when its session ends, runs whatever it is allowed to run, and keeps working at three in the morning when nobody is watching. A human team needs to give it work, see what it is doing, approve what is risky and build on what it learned. So the task manager has to be built for both readers at once: the agent, which reads it over MCP, and the people, who read it on a board.

This page goes through every characteristic that makes that work, using AgentRQ as the worked example: **memory**, **skills**, **workflows and events**, **schedulers**, **tools with Mesher**, and the **human controls** that make it safe to let agents run. Each feature gets a small section of its own: what it is, why it is critical, and what it unlocks. Everything was checked against the AgentRQ and Mesher source code on November 22, 2026.

This page is part of our [task manager guidelines](https://agentrq.com/guidelines/task-manager-for-ai-agents/).

![The AI agent task manager loop in AgentRQ: at 09:00 the daily Nightly audit template spawns a run that claude picks up; claude loads the workspace memory index and the dep-audit skill, calls github.tools listAlerts through Mesher's callTool, and waits in Blocked on an Authorization Required card for npm audit fix --force until you click Allow Once; then it saves a memory and fires audit_finished, which gives the release-notes workspace a task that codex finishes.](https://agentrq.com/assets/sketches/agent-task-manager-loop.svg)

## The Short Answer

An efficient task manager for AI agents does seven things:

1. **Pushes work to agents** the moment it exists, from people, schedules and events, so no agent polls and no person has to wake one.
2. **Gives every task its context**: a shared memory of what earlier tasks learned, and skills that say how the team does this kind of work.
3. **Chains work** from one agent to the next with events and workflows, so people stop copying results between them.
4. **Runs routine work on a schedule**, once or on repeat, without anyone remembering it.
5. **Gives agents tools that are few, cheap and safe**: one tool for every service, results in fewer tokens, credentials kept away from the model. That is what Mesher does.
6. **Keeps people in control**: approvals for risky actions, a record of every step, and answers from any device.
7. **Scales from one agent to a team**: isolated projects, parallel agents, shared documents and teammates who can see each other's work.

The rest of this page takes each one apart.

## The Loop Every Agent Task Goes Through

Every task, from a one-line fix to a nightly audit, goes through the same five steps. Each step needs something from the task manager, and each step is where a weaker tool breaks.

1. **The work arrives.** A person writes a task, a schedule creates one, or an event from another agent or from GitHub does.
2. **The agent gets its context.** What this project already learned, and the playbook for this kind of job.
3. **The agent acts.** It reads code, calls APIs and runs commands.
4. **The agent asks.** A risky command, an unclear requirement, a choice only a person can make.
5. **The work finishes.** The result is reviewed, the lesson is saved, and the next piece of work starts on its own.

The animation at the top of this page is that loop in AgentRQ, start to finish. The sections below follow the same order.

## Part 1: Getting Work to Agents

### Isolated Workspaces

**What it is.** A [workspace](https://agentrq.com/features/workspace) is one project or mission with its own MCP address and token, its own task queue, memory, skills and settings, and its own folder on every machine that runs it. An agent connects with one workspace's token and sees that workspace alone.

**Why it is critical.** An agent that can see everything will eventually act on the wrong thing: a task from another project, a memory that belongs to another codebase, a permission meant for somewhere else. Isolation is also what makes a leaked token a small problem instead of a large one.

**What it unlocks.** You can run ten agents on ten projects from one account without any of them stepping on another. Each workspace can have its own rules, such as which commands are auto-allowed, and a mistake in one cannot spill into the next.

### Tasks With One Clear Status

**What it is.** A task is a description of the work, an assignee (the workspace's agent, or a person), and a status: Not Started, Ongoing, Blocked, Completed or Rejected. An agent pulls its next task, marks it Ongoing, and marks it Completed or Blocked when it is done or stuck. Before a Claude Code agent picks up a task, AgentRQ can [clear its context](https://agentrq.com/features/clear-context), so it starts the new task on a clean slate instead of carrying the last one.

**Why it is critical.** Agents do their best work on one goal at a time, with a context that is not full of the previous job. People need a status they can trust at a glance: a task stuck in Ongoing for an hour and a task waiting on them look very different, and they should.

**What it unlocks.** The status is the contract between the two sides. The agent uses it to say "I am on it", "I need you" and "done". The person uses it to know where to look. Nobody has to read a chat log to find out what is happening.

### Push, Not Poll

**What it is.** AgentRQ pushes a new task or a human reply straight into the running agent through [real-time notifications](https://agentrq.com/features/real-time-notifications): Server-Sent Events and Claude Code's channels. The agent does not ask "anything new?" over and over.

**Why it is critical.** Polling wastes turns and tokens, and it adds delay: an agent that checks every five minutes answers you up to five minutes late. An agent that is never woken does nothing at all.

**What it unlocks.** An idle agent costs nothing and responds in seconds. You can leave agents running all day and they act only when there is work, the way a teammate on call would.

### A Board People Can Read

**What it is.** The [task board](https://agentrq.com/features/task-board) shows every task as a card, as a list or a Kanban, on any device. Each card shows its status, its workspace and its agent.

**Why it is critical.** Agents read the task manager through MCP, but people do not. Without a view built for people, the only way to know what agents are doing is to open each terminal.

**What it unlocks.** A manager, a designer or an on-call engineer can see in a few seconds what every agent is doing, what is waiting on a person and what just finished, and act from a phone.

![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.](https://agentrq.com/assets/sketches/task-board.svg)

## Part 2: Memory and Skills

### Shared Workspace Memory

**What it is.** [Workspace memory](https://agentrq.com/features/workspace-memory) is a set of notes every agent in a workspace shares. One of them, the memory.md index, lists the others with a line each. An agent loads the index at the start of a task, loads the entries that matter, and saves what the next agent should know before it finishes. It works the same for Claude Code, Codex, Gemini CLI or any other agent, on any machine.

**Why it is critical.** Every agent session starts empty. Without memory, every task re-discovers the same things: the build needs a flag, the test suite needs a time zone, the staging database is read-only. The cost is not just tokens: the agent makes the same mistake again, and a person has to catch it again.

**What it unlocks.** The workspace gets smarter with every task, not just the agent that did it. You can swap Claude for Codex, add a second agent, or come back after a month, and the knowledge is still there. People can read and edit the same notes in the workspace's **Memories** tab, so a correction you make reaches every agent.

![AgentRQ workspace memory: claude starts a task in storefront-api by loading MEMORY.md, reads the build note it links to, then learns tests need TZ=UTC and saves that as a memory the index now links. The next day codex, in a fork that shares the workspace's memory, loads the index, reads the note and passes the tests first time. When both agents save tests.md at once, codex's save is refused because the version changed, so it loads it again, merges its line and saves version 3, and the agents celebrate.](https://agentrq.com/assets/sketches/agent-memory.svg)

### Versioned Memory Writes

**What it is.** Every memory has a version. An agent that changes a memory has to send the version it read. If another agent saved in between, the save is refused; the agent loads the new version, merges its change and tries again.

**Why it is critical.** Once several agents share one memory, two of them will write at the same time. Without versions, the second write silently erases the first, and you lose exactly the knowledge you wanted to keep.

**What it unlocks.** Many agents, in forks and on teammates' accounts, can write to one memory without a lock, a queue or a person refereeing. Nothing anyone learned is lost.

### Distributed Skills

**What it is.** A skill is a playbook: a SKILL.md file plus the files it points to, in the same format Claude Code uses. With [distributed skills](https://agentrq.com/features/distributed-skills), skills live in your AgentRQ account instead of in a folder on one machine. You import them from a GitHub link, write your own, or let an agent save one, then turn each one on in the workspaces that need it. Agents search for the skill that matches their task and load it over MCP. People can call one directly by typing / and its name in a task or reply.

**Why it is critical.** Without shared skills, each agent does the same job its own way, and each machine has its own copy of the instructions, slowly drifting apart. Improving the procedure means finding every copy.

**What it unlocks.** One playbook, one copy, every agent. Edit the code-review skill once and every agent in every workspace follows the new version on its next task, on any computer. New team members, and new agents, do things the team's way from day one.

![AgentRQ skills: you paste a GitHub link and import three skills, tdd, code-review and release, then turn them on in the api, web and docs workspaces. Each agent, claude, codex and agy, gets a task, finds the skill that matches and loads it; you edit code-review and the one copy updates in every workspace, and the agents finish and celebrate.](https://agentrq.com/assets/sketches/skills.svg)

### Skills on Demand, Not Up Front

**What it is.** An agent sees each skill's name and description first, and loads the full instructions only when a task matches. A person can force one with the / command.

**Why it is critical.** Pasting every playbook into every prompt fills the context window before the work starts, and an agent with too many instructions follows none of them well.

**What it unlocks.** You can keep dozens of skills, for releases, reviews, migrations and reports, and each task pays only for the one it uses.

### Presets for Repeated Instructions

**What it is.** [Presets](https://agentrq.com/features/presets) are saved messages. Type # and a name in any task or reply, and the full message takes the name's place.

**Why it is critical.** People repeat themselves to agents: "pull latest main, branch, open a PR with this template". Typing it each time is slow, and each version is a little different.

**What it unlocks.** The person's side of consistency. Skills make agents do the job the same way; presets make people ask for it the same way, in two keystrokes.

### Shared Documents on the Pano

**What it is.** The [Pano](https://agentrq.com/features/pano) is a board of Markdown docs every workspace in your account shares. An agent posts a plan or a report and hands its id to the agents that need it; they read it, comment and attach files. People see each doc as a post-it, edit it, and turn it, or one checklist item in it, into a task.

**Why it is critical.** Some context is bigger than a memory note and belongs to more than one workspace: a release plan, a research report, a glossary. Without a shared place, agents paste it into each other's tasks and the copies drift.

**What it unlocks.** One plan that several agents work from at once, with checklist items that tick themselves as their tasks finish. Docs are versioned like memory, so agents and people can edit the same doc safely.

## Part 3: Workflows, Events and Schedulers

### Events and Triggers

**What it is.** [Events](https://agentrq.com/features/events) are named signals, such as qa_passed or deploy_finished, that a task fires when it completes. A trigger subscribes a workspace to an event: when it fires, that workspace gets a new task, with the instructions you wrote for it.

**Why it is critical.** Without events, a person sits between every two agents: waiting for one to finish, reading its result, writing the next task. That person becomes the bottleneck, and the work stops at night.

**What it unlocks.** Hand-offs with no glue code and no human relay. QA passes, deploy starts; deploy finishes, the release notes get written. Each agent stays in its own workspace with its own tools, and the chain runs on its own.

### Workflows

**What it is.** A [workflow](https://agentrq.com/features/workflows) is events and workspaces arranged on a graph. Drag a workspace onto an event to subscribe it; drag an event onto a workspace to fire it when that workspace's task completes. The same graph can be written as an indented text document.

**Why it is critical.** Once you have more than a few events, nobody remembers which workspace listens to what. A process you cannot see is a process you cannot change safely.

**What it unlocks.** Your release process, your content pipeline or your incident response becomes a picture everyone can read and change. Adding a step is a drag, not a code change.

![AgentRQ workflows: you drag the release workspace onto the deploy_finished event. claude finishes the qa task, so qa_passed fires and a pulse runs into deploy, which gets a new task; codex deploys, deploy_finished fires and release gets its task; hermes writes the release notes and claude, codex and hermes celebrate.](https://agentrq.com/assets/sketches/events-workflows.svg)

### Hooks From Outside Services

**What it is.** A hook turns an outside HTTP request into an event. Point a GitHub webhook, or any curl, at a hook URL, and a failed CI run or a new issue becomes a task for the right workspace. The built-in GitHub hook checks the webhook's signature; a generic hook accepts a shared token.

**Why it is critical.** Much of the work agents should do starts outside the task manager: a red build, a security alert, a customer ticket. If a person has to notice each one and type a task, the agent is only as fast as that person.

**What it unlocks.** Agents that react to the world. A broken build at 2 a.m. already has an agent on it, and its task waits for you in the morning with the fix and the history. See [waking Claude on Dependabot alerts](https://agentrq.com/blog/dependabot-alerts-wake-claude-code-agent-with-agentrq-hooks) for a full example.

### Task Scheduling

**What it is.** [Task scheduling](https://agentrq.com/features/task-scheduling) gives a task a date and time, or a repeating cadence: every 15 minutes, hourly, daily, on weekdays, weekly or monthly. The task waits under **Scheduled** as a template; when it is due, AgentRQ creates a new task from it, and the workspace's agent picks that one up. A poller checks every minute, so no agent has to stay awake waiting.

**Why it is critical.** Routine work is the work people forget: the dependency audit, the error triage, the weekly report. Agents are ideal for it, but only if something starts them.

**What it unlocks.** Work that happens because it is due, not because someone remembered. Each run is its own task with its own thread, history and result, so you can compare this week's audit with last week's. A run can fire an event when it finishes, so a schedule can start a whole workflow. The [scheduling guides](https://agentrq.com/guidelines/tasks/schedule-a-repeating-task) show the steps.

![Scheduled cron agents in AgentRQ: you give Dependency audit a Repeated, Daily 09:00 schedule and it waits in Scheduled beside an hourly Triage issues and a weekly Release notes; at 09:00 each template spawns a fresh run that claude and hermes pick up; at 10:00 the hourly triage is skipped because its 09:00 run is still open, while the weekly notes run starts for agy; when it finishes it fires notes_ready, the deploy workspace gets Ship changelog for openclaw, and every run lands in Done as the agents celebrate.](https://agentrq.com/assets/sketches/scheduled-cron-agents.svg)

### Two Kinds of Schedule: With a Model and Without

**What it is.** AgentRQ schedules start an agent: the work needs judgment. Mesher, the tools layer below, has its own cron and workflows for work that needs no model at all: call a tool every 15 minutes, or chain three tool calls each weekday at 9.

**Why it is critical.** Waking a model to fetch a number or move a file is slow and costs tokens for nothing. Making a script do work that needs judgment fails the other way.

**What it unlocks.** Each job runs at the right level. Mesher fetches and prepares the data on a schedule, and an AgentRQ task brings in an agent only when there is something to think about.

## Part 4: Tools With Mesher

[Mesher](https://mesher.sh) is the tools layer of AgentRQ: an open-source host, built by the AgentRQ team at [github.com/agentrq/mesher](https://github.com/agentrq/mesher), that runs connectors for the services your agents use, such as Gmail, GitHub or an existing remote MCP server. AgentRQ decides what an agent should do and when; Mesher gives it the hands to do it. An agent connects to both: its AgentRQ workspace for tasks, memory and skills, and Mesher for tools. You can run Mesher yourself or use the hosted service at app.mesher.sh.

![Mesher tools for AgentRQ agents: claude has one MCP tool, callTool, and runs gmail.searchTools and then gmail@work.tools searchEmails through the Mesher host. The host checks the connector's allowlist and adds the work profile's token itself, so the agent never sees it, and a request to evil.example.net is denied. Switching the profile from JSON to TOON returns the same emails in 42% fewer characters. The live Trajectory then shows a cron schedule, the digest workflow run it starts, and that run's Gmail call, each with who made it.](https://agentrq.com/assets/sketches/mesher-tools.svg)

### One Tool for Every Service

**What it is.** Every connector installed in Mesher is reached through one MCP tool, callTool, which takes a command line: gmail.searchTools 'unread' to find a tool, gmail.tools sendEmail help to read its arguments, and gmail.tools sendEmail -b '{...}' to call it. The same commands run from a shell as mesher gmail tools sendEmail.

**Why it is critical.** Every MCP server an agent connects to adds its tool definitions to the context, whether the task needs them or not. Ten services can mean hundreds of tool definitions and thousands of tokens before the agent reads its task, and an agent choosing among hundreds of tools chooses worse.

**What it unlocks.** An agent can reach dozens of services and still start every task with one tool in its context. It searches for the tool it needs, reads its help, and calls it, the way a person uses a command line. A person can run the exact same command in a terminal to check what the agent saw.

### Credentials Stay on the Host

**What it is.** A connector is a sandboxed WebAssembly component. When it calls out, the Mesher host checks every request against the connector's allowlist of hosts and adds the user's credential itself: an OAuth token, an API key or a bearer token. The agent, and the connector code, never see it. Mesher handles the OAuth sign-in, refresh and storage.

**Why it is critical.** An API key in an agent's environment ends up in its context, its logs and, sooner or later, somewhere it should not be. An agent that can reach any host can be tricked into sending data anywhere.

**What it unlocks.** You can give an agent access to your email or your GitHub without giving it your password or token. A prompt injection cannot leak a credential the agent never had, or send data to a host the connector was never allowed to call.

### Profiles Keep Accounts Apart

**What it is.** A Mesher profile is a named set of connectors, each signed in to one account: gmail@work and gmail@personal side by side. Each profile chooses which connectors, and which of their tools, it exposes. An MCP app is let into one profile and sees only that profile's tools.

**Why it is critical.** One agent with access to every account is one mistake away from emailing a customer from your personal address. Different agents need different reach.

**What it unlocks.** Least privilege without extra servers. The support agent's profile exposes reading tickets but not deleting them; the release agent's profile exposes GitHub but not email. You change an agent's reach by ticking boxes, not by rewriting its setup.

### Results in Fewer Tokens

**What it is.** A profile, or a single call, can ask for results in TOON instead of JSON: the same data written as a compact table, with the field names once instead of on every row.

**Why it is critical.** Tool results are often the biggest thing in an agent's context: a list of fifty messages or issues repeats every key fifty times. That is tokens paid on every turn after.

**What it unlocks.** Longer tasks in the same context window, and cheaper ones. An agent can read a long list of results without pushing out the instructions it needs.

### Model-Free Cron and Workflows

**What it is.** Mesher's built-in cron connector calls any tool on a schedule, as a profile. Its workflows chain tool calls through small step functions, with retries, waits for events and parallel branches, and no model in between.

**Why it is critical.** Not every step of a process needs an agent. Fetching, filtering and posting are deterministic, and doing them with a model is slow, costly and less predictable.

**What it unlocks.** The deterministic part of a process runs reliably and cheaply in Mesher, and the judgment part runs in an AgentRQ task. Together they cover the whole process.

### Guard Rails for Calls

**What it is.** Mesher limits every call: requests per minute per organization, user and profile; a time and memory limit on each call; and a circuit breaker that stops calls to a service for a while when half of the recent ones failed.

**Why it is critical.** An agent in a loop can hammer an API thousands of times in minutes, run up a bill or get your account blocked. A failing service makes an agent retry over and over, burning tokens.

**What it unlocks.** Agents can run unattended without a runaway loop becoming an incident. A failing service fails fast, so the agent moves on or asks a person instead of retrying for an hour.

### A Live Trajectory of Every Call

**What it is.** Mesher's Trajectory view shows a profile's tool calls live: who made each one (an MCP app, a scheduled call, a workflow run), what it sent, what came back, how it ended and how long it took. Header values, where credentials live, are masked.

**Why it is critical.** When an agent's tool call goes wrong, you need to see the exact request and response, not the agent's summary of them.

**What it unlocks.** Debugging an agent's integration takes minutes. Together with AgentRQ's own tool call history, you can follow a task from the agent's decision to the exact API call it made.

### Agents That Add Their Own Tools

**What it is.** Mesher's built-in manage connector does what its web UI does, as tools: an agent can search the catalog, install a connector or connect an existing remote MCP server by its URL. The wasmrs built-in lets an agent write, compile and install a new connector in Rust on the host. Connectors can also ship skills that teach an agent how to use them.

**Why it is critical.** Sooner or later an agent needs a service you have not set up. Without a way to add one, the task stops until a person does it by hand.

**What it unlocks.** An agent can extend its own toolbox inside the same guard rails: the new connector is sandboxed, allowlisted, and signs in through you. Signing in to a service always stays a person's step.

## Part 5: Human Control and Trust

### Approvals for Risky Actions

**What it is.** When an agent wants to run a command it is not allowed to run on its own, AgentRQ shows an **Authorization Required** card on the task, with the exact command, and the choices **Allow Once**, **Always Allow** or **Deny**. The task shows as waiting on you until you answer, in the browser, the desktop app or on your phone, and in Slack the same request arrives as buttons in the task's thread.

**Why it is critical.** Without approvals you have two bad options: let agents do anything, or sit at the terminal and watch them. Neither scales.

**What it unlocks.** Agents work on their own until they reach something that needs a person, then wait for exactly that decision. You approve a production deploy from your phone in the queue for coffee, and the agent carries on.

![Managing agents by role in AgentRQ: claude, as supervisor, files four tasks into four role workspaces, api for codex, web for agy, qa for hermes and deploy for openclaw, and every card on the board shows its workspace and owner; hermes goes to Blocked and claude unblocks it; openclaw asks to run kubectl rollout restart deploy/api, the request waits as Authorization Required until you click Allow Once, and all four tasks land in Done as the agents celebrate.](https://agentrq.com/assets/sketches/roles-owners-approvals.svg)

### YOLO Mode, Per Task

**What it is.** Turn on [YOLO mode](https://agentrq.com/features/yolo-mode) for one task and every permission request its agent sends from then on is allowed automatically, and still recorded as auto-allowed. A workspace, an event trigger or a workflow step can create tasks with it on.

**Why it is critical.** Some work is safe to run unattended, such as a sandboxed refactor or a docs update, and approving every step of it wastes your time. But turning approvals off for a whole agent forever is a risk you take on every future task.

**What it unlocks.** Trust at the right size: one task, not the whole agent. Turn it off, and approvals come back for the next request.

### Tool Call History

**What it is.** Every task's [tool call history](https://agentrq.com/features/tool-call-history) lays out the run on three lanes, Input, Agent and Tools: each tool call, what it returned, and whether it was allowed or denied. You can search it and open any entry.

**Why it is critical.** "The agent says it fixed it" is not enough. To trust an agent's result, and to fix its mistakes, you need to see what it actually did.

**What it unlocks.** A full audit of every agent run, for reviews, for compliance and for teaching. When something goes wrong, you find the exact step in seconds.

### Task Timeline

**What it is.** Under every task, a [timeline](https://agentrq.com/features/task-timeline) shows each status it went through and for how long: working, waiting on you, blocked. The totals say how long the agent worked and how long it waited.

**Why it is critical.** When agents feel slow, the reason is often not the agent: it is a question that sat unanswered for two hours. Without the timeline, you cannot tell the difference.

**What it unlocks.** You can see where time really goes, across agents and people, and fix the slow part: answer faster, approve more by default, or split the task.

### Answer From Anywhere

**What it is.** AgentRQ runs in the browser, as a desktop app, on a phone, and in [Slack](https://agentrq.com/features/team-collaboration): one private channel per workspace, tasks created with /t, replies with @agentrq, and approvals as buttons in the thread, each attributed to the teammate who clicked it. Click the mic to [dictate](https://agentrq.com/features/speech-to-text) a task or a reply; the speech is turned into text on your device. A [message send delay](https://agentrq.com/features/message-send-delay) can hold each message for a few seconds, so you can cancel one before the agent sees it.

**Why it is critical.** An agent waiting on a person is an agent doing nothing. If the only way to answer is a laptop at a desk, agents stall every time you step away.

**What it unlocks.** Your agents keep working through your day, because their questions reach you wherever you are and your answers go straight back to the task.

## Part 6: Scaling From One Agent to a Team

### Machines and Live Terminals

**What it is.** Install the agentrqd daemon on a computer you own, enrol it once, and it becomes a [machine](https://agentrq.com/features/machines) where agents run in your repositories, with your toolchain. Start an agent in a workspace from AgentRQ, and open its live terminal from any browser.

**Why it is critical.** Agents need real computers with real code and real tools, and you need to start, stop and step into them without being at that computer.

**What it unlocks.** A fleet of agents on your own hardware, run from one place. When an agent takes a wrong turn, you open its terminal from your phone and press Esc.

### Workspace Forks

**What it is.** Fork a workspace to have a second agent take some of its tasks in parallel. The fork has its own queue and agent, shares the parent's memory, skills and settings, and works in its own git worktree. When its tasks are done, merge it back.

**Why it is critical.** When one agent has six tasks queued, the work waits. Setting up a second agent from scratch means copying all its context by hand.

**What it unlocks.** Parallel agents in one click, already knowing everything the first one knows. Because memory is shared, what the fork learns comes back too.

![AgentRQ workspace forks: claude has six tasks in the api workspace, so you fork it into api-fork and move three tasks there. codex works the fork while claude works api, both sharing the same memory, skills and settings; when the fork's tasks are done you merge it back, its three tasks return to api with their threads, and the agents celebrate.](https://agentrq.com/assets/sketches/workspace-forks.svg)

### A Supervisor Agent

**What it is.** The [Supervisor](https://agentrq.com/docs/supervisor-mcp) is an MCP server for your whole account. An agent connected to it can list and create workspaces, create tasks anywhere, read every workspace's memory and skills, wire events and workflows, launch agents on machines, and report on every workspace at once.

**Why it is critical.** Past a handful of workspaces, someone has to plan: split a goal into tasks, hand each to the right workspace, follow up on the stuck ones. Doing that by hand across many workspaces is a job in itself.

**What it unlocks.** One agent that manages the others, the way a lead manages a team, while each worker agent still sees only its own workspace.

### Teams

**What it is.** [Teams](https://agentrq.com/features/teams) let you share a workspace with teammates. You choose what to share: tasks, memory, skills, Pano docs. Teammates see your agents' tasks live, read-only. Their agents can read what yours learned, and everyone improves one set of skills.

**Why it is critical.** If every person's agents learn alone, a team of five learns the same lesson five times. If nobody can see anyone else's agents, the team cannot coordinate.

**What it unlocks.** People and their agents learn as one team. A fix one person's agent found reaches every teammate's agent on its next task, and everyone can see what is happening without being able to break it.

![AgentRQ teams, for people and their agents: Ada shares a workspace with teammates Ben and Cy, switching on Tasks, Skills and Memory, and each person hands their own agent a task. Ada's agent, claude, fixes an export timeout and saves what it learned to the team memory; Ben's agent, codex, reads that note before it starts and finishes with no wrong turns; Cy's agent, agy, improves the team's release skill and the new version reaches every agent.](https://agentrq.com/assets/sketches/teams.svg)

## The Checklist: What Makes a Task Manager Efficient

The same feature usually serves both sides in different ways. Use this table to judge any task manager for AI agents.

| Characteristic | What the agent gets | What the human team gets | In AgentRQ |
| --- | --- | --- | --- |
| Push, not poll | Work arrives the moment it exists | Nothing to babysit | Real-time notifications, events, scheduler |
| One task, one status | A single goal and a clean context | A board that shows who does what | Task board, statuses, clear context |
| Shared memory | Starts each task knowing what earlier ones learned | Knowledge that survives agent swaps | Workspace memory with an index and versions |
| Shared skills | The team's procedure, loaded on demand | One copy to improve | Distributed skills, the / command |
| Event-driven hand-offs | Knows when its input is ready | No glue code, no relaying results | Events, triggers, workflows, hooks |
| Schedules | Wakes for routine work by itself | Routine work never forgotten | One-time and repeating tasks, Mesher cron |
| Few, safe tools | One tool to learn, smaller results | Credentials out of prompts, calls allowlisted | Mesher callTool, profiles, TOON, sandbox |
| Guard rails | Fails fast on a broken service | No runaway loops or surprise bills | Mesher rate limits, call limits, circuit breaker |
| Approvals | Can ask instead of guessing | Decides risky actions from any device | Authorization Required, YOLO per task |
| Isolation | Sees only its own project | Mistakes stay in one project | Isolated workspaces, one token each |
| A record of every step | Can resume from its own history | Audits every command, sees where time went | Tool call history, task timeline, Mesher Trajectory |
| Parallelism | A helper that shares its context | More throughput without setup | Workspace forks, machines |
| Shared documents | Plans and reports by id | Edits and comments on the same doc | Pano |
| Team visibility | Learns from teammates' agents | Sees everyone's agents, read-only | Teams |

## How to Get Started

1. **Create a workspace** for one project and connect your agent to it. The [connect agents guides](https://agentrq.com/guidelines/connect-agents/) cover Claude Code, the ACP Gateway and machines.
2. **Give it a few tasks** and watch them move across the board. [Create a task in a workspace](https://agentrq.com/guidelines/tasks/create-a-task-in-a-workspace) shows the form.
3. **Let memory build up.** After a few tasks, open the workspace's **Memories** tab and read what the agent saved. Correct anything that is wrong.
4. **Add skills** when you notice yourself repeating instructions. [Use a teammate's skills](https://agentrq.com/guidelines/teams/use-a-teammates-skills) shows how to share them.
5. **Add events and schedules** when you notice yourself copying results between agents or remembering routine work.
6. **Add Mesher** when an agent needs more than a couple of outside services, or when you do not want it holding API keys. Connect it as an MCP server next to the AgentRQ workspace server: claude mcp add --transport http mesher https://app.mesher.sh/mcp for the hosted service, or the URL of your own server.

## Frequently Asked Questions

**What is a task manager for AI agents?**

It is the system where people give AI agents work, agents report progress and ask for decisions, and the results are kept. Unlike a task manager for people, it has to be readable by agents over a protocol such as MCP, push work to them instead of waiting to be checked, and give them context, tools and approvals.

**Is AgentRQ only for coding agents?**

No. Any agent that speaks MCP or the Agent Client Protocol can take tasks: Claude Code, Codex, Gemini CLI, Antigravity and many more. Research, writing, operations and support agents use the same memory, skills, workflows and approvals.

**Do I need Mesher to use AgentRQ?**

No. Agents can use their own tools and any MCP server. Mesher is the answer when an agent needs many services: one tool instead of dozens, results in fewer tokens, and credentials kept on the host instead of in the agent's environment.

**What is the difference between memory, skills and Pano docs?**

Memory is what the agents in one workspace learned, written by agents as they work. Skills are how to do a kind of job, written once and shared across workspaces. Pano docs are plans, reports and other documents that several workspaces and people work from at the same time.

**Which feature should I set up first?**

A workspace and tasks, then memory, which pays off from the second task on. Add the rest when you notice the problem it solves.
