---
title: "How to Enable YOLO Mode in AgentPool | AgentRQ Guidelines"
url: https://agentrq.com/guidelines/yolo-mode/agentpool
description: "AgentPool YOLO mode: requires_tool_confirmation: never in the agent's YAML, or the Never mode over ACP. The always, never and per_tool modes explained."
---

Checked October 30, 2026 | [All YOLO Mode guides](https://agentrq.com/guidelines/yolo-mode/)

# How to Enable YOLO Mode in AgentPool

AgentPool's YOLO mode is a line of YAML: set `requires_tool_confirmation: never` on an agent and it runs every tool without asking. Over ACP the same setting appears as a session mode called **Never**. The catch is that AgentPool's default, `per_tool`, already asks very little.

This page is one of our [YOLO mode guides](https://agentrq.com/guidelines/yolo-mode/), and part of our guide to [YOLO mode in every coding agent](https://agentrq.com/blog/what-is-yolo-mode-and-how-to-turn-it-on-in-every-coding-agent). Everything below was checked against the AgentPool source and docs (phil65/agentpool, version 2.9.18) on October 30, 2026.

![Animated sketch of YOLO mode in AgentRQ: claude waits to run go test, YOLO is flipped on for the task, and every later edit and test run lands auto-allowed in the Trajectory view](https://agentrq.com/assets/sketches/yolo-mode.svg)

## AgentPool's Three Confirmation Modes

AgentPool is a framework for defining agents in a YAML manifest, not a single agent. Each native agent has a tool confirmation mode:

| Mode | What it does |
| --- | --- |
| `always` | Ask before every tool call |
| `per_tool` (default) | Ask only for tools marked `requires_confirmation` |
| `never` | Never ask, whatever the tools say |

`never` is YOLO mode. `per_tool` is the default, and AgentPool's tool factories set `requires_confirmation` to false unless you pass true, so under the default an agent asks only about the tools you marked.

## How to Enable YOLO Mode in AgentPool

Set it per agent in your manifest:

yaml

```yaml
agents:
  coder:
    model: openai:gpt-5
    requires_tool_confirmation: never
```

When AgentPool runs as an ACP server (`agentpool serve-acp agents.yml`), it advertises the three modes to the client as session modes, with the ids `always`, `never` and `per_tool` and the names **Always**, **Never** and **Per Tool**. Switching to Never from the client is the same as the YAML setting, for that session.

### The Halfway Option

`per_tool` is the halfway point: mark the risky tools with `requires_confirmation` and leave the rest free. At a prompt, **Always Allow** approves that tool for the rest of the session, and **Always Deny** blocks it.

### Sandbox

AgentPool can run an agent's commands in a different execution environment, such as a Docker container or an E2B sandbox, configured with the agent's `environment` key. YOLO doesn't change the environment. In an ACP session the default environment is the ACP client's.

## How to Enable YOLO Mode in AgentPool Through AgentRQ

AgentPool's own switch is fixed per agent in YAML. AgentRQ lets you make the decision per task, and answer from somewhere other than the terminal.

### Approve From the AgentRQ Task Instead of the Terminal

Connect AgentPool to an AgentRQ workspace through the [ACP Gateway](https://agentrq.com/docs/connect-acp-agent) ([AgentPool setup guide](https://agentrq.com/docs/agents/agentpool)), wrapping its ACP command:

bash

```bash
npx @agentrq/acp-gateway@latest -- agentpool serve-acp agents.yml
```

Then set `requires_tool_confirmation: always` on the agents you want supervised. Under `never` AgentPool asks nothing, and under the default `per_tool` it asks only about marked tools, so most calls would never reach AgentRQ. AgentPool's mode names don't say "ask", so don't count on AgentRQ picking the mode for you: set it in YAML.

With `always`, each permission request shows up in the AgentRQ task on the web, on your phone or in Slack, together with the call it is asking about. Answer **Allow Once**, **Always Allow** or **Deny** from wherever you are, and AgentPool carries on. If nobody answers within 30 minutes, the gateway cancels the turn instead of guessing. Change the limit with `--permission-timeout`.

If your pool includes other ACP agents, their permission requests are forwarded up the same way, unless you set `auto_approve: true` on that agent's entry, which grants them all.

### Turn On YOLO for One Task

Flip the **YOLO** toggle on a task, or when you create it, to put just that task in [YOLO mode](https://agentrq.com/features/yolo-mode). Every permission request in it is approved automatically and AgentPool never waits, while every other task in the workspace still asks. [Scheduled tasks](https://agentrq.com/features/task-scheduling), [event triggers](https://agentrq.com/features/events) and [workflow](https://agentrq.com/features/workflows) steps have the same switch, so an unattended job can run in YOLO while your interactive work stays supervised.

![The YOLO toggle on a task in AgentRQ being switched on, then off again](https://agentrq.com/assets/guidelines/yolo-mode-task-toggle.gif)

### Turn YOLO On or Off in Workspace Settings

To make YOLO the default for a whole workspace, open the workspace, go to **Settings**, choose the **Automations** tab and flip **YOLO Mode (Execute All)**. Click **Update Workspace** to save. Switch it off the same way. The switch is off by default, and every permission request in the workspace is approved automatically while it is on.

![Workspace Settings in AgentRQ: the YOLO Mode (Execute All) switch turned on and saved, then off and saved](https://agentrq.com/assets/guidelines/yolo-mode-workspace-settings.gif)

### A Safe YOLO Setup for AgentPool

- → **Use always, then relax per task.** With `requires_tool_confirmation: always` in YAML, the AgentRQ toggle decides which tasks run free.
- → **Allow the boring tools, not everything.** **Always Allow** adds the tool to the workspace's auto-approved list, so the routine calls stop asking and the risky ones still do. Prune that list in workspace settings now and then.
- → **Leave the workspace-wide switch off.** Turn YOLO on per task instead, so it never outlives the job you trusted.
- → **Use an execution environment.** Point the agent's `environment` at a container or a remote sandbox for YOLO work.
- → **Commit first.** Start every YOLO task from a clean git tree, so any change is one `git reset` away.
- → **Read the record.** The [tool call history](https://agentrq.com/features/tool-call-history) lists every call the task made, including the ones that were auto-approved.

## FAQ

**How do I enable YOLO mode in AgentPool?** Set `requires_tool_confirmation: never` on the agent in your YAML manifest, or pick the Never mode from an ACP client.

**What is AgentPool's default confirmation mode?** `per_tool`. The agent asks only about tools marked `requires_confirmation`, and tools are unmarked unless you mark them.

**How do I make AgentPool ask before every tool?** Set `requires_tool_confirmation: always`. Over ACP, the requests go to the client as permission requests.

**Does AgentPool have a sandbox?** It can run an agent's commands in another execution environment, such as Docker or E2B, set with the `environment` key.

**How do I approve AgentPool tool calls remotely?** Run `agentpool serve-acp` behind [AgentRQ](https://agentrq.com)'s ACP Gateway with `requires_tool_confirmation: always`. Its permission requests show up in the task on the web, your phone or Slack.

For every other agent, see [what YOLO mode is and how to turn it on in every coding agent](https://agentrq.com/blog/what-is-yolo-mode-and-how-to-turn-it-on-in-every-coding-agent).