# Agent Process Design

> Canonical: https://auxfirst.com/agentic-experience-center/agent-process-design.html
> License: CC BY 4.0 · auxfirst agency 2026

> Pillar 03 of the Agentic Experience Center · The work

The discipline of turning a workflow into **a defensible agentic service** — autonomy boundaries, escalation paths, audit trails, memory policies, and the named human who owns the outcome.

## The two-lens approach

Every engagement runs two lenses simultaneously. Without the aggregate view you ship orphans. Without the individual-agent view you ship a roadmap.

> The deliverable is a working **HTML prototype** of both surfaces — what the workforce looks like at the top, and what one agent looks like at the bottom. Not slides, not Figma frames. The engineering team can read, fork, and build straight from the artefact.

### Lens A — Aggregate view (the workforce)

What the CTO opens on Monday morning. Four artefacts make the agentic workforce visible:

#### A1 · Agent Home dashboard
Live agents at a glance — what's running, what's paused, what's escalated, what each one cost and saved this week. KPI tiles, activity stream, escalation surface. Designed to be the first tab on the CTO's browser, not buried inside a vendor console.

**Deliverable:** Interactive HTML mockup · Owner: CTO / Head of AI · Cadence: Live

#### A2 · Agent Maps
Agents do not live alone. They consume each other's outputs, feed shared knowledge banks, share tools, call each other for help. The workforce drawn as a graph — nodes, named connections, data-flow arrows — so the team sees where one agent's change ripples to three others.

**Deliverable:** Interactive node graph · Owner: Engineering / Architecture · Cadence: Per release

#### A3 · Inventory & planning
Every live agent, every agent in build, every agent on the roadmap — in one register. Each row carries the agent's type, owner, autonomy tier, trust stage, and economic case. Plus the quarter-by-quarter sequencing of what lands when.

**Deliverable:** Inventory + roadmap · Owner: Head of AI / COO · Cadence: Quarterly

#### A4 · Workforce summary
The mix view. Per function, per workflow, per region — how the work splits between human, human-supervised agent, and autonomous agent. Drives capacity planning, hiring posture, and the agentic-budget conversation.

**Deliverable:** Workforce composition · Owner: CHRO + CTO · Cadence: Half-yearly

### Lens B — Individual agent

The end-to-end design of one agent — process analysis, trust spec, scaffolding, storyboard, runtime, codebase, evaluation harness, audit trail. The product team builds straight from it.

## The 10-stage design process

Each stage produces a named artefact. Every artefact is a clickable HTML page the build team can fork. By the end the agent has a homepage of its own, before a single production endpoint is touched.

### 01 · Business process analysis
Before any prompt or model: we read the workflow. Who triggers it, what fires it, what counts as success, what breaks today, where time leaks. Most agents fail because they automated a process nobody had written down clearly enough to read.

**Output:** Workflow brief

### 02 · Process map, actors & taxonomies
The workflow drawn as a graph. Every actor — human, system, agent — named with role, scope, and decision rights. Every artefact named with its taxonomy class (input · intermediate · output · audit). The shared vocabulary of the engagement gets fixed here, and stops changing.

**Output:** Process graph · actor register · taxonomy

### 03 · Business goals → agent KPIs
Business outcomes translated into things an agent can actually move. Revenue uplift becomes *decisions queued · approve-rate · cycle-time · error-rate · escalation-rate*. We separate **quality KPIs**, **trust KPIs**, and **economic KPIs** so the agent is judged on all three.

**Output:** KPI tree · scorecard

### 04 · Trust layer — Canvas & harness
The agent's constitution. We run the **Trust Canvas** session to fix autonomy boundaries per action class, name the escalation rules, set the memory policy, and draft the explainability contract. Then we design the runtime harness — the deterministic policy layer that enforces all of it in code, AGT-compatible by default.

*This is the artefact a regulator and a CFO can both read.*

**Output:** Trust Canvas · YAML policy spec · escalation matrix

### 05 · Agent scaffolding — brains, skills, knowledge, context
What the agent is *made of*. Which reasoning brain (deterministic, probabilistic, generative, retrieval-augmented). Which named skills it can call. Which knowledge banks it reads. Which short-term and long-term context it carries between sessions. Every component named, every component owned — no shadow cognition.

**Output:** Scaffolding spec · brain manifest · skill registry

### 06 · Storyboarding — escape hatches, visible controls
The end-to-end user experience, frame by frame. Where the intent handshake happens. Where the confidence cue surfaces. Where the human can revise or undo without losing work. Every storyboard frame names the AUX pattern it instantiates.

**Output:** Storyboard · pattern map · interactive HTML walkthrough

### 07 · Runtime — triggers, dead ends, reruns, cycles
How the agent actually runs in time. What triggers a session — schedule, event, user invocation, escalation. What counts as a successful end. What counts as a dead end and how it routes. When the agent reruns a step, retries with a different brain, or cycles back to a human. The runtime is the part most teams forget to design — then it shows up in production as the bug they cannot reproduce.

**Output:** Runtime state diagram · trigger map · retry policy

### 08 · Codebase, tools, integrations, deployment
The engineering hand-off. Repo structure, tool catalogue (what the agent is allowed to call, with what scope), integrations (which platforms, which auth, which observability), and deployment shape (managed runtime, edge, self-hosted). The brief is small enough to commit, complete enough to ship from.

**Output:** Build spec · tool catalogue · deploy plan

### 09 · Evaluations & improvements
The agent ships, then it earns the right to keep running. We design the eval harness — quality checks, hallucination detection, trust-stage scorecards, A/B against the legacy human process. Improvement cadence is named: who reviews what, on which day, with what authority to roll back.

**Output:** Eval harness · improvement cadence · rollback runbook

### 10 · Audits with audit trails
Every action the agent takes is logged immutably — prompt, model, version, inputs, decision, outputs, the human approval that came after. Two years later, a trustee or regulator should be able to reconstruct what happened from the log alone. Without this, agentic systems are fiduciarily indefensible.

**Output:** Audit schema · readout template · retention policy

## Deliverables

What you take home — every one a clickable HTML page or component:

- **Agent Home page** — the CTO's Monday-morning surface
- **Agent Map graph** — node-and-edge view of agent dependencies
- **Inventory & roadmap** — one row per agent
- **Trust Canvas + policy YAML** — the agent's constitution in two formats
- **Storyboard walkthrough** — frame-by-frame user-facing journey
- **Runtime state diagram** — triggers, happy path, dead ends, reruns
- **Build spec + tool catalogue** — the brief engineering commits to git
- **Eval harness + audit format** — quality scorecard, rollback runbook, audit-log schema

## Engagement formats

### Blueprint Sprint · 6 weeks
A single workflow. All ten stages, both lenses framed. You walk out with the agent home mockup, the trust canvas, the storyboard, the runtime spec, and the build brief — everything engineering needs to start building Monday.

### Advisory Retainer · Quarterly
The Blueprint Sprint outcome, extended across the agentic workforce. We sit alongside your AI council, design successive agents on the same template, evolve the aggregate view, own the consistency of the deliverable as the surface grows.

## Position

Agent Process Design is the third pillar of the **Agentic Experience Center**:

- Pillar 01 — Agentic API Experience (the wire)
- Pillar 02 — AI Product Experience (the surface)
- **Pillar 03 — Agent Process Design (the work) — live, accepting briefs**

## How to start

Bring one workflow. We'll bring back two homepages. One for the agent. One for the workforce. Both clickable. Both forkable. Both small enough to commit, complete enough to ship from.

Start a project: https://auxfirst.com/index.html#contact

## Related

- [The Agentic Experience Center hub](https://auxfirst.com/agentic-experience-center/)
- [Agent-First Design](https://auxfirst.com/agent-first-design.html) — the master pillar guide
- [Agent Enablement — The Operational Layer](https://auxfirst.com/news/agent-enablement.html) — the four pillars of reliability
- [Agency Brains Design](https://auxfirst.com/ad-industry/agency-brains-design.html) — sister methodology for ad agencies
- [TrustKit on GitHub](https://github.com/auxfirst/trustkit) — the open-source schemas behind the trust spec