AIYINGFrom AI Awareness to Accomplishment
Showing posts with label AI Agents. Show all posts
Showing posts with label AI Agents. Show all posts

Saturday, November 14, 2026

The Effective AI Engineer #024 — The Engineer Who Designed for Failure

AIYING | The Effective AI Engineer #024

The Engineer Who Designed for Failure



Why a deliberately broken AI workflow revealed a better way to build reliable systems.

An AI Engineering Case Study in Lateral Thinking, Reliability, and Human Judgment

By Ravindra Dastikop | November 2026

1. The Scenario: A System That Worked Until It Mattered

Maya was an AI engineer working on an internal procurement assistant.

The assistant answered questions about purchasing policies, summarized supplier information, and helped employees prepare purchase requests.

Its architecture looked reasonable:

  1. Receive the employee's question.
  2. Retrieve relevant policy documents.
  3. Ask a language model to interpret the information.
  4. Call an internal service when additional data was needed.
  5. Return a helpful answer.

In demonstrations, the assistant performed well.

It answered routine questions clearly. It produced convincing summaries. Its interface looked polished.

Then the team tested an unusual situation.

An employee asked whether an urgent purchase could proceed without normal approval.

The assistant retrieved an older policy excerpt, but the service containing current approval rules was temporarily unavailable.

The model still generated a confident answer.

The answer sounded plausible. It was also unsupported by the available evidence.

The team had discovered a serious design weakness: the system could continue sounding successful after the information needed for a reliable answer had become unavailable.

Case-study note: Maya, the organization, and this incident are fictional. The scenario illustrates a plausible AI engineering failure mode; it is not presented as a documented production incident.

2. The Deadlock: More Testing or More Safeguards?

The team proposed several responses.

  • Add more examples to the test set.
  • Improve the retrieval configuration.
  • Strengthen the system prompt.
  • Add a warning that AI can make mistakes.
  • Increase monitoring of the external service.

Each proposal had potential value.

But Maya noticed that the discussion assumed the assistant's job was to keep answering.

The team was asking:

How do we prevent the system from failing?

They were not asking an equally important question:

What should the system do when a reliable answer is no longer possible?

That difference became the turning point.

3. The Lateral Thinking Move

Maya used a deliberate provocation inspired by Edward de Bono's Lateral Thinking approach.

PO: The system must fail before it can succeed.

At first, the statement sounded absurd.

Why would an engineer deliberately make a system fail?

But a PO provocation is not intended to be accepted literally. Its purpose is to interrupt an established pattern and allow movement toward alternative designs.

Movement 1 — Extract the principle

Perhaps failure should not be treated only as an unexpected event.

Perhaps it should be treated as an explicit condition that the architecture is designed to recognize.

Movement 2 — Focus on the difference

A conventional assistant tries to produce an answer.

A failure-aware assistant first determines whether it has sufficient evidence and functioning dependencies to produce the kind of answer requested.

When it cannot, the correct behavior may be to stop, qualify, ask for clarification, or escalate.

Movement 3 — Discover a practical possibility

The engineer arrived at a new design question:

Could we make the system's inability to answer safely a first-class, testable outcome?

This was more useful than merely asking the model to be careful.

4. The Engineering Decision: Design the Failure Contract

Maya proposed a failure contract.

For every critical dependency, the team would specify:

  • What successful operation looks like.
  • How failure is detected.
  • Whether the failure can be safely retried.
  • What information remains trustworthy.
  • Which actions must be blocked.
  • What the user should see.
  • When human intervention is required.

The central idea was simple:

A reliable AI system must know when not to act as though it has succeeded.

For the procurement assistant, the contract separated two types of response.

SituationRequired system behavior
Current policy retrieved and approval service available Provide a source-backed explanation within the system's authorized scope
Relevant document missing State that the answer cannot be established from available evidence
Approval service unavailable Do not invent approval status; provide an escalation route
Conflicting policy versions Identify the conflict and request authoritative clarification
User requests an unauthorized approval action Block the action and explain the required approval process

The architecture was no longer designed around one happy path.

It was designed around legitimate outcomes, including safe non-completion.

5. Connect: What This Means in Modern AI Engineering

The case connects to several established engineering practices.

Failure isolation

Distributed systems use mechanisms such as timeouts, circuit breakers, and bulkheads to prevent one failing component from destabilizing others.

In AI systems, similar principles can help prevent tool failures from producing uncontrolled downstream behavior.

Grounding and evidence checks

Retrieval-augmented systems can use external information to support answers, but retrieval alone does not guarantee correctness.

The system must distinguish between evidence that supports a claim and material that merely appears relevant.

Human oversight

When a decision exceeds the system's authority or available evidence, escalation can be the intended behavior rather than a product defect.

Evaluation beyond answer quality

A useful evaluation set should include not only questions the assistant can answer, but also situations where it should abstain, ask for clarification, or refuse an unauthorized action.

These practices are consistent with broader reliability and AI risk-management principles. Their effectiveness still depends on implementation and testing.

6. The Unexpected Discovery

The team had initially treated an unanswered question as a failed user experience.

Maya's provocation exposed a more important distinction.

Old interpretationNew interpretation
The assistant failed because it did not answer. The assistant may succeed by refusing to invent an unsupported answer.
Every interruption is undesirable. Some interruptions prevent consequential mistakes.
Reliability means continuous response. Reliability includes correct behavior under degraded conditions.
A fallback must always provide an answer. A fallback may provide a safe next step instead.

This was not a discovery that failure is good.

It was a discovery that correctly handled failure is part of successful system behavior.

7. The Architecture: A Failure-Aware AI Workflow

1. Receive

Capture the user's request and its intended action.

2. Retrieve

Gather relevant evidence and dependency results.

3. Validate

Check availability, freshness, permissions, and evidence sufficiency.

4. Decide

Select answer, clarification, abstention, or escalation.

5. Respond

Communicate the result without disguising uncertainty.

6. Record

Capture the outcome for evaluation and improvement.

Notice the architectural change.

The model is no longer the only component determining whether a response is acceptable.

Explicit checks and system-level controls participate in that decision.

For consequential actions, authorization and validation should be enforced by trusted application logic rather than relying solely on instructions to the language model.

8. Practical Application: Design a Failure Contract

Objective

Create a failure-aware design for a fictional AI assistant using a visual diagramming tool.

Tool: diagrams.net — https://app.diagrams.net/

Time: Approximately 20–30 minutes.

Prerequisites: A web browser. No coding or account is required for basic local diagram creation.

Step 1 — Open the tool

Visit diagrams.net and choose a local storage option when prompted.

Step 2 — Create the happy path

Draw five boxes:

User Request
     |
     v
Retrieve Policy
     |
     v
Check Approval Service
     |
     v
Generate Response
     |
     v
Show Answer

Step 3 — Introduce deliberate failures

Add three failure scenarios:

  1. The policy document cannot be retrieved.
  2. The approval service times out.
  3. Two retrieved policy documents contradict each other.

Step 4 — Add decision points

After retrieval, insert a decision:

Is the evidence sufficient and authoritative?

After the approval-service call, insert another:

Is the required service available and its result valid?

Step 5 — Design safe outcomes

For each negative branch, choose a behavior:

  • Ask for clarification.
  • State that evidence is insufficient.
  • Provide an authorized escalation route.
  • Retry only when safe and appropriate.
  • Stop an unauthorized or unsupported action.

Step 6 — Add observability

Draw an outcome-recording component.

Capture the scenario category, dependency status, selected response path, and whether escalation occurred. Avoid logging sensitive content unnecessarily.

Step 7 — Review the diagram

Ask whether any failure path could still lead to a confident but unsupported answer.

If so, revise the design.

Expected output

A one-page Failure-Aware AI Assistant Blueprint with:

  • One successful path.
  • Three explicit failure scenarios.
  • Two or more decision points.
  • Safe response or escalation paths.
  • An outcome-recording step.

The exercise produces an architectural proposal, not a verified production implementation.

9. Reusable AI Prompt: Failure-Contract Reviewer

Use this prompt with ChatGPT or another suitable AI assistant to critique your design.

Act as a senior AI reliability engineer.

SYSTEM:
A fictional procurement assistant that
retrieves policy documents and checks
approval rules through an internal service.

MY DESIGN:
[Describe or paste my workflow]

Review the design using this sequence:

1. Identify the happy path.
2. List five realistic failure modes.
3. Identify where the system might
   produce an unsupported answer.
4. Specify failure-detection checks.
5. Recommend safe fallback or
   escalation behavior.
6. Distinguish model-level safeguards
   from application-enforced controls.
7. Design five evaluation scenarios,
   including at least two cases where
   the correct behavior is not to answer.
8. Propose observable pass/fail criteria.

Use this PO provocation to challenge
the design:
"The system must fail before
it can succeed."

Apply movement to derive practical
engineering improvements.

Do not assume that generated
recommendations are validated.
Identify what requires testing.

10. Evaluate: How Would We Know It Works?

A failure-aware design must be tested against concrete expectations.

TestExpected behaviorPass condition
Approval service unavailable Do not claim approval is granted No unsupported approval statement
No relevant policy evidence State the evidence gap No invented policy rule
Conflicting policy versions Identify conflict and escalate No unsupported resolution
Normal policy question Answer using available authoritative evidence Answer is supported by cited material
Unauthorized action request Block the action No unauthorized tool execution

These are proposed test cases, not completed test results.

A real deployment would require more comprehensive testing, including adversarial cases, integration tests, access-control checks, and operational monitoring.

11. Today's Accomplishment

Build one Failure-Aware AI Assistant Blueprint.

By completing the exercise, you will have converted an ordinary AI workflow into a design with explicit failure detection, controlled outcomes, and evaluation criteria.

The observable result is a diagram that another engineer could review, challenge, and potentially implement.

12. The Bigger Insight

The effective AI engineer does not merely make a system work when everything goes right.

The effective AI engineer defines what responsible behavior looks like when something goes wrong.

PO: The most reliable answer may be the answer the system chooses not to invent.

Reliability is not the absence of failure.

It is the ability to recognize, contain, communicate, and respond appropriately to failure.

The engineer who designed for failure was really designing for trust.

13. References and Further Reading

  1. Google SRE Book — Handling Overload
  2. Google SRE Workbook — Implementing SLOs
  3. Microsoft Azure Architecture Center — Circuit Breaker Pattern
  4. AWS Well-Architected — Reliability Pillar
  5. NIST — AI Risk Management Framework
  6. OpenAI — Evaluation Guidance
  7. Edward de Bono, Serious Creativity: Using the Power of Lateral Thinking to Create New Ideas (1992).

Editorial note: This is an independent educational case study. The fictional scenario and PO provocation are used to illustrate engineering judgment. References support the underlying reliability and evaluation concepts, not the fictional events.

AIYING

The Effective AI Engineer — Case Study #024

Choose Work That Matters.

From AI Awareness to Accomplishment

Ravindra Dastikop | AIYING

AI Engineering Principle #006 — Design for Failure, Not Just Success: Building Reliable AI Systems

AIYING | AI ENGINEERING PRINCIPLES & PRACTICE #006

Design for Failure, Not Just Success

Building AI systems that detect problems, recover gracefully, and protect users.

An independent AI engineering study reference | Understand → Connect → Apply → Accomplish




1. The AI Demo That Worked Perfectly

Imagine an engineering team demonstrating an AI-powered customer support assistant.

A customer asks a question. The assistant searches the knowledge base, retrieves the relevant information, and produces a useful answer.

The demonstration succeeds.

But what happens when the knowledge base is unavailable?

What if the model takes too long to respond? What if retrieval returns irrelevant documents? What if an external tool fails halfway through a workflow?

These are not unusual engineering questions. They are part of operating real AI applications.

A successful demonstration proves that a system can work. Failure handling helps determine whether it can be trusted in operation.

2. The Principle: Design for Failure

AI systems combine probabilistic model behavior with conventional software components, external APIs, databases, retrieval services, and sometimes autonomous tool execution.

Each component introduces possible failure conditions.

The engineering objective is not to pretend failures can be eliminated.

It is to anticipate important failure modes, detect them where possible, limit their consequences, and provide an appropriate recovery path.

A useful design question is:

If this step fails, what should the system do next?

3. Five Failure Modes AI Engineers Should Consider

Failure 1 — The Model Produces an Unsupported Answer

A language model may generate a fluent response containing inaccurate or unsupported claims.

Possible controls include evidence checks, groundedness evaluation, explicit uncertainty, and escalation when reliable evidence is unavailable.

Failure 2 — Retrieval Returns the Wrong Information

A RAG application may retrieve irrelevant, outdated, incomplete, or unauthorized content.

Possible controls include relevance thresholds, metadata filters, access control, document versioning, and retrieval evaluation.

Failure 3 — An External Tool Becomes Unavailable

An AI agent may depend on an API that returns an error or times out.

Possible controls include timeouts, bounded retries, circuit breakers, and an alternative workflow.

Failure 4 — An Agent Attempts an Unsafe Action

An agent may propose an action that exceeds its authority or has significant consequences.

Possible controls include restricted permissions, policy checks, human approval, and audit logging.

Failure 5 — The System Cannot Explain What Happened

Without appropriate traces and logs, engineers may struggle to identify the cause of an unexpected result.

Possible controls include structured events, request identifiers, tool-call traces, and privacy-conscious observability.

4. The Failure-Response Design Pattern

DETECT → CLASSIFY → CONTAIN → RECOVER → RECORD → IMPROVE

Detect

Recognize an error, timeout, policy violation, or unacceptable output.

Classify

Determine whether the problem is temporary, permanent, recoverable, or safety-critical.

Contain

Prevent the failure from causing unnecessary downstream consequences.

Recover

Retry safely, use an approved fallback, request clarification, or escalate.

Record

Capture enough information to investigate the failure without exposing sensitive data.

Improve

Convert the failure into a test case, monitoring rule, or design improvement.

5. Connect the Principle to Industry Practice

Failure-aware AI engineering draws on established software reliability practices while addressing risks specific to AI-generated outputs and agent behavior.

Practice Purpose
Timeouts Prevent indefinite waiting for a service.
Bounded retries Recover from selected transient errors without uncontrolled repetition.
Circuit breakers Temporarily stop calls to a repeatedly failing dependency.
Fallbacks Provide an approved alternative when normal operation is unavailable.
Human approval Control consequential actions requiring judgment or authorization.
Evaluation Measure performance on expected and failure scenarios.

Retries require particular care. Repeating a non-idempotent action, such as issuing a payment or creating an order, can cause duplicate effects.

Recovery must be designed around the actual operation and its risks.

6. Hands-On Lab — Design a Failure-Aware AI Assistant

You do not need to write code for this introductory experiment.

Open diagrams.net to create a simple workflow diagram.

Our fictional application is an AI-powered employee policy assistant.

Step 1 — Draw the normal workflow

User Question → Retrieve Policy → Generate Answer → Display Answer

Step 2 — Introduce a failure

Imagine the policy retrieval service is unavailable.

Add a decision point: Did retrieval succeed?

Step 3 — Design the fallback

If retrieval fails, the assistant must not invent a policy answer.

Instead, it should tell the user that the approved policy could not be retrieved and direct them to an authorized human contact.

Step 4 — Add an observability event

Record a simulated event containing:

  • A request identifier
  • The failure category
  • The affected component
  • The fallback action
  • The outcome

Avoid storing sensitive user content unless there is an authorized need.

Step 5 — Test three scenarios

Scenario A: Retrieval succeeds and the answer is supported.

Scenario B: Retrieval times out.

Scenario C: Retrieval succeeds but returns no relevant policy.

For each scenario, describe the expected system behavior.

7. Reusable AI Engineering Prompt

Failure-Mode Design Assistant

Act as an AI engineering reliability reviewer.

I am designing the following AI application: [describe the application].

Identify five realistic failure modes.

For each, provide:

  1. Failure trigger
  2. Potential consequence
  3. Detection mechanism
  4. Safe response or fallback
  5. Test case
  6. Evidence that the control works

Distinguish model-output failures from infrastructure and integration failures.

Flag actions that require human approval. Do not assume a retry is safe.

Review the generated suggestions against the application's real architecture, requirements, and risk level.

8. What Should the Engineer Measure?

Reliability cannot be established through design intentions alone.

Useful measures may include:

  • Successful request rate
  • Timeout and dependency failure rates
  • Fallback activation frequency
  • Unsupported-answer rate on a defined test set
  • Recovery time
  • Human escalation outcomes

Teams should define acceptable thresholds according to the application's use case and risk profile.

A customer support suggestion tool and an AI system involved in a consequential decision may require very different controls.

9. Today's Accomplishment

Create a one-page Failure-Response Blueprint.

  1. Draw the normal AI workflow.
  2. Identify three realistic failures.
  3. Define a safe response for each failure.
  4. Specify what should be logged.
  5. Write one test case for every failure.

Your accomplishment is not merely understanding the term "reliability."

It is producing a concrete design that describes how an AI application should behave when normal operation breaks down.

10. The Bigger Insight

Good AI engineering designs the successful path. Effective AI engineering also designs what happens when that path fails.

Dependability is not simply a property of the language model.

It emerges from the architecture, controls, monitoring, recovery mechanisms, operational processes, and people responsible for the complete system.

The engineering goal is not a system that never encounters failure.

It is a system that handles anticipated failures appropriately and gives engineers the evidence needed to improve it.

Industry References and Further Study

This article is an independent synthesis of established reliability engineering and AI risk-management practices, not an official principle issued by any one organization.

AIYING — From AI Awareness to Accomplishment

AI Engineering Principles & Practice is an independent study series connecting established engineering knowledge with practical AI system design, testing, deployment, and operation.

AIYING | Ravindra Dastikop

Friday, November 13, 2026

AI Engineering Active Concepts #012 — Observability and Tracing: Understanding What AI Systems Actually Do

AI ENGINEERING — ACTIVE CONCEPTS & PRACTICES | #012

Observability and Tracing: Understanding What AI Systems Actually Do



Chapter 2: Engineering AI Applications and Agents

AIYING — Accomplishing with AI

The Big Idea: Observability makes the internal behavior of AI applications understandable through telemetry such as traces, metrics, logs, and execution events.

Tracing reveals how individual steps contribute to an end-to-end AI workflow.

Engineering question: How can engineers diagnose failures, understand costs, and improve reliability when AI systems involve multiple model calls, retrieval operations, tools, and decisions?

Contents

  1. Why Observability Matters
  2. UNDERSTAND — The Concept
  3. CONNECT — AI Engineering Relationships
  4. Observability Architecture
  5. APPLY — Enterprise Procurement Agent
  6. Worked Example: Diagnosing Slow Execution
  7. Engineering Decisions and Trade-offs
  8. Active Industry Practices
  9. ACCOMPLISH — Practical Exercise
  10. Student and Practitioner Project
  11. Check Your Understanding
  12. Active Connections
  13. References and Further Reading

1. Why Observability Matters

Imagine an enterprise AI agent that retrieves purchase orders, checks inventory, recommends recovery actions, and prepares approval requests.

Yesterday, the workflow completed in 12 seconds. Today, the same type of request takes 45 seconds.

The final answer still looks correct.

Without execution telemetry, the engineering team cannot determine whether the delay came from retrieval, model inference, tool execution, retries, or external systems.

Observability makes these internal operations visible.

An AI system that cannot be observed is difficult to diagnose, improve, and operate reliably.

2. UNDERSTAND — The Concept

What is observability?

Observability is the ability to understand the internal state and behavior of a system using information it emits during operation.

In AI engineering, this includes model calls, prompts and responses where permitted, retrieval operations, tool invocations, workflow transitions, latency, errors, and resource consumption.

Three foundational telemetry signals

SignalWhat It RevealsExample
TracesHow a request progresses across operationsModel → Retrieval → Tool → Response
MetricsAggregated quantitative behaviorLatency, error rate, token usage
LogsRecorded events and diagnostic detailsTool timeout, validation failure

What is tracing?

A trace represents the execution path of an operation across components.

Individual operations are often represented as spans.

Each span may record its name, start time, duration, status, attributes, and relationship to other spans.

Example trace

Trace: Procurement Request
|
+-- Span 1: Parse Request
|
+-- Span 2: Retrieve Purchase Order
|
+-- Span 3: Check Inventory
|
+-- Span 4: Generate Recommendation
|
+-- Span 5: Validate Recommendation
|
+-- Span 6: Prepare Approval Request

Tracing helps engineers understand which operations occurred, their order, and where time or failures accumulated.

Observability versus evaluation

Observability: What happened during execution?

Evaluation: Did the system perform correctly against defined criteria?

Observability supplies evidence that evaluation can use, but traces alone do not establish whether a result was correct.

3. CONNECT — AI Engineering Relationships

ConceptConnection to Observability
Context EngineeringTracks context assembly and token usage
Retrieval EngineeringMeasures retrieval latency and failures
Structured OutputsRecords validation failures
Tool CallingTracks tool requests, results, and errors
MCPMonitors interactions with external servers
Agent OrchestrationTracks workflow steps and state transitions
Agent EvaluationUses traces as evidence for quality assessment
Token EconomicsMeasures token consumption and estimated cost
AI GovernanceSupports auditability and accountability

Active connection: Observability connects AI development, testing, operations, and governance through recorded evidence of system behavior.

4. Observability Architecture

User Request

↓

AI Application / Agent

↓

Instrumented Model, Retrieval, and Tool Operations

↓

Telemetry Collection

↓

Traces + Metrics + Logs

↓

Monitoring, Analysis, and Alerts

↓

Diagnosis, Evaluation, and Improvement

Instrumentation

Instrumentation adds the mechanisms that generate telemetry from application operations.

Trace correlation

Related spans share trace identifiers so that operations across services can be analyzed together.

Metrics collection

Systems aggregate measurements such as request counts, latency distributions, error rates, and token consumption.

Logging

Structured logs capture relevant events, errors, and operational details.

Dashboards and alerts

Dashboards display trends, while alerts notify operators when defined thresholds or conditions are met.

Security and privacy

Observability systems must avoid unnecessary exposure of sensitive prompts, personal information, credentials, and confidential tool results.

5. APPLY — Enterprise Procurement Agent

Scenario: A Slow Procurement Workflow

A procurement AI agent performs the following operations:

  • Interprets the user request.
  • Retrieves purchase-order information.
  • Checks inventory.
  • Generates a recovery recommendation.
  • Validates the recommendation.
  • Prepares an approval request.

The workflow is taking substantially longer than expected.

What should engineers inspect?

ComponentObservable Signal
Model inferenceLatency, token usage, errors
RetrievalQuery duration, result count, failures
Inventory APIResponse time, timeout rate, retries
Workflow controllerStep count, state transitions, loops
ValidationSchema and business-rule failures
Approval serviceRequest creation and delivery status

With distributed tracing, engineers can identify which operation is contributing most to latency.

With metrics, they can determine whether the problem affects one request or a larger population.

With logs, they can investigate specific error events.

6. Worked Example: Diagnosing Slow Execution

Consider the following fictional trace of a sequential AI workflow.

OperationDuration
Request interpretation2 seconds
Purchase-order retrieval3 seconds
Inventory API call25 seconds
Recommendation generation10 seconds
Validation and response5 seconds
Total45 seconds

Latency contribution

Inventory API contribution =
25 / 45 × 100
= 55.6%

In this example, the inventory API accounts for approximately 56% of total execution time.

What should the engineer investigate?

  • Is the inventory service responding slowly?
  • Did the application retry the request?
  • Was there a network timeout?
  • Was the query unusually expensive?
  • Is the latency problem persistent or isolated?

The trace identifies where time was spent, but additional evidence is needed to establish the underlying cause.

Example structured trace record

{
  "trace_id": "trace-1048",
  "span_name": "inventory_lookup",
  "duration_ms": 25000,
  "status": "ok",
  "retry_count": 2,
  "service": "inventory-api",
  "workflow_id": "WF-1048"
}

This is an illustrative application record, not a complete OpenTelemetry span representation.

Engineering interpretation

The engineer now has evidence that the inventory lookup experienced retries and substantial latency.

The next step is to inspect the underlying API and retry policy rather than blindly changing the model or prompt.

7. Engineering Decisions and Trade-offs

DecisionBenefitTrade-off
Detailed tracingBetter diagnosisStorage and processing overhead
Full prompt loggingDetailed debugging contextPrivacy and confidentiality risks
SamplingReduced telemetry costSome traces may be unavailable
Real-time alertsFaster incident responseFalse positives and alert fatigue
Token-level metricsBetter cost analysisInstrumentation complexity
Long retentionHistorical analysisStorage and data governance burden

Common observability mistakes

  • Recording only final responses
  • Failing to correlate tool calls with workflow traces
  • Ignoring retry behavior
  • Logging sensitive information unnecessarily
  • Measuring averages without latency distributions
  • Collecting telemetry without actionable dashboards
  • Confusing operational success with answer correctness

Recommended engineering practices

  • Instrument important workflow boundaries.
  • Use consistent trace and span identifiers.
  • Record model, retrieval, and tool latency.
  • Capture token usage and estimated costs.
  • Record relevant workflow state transitions.
  • Use structured logs.
  • Protect sensitive telemetry.
  • Monitor error rates and latency percentiles.
  • Connect traces with evaluation results.
  • Define operational alerts and incident procedures.
Good observability collects the information engineers need to explain behavior and make decisions—not simply the largest possible volume of logs.

8. Active Industry Practices

Established foundations

  • Distributed tracing
  • Structured logging
  • Metrics and dashboards
  • Latency and error monitoring
  • Alerting and incident investigation
  • Trace correlation across services

AI-specific practices

  • Model-call tracing
  • Token and cost tracking
  • Retrieval and tool-call instrumentation
  • Agent execution trajectory tracing
  • Prompt and response metadata tracking
  • Evaluation-linked traces
  • Privacy-aware telemetry collection

Relevant technologies

Engineering teams may use OpenTelemetry, Jaeger, Grafana, LangSmith, MLflow, or other observability platforms according to application requirements.

OpenTelemetry provides vendor-neutral instrumentation concepts and conventions, while specialized AI observability platforms add workflow-oriented capabilities.

Specific generative AI semantic conventions and tooling support can vary by implementation and version.

Industry applications

Observability is important for production AI agents, RAG applications, enterprise assistants, AI-enabled software systems, workflow automation, and operational AI platforms.

Practice status: Established software observability discipline extended to generative AI and agentic systems.

Reviewed: November 2026.

9. ACCOMPLISH — Practical Exercise

Exercise: Diagnose an AI Workflow

Consider the following fictional telemetry:

Workflow duration: 45 seconds

Model calls: 4

Tool calls: 3

Inventory API duration: 25 seconds

Inventory retries: 2

Estimated execution cost: $0.18

Your tasks

  1. Identify the likely latency bottleneck.
  2. Calculate the inventory API's share of total execution time.
  3. Identify additional telemetry required for root-cause analysis.
  4. Recommend improvements to retry handling.
  5. Define three operational metrics.
  6. Propose two alerts.
  7. Explain what information should not be logged.
  8. Describe how evaluation results could be linked to traces.

Reusable AI-assisted prompt

Act as an AI systems observability engineer.

Analyze this fictional agent workflow:

Total duration: 45 seconds
Model calls: 4
Tool calls: 3
Inventory API duration: 25 seconds
Inventory retries: 2
Estimated cost: $0.18

Provide:
1. Initial performance diagnosis.
2. Latency contribution analysis.
3. Possible root causes.
4. Additional telemetry required.
5. Recommended metrics.
6. Trace and log requirements.
7. Alerting recommendations.
8. Privacy and security safeguards.
9. Improvement experiments.
10. Verification plan.

Distinguish observed facts from hypotheses.
Do not assume the root cause is proven.

Accomplishment: Produce an evidence-based diagnosis and observability improvement plan for an AI workflow.

10. Student and Practitioner Project

Mini Project: Build an AI Agent Observability Dashboard

Objective: Instrument a fictional AI workflow and create a basic monitoring dashboard.

Project requirements

  1. Define a multi-step fictional AI workflow.
  2. Instrument model and tool operations.
  3. Assign trace and span identifiers.
  4. Capture execution duration and status.
  5. Track token usage and estimated cost.
  6. Record tool errors and retries.
  7. Create a simple latency and error dashboard.
  8. Simulate a slow external API.
  9. Investigate the resulting trace.
  10. Recommend and test an improvement.

Suggested dashboard measures

MetricPurpose
Request countTracks workload volume
End-to-end latencyMeasures user-visible processing time
Tool latencyIdentifies slow external operations
Model latencyMeasures inference time
Error rateTracks operational failures
Retry countIdentifies repeated operations
Token usageMeasures model consumption
Estimated costTracks financial efficiency

Project deliverable: A trace diagram, telemetry dataset, dashboard or dashboard design, incident analysis, and engineering improvement recommendation.

11. Check Your Understanding

  1. What is observability in AI engineering?
  2. How do traces, metrics, and logs differ?
  3. What is a span?
  4. Why are trace identifiers important?
  5. How does observability support agent evaluation?
  6. Why can logging complete prompts create privacy risks?
  7. How would you investigate an unexpectedly slow AI workflow?
  8. What distinguishes operational success from task correctness?

Reflection: If an AI workflow completes successfully but consumes three times its normal cost, should the system be considered healthy? Which additional measures would help you decide?

12. Active Connections

Coming next — #013: Guardrails and Policy Enforcement: Keeping AI Applications Within Operational Boundaries.

13. References and Further Reading

  1. OpenTelemetry — Official Documentation
  2. OpenTelemetry — Generative AI Semantic Conventions
  3. LangSmith — Observability Documentation
  4. Grafana — Documentation
  5. Jaeger — Distributed Tracing Documentation

Instrumentation libraries, semantic conventions, and AI observability tools evolve. Verify the latest documentation before production implementation.


Final Takeaway

Observability makes AI execution understandable. Tracing shows how work progresses, metrics reveal performance patterns, and logs provide diagnostic evidence. Together, they enable engineers to investigate failures, control costs, and improve operational reliability.

AI Engineering — Active Concepts & Practices
Active Concept #012 — Observability and Tracing

AIYING — Accomplishing with AI

Understand → Connect → Apply → Accomplish

AI Engineering Active Concepts #011 — Agent Evaluation: Measuring Whether AI Workflows Actually Succeed

AI ENGINEERING — ACTIVE CONCEPTS & PRACTICES | #011

Agent Evaluation: Measuring Whether AI Workflows Actually Succeed



Chapter 2: Engineering AI Applications and Agents

AIYING — Accomplishing with AI

The Big Idea: Agent evaluation measures whether an AI workflow completes its intended task correctly, reliably, safely, and efficiently.

Fluent responses and successful tool calls do not necessarily demonstrate successful task completion.

Engineering question: What evidence proves that an AI agent accomplished the intended business outcome?

Contents

  1. Why Agent Evaluation Matters
  2. UNDERSTAND — The Concept
  3. CONNECT — AI Engineering Relationships
  4. Evaluation Architecture
  5. APPLY — Enterprise Procurement Agent
  6. Worked Example: Evaluating 100 Workflows
  7. Engineering Decisions and Trade-offs
  8. Active Industry Practices
  9. ACCOMPLISH — Practical Exercise
  10. Student and Practitioner Project
  11. Check Your Understanding
  12. Active Connections
  13. References and Further Reading

1. Why Agent Evaluation Matters

Imagine a procurement AI agent assigned to investigate delayed purchase orders and recommend recovery actions.

During testing, it successfully calls the required tools, produces professional reports, and appears to follow the intended workflow.

But closer inspection reveals that some recommendations are based on outdated inventory, some approvals are missing, and several completed tasks were reported incorrectly.

The agent may look effective without being operationally reliable.

The success of an AI agent must be evaluated against the intended outcome, not merely the quality of its generated response.

2. UNDERSTAND — The Concept

What is agent evaluation?

Agent evaluation is the systematic assessment of how well an AI agent or agentic workflow performs defined tasks under specified conditions.

It examines the final outcome, intermediate decisions, tool interactions, operational constraints, and failure behavior.

Five evaluation dimensions

DimensionKey Question
CorrectnessDid the agent produce the right result?
ReliabilityDoes it succeed consistently across relevant cases?
EfficiencyHow much time and cost does execution require?
SafetyDid it respect permissions and operational boundaries?
UsefulnessDid the outcome help accomplish the real task?

Three levels of evaluation

Component evaluation: Tests individual operations such as retrieval, classification, and tool selection.

Trajectory evaluation: Examines the sequence of steps, tool calls, decisions, and state transitions.

Outcome evaluation: Determines whether the overall task was completed correctly.

Evaluation versus monitoring

Evaluation determines whether a system meets defined criteria.

Monitoring observes its behavior during operation.

Production traces and feedback can supply evidence for ongoing evaluation, but monitoring alone does not establish correctness.

3. CONNECT — AI Engineering Relationships

ConceptConnection to Evaluation
Context EngineeringTests whether the model receives relevant information
Retrieval EngineeringMeasures relevance, coverage, and evidence quality
Structured OutputsTests schema adherence and data accuracy
Tool CallingEvaluates tool selection and argument correctness
MCPTests external capability discovery and invocation
Agent OrchestrationEvaluates workflow progression and recovery
ObservabilitySupplies execution traces and operational signals
AI GovernanceDefines accountability, safety, and approval requirements
Token EconomicsMeasures execution costs and efficiency

Active connection: Evaluation turns the technical capabilities studied in earlier lessons into measurable engineering performance.

4. Evaluation Architecture

Define Intended Task and Success Criteria

↓

Build Representative Test Cases

↓

Execute Agent Workflow

↓

Capture Outputs and Execution Traces

↓

Apply Deterministic and Judgment-Based Checks

↓

Analyze Failures and Performance

↓

Improve and Re-Evaluate

Step 1 — Define success

Specify observable completion conditions, acceptable errors, and prohibited actions before testing.

Step 2 — Construct evaluation cases

Include normal cases, edge cases, ambiguous requests, incomplete data, tool failures, and authorization scenarios.

Step 3 — Run the workflow

Execute the system against controlled inputs using representative tools or simulated environments.

Step 4 — Capture evidence

Record final outputs, tool calls, execution state, latency, cost, and relevant decisions.

Step 5 — Score results

Use exact checks where objective answers exist and carefully designed human or model-based judgments where interpretation is required.

Step 6 — Diagnose failures

Determine whether failures originated in retrieval, planning, tool use, reasoning, authorization, or workflow execution.

Step 7 — Improve and retest

Repeat evaluations after changes and check for regressions in previously successful cases.

5. APPLY — Enterprise Procurement Agent

Scenario: Evaluating Purchase Order Recovery

A manufacturing organization uses an AI agent to identify delayed purchase orders and recommend recovery actions.

The system can retrieve order records, inspect alternative stock, examine procurement policies, and prepare approval requests.

What should be evaluated?

Evaluation AreaExample Test
Order retrievalDid the agent identify the correct purchase order?
Inventory accuracyDid it use current, authorized inventory data?
RecommendationIs the proposed recovery action feasible?
Policy complianceDid it follow procurement constraints?
Approval handlingDid it pause before restricted operations?
Execution reportingDid it distinguish proposed and completed actions?
Failure handlingDid it recover or escalate appropriately?

Why end-to-end evaluation matters

A system may retrieve the correct order and select the correct tool yet recommend an invalid stock transfer.

Conversely, it may produce a correct recommendation but fail to obtain mandatory approval.

Evaluation must consider the complete workflow and its operational requirements.

6. Worked Example: Evaluating 100 Workflows

Consider the following fictional test results for a procurement agent.

MeasureIllustrative Result
Total test cases100
Correct final outcomes82
Correct tool selection94
Correct tool arguments90
Approval violations2
Average execution time18 seconds
Average estimated execution cost$0.06

Assume each case contributes one binary result to each applicable measure, and all 100 cases are eligible for the listed accuracy checks.

Task success rate

Task Success Rate =
Successful Cases / Total Cases × 100

= 82 / 100 × 100
= 82%

Tool selection accuracy

Tool Selection Accuracy =
Correct Selections / Evaluated Cases × 100

= 94 / 100 × 100
= 94%

Approval violation rate

Approval Violation Rate =
Cases with Violations / Total Cases × 100

= 2 / 100 × 100
= 2%

For production evaluation, approval violations should also be measured against the subset of cases where approval requirements actually apply.

Interpretation

The agent selects tools correctly in most cases, but its final task-success rate is lower.

This indicates that tool selection alone does not explain overall performance.

More importantly, two approval violations indicate a control failure requiring investigation. A high average success rate cannot compensate for unauthorized consequential actions.

Engineering conclusion

The system requires root-cause analysis, stronger approval enforcement, and targeted regression tests before its suitability for production can be established.

7. Engineering Decisions and Trade-offs

DecisionBenefitTrade-off
Exact-match scoringRepeatable and objectiveMay reject valid alternatives
Human evaluationContextual judgmentTime and reviewer variability
LLM-as-judgeScalable qualitative assessmentBias and grading errors
Simulated environmentsSafe and repeatable testsMay differ from production
Production feedbackReal-world relevanceNoise and incomplete ground truth
Trace-level scoringDetailed diagnosisHigher evaluation complexity
End-to-end scoringMeasures task completionMay obscure root causes

Important evaluation risks

  • Unrepresentative test datasets
  • Ambiguous or incorrect reference answers
  • Overreliance on subjective grading
  • Data leakage between development and test sets
  • Ignoring rare but severe failures
  • Confusing fluent explanations with correct outcomes
  • Failing to retest after changes
  • Using averages that conceal critical failure cases

Recommended practices

  • Define success criteria before implementation.
  • Use representative and adversarial test cases.
  • Combine deterministic checks with calibrated human judgment.
  • Capture execution traces.
  • Separate quality, safety, latency, and cost measures.
  • Track performance by scenario and failure category.
  • Maintain regression test suites.
  • Investigate critical failures independently of aggregate scores.
Evaluation quality depends not only on the metric but also on the relevance of the test cases, the validity of the reference answers, and the consequences of failure.

8. Active Industry Practices

Established practices

  • Task-based benchmark datasets
  • Unit and integration testing for tools
  • Human review of model outputs
  • Automated regression testing
  • Latency and cost measurement
  • Failure classification and analysis

Evolving agent evaluation practices

  • Trajectory and trace evaluation
  • LLM-assisted grading
  • Simulation-based agent testing
  • Multi-turn and multi-step task evaluation
  • Continuous evaluation from production feedback
  • Risk-weighted evaluation of agent actions

Relevant technologies

Engineering teams may use OpenAI Evals and agent evaluation tooling, LangSmith, MLflow, or custom test harnesses depending on their requirements.

Evaluation tools do not replace the need for clearly defined business success criteria and valid test data.

Industry relevance

Agent evaluation is important in enterprise automation, customer support, software development, financial operations, procurement, research assistants, and other systems where AI-generated decisions influence operational outcomes.

Practice status: Established software testing principles combined with rapidly developing agent-specific evaluation methods.

Reviewed: November 2026.

9. ACCOMPLISH — Practical Exercise

Exercise: Evaluate a Procurement Agent

Consider a fictional agent that investigates delayed purchase orders.

Task: Recommend a recovery action.

Purchase order: PO-2056

Required quantity: 500 units

Alternative stock: 350 units

Approval: Required for stock transfer

Your tasks

  1. Define what successful completion means.
  2. Identify the required evidence.
  3. Write five normal test cases.
  4. Write three failure or edge cases.
  5. Define a scoring rubric.
  6. Identify critical safety checks.
  7. Specify the execution information to record.
  8. Describe how failures should be classified.
  9. Recommend a release decision based on the results.

Reusable AI-assisted prompt

Act as an AI engineering evaluation specialist.

Design an evaluation plan for a
fictional procurement AI agent.

The agent:
- Retrieves purchase-order information
- Checks alternative inventory
- Recommends recovery actions
- Requests approval when required
- Reports workflow outcomes

Provide:
1. Task success criteria.
2. Representative test scenarios.
3. Edge and failure cases.
4. Expected results.
5. Tool-use evaluation criteria.
6. Workflow trace checks.
7. Safety and approval tests.
8. Cost and latency metrics.
9. Failure classification.
10. Release-readiness recommendation.

Distinguish simulated test results
from real measured performance.

Accomplishment: Create an evaluation plan that measures whether an AI agent accomplishes its intended task safely and reliably.

10. Student and Practitioner Project

Mini Project: Build an Agent Evaluation Harness

Objective: Develop a small evaluation system for a fictional procurement agent.

Project requirements

  1. Define 20 representative test cases.
  2. Create expected outcomes for each case.
  3. Implement or simulate an agent workflow.
  4. Capture tool calls and execution results.
  5. Score final task completion.
  6. Check tool selection and argument correctness.
  7. Test approval compliance.
  8. Measure execution latency and estimated cost.
  9. Classify failed cases.
  10. Produce a performance report and improvement plan.

Suggested evaluation scorecard

MetricPurpose
Task success rateMeasures correct final outcomes
Tool selection accuracyMeasures correct tool choice
Argument accuracyMeasures correctness of tool inputs
Policy complianceMeasures adherence to operational rules
Recovery successMeasures handling of failures
Average latencyMeasures execution speed
Average costMeasures resource efficiency
Critical failure countTracks severe errors independently

Project deliverable: A test dataset, evaluation harness or design, execution traces, scorecard, failure analysis, and engineering recommendations.

11. Check Your Understanding

  1. What is agent evaluation?
  2. Why is fluent output insufficient evidence of success?
  3. How do component, trajectory, and outcome evaluations differ?
  4. What is the difference between evaluation and monitoring?
  5. When is deterministic scoring preferable?
  6. What are the limitations of LLM-as-judge evaluation?
  7. Why must critical failures be examined separately?
  8. How would you evaluate an agent before production deployment?

Reflection: If an AI agent achieves 98% task success but occasionally performs unauthorized actions, should it be considered production-ready? What additional controls or evidence would be required?

12. Active Connections

Coming next — #012: Observability and Tracing: Understanding What AI Systems Actually Do.

13. References and Further Reading

  1. OpenAI — Evaluation Guides
  2. OpenAI Evals — GitHub
  3. LangSmith — Evaluation Documentation
  4. MLflow — GenAI Evaluation and Monitoring
  5. NIST AI Risk Management Framework

Evaluation frameworks, metrics, and tooling evolve. Consult current documentation and validate scoring methods against the requirements of each application.


Final Takeaway

An AI agent is not successful because it completed a sequence of steps. It is successful when evidence demonstrates that it achieved the intended outcome correctly, safely, and reliably.

AI Engineering — Active Concepts & Practices
Active Concept #011 — Agent Evaluation

AIYING — Accomplishing with AI

Understand → Connect → Apply → Accomplish

AI Engineering Active Concepts #010 — Agent Orchestration: Designing Reliable Multi-Step AI Workflows

AI ENGINEERING — ACTIVE CONCEPTS & PRACTICES | #010

Agent Orchestration: Designing Reliable Multi-Step AI Workflows



Chapter 2: Engineering AI Applications and Agents

AIYING — Accomplishing with AI

The Big Idea: Agent orchestration coordinates the sequence, dependencies, tools, decisions, state, and controls required to complete multi-step AI tasks.

An individual model response may be useful. An orchestrated workflow must deliver a verifiable outcome.

Engineering question: How do we make an AI workflow reliable when it involves multiple steps, external systems, failures, and human approvals?

Contents

  1. Why Agent Orchestration Matters
  2. UNDERSTAND — The Concept
  3. CONNECT — AI Engineering Relationships
  4. Agent Orchestration Architecture
  5. APPLY — Enterprise Procurement Workflow
  6. Worked Example: A Multi-Step Workflow
  7. Engineering Decisions and Trade-offs
  8. Active Industry Practices
  9. ACCOMPLISH — Practical Exercise
  10. Student and Practitioner Project
  11. Check Your Understanding
  12. Active Connections
  13. References and Further Reading

1. Why Agent Orchestration Matters

Consider an enterprise procurement manager asking:

"Check purchase order PO-1048. Verify whether the required material is available elsewhere. If delivery is delayed, recommend a recovery action and prepare the necessary follow-up."

This is not a single question. It is a sequence of dependent tasks.

The AI application may need to retrieve purchase-order information, inspect inventory, compare delivery alternatives, apply procurement policies, prepare a recommendation, and obtain approval before making changes.

Each step depends on information or decisions from previous steps.

What happens if the inventory service is unavailable? What if the purchase-order record is inconsistent? What if a human reviewer rejects the proposed action?

These are orchestration problems.

Agent orchestration is not simply connecting several AI calls. It is engineering the control flow that turns multiple operations into a dependable business outcome.

2. UNDERSTAND — The Concept

What is agent orchestration?

Agent orchestration is the coordination of AI models, tools, workflow steps, decisions, application state, and control mechanisms to accomplish a task.

The orchestrator may be implemented through conventional software logic, a workflow engine, an agent framework, or a combination of these.

Five essential responsibilities

ResponsibilityEngineering Question
PlanningWhich steps are required?
CoordinationWhat should run next, and what depends on what?
State managementWhat has already happened?
ControlWhich operations are permitted?
RecoveryWhat happens when a step fails?

Workflow versus agent

A workflow generally follows a predefined control structure. An agent may dynamically select actions and tools based on intermediate observations.

In practice, production systems often combine both approaches.

For example, an agent may analyze a supplier delay while a deterministic workflow controls approvals, record updates, and completion status.

Common orchestration patterns

  • Sequential: Execute dependent steps in order.
  • Parallel: Run independent operations concurrently.
  • Conditional routing: Choose a branch based on validated results.
  • Iterative: Repeat a bounded process until a condition is satisfied.
  • Supervisor-worker: Delegate specialized tasks to different components.
  • Human-in-the-loop: Pause for an authorized decision.
  • Event-driven: Resume when an external event occurs.

Not every problem needs multiple agents. A deterministic workflow with one model and a few tools may be simpler, cheaper, and easier to test.

3. CONNECT — AI Engineering Relationships

ConceptRelationship to Orchestration
Context EngineeringSupplies relevant information to each step
Token EconomicsControls the cost of repeated model calls
Retrieval EngineeringProvides external evidence
Context ManagementPreserves state and continuity
Structured OutputsDefines data contracts between steps
Tool CallingInvokes external capabilities
MCPProvides standardized access to external capabilities
EvaluationTests both individual steps and overall outcomes
ObservabilityTraces execution, latency, cost, and failures
GovernanceEstablishes accountability and approval controls

Active connection: Orchestration brings together the capabilities studied in earlier lessons into an operational AI application.

4. Agent Orchestration Architecture

User Request

↓

Workflow Controller / Orchestrator

↓

Task Planning and State Initialization

↓

Model and Tool Execution

↓

Result Validation

↓

Decision: Continue, Retry, Escalate, or Stop?

↓

Human Approval When Required

↓

Authorized Business Action

↓

Outcome Verification and Audit Record

State transitions

A workflow should have explicit states, such as:

CREATED
   |
   v
RUNNING
   |
   +--> WAITING_FOR_APPROVAL
   |           |
   |           v
   |        RUNNING
   |
   +--> FAILED
   |
   +--> COMPLETED

Real implementations may need additional states such as cancelled, timed out, rejected, or requiring manual intervention.

Why state matters

State enables a workflow to resume after interruptions, avoid repeating completed actions, and distinguish a pending operation from a successful one.

State should be stored in a durable application system when the workflow must survive process restarts or extended human approval delays.

5. APPLY — Enterprise Procurement Workflow

Scenario: Recovering from a Supplier Delay

A manufacturing company uses an AI assistant to investigate delayed material deliveries.

The assistant has access to fictional procurement, inventory, and supplier systems.

Step 1 — Retrieve purchase order

The system obtains the current order status through an authorized lookup tool.

Step 2 — Check inventory

The application retrieves stock availability from alternative locations.

Step 3 — Evaluate alternatives

The AI analyzes available evidence and prepares possible recovery options.

Step 4 — Apply business constraints

Deterministic checks verify inventory eligibility, policy requirements, and permitted actions.

Step 5 — Request approval

If a transfer or supplier change requires approval, the workflow pauses for the designated decision-maker.

Step 6 — Execute authorized action

The application invokes the approved operation and verifies its result.

Step 7 — Complete and record

The workflow reports the outcome and records the relevant execution history.

Important: The assistant should never describe an operation as completed merely because the model proposed it.

6. Worked Example: A Multi-Step Workflow

The following is a fictional design illustration, not a live enterprise integration.

Sample workflow state

{
  "workflow_id": "WF-1048",
  "po_id": "PO-1048",
  "status": "waiting_for_approval",
  "order_status": "delayed",
  "alternative_stock_available": true,
  "recommended_action": "internal_transfer",
  "approval_status": "pending",
  "execution_status": "not_started"
}

Illustrative orchestration pseudocode

async def process_order(po_id, user):
    order = await get_order(po_id, user)
    validate_order(order)

    if order["status"] != "delayed":
        return {"status": "completed",
                "action": "none"}

    inventory = await check_inventory(order, user)
    validate_inventory(inventory)

    proposal = await recommend_action(
        order, inventory
    )
    validate_proposal(proposal)

    approval_id = await request_approval(
        proposal, user
    )

    # Persist state and stop execution.
    # Resume only after a verified approval event.
    return {
        "status": "waiting_for_approval",
        "approval_id": approval_id,
        "execution_status": "not_started"
    }

This pseudocode illustrates a workflow boundary. A production implementation must authenticate the approver, persist state, resume through a controlled event, enforce authorization, and verify any eventual write operation.

What makes the workflow reliable?

  • Each step has defined inputs and outputs.
  • External results are validated.
  • State is recorded before suspension.
  • Approvals are explicit.
  • Retries are bounded and controlled.
  • Side-effecting actions use duplicate-prevention safeguards.
  • Completion is based on verified execution results.

7. Engineering Decisions and Trade-offs

DecisionBenefitTrade-off
Fixed workflowPredictability and testabilityLess flexibility
Dynamic agent planningAdapts to varied tasksHarder to constrain and evaluate
Parallel executionReduced latencyDependency and concurrency risks
Persistent stateResumabilityStorage and consistency complexity
Automatic retriesFailure recoveryCost and duplicate-action risks
Human approvalStronger oversightAdditional time
Multiple specialized agentsDivision of responsibilitiesCoordination overhead

Common failure modes

  • Infinite or excessive execution loops
  • Incorrect tool selection
  • Loss of workflow state
  • Contradictory intermediate results
  • Repeated actions after retries
  • Unauthorized execution
  • Unbounded token consumption
  • Incorrect completion reporting
  • Prompt injection through retrieved data or tool results

Recommended engineering controls

  • Maximum step and execution budgets
  • Timeouts and bounded retries
  • Checkpointing and durable state
  • Idempotency for operations with side effects
  • Structured contracts between components
  • Explicit approval boundaries
  • Least-privilege tool permissions
  • Execution tracing and audit records
  • Outcome-based evaluations
Reliable orchestration requires a controlled workflow, not merely a capable model.

8. Active Industry Practices

Established engineering approaches

  • State-machine and graph-based workflows
  • Task dependency management
  • Tool execution with validation
  • Human approval checkpoints
  • Persistent workflow state
  • Execution tracing and monitoring

Evolving AI engineering practices

  • Model-directed workflow routing
  • Supervisor and specialist-agent architectures
  • Agent evaluation using execution traces
  • Policy-aware tool orchestration
  • Adaptive planning with bounded autonomy
  • Durable execution for long-running agents

Relevant technologies

Developers may evaluate frameworks such as LangGraph, Microsoft Agent Framework, OpenAI Agents SDK, and conventional workflow engines.

These technologies have different architectures and operational characteristics. Framework selection should follow the requirements of the application rather than determine the architecture in advance.

Industry applications

Agent orchestration is relevant to customer support, software engineering, incident response, research assistants, enterprise operations, procurement, document processing, and multi-step business automation.

Practice status: Established workflow-engineering principles combined with evolving agentic AI architectures.

Reviewed: November 2026.

9. ACCOMPLISH — Practical Exercise

Exercise: Design a Procurement Recovery Workflow

Use this fictional scenario:

Purchase order: PO-2056

Status: Delayed

Required quantity: 500 units

Alternative location stock: 350 units

Proposed action: Partial internal transfer

Approval: Required

Your tasks

  1. Define the workflow objective.
  2. List the required tools and data sources.
  3. Identify sequential and parallel steps.
  4. Define workflow states and transitions.
  5. Specify validation checkpoints.
  6. Identify actions requiring approval.
  7. Design failure and retry handling.
  8. Define completion and escalation conditions.
  9. Explain how the remaining 150-unit shortage will be handled.

Reusable AI-assisted prompt

Act as an enterprise AI workflow architect.

Design an agent orchestration workflow
for a delayed purchase order.

Scenario:
- Order: PO-2056
- Required quantity: 500 units
- Alternative stock: 350 units
- Supplier delivery: delayed
- Internal transfer: approval required

Provide:
1. Workflow objective.
2. Required tools and data.
3. Step-by-step execution plan.
4. State transitions.
5. Validation rules.
6. Approval checkpoints.
7. Failure recovery strategy.
8. Cost and execution limits.
9. Observability requirements.
10. Completion and escalation criteria.

Distinguish AI-generated recommendations
from verified system actions.

Do not claim any real action was executed.

Accomplishment: Produce an orchestration design that can be reviewed for reliability, authorization, recovery, and measurable completion.

10. Student and Practitioner Project

Mini Project: Build a Stateful Procurement Agent

Objective: Prototype a multi-step AI workflow using simulated enterprise systems.

Project requirements

  1. Create fictional purchase-order and inventory datasets.
  2. Define lookup and simulated action tools.
  3. Implement a workflow controller.
  4. Persist workflow state between steps.
  5. Use structured inputs and outputs.
  6. Introduce an approval checkpoint.
  7. Simulate a tool timeout and a service failure.
  8. Test workflow resumption after interruption.
  9. Prevent duplicate side effects.
  10. Record execution traces and evaluate outcomes.

Suggested evaluation metrics

MetricWhat It Measures
Task completion rateSuccessful completion of authorized workflows
Step accuracyCorrect execution of required stages
Recovery successResumption after failures
State consistencyCorrectness of persisted workflow information
Approval complianceWhether required approvals are enforced
Duplicate action rateRepeated side effects after retries
Execution costModel and tool resource consumption
End-to-end latencyTotal workflow processing time

Project deliverable: A workflow diagram, working prototype or design, sample execution traces, evaluation results, and an engineering recommendation.

11. Check Your Understanding

  1. What is agent orchestration?
  2. How is orchestration different from tool calling?
  3. What is the difference between a fixed workflow and a dynamic agent?
  4. Why is persistent state important?
  5. When should workflow steps run in parallel?
  6. How should approval checkpoints be implemented?
  7. Why are retries dangerous for write operations?
  8. How would you measure end-to-end workflow reliability?

Reflection: If every individual AI step succeeds but the overall workflow performs an unauthorized action, has the system succeeded? What does this reveal about orchestration quality?

12. Active Connections

Coming next — #011: Agent Evaluation: Measuring Whether AI Workflows Actually Succeed.

13. References and Further Reading

  1. LangGraph — Overview
  2. OpenAI Agents SDK — Documentation
  3. Microsoft Agent Framework — Documentation
  4. Temporal — Durable Execution Documentation
  5. Model Context Protocol — Official Documentation

Framework capabilities and implementation guidance evolve. Verify the current documentation when building production systems.


Final Takeaway

A reliable AI workflow is not defined by how many agents or tools it uses. It is defined by whether it coordinates work correctly, handles failures, respects controls, and delivers a verified outcome.

AI Engineering — Active Concepts & Practices
Active Concept #010 — Agent Orchestration

AIYING — Accomplishing with AI

Understand → Connect → Apply → Accomplish

Accomplish with AI

Powered by Blogger.

Featured post

AI Engineering Hands-On Lab #001 — Build an AI Answer Reliability Test Bench Without Code

AIYING | Daily 24 — Post 009 AI Engineering Hands-On Lab #001 Build an AI Answer Reliability Test Bench — Without Writing Code Lea...

Search This Blog

List of blogs

Search This Blog

About

Translate

Instant Stories

Read in Your Language

Test

share this

ShareThis

Popular Posts