# Agent Taskbay: A Human-in-the-Loop Console for A2A Agents

> Source: <https://dev.to/shashikanthgs/agent-taskbay-a-human-in-the-loop-console-for-a2a-agents-42c2>
> Published: 2026-11-19 11:32:08+00:00

**Key takeaway:** Agents that speak A2A can route human approvals through a shared console by setting tasks to input-required and advertising the approval-request extension, keeping execution in their own frameworks while Taskbay records what was approved and sent.

Your AI agents are running. Who is watching when they need a human?

One agent is waiting for deployment approval. Another needs clarification before it can continue an investigation. A third has been running for hours, and the engineer who started it has closed the browser. The agents may all speak [A2A](https://a2a-protocol.org). That shared protocol does not, by itself, give the team one place to see the pending decisions, assign an owner, or look up exactly what was approved.

[Agent Taskbay](https://taskbay.allsrc.dev) is the answer to that operational gap. It is a durable, self-hosted human operations console for A2A agents. It does not take over their execution. The npm package is [`agent-taskbay`](https://www.npmjs.com/package/agent-taskbay) (MIT), and [version 1.0.0](https://github.com/allsrc/agent-taskbay/releases/tag/v1.0.0) is the first stable release. The cover image is Home: what needs a person, the recent conversations, and the agents already connected.

`409`. Nothing is sent until someone reviews the current revision.`npx agent-taskbay`.
A chat window can hold one conversation with one agent. A team running several agents needs somewhere else. Questions, approvals, and tasks that run for minutes or days have to survive a closed laptop, and the person who should answer is often not the person who started the run. A decision kept in that place has to show what was approved, who approved it, and that the same version was the one sent.

The same rule, inside a single harness, is the [HITL approval gate](https://www.allsrc.dev/posts/pattern-hitl-approval-gate/) on allsrc.dev: approve an action, not a session. Taskbay carries it onto A2A, so any agent that speaks the protocol can use the console, in whatever language or framework it is written.

*Execution stays with the agents. Taskbay is the console in front of the protocol.*

If you use LangGraph, Google ADK, or another agent framework, you may already have human-in-the-loop capabilities. You can pause execution, request human input, and resume when a decision arrives.

Agent Taskbay does not replace those mechanisms. It solves a different problem.

Framework-level HITL is an execution capability. Taskbay is a human operations capability.

Framework HITL makes an agent interruptible. Agent Taskbay makes human intervention operationally manageable across A2A agents.

Consider a system with several agents:

Each agent may use a different framework. Each framework can manage its own execution state, checkpoints, and interruptions.

But where does an operator go to see all these requests? Who owns each decision? What happens when the assigned reviewer is unavailable? How do teams track pending work, escalate overdue tasks, or inspect what happened afterward?

These are operational concerns, not execution concerns.

Agent Taskbay provides a shared human-facing console for A2A-compatible agents. It brings task visibility, human requests, approvals, assignments, and audit history into one place.

The division of responsibility is intentional:

Your agents continue to run in their existing frameworks. Taskbay does not need to become their orchestrator.

The objective is not to introduce another way to implement HITL inside an agent. It is to make human participation manageable when multiple agents, tasks, and operators are involved.

A framework pause shows up in Taskbay when the agent puts the task in `input-required` and advertises the [approval-request extension](https://taskbay.allsrc.dev/docs/reference/extensions/approval-request). Typed questions use the [structured-form extension](https://taskbay.allsrc.dev/docs/reference/extensions/structured-form) the same way. The agent, in its own runtime, checks the decision before it performs the action. Taskbay supplies the reviewed decision and the record of the send.

Home counts reachable agents, items waiting on a person, active tasks, and unread notifications. Inbox is the list across agents: tasks that need input, and approvals still open. The views are what needs you, what is yours, what is overdue, what is active, and what is done. The list can be narrowed by risk.

An approval is one proposed action on one task. A reviewer with operate access settles it in one of five ways: approve, edit and then approve, reject, request changes, or delegate. Approve sends the reviewed action once, after a confirmation. An edit is recorded as a new revision and sent. Reject and request-changes send nothing. Delegate hands the open request to another eligible reviewer. Every outcome except a plain approval needs a rationale. Separation of duties is on by default, so the person who opened a request cannot decide it. An approval the agent opened has no requester. An assigned request is decided by the assignee or an administrator.

The [README](https://github.com/allsrc/agent-taskbay) also covers the work around the decision. A person can claim a task, assign it to someone who can operate that agent, and set a due time. An administrator names who receives overdue work, for the organization or for one agent, and overdue tasks are escalated once to that person. Extra input to a running task is reported as delivered, answered, refused, or still unknown. **Stop and restart with this** cancels the task and starts a new one in the same context.

Connect an agent by its Agent Card, start a task, and the inbox is where the human part lands.

*Three demo agents, connected by card URL.*

*Inbox, on Needs you. A high-risk approval sits in the same queue as ordinary questions.*

*A task page: history, and the audit line for the approval the agent requested.*

The proposal is stored as a numbered revision and is not edited in place. Its digest is the SHA-256 of the canonical JSON of the action, with object keys sorted at every level. The reviewer names the revision they read. The field list, the media type, and the message that carries the digest back to the agent are in the [approval-request extension](https://github.com/allsrc/agent-taskbay/blob/main/docs/reference/extensions/approval-request.md).

Here is the rule with a deploy as the example.

An edit by the reviewer works the same way. It becomes a new revision, with its own digest, and that revision is what gets approved. A rejection or a request for changes sends nothing. The decision and the command commit together, the approved action goes out once, and the page records whether the delivery succeeded. An unknown delivery is not sent again.

*The audit trail. Decisions, revisions, and the delivery sit in an append-only record.*

Three roles cover the console: `admin`, `operator`, and `viewer`. Teams, and grants per agent and per skill, decide who can read and who can operate. The trail keeps the proposal, the digest, the rationale, the reviewer, the delivery, and the ownership events. Database triggers reject updates and deletes of decisions and revisions. How commands are stored before they are sent, and how the screens keep reading that record after a restart, is covered in [durable tasks](https://taskbay.allsrc.dev/docs/concepts/durable-tasks). Ownership, due times, and escalation are in [human in the loop](https://taskbay.allsrc.dev/docs/concepts/human-in-the-loop).

The project is on the [Allsrc projects page](https://www.allsrc.dev/projects/). [a2a-wrapper](https://github.com/shashikanth-gs/a2a-wrapper) exposes Claude, Codex, Copilot, OpenCode, and Antigravity as A2A servers, each with a card Taskbay can connect to. Source is in the [repository](https://github.com/allsrc/agent-taskbay).

You need Node.js 22.19 or newer. No database server, no account, and no `.env` file.

```
npx agent-taskbay
```

The console listens on `http://127.0.0.1:3002`, opens the browser, and signs you in as a local administrator. The database is `~/.agent-taskbay`. The process binds to this machine only.

In a second terminal, start the sample agents. They are fixtures.

```
npx agent-taskbay demo-agent
```

It prints five Agent Card URLs on port 4010. Use the showcase card. Open **Agents**, choose **Add agent**, and paste:

```
http://127.0.0.1:4010/showcase/card.json
```

Choose **Fetch Agent Card**, then **Continue**, then **Connect**. Open the agent, choose **Start chat**, and send:

```
please approve the deploy
```

Open **Inbox**. Under **Needs you** the pending approval is "Delete the staging cluster", marked **High risk**. Review the proposed action, choose **Approve**, and confirm. The approval becomes `approved`, the content you reviewed is sent once, and the task completes. **Administration → Audit trail** lists the steps.

The [quickstart](https://taskbay.allsrc.dev/docs/quickstart) covers the same path from a checkout, including a task started elsewhere. Issues go to the [repository](https://github.com/allsrc/agent-taskbay/issues).

*Originally published on [allsrc.dev](https://www.allsrc.dev/posts/agent-taskbay-human-in-the-loop-console-for-a2a-agents/).*
