Ride the AI wave.
Build the skills to lead it.

Start with the implementation decisions your organization faces. Get oriented to OpsPilot, the classroom flight simulator, and learn what to observe when an AI system succeeds, fails, or needs human help.

• Course goals, participant context, and the learning path
• A realistic application with synthetic data
• Observe quality, cost, latency, and allowed actions

Understand what a model adds to an application and what surrounding software must still control. Explore why a convincing answer can be wrong, and why a successful demo leaves important engineering questions unanswered.

• Code, AI, or hybrid: deterministic and probabilistic behavior
• Models, tokens, context, memory, and hallucination
• Escalation, confidence, approval, and observable failure

Turn a painful business workflow into a bounded AI pilot. Compare model and hosting choices against the work you actually need done, including the full cost of routing, retries, and review.

• Automation versus augmentation; pilot scope and ownership
• Frontier, smaller, local, hosted, and privately deployed models
• Model selection, workflow cost, routing, and escalation

Learn how an application supplies current, authorized evidence to a model. Understand the mechanics of retrieval and the checks needed before presenting an answer as grounded in company information.

• Embeddings, semantic search, chunking, and retrieval-augmented generation (RAG)
• Documents versus authoritative APIs; RAG versus fine-tuning
• Access boundaries, prompt versions, citations, and evidence checks

Follow a proposed action through the application: structured output, validation, permission checks, approval, and execution. Compare fixed workflows with agent loops and decide when a direct API or Model Context Protocol (MCP) integration fits.

• Tool schemas, permissions, and approval for the exact action
• Retries, idempotency, partial failure, and durable progress
• Agent autonomy, stop conditions, direct APIs, and MCP

Define what acceptable behavior looks like and test it against independently checked examples. Learn why average quality scores can hide unacceptable failures and why an AI reviewer needs evaluation too.

• Deterministic validation, evaluation datasets, and quality rubrics
• Offline tests, runtime checks, AI review, and human escalation
• Check the answer and the actual outcome; state evaluation limits

Examine what happens when inputs are hostile, dependencies fail, or costs grow. Bring the architecture together into a practical pilot plan with explicit controls, evidence, and remaining readiness gaps.

• Prompt injection, data leakage, least privilege, and tool abuse
• Observability, versioning, regression evaluation, and graceful degradation
• Production-readiness review and a concrete first-pilot plan

Begin with a bounded use case and implement a model-backed application path. Make inputs, outputs, and failure behavior explicit so the model can be tested as one component of a larger system.

• Task boundaries, request flow, and model-provider integration
• Prompt configuration and structured output schemas
• Baseline behavior, validation, and error handling

Implement retrieval that supplies relevant evidence to a model, then examine how changes to context affect the response. Compare a document-based answer with a lookup from an authoritative application source.

• Embeddings, indexing, chunking, and retrieval
• Authorized context, citations, and source traceability
• Missing evidence, poor retrieval, and grounded-answer checks

Connect the model to a narrowly scoped application operation. Keep permission checks and business rules in code, and make approval apply to the action that will actually execute.

• Tool definitions, schema validation, and application APIs
• Read and write permissions; human approval boundaries
• Idempotency, retries, and partial-failure handling

Implement the next-step logic for a controlled workflow or agent. Explore where MCP helps expose tools, and how persistent state and limits prevent a restart from repeating an action or resetting a budget.

• Fixed orchestration versus model-selected next steps
• Direct API and MCP integration boundaries
• Durable progress, context management, budgets, and stop conditions

Build an evaluation set and compare the application against explicit acceptance criteria. Combine exact checks with rubric-based review while keeping severe failures visible instead of averaging them away.

• Representative examples and independently checked expected results
• Deterministic assertions and AI-reviewer rubrics
• Regression evaluation, failure categories, and human review

Compare execution paths for the same task and implement a routing policy. Account for the whole workflow, including retrieval, tool use, retries, and stronger-model review.

• Code, smaller models, and frontier-model paths
• Observable escalation triggers and fallback behavior
• Measure per-task quality, latency, and total cost

Challenge the implementation with hostile content and broken dependencies. Check whether the surrounding application preserves its boundaries when the model is persuaded, uncertain, interrupted, or unavailable.

• Prompt injection, unauthorized access, and unsafe tool requests
• Timeouts, repeated requests, partial completion, and recovery
• Audit evidence, graceful degradation, and operational limits

Bring the application path, evaluation evidence, and operating controls together. Identify what the training implementation demonstrates and what still needs to be proven before use in your organization.

• Trace behavior across model, data, tools, and validation
• Version prompts and configuration; rerun tests after changes
• Readiness gaps, pilot acceptance criteria, and next engineering steps

Begin with the business workflow and learn where probabilistic models fit alongside conventional software. Compare model and hosting options, then scope a pilot that is small enough to evaluate and meaningful enough to matter.

• Orientation; AI terminology, context, and model behavior
• Code, AI, or hybrid; augmentation versus automation
• Model selection, hosting tradeoffs, routing, and workflow cost

Follow information and proposed actions through the system. Choose authoritative sources, understand retrieval, and define what tools and agents may do before deciding how much autonomy to give them.

• Embeddings, RAG, APIs, and evidence quality
• Structured output, permissions, approval, and idempotency
• Agent workflows, durable state, stopping limits, and MCP

Define how you will recognize acceptable behavior and unacceptable failures. Connect evaluation, security, and operations to a first-pilot plan that your engineering and business stakeholders can discuss.

• Evaluation datasets, deterministic checks, and AI review
• Prompt injection, data boundaries, observability, and recovery
• Acceptance criteria, ownership, readiness gaps, and pilot planning

Move from architectural choices into code. Connect a model to the application, add structured validation, and implement a knowledge path whose evidence can be inspected.

• Application inputs, outputs, and model integration
• Retrieval, authorized context, and citations
• Baseline comparison and grounded-answer checks

Implement controlled application actions and the workflow that surrounds them. Explore direct APIs and MCP while keeping permissions, approvals, and recovery in application logic.

• Tool contracts and permission enforcement
• Approval for the exact action; retries and duplicate prevention
• Workflow and agent state, budgets, and stopping conditions

Build repeatable evidence for quality and efficiency. Compare models and execution paths against the same criteria, keeping severe failures separate from average performance.

• Evaluation cases, rubrics, and regression checks
• Reviewer evaluation, escalation, and human oversight
• Quality, latency, cost, and model-routing decisions

Exercise the system with malicious inputs and dependency failures. Review the actual outcomes and identify the next work needed before a training implementation becomes an enterprise pilot.

• Injection, unauthorized actions, timeouts, and partial failure
• Audit trails, graceful degradation, and versioned changes
• Integrated readiness review and next-iteration planning