AI Skill Report Card
Orchestrating Multi Agent Workflows
Quick Start14 / 15
Given a task, produce five outputs in this order: Agent Map, Task Flow, Delegation Logic, Trust Flow, Execution Chain.
Request: "Process customer refund and update inventory"
Agent Map:
- IntakeAgent (parses request)
- RefundAgent (handles payment reversal)
- InventoryAgent (updates stock)
- AuditAgent (logs all actions)
Task Flow:
IntakeAgent -> [RefundAgent, InventoryAgent] (parallel) -> AuditAgent
Delegation Logic:
- IntakeAgent routes by request.type
- RefundAgent triggered if payment_id exists
- InventoryAgent triggered if sku exists
- Conflict: if RefundAgent fails, InventoryAgent action rolls back
Trust Flow:
IntakeAgent (untrusted input) -> validated schema -> RefundAgent/InventoryAgent (trusted, sandboxed) -> AuditAgent (read-only, full trust)
Execution Chain:
1. IntakeAgent.validate()
2. parallel: RefundAgent.execute(), InventoryAgent.execute()
3. on any failure: rollback both
4. AuditAgent.log(all_events)
Recommendation▾
Add an example showing a failure/bad outcome (e.g., missing rollback path) to contrast with the good examples
Workflow14 / 15
Progress:
- Identify all agents involved and their single responsibility
- Map task flow (sequential/parallel/conditional)
- Define delegation logic (routing rules + trigger conditions)
- Define trust boundaries between agents
- Define execution chain (ordered steps + rollback/error paths)
- Verify auditability, monitorability, isolatability for every agent
- Agent Map — list every agent with a one-line responsibility. No agent should have overlapping responsibility with another.
- Task Flow — diagram (text-based) showing sequence, parallelism, and branching between agents.
- Delegation Logic — explicit rules: which agent handles which input condition, and how conflicts are resolved (priority order, fallback, rollback).
- Trust Flow — classify each agent's trust level (untrusted input / sandboxed / trusted / read-only) and how data crosses boundaries (validation, sanitization).
- Execution Chain — numbered, ordered steps with explicit error handling and rollback at each stage.
Recommendation▾
Include a note on scaling this framework down for simple 2-agent cases vs. complex 10+ agent systems
Examples15 / 20
Example 1: Input: "Coordinate agents to onboard a new user: verify identity, create account, send welcome email" Output:
Agent Map:
- VerifyAgent (identity check)
- AccountAgent (creates DB record)
- NotifyAgent (sends email)
Task Flow:
VerifyAgent -> AccountAgent -> NotifyAgent (strictly sequential, each gated on prior success)
Delegation Logic:
- If VerifyAgent fails: halt chain, no account created
- If AccountAgent fails: no notification sent, rollback verification token
- NotifyAgent failure is non-blocking (retry queue, does not rollback account)
Trust Flow:
VerifyAgent (untrusted external input) -> sanitized identity payload ->
AccountAgent (trusted, isolated DB write scope) -> AccountAgent output (trusted) ->
NotifyAgent (sandboxed, outbound-only, no DB access)
Execution Chain:
1. VerifyAgent.check(identity) -> pass/fail
2. if pass: AccountAgent.create(user) -> account_id
3. if success: NotifyAgent.send(welcome, account_id)
4. if fail at step 3: enqueue retry, log to AuditAgent
5. AuditAgent.log(full_trace) at every step
Example 2: Input: "Two agents disagree on classification of a support ticket (BugAgent says bug, FeatureAgent says feature request)" Output:
Delegation Logic (conflict resolution):
- ArbiterAgent invoked when confidence scores overlap (<15% difference)
- Priority: BugAgent wins if reproducible steps present in ticket
- Otherwise escalate to HumanReviewAgent
- Decision + reasoning logged by AuditAgent for traceability
Recommendation▾
Provide a minimal template/skeleton block that can be copy-pasted for new requests, separate from the fully worked examples
Best Practices
- One agent = one responsibility. Never let two agents own the same decision.
- Every agent must emit structured logs consumable by an AuditAgent — no silent actions.
- Define explicit trust boundaries; never let untrusted input reach a trusted agent without validation/sanitization.
- Every agent must be independently isolatable (can be disabled/replaced without breaking the chain, only degrading it).
- Always define a conflict resolution path before deployment, not after the first conflict occurs.
- Prefer parallel execution only when agents are truly independent; otherwise use sequential gating to prevent race conditions.
Common Pitfalls
- Do not let agents call each other directly without going through the defined task flow — this breaks auditability.
- Do not skip the rollback/error path in Execution Chain — every step needs a defined failure behavior.
- Do not merge Trust Flow into Task Flow — trust boundaries must be explicit and separately reviewable.
- Do not allow an agent with write access to also be the sole auditor of its own actions.
- Do not leave delegation logic implicit ("the system decides") — always specify the exact rule or priority order.