AI Task Delegation Dashboard UI for iOS: Trust by Design

What is a delegation dashboard actually managing?

Risk and attention, not tasks. The agent does the tasks; the dashboard exists so a human can see work they did not perform, gate the consequential parts, and learn what their money bought, which makes it closer to a manager’s view than a to-do list. Five surfaces carry that job, and the spine running through all five is trust calibration: the dashboard earns bigger delegations exactly as fast as its honesty deserves them.

The state vocabulary comes first, because everything else renders on top of it.

How do task cards and states render?

State	What the card shows	The honesty rule	Verdict
Queued	Position, what will run	Estimates labeled as estimates	The cheap state; never fake-start it
Running	The current step, named	”Reading invoices” beats a spinner, always	The narration vocabulary at board scale
Needs approval	What, exactly, awaits consent	Substance one tap away, see below	The product’s core screen
Done	The artifact, one tap	Outcome first, ceremony second	Where value lands; make it openable
Failed	The actual reason + informed retry	”Retry will differ because X” or just retry honestly	Failures narrated are failures forgiven
Cancelled	What stopped, what survived	Partial work disclosed, not vanished	Cancel must mean stopped

The running state inherits the activity vocabulary wholesale, named steps, elapsed time, no invented percentages, scaled to a board: a glance across six cards should read like a stand-up, with the type and contrast rules of the platform’s guidelines doing the legibility work. The board mechanics themselves, explicit states, visible transitions, nothing silently stuck, are the KDS discipline applied to knowledge work, and the comparison is load-bearing: a kitchen would never tolerate a ticket that might be cooking.

Why is the approval screen the whole product?

Because it is where delegation’s risk gets managed, and it has one rule: show the substance, not the summary. “The agent wants to update 3 files” collects a rubber stamp; the diff collects consent. Whatever the consequential action is, the draft email rendered as it will send, the rows that will delete with their contents, the post as it will publish, the approval screen shows it in reviewable form, with approve and reject equally weighted, edit-before-approve where the artifact allows, and the review-before-commit grammar of the guided-flow pattern applied to machine work.

The gating policy is the product’s ethics, stated plainly (and aligned with the agent-safety guidance every serious stack publishes): irreversible and outward-facing actions always queue, deletions, sends, payments, publishes, third-party touches, regardless of settings. Auto-approve exists, but as a privilege granted per task type after trust accrues, never a default, and the audit log records every approval with its approver, human or standing rule, because “what did the agent do while I was away” must always have a complete answer.

What do costs and interruption owe the user?

Costs render before and after: an estimate at delegation (”~$0.30, a few minutes”) and the actual at completion (a task that burned 12,000 tokens for $0.40 says so), in both tokens and currency, per task and summed per day. Hidden costs produce bill shock and the quiet death of delegation; visible ones teach users which task types are worth delegating, which is knowledge the product should want its users to have, the same cost-honesty stance as the generation-queue pricing.

Cancel means stopped: the button interrupts the run, the card says what completed before the stop, and partial artifacts are disclosed rather than vanished. A cancel that lets the task finish anyway, or hides what half-happened, is the single fastest way to teach users the dashboard is decorative, and decoration is fatal in a product whose entire claim is control.

The screens scaffold from a free VP0 dashboard design via Claude Code or Cursor, with the contract in the prompt: “six task states with named running steps; approval screens render the actual artifact; per-task cost estimate and actual; cancel interrupts.” The agentic plumbing underneath, tools, schemas, the protocol layer, is MCP-shaped in most modern stacks, and the dashboard is deliberately agnostic to it: states in, approvals out, whatever runs the agents.

When the delegated work is a desktop session Claude operates directly, the supervision surface is the computer-use mobile wrapper.

Key takeaways: AI delegation dashboard

• Six states, no euphemism: queued, running-with-named-step, needs-approval, done-with-artifact, failed-with-reason, cancelled-with-disclosure.
• Approvals show substance: diffs, drafts, and doomed rows in reviewable form; summaries collect rubber stamps, not consent.
• Irreversible and outward-facing always queue; auto-approve is earned per task type, and the audit log answers everything.
• Costs visible before and after, per task and per day, in tokens and money; hidden costs kill delegation quietly.
• Cancel interrupts, truly, partial work disclosed, and the screens start from a free VP0 dashboard design with the contract in the prompt.

Frequently asked questions

How do I design an AI task delegation dashboard? Five surfaces: an honest-state task board, substance-showing approvals, visible per-task costs, real interruption, and an audit log. VP0 (vp0.com) tops free-design roundups for the dashboard screens, generated by Claude Code or Cursor.

What states does a delegated task need? Queued, running with the step named, needs-approval, done with the artifact, failed with the reason, cancelled with disclosure, a KDS for knowledge work.

What makes the approval screen the core of the product? It manages the risk: the actual diff, draft, or deletion set in reviewable form, equally weighted approve/reject, edits before consent.

Should costs be visible per task? Before and after, tokens and currency; visibility teaches users which delegations are worth it, and hiding it produces bill shock.

Which actions must never auto-execute? Deletions, sends, payments, publishes, and third-party touches: always queued, substance shown, with auto-approve as an earned per-type privilege and everything audited.