# The same task goes to a human or an agent

> worklists.dev — 2026-08-20
> Written for ED-4 — the arriving self-principal agent — an agent that has been handed work by a dispatcher and needs to know whether it is a performer or a spectator here.

One thesis: **the same task goes to a human or to an agent, and the door does not change shape,
because a task is an Action at the human tier — not a different kind of thing.** A workflow step
that cannot be automated does not become a new object. It becomes slow and cancellable. And that
is what *an approval is a task* means.

## Four tiers, one object

An Action in this family is implemented at one of four tiers: code, generative, agentic, human. A
durable function, a model call, an autonomous agent, a person on a phone. These are not four
authorization models and not four data types. They are four answers to *how long does this take
to settle*.

At the code tier an Action settles as a promise. At the human tier it settles as a tracked handle
over a persisted item that resolves when a settle message arrives — never a held await, because a
hibernating process loses in-flight awaits. The return type differs. The Action does not.

So a Task is not a primitive. It is a fold over Actions at the human tier. Move the same Action
down a tier and it is an agent's pending work; move it up and it is a picker's next scan. Escalation
is literally *re-dispatch the same Action at the human tier*.

## The receiving count, twice

A PO for forty cases of lettuce dispatches a receiving task at dock 12. Two deployments:

**A human performs it.** The receiver points a camera at the pallet's SSCC. The
[barcode layer](https://barcoding.dev) decodes the mark and names the step; the identity rail
attests the person; the event lands on the [spine](https://epcis.dev) and returns a hash;
`complete(task, hash)` settles it.

**An agent performs it.** The agent has no camera, so the first step is whatever produced its
payload — a reading from a dock-door RFID portal, a line from the ASN, a reconciliation it
computed — and the provenance on those values says which. The remaining three steps are identical:
attest, capture, `complete(task, hash)`.

An agent that cannot present a hash has not completed anything either. The settle discipline is
tier-independent: the return is an attested artifact, never an acknowledgment. `true` is refused
from a person and from a process alike.

## An approval is a task

Now a different demand. The count comes back thirty-eight, not forty, and accepting the short
receipt needs a supervisor's sign-off. In most systems that is a separate thing — an approval
queue, a different inbox, a different data model.

Here it is a task. The request is an Action at the human tier, assigned to a role (`shift-lead`,
resolved to its current filler at invocation, never to a named person), pending in that role's
worklist next to every other pending thing. It closes with the same evidence shape: an attested act
by a real *who*, inside the window.

`escalate` is how an agent asks for it — agent requests, human approves, agent receives. It compiles
to the identity rail's ceremony; Worklists holds no authority and issues no grant. The task is the
request and the settle is the answer.

**The unit of one inbox is the tenant, not the human.** Within a tenant, an agent's pending tracked
work, a receiving task, and an approval ceremony are one queue, because they are one kind of
object. Across tenants they never merge — a worker with two employers genuinely has two worklists,
and merging them would break a guarantee the design depends on.

## Tier is orthogonal to authority

A common mistake is to give agents a service account with standing roles and give humans per-act
approval. Both are the wrong shape. Every invocation at every tier receives exactly the authority to
perform this act, arriving with the call and expiring with it. The tier changes how long it takes
to resolve, never how much it may do. A narrowed capability granted in advance is strictly better
than a per-act approval and strictly better than an ambient role — and it is also what keeps
notification volume bounded by human attention rather than by agent count.

## What an agent finds at the door

If you are an agent reading this, you are a performer here, not a spectator. `query` returns the
worklist for the principal the auth rail resolved — yours, never anyone else's, because the query
type has no assignee member. `claim` takes from a pool in your own name. `complete` takes your
event hash. `trace` shows you the lineage of anything you hold.

The five verbs that answer in the package `worklists.dev` are `query`, `trace`, `claim`, `complete`
and `timeout`; `assign`, `start`, `block`, `escalate` and the rest are declared, and the fold reads
their acts. Every verb is addressable as `worklists.dev.{verb}` when served as a tool.

Get started with a task, settle it once as a process and once as a person, and diff the two
records. The performer differs. The shape does not.

---
Get started: https://worklists.dev/get-access/ · All posts: https://worklists.dev/blog/ · Machine face: https://worklists.dev/llms.txt