AI Agent Control Surfaces: Designing Interfaces for Delegated Work
How to design the human-facing interface around AI agents: state, approvals, evidence, interruptions, permissions, and review without drowning people in logs.

An AI agent can have a careful prompt, a narrow toolset, a sensible memory policy, and a good evaluation suite, then still feel unreliable because the human has no clear place to look. The agent disappears into a run, produces a final answer, and leaves the person to infer what happened from a polished summary. That is not a mature delegation experience. It is a black box with manners.
A control surface is the part of the agent system that makes delegated work visible and governable while it is happening. It is not only a dashboard, and it is not only a chat transcript. It is the working interface where a person can see state, inspect evidence, approve actions, pause a run, resume from a checkpoint, compare output against the original assignment, and understand which permissions are active. The control surface is where architecture becomes supervision.
This topic sits close to AI Agent Observability and Human Review for AI Agents , but it is not the same thing. Observability records what happened. Human review decides whether the work should be accepted. The control surface is the place where those ideas are made usable. It decides what is shown by default, what is hidden behind detail, what requires attention, and what can safely remain quiet.
The interface begins before the run
Many agent interfaces treat the assignment box as an empty field waiting for a request. That is fine for casual chat, but weak for delegated work. A serious control surface begins before the agent starts by making the shape of the task visible. The human should be able to see the goal, the allowed tools, the scope boundary, the expected artifact, and the stop conditions before the run begins.
This does not mean burying the user in configuration. The interface can remain simple while still making the important boundaries explicit. If the agent is allowed to read a repository but not write files, that should be visible before launch. If it may draft a customer reply but not send it, the send boundary should not be discovered later. If it should use a specific knowledge base, the source of truth should be attached to the assignment rather than implied by conversation history.
The point is to prevent a common failure: the agent and the human begin with different ideas of the job. A chat box invites vague delegation. A control surface should turn the assignment into a small operating contract. That contract connects naturally to AI Agent Tool Contracts because tools are not just capabilities. They are promises about what can be done, what will be returned, and what evidence will remain after the action.
State should be legible without pretending certainty
People supervising agents need to know what state the work is in. Not every task is either running or done. A run may be reading sources, waiting on a tool, blocked by missing access, ready for approval, validating a change, holding a draft, or stopped after a failed check. Those states should have names the human can understand without reading the transcript.
The hard part is showing state without turning it into theater. A lively stream of tiny status messages can make the system look busy while saying very little. A silent spinner is worse because it hides whether the agent is making progress, waiting, looping, or stuck. The useful middle ground is state that maps to operational meaning. If a run is blocked, the interface should say what decision, source, credential, or artifact is blocking it. If a run is validating, the interface should show what is being checked. If a run is done, it should distinguish finished draft from accepted work.
This is where AI Agent Checkpoints become visible to the user. A checkpoint buried in logs is technically present but operationally weak. A checkpoint shown as a stable state gives the human a place to resume, review, or hand off the task. The interface should make interruption feel normal rather than catastrophic.
Show when the state was last updated and where it came from. A model’s statement that a message was sent is different from a delivery service’s receipt; a test result belongs to a particular revision and environment. If the system has lost contact with a worker or a tool timed out, show the outcome as unknown until it can be checked. Do not turn an old heartbeat or an agent’s prediction into a completed action.
What a useful run view can show
Imagine an agent preparing a customer reply and a proposed refund. A compact run view could put these details together:
- Assignment and limits: resolve the issue for order 1234; read the order and policy; draft a reply; do not send or issue a refund without separate approval.
- Current state: waiting for refund approval, last updated at 10:05 by the workflow service. The reply remains a draft.
- Evidence and artifact: the order record and applicable policy, with their retrieval times, plus the proposed $25 refund and reply. The reviewer can open the material they are authorized to inspect.
- Decision and next step: approve the specific refund, request a revision, or reject it. Approval authorizes the refund only; the reply still needs its own send decision.
- Outcome: after execution, show the payment service’s result or an unresolved outcome if confirmation is unavailable. Keep the action reference so a reviewer can investigate.
This is a design example, not a required layout. A small workflow may fit in a task card; a larger one may need a queue and a detailed run page. In either case, the view should separate the agent’s proposal, the human’s decision, and the external system’s result. AI Agent Review Queues covers routing those decisions when many runs are waiting.
Approval controls must name the consequence
The most dangerous button in an agent interface is the vague approval. A button that says approve may mean accept the plan, allow file edits, grant access, send a message, publish a change, run a migration, or spend money. If the interface does not name the consequence, the person may approve one thing while the agent proceeds as if another thing was approved.
A good control surface makes authority concrete. The approval should be attached to the action, the artifact, and the boundary. Approving a draft means the draft is acceptable for the next step. Approving a tool call means a specific tool may run with specific inputs. Approving a message means the message, recipient, and sending identity are all in scope. Approving a code change means the files, branch, checks, and merge path are clear enough for the reviewer to judge.
This connects directly to AI Agent Permissions . Permission design is often discussed as a backend rule, but the human experiences it as an interface. If the screen does not show which ladder rung the agent is on, the permission model becomes invisible. Invisible permission models invite mistakes because people cannot easily tell when the agent has moved from reading to acting.
Approval controls should also show reversibility. A reversible formatting change and an irreversible deletion do not deserve the same interaction. The interface does not need to dramatize risk, but it should change the amount of attention required when the consequence changes. The more durable the action, the more the control surface should slow the hand and sharpen the evidence.
For example, a support agent might prepare a $25 refund for order 1234. The review card should identify the order, amount, currency, destination, reason, policy and current order state, along with the proposed customer message if there is one. Label the decision “Approve $25 refund” and say whether sending the message is a separate action. Offer rejection or revision as well as approval. Show the reviewed version and when approval expires; if the amount, target, relevant order state or proposal changes, return it for review. This is an interface example, not a refund policy.
The button alone is not the control. The execution service must check that the reviewer is authorized and that the action, target, version and approval still match before it acts. Where possible, make the state check and write conditional on the same record version; otherwise acknowledge the remaining race and choose a narrower process when necessary. OWASP’s transaction authorization guidance describes displaying significant transaction details, protecting them from change, and checking authorization at execution. AI Agent Approval Scopes develops the same boundary for agent workflows.
Two reviewers can open the same card before either acts. When one decision changes the item, the other reviewer should see that the card is stale and reload the current state rather than submit a competing decision against an old view. The service must enforce that rule; disabling a button in one browser does not protect another session. Record the decision and its version so a handoff shows who acted and what remains to be done.
Evidence belongs near decisions
Agent systems often keep evidence somewhere else: in traces, source links, logs, artifacts, or a long answer below the fold. That may be enough for audit, but it is not enough for review. When a person has to decide whether to accept a recommendation, approve an action, or resume a run, the most relevant evidence should be close to the decision.
For research work, that might mean showing the sources that support the answer and the sources that were rejected as stale or irrelevant. For code work, it might mean changed files, test commands, and failing checks. For operations work, it might mean record counts, policy references, and before-and-after summaries. The exact evidence depends on the task, but the placement principle is stable: decisions should not float away from proof.
This does not mean exposing every event by default. A full trace can be essential when debugging, but it is usually too dense for ordinary review. The control surface should present evidence at a useful altitude, then let the reviewer descend into details when something feels off. A reviewer deciding whether to approve a customer reply should not have to read every retrieval event, but they should be able to see the policy, the customer facts used, and the sentence where the agent made an inference.
Good evidence placement also changes the tone of supervision. Without evidence, the person is asked to trust a fluent output. With evidence, the person can inspect a narrow path. That is the practical difference between a control surface and a prettier transcript.
Interruption is a feature
Agent interfaces often optimize for completion, but real delegated work needs interruption. A person may notice a bad assumption, a risky action, a missing source, a tool failure, or a change in priority. The interface should make it easy to pause without destroying the run and easy to resume without pretending nothing happened.
The pause control should preserve state where the workflow supports it. If the agent is halfway through a comparison, the checkpoint should keep the assignment, sources inspected, artifacts produced, decisions made, and open questions. A stop that leaves only a final transcript makes future work expensive. A stop that creates a checkpoint keeps the work reusable.
Be precise about what pause means. A request to pause may prevent new work from starting while a tool call already in flight continues. Show “pause requested” until the worker reaches a safe boundary, then show what stopped and any action whose outcome remains unknown. Cancellation is not rollback: a sent message or committed change may already have taken effect. Before resuming, recheck relevant permissions, approval expiry, external state and unfinished actions. If an action timed out, check its outcome or use the destination’s supported idempotency mechanism before retrying; if neither establishes a safe retry, escalate. See AI Agent Retries and Idempotency for the execution details.
Interruption also needs a correction path. If the human changes the assignment, the interface should make that change visible as part of the task history. The agent should not silently blend the old and new instructions into a confusing compromise. A corrected boundary, a newly approved tool, or a revised definition of done should become part of the working state.
This matters more as teams use coordinated agents. In a multi-agent workflow, one delegate may research, another may edit, and another may validate. The control surface should show ownership and handoff state clearly enough that people do not confuse parallel motion with coordinated progress. AI Agent Coordination depends on this kind of visible boundary because shared work fails when everyone sees activity but nobody sees responsibility.
The surface should respect privacy and attention
A control surface can easily become too revealing. If it exposes every private document, every prompt, every customer record, and every tool output to every reviewer, it may reduce one risk while creating another. Human visibility is necessary, but it should follow the same data boundaries as the rest of the system.
The interface should show enough for accountability without copying sensitive material into places it does not belong. A reviewer may need to know that the agent used a restricted document, but not see the full document. A manager may need to see that an approval happened, but not the private content behind it. A support lead may need record identifiers and policy references, while a broader audit surface may need only the shape of the run.
Apply access checks to linked artifacts and evidence as well as the main screen. Redact secrets and unnecessary personal data from summaries and logs, and set retention according to the data and the organization’s obligations. When a reviewer cannot access evidence needed for the decision, route the work to an authorized reviewer instead of asking for approval based on a hidden source. AI Agent Data Boundaries offers more detail.
Attention is another boundary. If the control surface highlights everything, it highlights nothing. Warnings should mean something. Required approvals should be distinct from optional review. Failed checks should be easier to notice than routine progress. The interface should protect the human from both hidden risk and pointless noise.
Make these distinctions available beyond color and motion. Use text labels for states and consequences, give controls clear names, and make them operable by keyboard. For a web interface, status changes that do not move focus should also be available to assistive technology; W3C’s guidance on status messages explains the requirement and ways to convey updates without unnecessary interruption. Test with the actual interaction, including a run that moves from waiting to blocked while the reviewer is elsewhere on the page.
Design for the next reviewer
The person who starts an agent run is not always the person who finishes it. A teammate may take over after a queue delay. A manager may inspect the work after a customer complaint. An engineer may debug the run after a failed deployment. A future version of the same user may return tomorrow and need to remember why the work stopped.
That means the control surface should be designed for continuity. It should preserve the original assignment, current state, evidence, artifacts, approvals, skipped checks, and remaining uncertainty in a form someone else can understand. This is not extra documentation after the work. It is part of the work.
A good surface can also encourage cleaner runs by requiring inspectable state, named decisions, evidence, and separate labels for drafts and actions. Those requirements do not guarantee the agent’s account is accurate; important claims still need checks against the artifact or the system that performed the action. Legible progress matters.
Test the surface with a real task
Before relying on the interface, give a reviewer a representative run and ask them to identify the current state, the next action, its target, and what their approval would authorize. Try a changed draft after approval, an expired permission, a failed check, a pause during a tool call, and a timeout with an unknown outcome. Verify that the action path actually blocks an invalid approval and that the screen does not report success without a confirmed result. Include keyboard and assistive-technology use, and test whether a reviewer can reach the evidence they need.
Track what happens in use: approvals sent back for revision, unclear or missed warnings, time spent waiting for review, and actions later corrected. Investigate these signals rather than treating a fast approval as proof of good review. The NIST AI RMF Playbook’s measurement guidance suggests testing whether interfaces serve their intended purposes and documenting human oversight and downstream actions. Use those observations to improve the surface and the underlying workflow together.
That is the deeper value of a control surface. It is not decoration around an agent. It is the place where delegation becomes accountable. It gives the human enough information to supervise without doing the whole task again. It gives the agent a structure for pausing, asking, proving, and handing off. It gives the organization a shared view of what delegated work means before, during, and after the run.
AI agents become more useful when people can see the right parts of their work at the right time. Not every trace needs to be on screen. Not every decision needs a modal. Not every task needs a command center. But every serious agent workflow needs a surface where state, evidence, permission, and consequence meet. Without that surface, the system may still be powerful. It will just be harder to trust, harder to repair, and harder to use responsibly.
Written By
JJ Ben-Joseph
Founder and CEO ยท TensorSpace
Founder and CEO of TensorSpace and the editor of Fondsites: an engineer working across software, AI, cybersecurity, and biosecurity who builds the site's games and tools.