Agent Process Design.

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 artefact 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 artefact 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 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). 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.