Chase NextGen LLC : 2026 Edition
AI Training Programs
Two distinct programs, each with its own audience and outcome. Choose one below to open its full session-by-session curriculum, hands-on labs and deliverables.
Program 01: Enterprise Team Training
AI Engineering & Agentic Systems
AI Engineering & Agentic Systems
Certification Program
Takes a whole software team from its first API call to a governed, evaluated, cost-controlled agentic system running on your own documents, tickets and pipelines. 100% live and instructor-led, taught end to end by a US-based Senior AI Solution Architect with 20+ years' experience. One hands-on track: every attendee builds the component, breaks it, and proves it holds. Nine 45-minute labs and a four-hour capstone, with Azure & AWS services covered at overview level inside the sessions.
10Live Sessions
17.5Live Hours
9Hands-On Labs
4 hrCapstone
Program 02: Individual Certification
AI & Generative AI
AI & Generative AI
Professional Certification Program
A 6-week intensive plus three advanced masterclasses, taking you from ML foundations and NLP through production RAG, agents, MCP and cloud AI deployment. Built for individual professionals, career transitioners and engineers moving into AI. Aligned with OWASP LLM Top 10, NIST AI RMF and the EU AI Act.
6Core Weeks
12Live Sessions
25+Hours Content
3Masterclasses
Back to Programs
Program 02 : Individual Certification
AI & Generative AI
AI & Generative AI
Professional Certification Program
6-week intensive curriculum + 3 advanced masterclasses. Industry-standard 2026, aligned with OWASP LLM Top 10. NIST AI RMF, EU AI Act.
Who This Program Is For
7 professional profiles: from career-changers & enthusiasts to ML engineers & enterprise architects.
- Career Transitioners: Pivoting from any field into AI/ML engineering as a new profession.
Beginner
- AI Enthusiasts: Experimenting with AI tools for personal projects and workflow automation, no engineering background required.
Beginner
- Software Developers: Integrating LLMs and AI agents into production-grade applications.
Intermediate
- Analysts & PMs: Using AI tools to accelerate analysis, automate reporting, and lead AI product decisions.
Beginner-Mid
- Consultants & Architects: Designing, evaluating, and presenting enterprise AI solutions to clients.
Advanced
- Data Scientists & ML Engineers: Bridging classical ML and modern LLM workflows in production environments.
Intermediate-Adv
- Business Leaders & Executives: Leading AI adoption strategy, managing AI initiatives, and driving org-wide transformation.
Non-technical
Prerequisites
Requirements vary by track: beginner, intermediate, and advanced paths each have their own entry points.
Beginner Tracks: Career Transitioners, AI Enthusiasts, Business Leaders
- No prior AI or ML experience required
- Basic comfort with computers and spreadsheets
- OpenAI API account with $5-10 credit: setup instructions provided in Week 1
Commitment3-5 hrs/week
Intermediate Tracks: Analysts & PMs, Software Developers
- Basic Python familiarity (variables, loops, functions), dev setup covered in Week 1
- Comfort with data concepts, APIs, and command-line basics
- OpenAI API account with $5-10 credit: setup instructions provided
- For Software Developers: familiarity with at least one backend language (Python preferred)
Commitment5-8 hrs/week
Advanced Tracks: Data Scientists, ML Engineers, Consultants & Architects
- Solid Python proficiency: OOP, data structures, and libraries (NumPy, Pandas)
- Familiarity with cloud platforms (AWS, Azure, or GCP) and API integration
- For ML Engineers: prior experience with model training, evaluation, and deployment
- For Consultants & Architects: experience with enterprise systems design or technical advisory
- OpenAI API account with $10-20 credit: additional cloud credits may apply
Commitment8-12 hrs/week
Core Curriculum
6-Week Learning Journey
Each tile covers 1-2 weeks. Click any tile to expand full session details, hands-on labs & deliverables.
Phase 1: AI Foundations & ML
Weeks 1-2 • Sessions 1-4 • From Zero to First Model • Build your dev environment, train ML models, and ship a working text classifier.
Week 1: AI Foundations, Algorithms & Dev Environment
Session 1 (2 hrs)History of AI, Gen AI Landscape & the ML Algorithm
- AI history → Modern AI boom (2017-2026)
- Gen AI vs. Discriminative AI: how they differ
- ML algorithm taxonomy: supervised, unsupervised, RL, deep learning
- Classification vs. regression vs. clustering vs. decision-making
- AI lifecycle: Data → Model → Deployment & Ops
- Dev environment setup: VS Code, Python 3.11+, Jupyter, GitHub Copilot
- HANDS-ON: Run your first Python ML script with scikit-learn
Session 2 (2 hrs)Deep Learning, Neural Networks & Vector Embeddings
- ANN, CNN, RNN architecture with real use cases
- Transformer models: self-attention, positional encoding, encoder-decoder
- Why transformers power GPT, Claude, Gemini
- Vector embeddings & multi-dimensional numerical space
- HANDS-ON: Train Word2Vec; visualize 50D embeddings in 2D with PCA
Week 1 DeliverableWorking Jupyter Notebook: word embedding visualization + dev environment checklist.
Week 2: Applied ML, NLP & Sentiment Analysis
Session 3 (2 hrs)NLP Pipelines & Sentiment Analysis at Scale
- NLP pipeline: tokenization → stop-word removal → lemmatization → vectorization
- VADER sentiment analysis: compound scores -1 to +1
- VADER vs. ML vs. LLMs for sentiment: when to use each
- Enterprise apps: customer feedback, brand monitoring, financial news
- HANDS-ON: Sentiment pipeline on 8,353 NFL draft comments
Session 4 (2 hrs)Address Classification: Regex, Gradient Boosting & Model Evaluation
- Rule-based regex approach: accuracy ceiling 74.32%
- Gradient Boosting Classifier: 97.70% accuracy
- Model evaluation: Accuracy, Precision, Recall, F1-Score
- Saves 222,000+ manual corrections per million addresses
- HANDS-ON: Build and evaluate a full text classification pipeline
Week 2 Deliverable: Mini CapstoneEnd-to-end text classification pipeline with evaluation report. Must exceed 80% accuracy.
Phase 2: LLMs, APIs & RAG
Weeks 3-4 • Sessions 5-8 • Make LLMs Know What Your Business Knows • Call GPT/Claude/Gemini APIs, master prompt engineering, and build a production RAG system.
Week 3: LLM Architecture, APIs & Prompt Engineering
Session 5 (2 hrs)LLM Architecture, API Integration & Model Selection
- LLM internals: tokenization, context windows, attention heads, parameter scale
- Proprietary vs. open-source models: cost, privacy, control trade-offs
- API integration: GPT-4o Mini, Gemini 1.5 Flash, Claude Haiku
- Model selection: use case → rate limits → context window → cost per token
- Secure API key management: .env locally; AWS Secrets Manager in prod
- HANDS-ON: Call 3 LLM APIs; compare latency, cost & output quality
Session 6 (2 hrs)Advanced Prompt Engineering & Open-Source LLMs on Hugging Face
- Prompt patterns: zero-shot, few-shot, chain-of-thought, tree-of-thought, ReAct
- System prompts, personas, and guardrail instructions
- HR job matching with all-MiniLM-L6-v2 (semantic similarity)
- Support ticket routing with facebook/bart-large-mnli (zero-shot classification)
- Running LLMs locally with Ollama
- HANDS-ON: Build a persona-based LLM chatbot with structured JSON output
Week 3 DeliverableDomain-specific LLM application using ≥1 Hugging Face model + 1 proprietary API.
Week 4: Retrieval-Augmented Generation (RAG)
Session 7 (2 hrs)RAG Architecture, Vector Databases & Financial Intelligence Demo
- Why RAG? Solving LLM limitations: knowledge cutoff, private data, hallucinations
- RAG vs. fine-tuning decision framework
- Indexing: PDF → chunking → OpenAI embeddings → ChromaDB
- "Lost in the Middle" problem and mitigation strategies
- Vector DB options: Pinecone, Qdrant, Weaviate, ChromaDB, pgvector
- HANDS-ON: Build FinRAG, financial chatbot over earnings reports & SEC filings
Session 8 (2 hrs)Advanced RAG, Multi-PDF Knowledge Base & Production Deployment
- Advanced RAG: multi-query, self-reflective, hierarchical, agentic RAG
- RAGAS evaluation: faithfulness, answer relevance, context precision/recall
- LLM-as-judge automated evaluation (1-5 scale per metric)
- SQLite audit logging: query history, EU AI Act compliance trail
- Production deployment: Gradio web UI + Flask REST API
- HANDS-ON: Deploy multi-PDF knowledge base with evaluation dashboard & audit trail
Week 4 Mid-Program ProjectProduction-ready RAG system with Gradio UI, source citations, evaluation scores & SQLite audit log.
Phase 3: Agents, MCP & Cloud AI
Weeks 5-6 • Sessions 9-12 • Build & Ship Production AI Systems • Autonomous agents, Model Context Protocol, n8n automation, cloud AI stacks & capstone.
Week 5: Agentic AI, LangGraph & MCP
Session 9 (2 hrs)LangChain, LangGraph & Building Enterprise AI Agents
- Agentic AI: reasoning engines, tool calling, state management, cyclic pipelines
- LangChain: LLM wrappers, prompt templates, chains, output parsers
- LangGraph: directed graphs, nodes, edges, Pydantic state objects
- Single-agent vs. multi-agent architecture
- HANDS-ON: Build SmartHire, AI talent recruitment agent (resume screening → email)
Session 10 (2 hrs)Model Context Protocol (MCP): Connecting AI to Enterprise Systems
- What is MCP? Open standard for structured, secure AI-to-enterprise-data connectivity
- MCP architecture: Host → Bridge → Servers (databases, APIs, tools)
- EU AI Act alignment: audit trails, human-in-the-loop, separation of concerns
- Connecting MCP to PostgreSQL, SharePoint & custom internal APIs
- HANDS-ON: Build enterprise AI assistant with FastAPI MCP server + GPT-4o Mini + Gradio
Week 5 DeliverableAgentic AI app connecting to ≥1 real data source via MCP or LangGraph tool use, with architecture diagram.
Week 6: Cloud AI, n8n Automation & Capstone
Session 11 (2 hrs)n8n Automation + AI System Design, Cloud AI Stack & MLOps
- n8n: triggers, nodes, 800+ integrations; AI Agent nodes with OpenAI/Claude/Gemini
- AWS AI Stack: Bedrock, SageMaker, Rekognition, Amazon Q
- Azure AI Stack: Azure OpenAI Service, AI Foundry, Cognitive Services
- GCP AI Stack: Vertex AI, Gemini API, AutoML, BigQuery ML
- MLOps: CI/CD for models, experiment tracking, drift monitoring
- HANDS-ON: Build 3-node AI workflow, news fetch → LLM summarize → auto-distribute
Session 12 (2 hrs)Capstone Presentations, Mock AI Technical Interview & Career Pathways
- Student capstone presentations: architecture + live demo + lessons learned
- Portfolio-building: GitHub standards, LinkedIn positioning
- Interview mastery: AI system design prompts + STAR method
- AI Engineer career paths 2026: roles, compensation bands, required skills
- LIVE MOCK INTERVIEW: Practice system design with peer & instructor feedback
Final Capstone DeliverableEnd-to-end AI app combining ≥3 program concepts, deployed on cloud. Required: GitHub repo, architecture diagram, 5-min demo, 1-page business impact summary, cloud ADR.
Assessment & Certification
Clear, measurable criteria across 4 assessment components. Three certification tiers from Core Certificate to AI Engineering Professional.
Assessment Components
- 30%: Weekly Hands-On Labs: Jupyter notebooks per session, graded on functionality & completeness
- 20%: Mid-Program Project (Week 4 RAG): graded on functionality, RAGAS metrics & documentation
- 30%: Final Capstone Presentation: live demo + architecture diagram + business impact summary
- 20%: Masterclass Deliverables: required for Advanced Practitioner and AI Engineering Professional tiers
Certification Requirements
- Complete 6-week core curriculum with 80%+ attendance
- Submit at least 1 project deliverable
- Core Certificate: complete the 6-week curriculum
- Advanced Practitioner: Core + MC1 (Fine-Tuning) or MC2 (Responsible AI)
- AI Engineering Professional: Core + all 3 Masterclasses + Capstone
Advanced Specializations
Advanced Masterclasses
Full-day intensive specializations recommended after Week 3+. Each masterclass is structured as 2-hour sessions. Click any tile to explore the complete agenda.
Masterclass 1. LLM Fine-Tuning with LoRA & QLoRA
Full-day intensive • Theme: Adapt Foundation Models to Your Domain • From theory to a fully evaluated, production-deployed fine-tuned model.
- Recommended after completing Week 3+
- Requires GPU access (Google Colab Pro or local GPU)
- Based on a real insurance industry use case
Session 1 LoRA & QLoRA Theory + Data Preparation
- Fine-tuning decision matrix: prompt engineering vs. LoRA/PEFT vs. full fine-tuning
- LoRA mechanics: low-rank adapter matrices A & B, 0.16% of parameters vs. full fine-tuning
- QLoRA: LoRA + 4-bit quantization, fine-tune 7B+ models on a single consumer GPU
- Label masking: prompt tokens → -100 (ignored); response tokens → actual IDs
- Data quality requirements, minimum dataset size, instruction-following format spec
- Insurance use case: emails + call transcripts + CRM notes → concise summaries
- HANDS-ON: Prepare fine-tuning dataset from multi-source customer communication data
Session 2 Fine-Tuning Execution, Evaluation & Production Deployment
- Configure LoRA hyperparameters: rank, alpha, target modules, LR, batch size
- Fine-tune Qwen 2.5 (0.5B) on domain-specific insurance summarization task
- Training monitoring: loss curves, gradient norms, overfitting detection
- BERTScore evaluation: precision, recall, F1, F1 > 0.9 is near human-level quality
- Merge LoRA adapters back into base model weights for production
- Hosting: Hugging Face Hub, AWS SageMaker, or self-hosted inference
- HIPAA & GDPR compliance for fine-tuning on enterprise data
- HANDS-ON: Full fine-tuning run + before/after quality comparison with BERTScore
MC1 DeliverableFine-tuned LLM on a domain of your choice (legal, medical, finance, HR) with a BERTScore evaluation report comparing base vs. fine-tuned outputs.
Masterclass 2: Responsible AI, LLM Security & Governance
Full-day intensive • Theme: Build AI That Is Safe, Fair & Compliant • Threat landscape, guardrail implementation, and compliance frameworks.
- Mandatory knowledge for any enterprise AI deployment
- Aligned with OWASP LLM Top 10, NIST AI RMF & EU AI Act 2026
Session 1 LLM Threat Landscape & Attack Scenarios
- OWASP LLM Top 10 (2026): LLM01 Prompt Injection → LLM10 Model Theft
- Prompt injection: direct, indirect, jailbreaking, multi-turn bypass techniques
- Real-world attacks across healthcare, finance & e-commerce with live examples
- Agentic AI & Excessive Agency: least-privilege, scoping tool permissions
- Data poisoning, model inversion & membership inference attacks
- HANDS-ON: Red-team a sample LLM application, find & document 3 attack surfaces
Session 2 Guardrail Architecture & Compliance Frameworks
- 4-layer defense-in-depth: input filtering → content validation → output review → monitoring
- Rule-based guardrails: regex, topic blocklists, PII detection & redaction
- ML-based guardrails: Detoxify classifier for real-time toxic content detection
- LLM-Guard framework: scanners, validators & shields
- NIST AI RMF: Govern → Map → Measure → Manage cycle
- EU AI Act 2026: high-risk classification, conformity assessments, audit trail requirements
- Human-in-the-loop design: when approval is required before any agent action
- HANDS-ON: Implement 4-layer guardrail system on Llama 3 with compliance audit logging
MC2 DeliverableSecurity assessment report: map attack surfaces to OWASP LLM Top 10, implement ≥2 guardrail layers, document NIST AI RMF and EU AI Act compliance posture.
Masterclass 3: AI Dev Lifecycle, Cloud AI & Agentic Desktop
Full-day intensive • From Problem Definition to Production Rollout • AI Dev Lifecycle, AWS / Azure / GCP deep-dive, and Claude CoWork agentic AI.
Session 1 AI Development Lifecycle & Pre-Development Checklist
- Automation: Eliminate repetitive tasks; reduce overhead by 40-70%
- Intelligence: Unlock insights invisible to traditional systems
- Scale: Serve millions with consistent quality and zero fatigue
- Pre-Dev Checklist: Problem Statement → Stakeholders → Data Availability → Feasibility → Success Criteria → Ethical Review
- HANDS-ON: Define a complete AI project pre-dev checklist for your organization
Session 2 Cloud AI Services: AWS, Azure & GCP Deep-Dive
- AWS: Amazon Bedrock (Model-as-a-Service), SageMaker AI, Amazon Q, Models: Nova Pro, Claude 4.6, Llama 4, Mistral Large 3
- Azure: Azure AI Foundry, Azure OpenAI Service, Azure AI Search (vector DB for RAG), Models: GPT-5.4, Claude 4.6, Phi-4, DeepSeek-R1
- GCP: Vertex AI Platform, Gemini API (multimodal), BigQuery ML, Vision AI, Models: Gemini 3.1 Pro, Claude 4.6 Sonnet, Llama 4
- Selection guide: when to choose each platform based on existing infra, compliance & use case
- HANDS-ON: Deploy the same RAG use case on AWS Bedrock vs. Azure OpenAI, compare cost, latency & quality
Session 3 Claude CoWork: Agentic AI for Knowledge Work
- Agentic desktop tool built around the outcome, not the prompt, launched Jan 2026
- Available for Pro, Max, Team & Enterprise subscribers; runs inside Claude Desktop (macOS & Windows)
- Same engine as Claude Code: no terminal needed; multi-step tasks executed end-to-end
- File System Access: reads, edits & creates files in folders you grant access to
- HANDS-ON: Use Claude CoWork to autonomously generate a technical report from raw data
MC3 DeliverableMaster the full AI application lifecycle. Navigate enterprise cloud platforms and deploy autonomous AI desktop tooling end-to-end.
Supplemental Resources & Stack
Curated frameworks, APIs, evaluation tools & research papers used throughout the program.
Frameworks & Platforms
- LangChain: RAG, agents & chain orchestration
- LangGraph: Stateful multi-agent graph workflows
- Hugging Face: Open-source models, datasets & spaces
- Ollama: Run LLMs locally without API costs
- n8n: Visual workflow automation with AI agent nodes
- ChromaDB: Embedded vector database for RAG
APIs & Model Providers
- OpenAI Platform: GPT-4o Mini, embeddings, fine-tuning
- Anthropic Console: Claude API (Haiku, Sonnet, Opus)
- Google AI Studio: Gemini 1.5 Flash/Pro API access
- Artificial Analysis Leaderboard: Compare models on speed, quality & cost
Evaluation & Quality Tools
- RAGAS: RAG evaluation: faithfulness, relevance, precision
- BERTScore: Semantic similarity evaluation for LLM outputs
- LLM-Guard: Open-source guardrail toolkit
Key Research Papers & Standards
- Lewis et al. (2020): RAG Original Paper: "Retrieval-Augmented Generation for NLU"
- Liu et al. (2023): "Lost in the Middle": LLM attention in long contexts
- Hu et al. (2021): LoRA Paper: "Low-Rank Adaptation of Large Language Models"
- OWASP LLM Top 10 (2025/2026): LLM application security
- NIST AI RMF: AI risk management framework
- EU AI Act: Current compliance requirements
Enroll: AI & Generative AI Professional Certification
6-week intensive plus 3 advanced masterclasses. Share a few details and the program coordinator will confirm your seat and the next cohort date.
Enroll Now Contact Program Coordinator
Back to Programs
Program 01 : Enterprise Team Training
AI Engineering & Agentic Systems
AI Engineering & Agentic Systems
Certification Program
10 sessions delivered in-house to a whole engineering team, 100% live and instructor-led throughout. Every session, lab and debrief is run personally by a Senior AI Solution Architect (US-based) with 20+ years of experience: the single instructor and guide for the entire program. One hands-on track, every attendee builds the same component, breaks it, and proves it holds. Industry-standard 2026, aligned with OWASP LLM Top 10, NIST AI RMF and the EU AI Act.
Who This Program Is For
6 engineering roles across one delivery team: from application developers to architects. No observer seats.
- Software Engineers: Building AI features into existing products and services.
Intermediate
- QA & Automation Engineers: Moving into eval engineering and AI test design.
Intermediate
- Tech Leads & Staff Engineers: Choosing architecture, autonomy levels and vendor stance.
Advanced
- DevOps & Platform Engineers: Operating AI systems: CI gates, tracing and cost control.
Intermediate-Adv
- Solution Architects: Designing governed agentic systems for regulated environments.
Advanced
- Engineering Managers: Deciding what ships and on what evidence. Narrative track, labs optional.
Non-lab
Prerequisites
Deep software engineering assumed. No AI or ML background required: the course starts at what a token is.
Required
- Working Python or JavaScript: you write and extend real code in every lab from Session 1
- Git and the command line: branch, commit and run a script unassisted
- Basic SQL: enough to read a query, for the tool-calling and audit-log labs
Helpful, Not Required
- Familiarity with a CI pipeline, used from Session 9 where the evaluation gate wires into pull requests
- No AI or ML background assumed: you know software engineering, and are new specifically to AI-native engineering
Commitment3 hrs live + 2 hrs/week
Accounts & Setup
- One provider API key with a small credit balance, or the pre-installed local model
- Setup pack issued one week before Session 1; keys pre-provisioned by the host organization
How the Program Works
One track, one shared system • Build It, Break It, Prove It • Every attendee implements the same component against the same pre-wired starter, then attacks it and measures it.
The Lab Model: Three Steps, Every Session
- 1. BUILD (~20 min): implement the session's component. The plumbing is supplied
- 2. BREAK (~15 min): attack your own build and record exactly how it fails
- 3. PROVE (~10 min): produce the evidence artifact you would show a reviewer
Standard 90-Minute Structure (Sessions 1-9)
- 00-30 min: Concept & context: what it is, why it matters, where it fails. Live demo, not slides
- 30-75 min: Hands-on lab: Build → Break → Prove from a pre-built starter
- 75-90 min: Debrief: compare results across the room, Q&A, set homework
Why the 45-Minute Lab Always Finishes
- Starter scaffolds: API wiring, sample data, vector index, MCP skeleton and CI pipeline pre-built
- One concept per lab: no linear algebra, no calculus, no model-training internals
- Cumulative artifacts: each session's output is the next session's input, with a reference version published
- Pair across seniority, so the explaining happens out loud
Course FramingAn AI feature is a prompt. An AI system is grounding + tools + control + evaluation + cost governance. Sessions 2-9 build each of those in turn.
Core Curriculum
10-Session Learning Journey
Each tile covers 2-3 sessions. Click any tile to expand full session details, hands-on labs & deliverables.
Block 1: Foundations, Context & Specs
Sessions 1-3 • From First API Call to Executable Specifications • Build a vendor-neutral client, engineer the context window instead of the prompt, and prove that spec quality now sets code quality.
Session 1: AI Foundations, Model Tiers & the Local / Hosted Decision
Session 1 (90 min)Lab: “Hello, Models”
- What an LLM does: next-token prediction; confident wrongness as a design constraint
- The three dials: tokens, context window, temperature
- 2026 model tiers: frontier / reasoning, balanced production, small & fast
- Hosted, gateway or local: cost, privacy, data residency, latency
- Cost model: price per million tokens, why output dominates, what caching changes
- BUILD: A two-provider client with retry, streaming and automatic failover
- BREAK: Run one prompt 10× at temperature 0 and 10× at 1.0; log the variance
- PROVE: Cost-quality worksheet: small vs frontier model at 1K and 100K calls/month
Session 1 DeliverableWorking environment, provider comparison sheet and non-determinism log.
Session 2: Prompt & Context Engineering, Structured Outputs
Session 2 (90 min)Lab: “The Requirement Extractor”
- Prompt anatomy: role, instructions, context, examples, output contract
- Context engineering: the window is a budget, not a bucket. Retrieve, don't dump
- Context rot and “lost in the middle”: why position changes the answer
- Prompt caching: stable prefixes cut cost and latency, and dictate assembly order
- Structured outputs: schema-enforced generation with Pydantic / Zod, validate and retry
- Prompts are source code: versioned, reviewed, tested, never edited in production
- BUILD: JSON schema and extraction prompt for a messy 3-page email thread
- BREAK: A 10-variant regression pack, including an instruction hidden in the email body
- PROVE: Measured cost and latency, with and without prompt caching
Session 2 DeliverableVersioned prompt file, JSON schema and a passing regression pack. The hidden-instruction case sets up Session 6.
Session 3: Spec-Driven Development & Codebase Onboarding
Session 3 (90 min)Lab: “Spec to Working Slice”
- Why “vibe coding” collapses at team scale: unreviewable diffs, no traceability
- Spec → Plan → Tasks → Code → Tests → Review, with a human gate at each arrow
- Writing specs an AI can execute: EARS notation, Given/When/Then. Precision beats prose
- Project context files: repo-level instructions that teach your standards and architecture
- Codebase onboarding: repository maps and pruning, for better accuracy and lower cost
- Traceability: requirement ID → spec → test case → commit → pull request
- SPEC: Write an EARS spec for one ReleaseIQ feature; hand it to another pair in writing only
- BREAK: Generate a test pack from the spec you received; log three ambiguities it failed to resolve
- BUILD: Implement the slice with an AI assistant; commit with the requirement ID
Session 3 DeliverableSpecification + test pack + implemented slice + traceability matrix. In most cohorts, most failures turn out to be specification failures, not model failures.
Block 2: Grounding, Retrieval & Evaluation
Sessions 4-5 • Stop the Model Guessing • Ground answers in your own documents with citations, then take retrieval from demo quality to something you could defend in a production readiness review.
Session 4: RAG Part 1: Grounding AI in Your Own Knowledge
Session 4 (90 min)Lab: “The ReleaseIQ Knowledge Base”
- Why RAG exists: knowledge cutoffs, private data, hallucination, “where did that answer come from?”
- The decision framework: RAG vs fine-tuning vs long context vs tool calls
- The indexing pipeline: source → parse → chunk → embed → store
- Chunking: size, overlap and structure-aware splitting: the highest-impact knob in most systems
- Storage options: pgvector, Chroma, Qdrant, Pinecone, Azure AI Search, Vertex AI Search
- Answer assembly: retrieve → rank → prompt → cite → refuse when unsupported
- Three failure modes: never retrieved, retrieved but ignored, retrieved but wrong
- BUILD: The ingest → retrieve → answer pipeline, with citation assembly
- PROVE: Author the golden question set: 20 real business questions with expected sources
- BREAK: Run the golden set and classify every failure as retrieval, generation or source data
Session 4 DeliverableGrounded Q&A over real team documents, plus the golden question set that every remaining session measures against.
Session 5: RAG Part 2: Hybrid Retrieval, Adaptive Routing & Evaluation
Session 5 (90 min)Lab: “Make It Actually Good”
- Hybrid search: BM25 + semantic, because error codes and identifiers defeat pure vector search
- Re-ranking: retrieve broadly, then rank precisely. Usually the cheapest large quality win
- Query transformation: rewriting vague questions, decomposing multi-part ones
- Adaptive / agentic RAG: a complexity router that decides how hard to work
- GraphRAG: when flat chunks cannot answer “what breaks if this component changes?”
- Evaluation: the RAG triad plus retrieval precision and recall. LLM-as-a-judge and its biases
- Production reality: freshness, permission-aware retrieval, audit logging, cost at corpus scale
- BUILD: Hybrid search, a re-ranking stage and a cheap-path / graph-path complexity router
- PROVE: The evaluation harness scoring the golden set. This becomes the CI gate in Session 9
- BREAK: Write the “who may see what” matrix, then attempt three deliberate access violations
Session 5 DeliverableA measured quality improvement backed by an evidence report, and a tested access-control boundary.
Block 3: Tool Calling, MCP & Single Agents
Sessions 6-7 • Giving AI Hands: Safely • Connect the assistant to real systems, watch it get hijacked in the same lab, then build an agent that is provably unable to run away, overspend or damage anything.
Session 6: Tool Calling, MCP, A2A & Enterprise Connectivity
Session 6 (90 min)Lab: “Connect ReleaseIQ to Real Systems”
- Tool calling: the model requests an action; your code decides whether to run it
- Designing tools a model can use: narrow scope, clear names, idempotency, recoverable errors
- Model Context Protocol: host / client / server, transports, write a server once and reuse it
- Pre-built vs custom servers, and the supply-chain question of trusting a third party
- Agent-to-agent (A2A): delegating across vendors, and when it is genuinely needed
- Security: least privilege, read/write separation, allow-lists, confirmation gates, audit trails
- Indirect prompt injection: instructions hidden in a ticket, a page or a tool's return payload
- BUILD: Extend the MCP server with search_tickets, run_tests and a read-only database query
- PROVE: The tool permission matrix: read or write, blast radius, unattended or not, who signs off
- BREAK: Plant a malicious instruction, watch your agent obey it, then contain it and re-run
Session 6 DeliverableWorking MCP tool server, documented permission matrix and an injection test report showing both attack and containment. The pivotal session of the course; never cut for time.
Session 7: Agentic AI Part 1: Single Agents That Do Real Work
Session 7 (90 min)Lab: “The Autonomous Ticket Agent”
- Definitions: an assistant responds, a workflow follows your path, an agent chooses its own
- The agent loop: goal → plan → act → observe → re-plan → stop, and what each stage costs
- Memory: working context, external long-term memory and scratchpad files
- Autonomy levels: suggest → act with approval → act and report → autonomous. A risk decision
- Control surfaces: step caps, token budgets, allow-lists, sandboxing, checkpoints, rollback
- Failure modes: infinite loops, goal drift, silent partial completion, hallucinated APIs
- Observability: if you cannot replay what the agent did, you cannot operate it
- BUILD: An agent that proposes a patch and stops for approval, with caps and rollback in code
- BREAK: Feed it a contradictory ticket; confirm the circuit breaker, budget cap and rollback fire
- PROVE: The autonomy policy your team would actually sign, ticket category by category
Session 7 DeliverableA working agent with enforced safety limits, an autonomy policy and a failure test report. Debrief watches a runaway loop killed by its own circuit breaker, live.
Block 4: Multi-Agent Pipelines & Governance
Sessions 8-9 • From Prototype to Production-Approved • Coordinate a four-agent delivery squad with a human gate, then make the whole system tested, guarded, governed and costed.
Session 8: Agentic AI Part 2: Multi-Agent Systems & Workflow Automation
Session 8 (90 min)Lab: “The ReleaseIQ Delivery Squad”
- When one agent is not enough, and the counter-case: more agents multiply cost and failure modes
- Orchestration patterns: supervisor, sequential, parallel fan-out, generator-critic, plan-execute-verify
- Handoff contracts: schema-validated payloads, not prose. Undefined handoffs are where these rot
- Choosing an orchestration layer: code-first agent SDK, graph framework, or visual automation
- Human-in-the-loop inside a workflow: approval nodes, timeouts, escalation
- Observability and cost: tracing a run end to end, attributing tokens per agent
- BUILD: Analyst → Developer → Tester → Reviewer → human gate, with JSON handoff schemas
- BREAK: Implement the Tester, then measure how often the squad catches its own defects
- PROVE: Rebuild it with no code in a visual tool; write the “when to use which” one-pager
Session 8 DeliverableA running multi-agent pipeline with a human approval gate, a full execution trace and a per-agent cost breakdown.
Session 9: Evaluation, Guardrails, Security, Governance & Cost
Session 9 (90 min)Lab: “Ship-Readiness Review”
- Testing a non-deterministic system: golden sets, assertions, rubric scoring, LLM-as-a-judge
- Eval engineering: a distinct, well-paid 2026 role and the natural evolution of the QA career path
- Four-layer guardrails: input filtering → policy hardening → output validation → monitoring
- OWASP LLM Top 10 in plain language, including excessive agency
- Authorization boundaries: an agent acting for User A must never reach User B's data
- Governance: NIST AI RMF, EU AI Act risk classification, audit trails, human oversight
- LLMOps & FinOps: version pinning, drift, caching, tier routing, cost per resolved ticket
- BUILD: Four-layer guardrails, a semantic cache and an append-only audit log
- BREAK: Wire the Session 5 harness into CI; demonstrate a merge blocked by a degraded prompt
- PROVE: The AI risk register, governance one-pager and ROI estimate
Session 9 DeliverableA CI evaluation gate, an active guardrail layer, a passing cross-tenant authorization test, an AI risk register and a cost/ROI report. Capstone teams form at the end of this session.
Session 10: Capstone Build & Demo Day
4 hours • Teams of 3-5 • Integrate, Demonstrate, Defend • Nine sessions of components become one working system, demonstrated live on unseen input and scored against a published 100-point rubric.
- Teams may build ReleaseIQ or a real problem from their own product, which is strongly encouraged
- Reference build: a Coder & Verifier pull-request pipeline with a mandatory human gate before merge
Four-Hour Schedule
- 0:00-0:15: Kickoff, rubric walkthrough, environment check
- 0:15-1:45: Sprint 1: integrate knowledge base, tools, agent flow and human gate
- 2:00-2:45: Sprint 2: evidence: evaluation run, guardrails, cost report, diagram, rehearsal
- 2:45-3:45: Live demos: 6 min demonstration + 4 min questions per team, run live, not from slides
- 3:45-4:00: Judging, retrospective and a 90-day individual application plan
The Demo Must Show All Eight
- 1. Grounded answers with citations on an unseen question (S4-5)
- 2. Two real tools called via MCP or function calling (S6)
- 3. An agent flow that pauses on screen for human approval (S7-8)
- 4. A safety limit triggered live, not claimed (S7)
- 5. A golden-set evaluation report and a CI gate blocking a pull request (S5, S9)
- 6. An injection attempt contained and logged (S6, S9)
- 7. A cost and ROI one-pager (S1, S9)
- 8. Architecture diagram, README and one requirement traced end to end (S3)
Scoring Rubric: 100 Points
- 25 pts: Working live demonstration on unseen input, without rescue
- 15 pts: Grounding and answer accuracy, including a clean refusal
- 15 pts: Safety and security demonstrated under adversarial conditions
- 15 pts: Evaluation evidence: golden set, scores, before/after, automated gate
- 15 pts: Business framing and ROI: honest cost model, credible business case
- 10 pts: Documentation and traceability
- 5 pts: Shared ownership: every member built part of it and can answer on it
Capstone DeliverableA working end-to-end system, demonstrated live, with evidence of quality, safety and cost.
Assessment & Certification
Three criteria, one certificate. No written exam: everything assessed is something you built and can defend.
Certification Requirements
- Attendance at 8 of the 10 sessions
- At least 5 session deliverables committed to the team repository
- A capstone team score of 60 points or above
What Is Assessed
- Session deliverables: the evidence artifact produced by each lab's PROVE step
- Capstone rubric: 100 points, weighting evidence, safety and cost as heavily as working code
- Missed a session? Artifacts are cumulative and published, so nobody is stranded
Reference & Platform
Cloud Stacks, Delivery Variants & Glossary
The labs stay vendor-neutral. These tiles cover the Azure and AWS mapping, the scheduling variants and the shared vocabulary issued in Session 1.
Azure & AWS AI Services Overview
Overview only • Shared Alongside the 9 Sessions • A short orientation to the managed Azure and AWS equivalent of each component, given in a few minutes within the session where that component is built.
Scope: Minimal by Design
- Time-limited: the 17.5 live hours belong to the labs, so cloud stacks are named and positioned only, not taught in depth
- Delivered inside the 9 sessions: a few minutes each in S1 (hosted vs local), S4-5 (managed retrieval), S6-7 (agent runtimes and permissions) and S9 (guardrails, evaluation, audit, cost)
- No cloud accounts and no cloud lab time required: every hands-on lab stays on the vendor-neutral adapter built in Session 1
- The lists below are issued as a Session 1 handout for reading outside class. A full cloud deep-dive is available as a separate add-on day
Microsoft Azure AI Stack
AzureNamed in Session, Detail in the Handout
- Azure AI Foundry: the workspace for models, prompts, agents and evaluations
- Azure OpenAI Service: models inside your own tenant, network and compliance boundary
- Azure AI Search: hybrid keyword + vector retrieval with a built-in semantic re-ranker
- Azure AI Agent Service: managed agent runtime with tool calling and connected enterprise data
- Azure AI Content Safety: Prompt Shields for injection defence, groundedness and PII checks
- Around them: Entra ID for identity-scoped tools, Azure Monitor for tracing, PTUs and caching for cost
Amazon Web Services AI Stack
AWSNamed in Session, Detail in the Handout
- Amazon Bedrock: one API across Anthropic, Meta, Mistral, Cohere and Amazon Nova models
- Bedrock Knowledge Bases: managed ingestion, chunking, embedding and retrieval with citations
- Bedrock Agents / AgentCore: managed agent runtime with action groups and tool invocation
- Bedrock Guardrails: content filters, denied topics, PII redaction and grounding checks
- Amazon SageMaker AI: training, fine-tuning and model hosting
- Around them: IAM for least-privilege tools, CloudTrail and CloudWatch for audit, provisioned throughput and caching for cost
Where It Comes Up: Session → Cloud Equivalent
- Grounded retrieval (S4-5): Azure AI Search | Bedrock Knowledge Bases
- Tool calling & agents (S6-7): Azure AI Agent Service | Bedrock Agents / AgentCore
- Permissions & blast radius (S6-7): Entra ID scoping + API Management quotas | IAM policies + session limits
- Guardrails & injection defence (S6, S9): Content Safety Prompt Shields | Bedrock Guardrails
- Evaluation (S5, S9): Azure AI Foundry evaluations | Bedrock model evaluation
- Tracing & audit (S8-9): Azure Monitor / Application Insights | CloudWatch + CloudTrail
- Cost control (S1, S9): PTUs, caching, gateway routing | Provisioned Throughput, caching, region routing
The One-Minute Version
- Follow the existing estate: identity, networking and data residency decide this more often than model quality
- Both stacks offer private networking, region pinning and audit logging. Confirm current terms per region rather than assuming
- Keep the Session 1 provider adapter either way: it is what makes a later switch a configuration change
What You Leave WithThe two-page cloud handout above, not a cloud lab. Teams that need a working Azure or AWS deployment take the optional add-on day rather than trading lab time for it.
Instruction, Delivery Variants & Platform Independence
One instructor, three scheduling shapes • Live, Instructor-Led Throughout • Who teaches it, the variants, and the contingencies for cohorts that cannot reach a public API.
Instruction: One Senior Architect, End to End
- Lead instructor: a Senior AI Solution Architect, US-based, with 20+ years of enterprise engineering and architecture experience
- Sole instructor and guide: no lab assistants and no co-trainers. The same architect teaches the concept, runs the lab and chairs the debrief in every session
- 100% live: all 10 sessions are delivered live and instructor-led. Nothing is pre-recorded and no session is self-paced
- Guided during the lab: the architect works the room throughout the 45 minutes, so a blocked pair is unblocked in the session rather than after it
- Live demonstrations: the Session 6 injection attack and the Session 7 runaway agent are run live in front of the room, never shown from slides
Delivery Variants
- 1. Standard (default): 10 sessions, 17.5 h. The full capstone rubric applies
- 2. Regulated industry: 11 sessions, 19 h. Session 9 splits into evaluation & CI gates and governance & FinOps, with NIST AI RMF and the EU AI Act taught in full
- 3. Compressed: 5 double sessions of 3 h over 5 weeks. Same hours, same labs
- Executive pattern: Session 1, the Session 6 debrief, Session 9 and the Session 10 demo hour. About three hours
Platform Independence
- Every lab runs against the thin provider adapter built in Session 1: one provider, a cloud gateway, or fully offline
- Where a session names a tool, at least two alternatives are listed and supported by the starter
- Pricing is fetched live in the Session 1 lab rather than read off a slide, so the material survives vendor changes
Cohort Sizing & Contingencies
- Cohort: 8-20 engineers, taught end to end by the Senior AI Solution Architect. Below 8 the debrief loses its range of results; above 20 it stops being a conversation
- Pairing: pair across seniority, because explaining is where the concept lands, and it keeps the room self-supporting between instructor passes
- No outbound API access: the course runs on the pre-downloaded local model, a configuration change
- No GPU: a small quantized model on CPU for labs, the hosted tier for instructor demos only
Keeping the Room TogetherNever demo faster than the slowest pair can follow. Protect the security demonstrations: the Session 6 injection attack and the Session 7 runaway agent are the moments attendees repeat to their colleagues.
Shared Glossary
Issued in Session 1, used across all ten sessions. Most disengagement in AI training is vocabulary, not capability.
Models & Context
- Token: a chunk of text, roughly three-quarters of a word. What you are billed on
- Context window: everything the model sees at once: instructions, history, documents, tool output
- Context rot: the quality decline that sets in as a prompt grows
- Structured output: output forced to match a schema, so software can consume it safely
Retrieval
- Embedding: text converted into coordinates that represent meaning
- RAG: find the relevant documents first, then answer only from them, with citations
- Chunking: splitting documents into retrievable pieces. Get it wrong and everything downstream is wrong
- Re-ranking: a second, more precise pass that re-orders results before they reach the model
Tools & Agents
- Tool / function calling: the model requests an action; your code decides whether to execute it
- MCP: the open standard for connecting tools and data sources to any AI application
- A2A: the adjacent standard for one agent delegating work to another
- Agent: a system that pursues a goal by deciding its own sequence of actions
- Circuit breaker: a hard limit in code that stops an agent regardless of what it intends next
- Human-in-the-loop: a required human decision before a consequential or irreversible action
Safety & Evaluation
- Prompt injection: hidden instructions inside data the model reads, which it then obeys
- Excessive agency: more permission or reach than the task requires. A top enterprise risk
- Golden set: fixed questions with known-good answers, used to measure quality over time
- Guardrails: controls around the model that constrain what can go in and come out
- Evaluation (eval): the automated test suite for an AI system
Enroll: AI Engineering & Agentic Systems Certification
10 live, instructor-led sessions delivered in-house to your engineering team. Share a few details and the program coordinator will confirm scheduling and cohort size.
Enroll Now Contact Program CoordinatorReady to Build the Future with AI?
Join professionals already transforming their careers with Chase NextGen's AI certification program.
Enroll Now Contact Program CoordinatorEnrollment Submitted
Thank you, . Your enrollment email has been sent to our training team.
Program:
We will reply to:
We will reply to:
You will receive a response within 1-2 business days.
Need to reach us sooner? Email training@chasenextgen.com
Enroll in AI Training
Tell us a little about yourself and the coordinator will be in touch.Message Sent
Thank you, . Your message has been sent to the program coordinator.
Subject:
We will reply to:
We will reply to:
You will receive a response within 1-2 business days.
