Design AI agents around real business workflows.
AI agent workflow design is the discipline of designing the work before you build the worker — turning one business workflow into a defensible agentic service. We design two layers in parallel: the aggregate view a CTO or COO uses to operate the agentic workforce, and the individual agent a product team actually ships. Both come out as interactive HTML mockups — not slides, not Figma frames — so the engineering team can read, fork, and build straight from the deliverable.
What AI agent workflow design actually is.
AI agent workflow design is the practice of specifying a business workflow — its steps, actors, decision points, failure modes, and accountable owner — before any agent is built to run it. The output is not a model choice or a prompt. It is a design: what the agent is allowed to decide alone, what it must escalate, what it records, what it remembers between runs, and which named human answers for the result when it goes wrong.
It sits upstream of engineering and downstream of strategy. A roadmap tells you which workflows to automate. An AI agent readiness assessment tells you whether your systems can support agents at all. Workflow design is the step between them: it turns “we should automate claims triage” into a specification a team can build against on Monday and an auditor can read in a year.
The distinction that matters most: this is process design, not model design. Changing the model underneath a well-designed workflow is a Tuesday afternoon. Changing the workflow underneath a well-tuned model is a rewrite. What the design must account for is how much supervision the platforms underneath you actually expose today, which we track entry by entry in the Agent Supervision Register.
Why agent projects stall at the pilot.
The demo works. The pilot works. Then it doesn’t reach production — or it reaches production and is quietly switched off two quarters later. In the work we see, the cause is almost never the model. It is that nobody designed the work the agent was supposed to do. Three failure modes account for most of it.
No boundary.
Autonomy was never scoped, so it is implicitly total. The first time the agent does something surprising, the only control anyone has is switching it off — because no one wrote down which decisions it could make alone and which it had to hand up.
A boundary is not a guardrail bolted on after launch. It is a decision made per step, in writing, before the build — which is what the Action Heat Ladder exists to make routine.
No owner.
The workflow crosses three teams, so it belongs to none of them. When the agent produces a bad outcome, the meeting is about whose budget pays for the fix rather than what the agent should have done instead.
Every workflow we design names one accountable human before we design anything else. If that name cannot be produced, that is the finding — and the fix is an AI agent operating model, not a better prompt.
No aggregate.
Agent number one ships. So does number four. By number nine nobody can answer what the agents collectively touch, which ones share a tool, or what breaks if one credential is rotated.
The aggregate view is cheap to design at agent one and expensive to reconstruct at agent nine. We build it on the first engagement, for the ninth.
Two views of one agent workflow.
Every engagement runs both 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.
The agentic workforce.
The shared surface — agent home, the map of how agents connect, the inventory of what exists today and what's coming next quarter, the workforce mix between humans and agents. The CTO opens this on Monday morning.
↓ Four artifactsThe specific agent service.
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.
↓ Ten stagesThe aggregate view of an agentic workforce.
Four artifacts make the agentic workforce visible. Each one ships as a live HTML mockup — your team can use it, edit it, route it to engineering, and bring it into the next steering meeting.
Agent Home — the dashboard.
The summary surface every stakeholder lands on. Live agents at a glance — what's running, what's paused, what's escalated, what each one cost and saved this week. Designed to be the first tab on the CTO's browser, not buried inside a vendor console.
We design the information architecture, the live-status colour system, the KPI tiles, the activity stream, and the escalation surface — then deliver a working HTML prototype your engineering team can implement on top of your stack.
Agent Maps — the sitemap.
Agents do not live alone. They consume each other's outputs, feed shared knowledge banks, share tools, and call each other for help. We draw the workforce as a graph — Clay-style nodes, named connections, data-flow arrows — so the team can see where one agent's change ripples to three others.
The map is the artifact that ends the question "so what does this agent actually depend on?" at the executive table.
Inventory & planning.
Everything live, everything in build, everything on the roadmap — in one register. Each row carries the agent's type, owner, autonomy tier, trust stage, and economic case. The artifact a CFO can read; the artifact procurement can defend.
We also draft the planning view — quarter-by-quarter sequencing of which agents land when, against which workflow, owned by which named human.
| ID | Agent | Tier | Owner | Stage |
|---|---|---|---|---|
| A001 | Pricing Brain | Act-notify | Pricing Ops | Live |
| A002 | Brand Voice | Approve-each | Brand Council | Live |
| A003 | Compliance | Human-conf. | Legal | Pilot |
| A004 | Reporting | Autonomous | Analytics | Live |
| A005 | Audience | Review-act | Insights | Live |
| A006 | Brief Brain | Approve-each | Strategy | Build · Q3 |
| A007 | Forecast | Act-notify | Finance Ops | Spec · Q4 |
Workforce summary.
The mix view. Per function, per workflow, per region — how the work splits between human, human-supervised agent, and autonomous agent. The artifact a CHRO and a CTO read together. Drives capacity planning, hiring posture, and the agentic budget conversation.
Where on the workforce mix you sit today — and where you are aiming for next year — is rarely written down. We write it down.
Ten stages of agent workflow design.
Each stage produces a named artifact. Every artifact is a clickable HTML page the build team can fork — the trust spec, the storyboard, the runbook, the audit format. By the end the agent has a homepage of its own, before a single production endpoint is touched. The ten stages map onto the wider AI agent development lifecycle; this engagement covers design, not the build and run phases that follow.
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.
Process map, actors & taxonomies.
The workflow drawn as a graph. Every actor — human, system, agent — named with role, scope, and decision rights. Every artifact named with its taxonomy class (input · intermediate · output · audit). The shared vocabulary of the engagement gets fixed here, and stops changing.
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, not just the one that looks easy.
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 artifact a regulator and a CFO can both read.
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.
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 — Intent Handshake, Memory in Motion, Escape Hatch — so the build team is not improvising.
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.
Codebase, tools, integrations, deployment.
The engineering hand-off. Repo structure, tool catalog (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). We do not write production code — we write the spec the build team writes production code from. The brief is small enough to commit, complete enough to ship from.
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. Continuous, not optional.
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. We design the log shape, the storage policy, and the audit-readout format the agent's owner can produce on request.
2026-05-28T14:02:13Z [BRAIN] brand-voice@2.1.0 · sources: brandbook/v4, claims-policy/q2
2026-05-28T14:02:14Z [FLAG] "transformational" violates rule BR-19 · soft-pause
2026-05-28T14:02:14Z [QUEUE] alt drafted · review queued for jane@
2026-05-28T14:08:42Z [APPROVE] jane@ · variant 2 · sig=verified
2026-05-28T14:08:43Z [AUDIT] hash=a91f…3c2b · merkle-anchored
Deliverables your engineers open on Monday.
Every deliverable from the engagement is a working HTML page or component — designed once, forkable by engineering, hostable on your intranet from day one. The agent has a homepage before it ships, and the workforce has a homepage before there's a workforce.
Agent Home page
The CTO's Monday morning surface. Live agent status, KPIs, escalation queue. Interactive HTML, your design system optional.
Agent Map graph
Node-and-edge view of how agents depend on each other. Editable, exportable, embeddable in your wiki.
Inventory & roadmap
One row per agent — type, owner, tier, stage, economic case. Plus the quarter-by-quarter sequencing for what's coming.
Trust Canvas + policy YAML
The agent's constitution in two formats: human-readable Canvas, machine-readable policy file. Wired for AGT, OPA, or your own enforcement layer.
Storyboard walkthrough
Interactive frame-by-frame HTML showing every AUX pattern at every moment. Click through what the user actually sees.
Runtime state diagram
Triggers · happy path · dead ends · reruns · cycles. The diagram the on-call engineer can actually read at 3am.
Build spec + tool catalog
The brief the build team commits to git. Small enough to read in an hour, complete enough to ship from.
Eval harness + audit format
The quality scorecard, the rollback runbook, the audit-log schema. The artifacts that turn the agent from "trust us" into "audit us."
Two ways to start.
Most engagements begin with an Agent Design Sprint on a single workflow — six weeks, fixed scope, fixed price. Teams that move to the workforce view then graduate to an Advisory Retainer covering successive agents through a quarter or year.
Agent Design Sprint.
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 the engineering team needs to start building on Monday.
- Process + KPI translation
- Trust Canvas + policy YAML
- Storyboard + runtime spec
- Build-ready hand-off
Advisory Retainer.
The Agent Design Sprint outcome, extended across the agentic workforce. We sit alongside your AI council, design successive agents on the same template, evolve the aggregate view, and own the consistency of the deliverable as the surface grows.
- Per-quarter agent designs
- Aggregate view maintained
- Audit + eval cadence supported
- Steering presence at AI council
What it covers, how long it takes, what it costs.
Both engagements are scoped before they start. There is no separate discovery phase you pay for in order to find out what the real engagement will cost.
| Engagement | Scope | Timeline | Price |
|---|---|---|---|
| Agent Design Sprint | One workflow, all ten stages, both lenses. Aggregate-view and individual-agent mockups, trust canvas and policy YAML, storyboard, runtime specification, evaluation format, build brief. | 6 weeks | From €14,500 |
| Advisory Retainer | Successive agents designed on the same template, the aggregate view maintained as the surface grows, audit and evaluation cadence supported, steering presence at your AI council. | Per quarter | On request |
Price depends on workflow complexity and the number of systems in scope, not on headcount or hours. If an AI agent readiness assessment shows the underlying systems cannot yet support an agent, we will say so before the sprint rather than during it.
Questions we get before signing.
What is AI agent workflow design?
AI agent workflow design is the practice of specifying a business workflow — its steps, actors, decision points, failure modes, and accountable owner — before any agent is built to run it. The output is a specification covering what the agent may decide alone, what it must escalate, what it records, and what it remembers between runs. It sits upstream of engineering and downstream of strategy.
How is it different from process mapping or automation design?
Process mapping documents how work happens today. Automation design specifies deterministic steps a system executes the same way every time. Agent workflow design has to answer a question neither of them asks: what happens when the system makes a judgment call and gets it wrong. That means designing autonomy boundaries, escalation paths, and audit trails as first-class parts of the workflow rather than as exception handling added later.
Do we need this if we already have an AI roadmap?
A roadmap tells you which workflows to automate and in what order. It does not tell you what the agent is allowed to decide, who answers for the outcome, or what the workforce looks like once nine agents are running. Those are design decisions, and they are cheapest to make before the first build rather than after the third.
What do we actually receive at the end?
Interactive HTML mockups of both layers — the aggregate view a CTO or COO uses to operate the agentic workforce, and the individual agent a product team ships — plus a trust canvas with policy YAML, a storyboard, a runtime specification, an evaluation harness format, and a build brief. Everything is HTML and text, small enough to commit to your repository and complete enough to build from.
How long does an engagement take, and what does it cost?
An Agent Design Sprint covers one workflow across all ten stages in six weeks, at a fixed scope and a fixed price from €14,500. Teams that move on to the workforce view continue on an Advisory Retainer, priced per quarter on request. We do not run discovery phases you pay for separately.
Can our engineering team build directly from the deliverable?
That is the point of shipping HTML rather than slides. The mockups are real pages your team can open, read, fork, and hand to a developer as a reference implementation. The trust canvas ships as policy YAML, and the runtime specification is written as state transitions rather than prose, so the hand-off does not require a translation meeting.
Bring us 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.