Courses and instructor-led workshops covering AI for every function — engineering, product, data, sales, finance, legal, HR, operations, leadership and risk.
Learn how AI models actually work, from tokens to probability, and why the same question can produce two different answers.
You buildA one-page explanation of tokens and probability in your own words
Discover the differences between frontier and small models, open and closed weights, and learn to pick the right one for a task.
You buildA model-selection cheat sheet for your team
Learn where AI models fail — hallucination, stale knowledge, arithmetic and false confidence — by making each failure happen yourself.
You buildA personal failure log with five real examples
Learn what data can and cannot go into a prompt, which tools are approved, and what to do when something goes wrong.
You buildA completed data-classification decision tree
Build a practical daily AI habit and learn to decide which tasks to delegate to a model and which to keep.
You buildA weekly AI habit plan with three named tasks
Learn practical techniques for checking AI answers, including source checking and cross-model verification.
You buildA reusable verification checklist for your function
Discover how tokens, context length and model choice drive the cost of AI, and learn to estimate the price of a workflow.
You buildA cost estimate for one of your own workflows
Break your job into tasks and learn to decide which to automate, which to augment and which to keep human.
You buildA task inventory split into automate / augment / keep
Learn to describe what AI systems actually do, without the hype that makes projects hard to evaluate.
You buildA rewritten internal update stripped of hype
Learn the parts of an effective prompt — task, context, constraints, examples and output format — and why vague instructions fail.
You buildA before/after prompt pair with measured difference
Master six reusable prompting patterns, including role framing, few-shot examples, decomposition and output contracts.
You buildSix reusable prompt patterns for your function
Learn what to put in a model's context window and in what order, and why a large window is not permission to paste everything.
You buildA restructured long-context prompt with measured lift
Discover how to split a difficult request into a sequence of simple ones, and learn where chains break down.
You buildA three-stage chain that beats a single prompt
Learn to use extended thinking and effort budgets, and to judge when deeper reasoning is worth the extra cost.
You buildA cost/quality curve across three thinking budgets
Learn to version, name, own and review prompts so they become shared assets rather than private tricks.
You buildA versioned prompt library with owners
Learn to work with images, PDFs, screenshots and charts as model input for contracts, invoices and reports.
You buildA document-to-structure workflow you use weekly
Learn to write the instruction layer behind a production feature, covering tone, refusals, escape hatches and drift.
You buildA production system prompt with a change log
Understand why pasting untrusted content into a model is a security risk, and learn to recognise it without writing code.
You buildA red-flag list for your team's tools
Learn to force reliable output shapes using schemas, enums and citations so downstream code can trust what it receives.
You buildA schema-locked prompt with a 100-case pass rate
Learn to call a language model API directly, handling roles, system instructions, stop reasons, errors and retries.
You buildA working client with retry and timeout handling
Learn to extract reliably typed data from a model, covering schema design, validation and repair loops.
You buildAn extraction service with schema validation
Learn to give a model access to your own functions and APIs, handling definitions, arguments, results and errors.
You buildA model that queries your own API correctly
Learn to stream model output token by token, with partial rendering, cancellation and good waiting states.
You buildA streaming endpoint with graceful cancellation
Learn to process images, PDFs and audio at scale, including pre-processing, page splitting and cost control.
You buildA document pipeline handling 200 mixed files
Learn to cut AI costs using prompt caching, batch endpoints and request shaping, with measured results.
You buildA workload with a measured cost reduction
Learn to route requests between cheap and expensive models and handle provider outages with circuit breakers.
You buildA router with a documented escalation policy
Build a production chat feature covering conversation state, truncation, memory, rate limits and abuse handling.
You buildA deployed chat feature with history and limits
Build a pipeline that turns contracts and forms into structured records through ingest, extract, validate and review.
You buildA pipeline turning contracts into structured records
Learn when a language model beats a trained classifier, and how to set thresholds, abstention and review queues.
You buildA classifier with a published confusion matrix
Learn to generate test cases, edge cases and training data, and to measure diversity and avoid model collapse.
You buildA synthetic test set with diversity metrics
Learn to make the build decision for an AI feature using cost, latency and accuracy evidence rather than preference.
You buildA written decision memo for one real feature
Learn how embeddings represent meaning as vectors, and build a working semantic search over your own documents.
You buildA working semantic search over your own docs
Learn structure-aware chunking, overlap, metadata and table handling — the step that decides retrieval quality.
You buildA chunking strategy with a retrieval score
Learn to index, filter and update vectors in production, covering multi-tenancy, namespaces and operational cost.
You buildA store with filters, namespaces and backups
Build a retrieval-augmented assistant end to end, with query rewriting, grounding, citation and refusal.
You buildA grounded assistant with citations
Learn to combine keyword and vector search with a reranker, usually the biggest available quality gain.
You buildA measured precision gain over pure vector search
Learn to use graph databases for retrieval when relationships matter more than similarity, including multi-hop questions.
You buildA graph-backed answer to a multi-hop question
Learn to measure recall, precision and faithfulness, and to score retrieval separately from generation.
You buildA retrieval scorecard on your own corpus
Learn to query a warehouse in natural language, with schema context, guardrails, validation and review gates.
You buildA guarded query interface with a review gate
Learn to detect change, re-embed efficiently and set staleness targets so answers do not silently go out of date.
You buildAn index refresh design with staleness SLOs
Build a working index over real corporate content: duplicates, contradictions, dead policies and scanned PDFs.
You buildA working index over genuinely bad source data
Learn what an agent actually is — a loop, tools and a stopping condition — and how to judge what is worth automating.
You buildA written spec for one candidate agent
Build an agent loop by hand before using a framework, covering tools, termination, iteration caps and error recovery.
You buildA working agent with three real tools
Learn to give an agent durable state so it survives a restart, and understand memory versus a longer prompt.
You buildAn agent that survives a restart mid-task
Learn plan-and-act, reflection and decomposition patterns, and which genuinely improve results rather than burning tokens.
You buildA planner/executor split with a measured gain
Learn supervisor, parallel and hand-off patterns for multiple agents — and when a single agent is the better design.
You buildA parallel fan-out with a synthesis stage
Learn the MCP standard for connecting models to tools and data, including primitives, transport and configuration.
You buildA client connected to three MCP servers
Build your own MCP server to expose an internal system as tools, covering schema design, auth and versioning.
You buildA published MCP server over an internal system
Learn to scope what an agent can touch using least privilege, allow-lists, execution isolation and action gates.
You buildA permission matrix and an enforced sandbox
Learn to design approval checkpoints people actually read, and avoid the rubber stamp that defeats the control.
You buildAn approval flow with a measured intervention rate
Learn to trace an agent run with spans, tool calls and token accounting so failures can be reconstructed.
You buildA traced agent run you can debug from logs
Learn to run agents on a schedule or for hours, covering idempotency, resumption, drift and unattended failure.
You buildA scheduled agent with alerting and a kill switch
Build real business automations in a visual builder, covering triggers, branching, error paths and handover.
You buildA live automation replacing a manual routine
Learn to drive interfaces that have no API, with a candid look at reliability, cost and the security surface.
You buildA guarded browser task with a scoped profile
Learn to apply loop detection, spend caps, dry runs and reversibility so a bad agent run does not become an incident.
You buildA budget guard and a rollback plan
Learn to use AI coding assistants effectively and establish an honest baseline of your current speed.
You buildA measured baseline on your own repository
Learn to write the specification a model needs in order to produce correct code first time.
You buildA spec that produced working code first time
Learn to review code you did not write, spotting hallucinated APIs, silent assumptions and plausible nonsense.
You buildA review checklist adopted by your team
Learn to generate tests that actually fail when the code is wrong, verified with mutation testing.
You buildA suite with mutation-tested quality
Learn to map a large unfamiliar repository quickly, covering call graphs, dead code and hidden coupling.
You buildA written architecture map of an unfamiliar repo
Learn to run codebase-scale migrations with agents, covering batching, verification gates and rollback.
You buildA migration executed across 50+ files
Learn a disciplined debugging loop — reproduce, bisect, hypothesise, verify — that keeps the model honest.
You buildA reproducible bug hunt logged end to end
Learn to generate architecture decision records, runbooks and API documentation that stay accurate.
You buildGenerated docs that survived a review
Learn to automate review, triage and release notes in your pipeline, and recognise where a bot becomes noise.
You buildAn automated review step running on PRs
Learn to define the boundary — cryptography, concurrency, regulated paths — before an incident defines it for you.
You buildA written no-go list for your codebase
Learn to measure AI's real effect using cycle time and change failure rate rather than lines accepted.
You buildA metric set your engineers do not game
Learn to build pipelines and transformations with AI assistance, protected by data contract tests.
You buildA generated pipeline with contract tests
Learn why demos are not evidence, and how to define what good means for an AI feature before building it.
You buildA written quality definition for one feature
Build a 100-case evaluation set from real examples and score your current system against it.
You buildA 100-case eval set with a baseline score
Learn to automate grading with a model judge, covering rubrics, position bias and calibration against humans.
You buildA judge validated against human labels
Learn to run annotators well, covering guidelines, inter-rater agreement, adjudication and cost per label.
You buildAn annotation guideline with measured agreement
Learn to treat prompts as code, with version control and CI gates that block quality regressions.
You buildAn eval gate blocking a bad prompt merge
Learn to measure quality live using sampling, implicit signals, drift detection and alert thresholds.
You buildA production quality dashboard with alerts
Learn to score answers for unsupported claims automatically, and to treat abstention as a feature.
You buildA faithfulness score wired into your pipeline
Learn to design experiments on systems whose output varies per call, covering variance and sample size.
You buildA powered experiment design for one feature
Learn to score an agent's trajectory rather than its answer, covering tool choice, step efficiency and partial credit.
You buildA trajectory rubric applied to 50 runs
Learn to run a recurring forum that holds AI features to their measured numbers.
You buildA standing review agenda and its first minutes
Learn the operational lifecycle of an AI system — prompt, model, data, eval, release, monitor — and how it differs from MLOps.
You buildA reference architecture for your stack
Learn to put every model call behind one front door with keys, quotas, logging, routing and provider abstraction.
You buildA gateway with keys, quotas and logging
Learn where the milliseconds go and how to cut them through model choice, output length, streaming and caching.
You buildA P95 reduction with a documented method
Learn to model cost per request, per user and per outcome, and to forecast and control AI spend.
You buildA per-request unit economic model
Learn to handle provider limits with queuing, backpressure and graceful degradation under load.
You buildA load plan surviving a 10x spike
Learn to serve open-weight models yourself, covering GPUs, quantisation and the true total cost.
You buildA served open model with a cost comparison
Learn to deploy models on Bedrock, Vertex or Azure AI Foundry, covering residency, networking and procurement.
You buildA deployment meeting your residency rules
Learn to move to a new model version without a quality regression, using shadow traffic and staged rollout.
You buildA migration runbook with an eval gate
Learn to detect, contain and disclose when a model is confidently wrong at scale, then run the post-mortem.
You buildA runbook plus one tabletop exercise
Learn to design for redaction, tokenisation, residency, retention and zero-retention endpoints.
You buildA data-flow diagram cleared by your DPO
Learn to threat model an AI feature, covering assets, actors and entry points, mapped to the OWASP LLM risks.
You buildA threat model for one live feature
Learn direct and indirect prompt injection by breaking a system you built, then attempting to defend it.
You buildThree successful injections against your own app
Learn to recognise and break the combination of private data, untrusted content and an outbound channel.
You buildAn audit of your tools against the trifecta
Learn to scope agent capability so that a compromised agent cannot cause real damage.
You buildA least-privilege design for one agent
Learn to run a structured campaign covering jailbreaks, extraction, poisoning and denial of wallet, then write it up.
You buildA red-team report with severity ratings
Learn to vet third-party models, MCP servers, skills and packages for provenance before adoption.
You buildA vetting standard for third-party components
Learn to treat model output as untrusted input, preventing XSS, SQL injection and unsafe rendering.
You buildA hardened rendering and execution path
Learn to keep sensitive data out of prompts, logs and traces, and to measure how well redaction works.
You buildA redaction layer with measured recall
Learn to design a review gate every AI feature passes, sized so that it does not become theatre.
You buildA review gate adopted into your SDLC
Learn to write an AI policy short enough to be read and specific enough to be applied.
You buildA one-page AI policy fit for your company
Learn the risk tiers, obligations, timelines and roles under the EU AI Act from a deployer's perspective.
You buildA risk classification of your AI inventory
Learn to build an AI management system that survives an audit without stalling delivery.
You buildA gap analysis against the standard
Learn to discover, register and maintain a live inventory of every AI system in your organisation.
You buildA populated register with owners and tiers
Learn to assess a use case before build, covering affected people, severity, reversibility and mitigation.
You buildA completed assessment on a real use case
Learn to assess an AI vendor on training data, retention, sub-processors, evaluations and incident history.
You buildA vendor questionnaire and a scoring rubric
Learn who owns model output, what your inputs expose, and where the real legal risk sits today.
You buildA guidance note for your content teams
Learn to move from fairness principles to actual tests, covering subgroup measurement, proxies and remediation.
You buildA bias test report on a real system
Learn to tell users that AI was involved, in language that informs rather than disclaims.
You buildDisclosure copy shipped in a real product
Learn to log what a regulator or auditor will ask for, before they ask for it.
You buildAn evidence pack for one AI system
Learn where financial services, healthcare, public sector and employment rules bite harder than AI law.
You buildA sector obligation map for your business
Learn to set decision rights and accountability so that governance does not become a bottleneck.
You buildAn RACI and a decision-rights map
Learn to screen AI feature ideas on error tolerance, value of speed and availability of ground truth.
You buildA scored shortlist of five candidate features
Learn to write requirements for a feature whose output varies, with acceptance criteria expressed as evaluations.
You buildA PRD with acceptance criteria as an eval set
Learn to design confidence, ambiguity and I-don't-know as intentional interface states rather than failures.
You buildThree interface states designed and tested
Learn to use citations, provenance, edit affordances and consent to earn trust without overclaiming.
You buildA trust pattern set for your product
Learn patterns for showing work, interruption, approval and undo on tasks with no progress bar.
You buildAn agent flow prototype with approval points
Learn what the interface should do when a model is wrong, slow, refuses, or is unavailable.
You buildA recovery flow for three failure modes
Learn to price a feature with variable marginal cost, covering seats, credits, outcomes and the margin trap.
You buildA pricing model with a margin floor
Learn to measure the real funnel — invoked, completed, accepted, edited, reverted — instead of raw usage.
You buildAn event schema and a live funnel
Learn to plan staged release, guardrails and the kill criteria you agree before launch.
You buildA rollout plan with pre-agreed kill criteria
Learn to build a throwaway AI prototype quickly, test it with users, and avoid accidentally shipping it.
You buildA tested prototype plus a written learning
Learn to use AI for account research, call preparation, follow-up and proposals, with clear honesty rules.
You buildA live pre-call research workflow
Learn to run a content pipeline from brief to review at volume, with brand voice and fact-checking built in.
You buildA content pipeline with a brand-voice check
Learn to use AI for draft assistance, deflection and quality assurance, and when to hand over to a human.
You buildA deflection design with an escalation policy
Learn to use AI for variance analysis, commentary and reconciliation, with controls an auditor will accept.
You buildA reconciliation workflow with a control step
Learn to use AI for contract review, clause extraction and first drafts, with privilege and confidentiality protected.
You buildA clause-review workflow with a risk register
Learn to use AI across job design, screening, interviews and onboarding, with fairness testing built in.
You buildA hiring workflow that passes a bias review
Learn to build training content, assessments and personalised paths with AI, without generating filler.
You buildA generated course outline with assessments
Learn to use AI for supplier analysis, tender review and spend analysis on real documents.
You buildA supplier comparison built from real documents
Learn to map a process, find the AI-shaped step, rebuild it and measure what changed.
You buildOne process re-designed and instrumented
Learn to run briefings, meeting synthesis, decision logs and follow-through at executive tempo.
You buildA weekly executive briefing pipeline
Learn to run structured research with citation discipline, gaining depth without fabrication.
You buildA sourced competitive brief
Learn to use AI for status synthesis, risk detection and reporting that reflects reality.
You buildA status pipeline drawn from real artefacts
Learn to take an analysis from question to query to chart to narrative, with verification at every stage.
You buildAn analysis delivered end to end with AI
Learn to produce finished reports, decks and spreadsheets rather than raw text.
You buildThree real deliverables produced and reviewed
Learn mobile-first, low-friction AI uses for field, retail, logistics and support staff.
You buildA shift-level use case adopted by a team
Learn what has genuinely changed in AI, what has not, and which vendor claims to discount.
You buildA briefing you could give your own board
Learn to build a portfolio of AI bets across horizons, managing concentration risk and killing projects on time.
You buildA scored portfolio across three horizons
Learn to make the three-way AI investment decision using switching cost, differentiation and time to value.
You buildA decision memo for one live proposal
Learn to choose between central, embedded and federated AI teams, and decide who owns the platform.
You buildA target operating model for your org
Learn to build an AI business case that survives finance, with baselines, attribution and sensitivity analysis.
You buildA defensible business case with sensitivities
Learn to handle fear, resistance and quiet non-adoption, and what not to promise.
You buildA communication plan and a listening loop
Learn to set the review rhythms, decision forums and the few metrics leadership should actually track.
You buildA cadence with named owners and metrics
Learn to map the capability you need, decide what to build versus hire, and retain people afterwards.
You buildA capability map with a build/hire split
Learn to report AI progress with evidence rather than ambition, and survive the follow-up question.
You buildA board-ready section with real evidence
Learn supervised learning, validation, leakage and metrics — the foundation generative AI still rests on.
You buildA trained model with a validated metric
Learn networks, gradients, optimisation and regularisation by building and training them yourself.
You buildA network trained from scratch
Learn attention, embeddings and positional encoding by writing a working small transformer.
You buildA working small transformer you wrote
Learn supervised fine-tuning end to end, covering dataset construction, training and honest evaluation.
You buildA fine-tuned model beating its base on your task
Learn how preference data and reward modelling shape model behaviour, and what alignment training really does.
You buildA preference-tuned model with a win rate
Learn to adapt large models on modest hardware using LoRA and QLoRA, and to judge when it is enough.
You buildAn adapter trained on a single GPU
Learn to teach a small model to do one job well at a fraction of the inference cost.
You buildA small model within 5% of a large one
Learn how precision, batching and KV cache affect throughput, and where quality starts to degrade.
You buildA served model with a latency/quality curve
Learn attribution and probing techniques, and the honest limits of explaining a large model's behaviour.
You buildAn explanation a regulator would accept
Learn where forecasting, ranking, optimisation and rules beat a language model, and benchmark it yourself.
You buildA benchmark where the simple model wins
Learn to set up Claude as a working environment using projects, artifacts, memory and connectors.
You buildA configured workspace with three live projects
Learn to work with Claude's large context window deliberately, covering document structure, ordering and caching.
You buildA long-context workflow with a measured lift
Learn to install and configure Claude Code on your own repository, covering permissions, memory files and first tasks.
You buildClaude Code configured on your own repository
Learn to use Claude Code for feature work, tests and refactors in an existing codebase under a real review gate.
You buildA merged pull request produced with Claude Code
Learn to author, package and distribute Claude Agent Skills, including executable scripts and versioning.
You buildA packaged skill your team can install
Learn to delegate work to subagents and run tasks in parallel without losing the thread.
You buildA parallel workflow across a large task
Learn to connect Claude to internal systems using MCP, covering server configuration, authorisation and scopes.
You buildClaude connected to three internal systems
Learn to build your own MCP server and then attack it, covering tool design, auth and injection surface.
You buildA reviewed MCP server exposing internal data
Learn to build and deploy production agents with the Agent SDK, covering the loop, tools, sessions and permissions.
You buildA deployed agent built on the SDK
Learn to produce finished Excel, PowerPoint, Word and PDF deliverables with Claude.
You buildThree finished deliverables produced end to end
Learn to run Claude inside your own cloud, covering regions, networking, IAM and quotas.
You buildA deployment meeting your residency requirements
Learn to manage seats, roles, data controls, retention and audit logs across an organisation.
You buildAn admin configuration with a written policy
Learn how Constitutional AI and the usage policy shape refusals, and how to design around them honestly.
You buildA refusal-handling guide for your teams
Learn to reduce spend with prompt caching, batch processing, model tiering and context discipline.
You buildA cost reduction with cache-hit evidence
Learn to get real leverage from Claude without writing code, using projects, files and artifacts.
You buildA personal workflow adopted for a week
Learn to choose between Claude model tiers and thinking budgets using evaluations rather than defaults.
You buildA model-choice decision backed by evals
Learn to use Copilot across Word, Excel, PowerPoint, Outlook and Teams, including its real limits.
You buildA weekly workflow across three apps
Learn to use Copilot for analysis, formulas, cleaning and modelling, with verification built in.
You buildA rebuilt model with checks
Learn to build, publish and govern an internal agent on Microsoft's stack.
You buildA published internal agent
Learn to automate real business processes, including the error paths most people skip.
You buildA production flow with error handling
Learn to deploy, filter, evaluate and monitor models in Azure AI Foundry.
You buildA deployed endpoint with monitoring
Learn to handle oversharing, sensitivity labels and the permission clean-up a Copilot rollout requires.
You buildA rollout plan with permission remediation
Learn to roll out GitHub Copilot with team standards, review expectations and honest measurement.
You buildA team standard with measured adoption
Learn to use Gemini across Docs, Sheets, Slides, Gmail and Meet for everyday work.
You buildA weekly workflow across Docs, Sheets and Gmail
Learn to synthesise your own sources with grounded answers and citation discipline.
You buildA sourced synthesis of a real document set
Learn to deploy, ground and evaluate models on Google Cloud using Vertex AI.
You buildA deployed model with grounding configured
Learn to build and deploy multi-tool agents with the Agent Development Kit.
You buildA working multi-tool agent
Learn to run embeddings and inference next to your warehouse in SQL, with cost control.
You buildA warehouse-native AI workflow
Learn to configure admin controls, data handling and retention across a Workspace tenancy.
You buildAn admin configuration with a data policy
Learn the differences between open weights and open source, and where open models genuinely win.
You buildA shortlist with licence notes
Learn to run models on a laptop or single server with Ollama and llama.cpp, with realistic expectations.
You buildA local model serving your own tool
Learn to use models, datasets and pipelines from the Hugging Face Hub in working code.
You buildA pipeline built from hub components
Learn to serve open models at scale, covering throughput, batching, KV cache and cost per million tokens.
You buildA benchmarked serving stack
Learn to design a fully self-hosted or air-gapped AI architecture, and what you take on by doing so.
You buildAn architecture meeting an air-gap requirement
Learn to build a retrieval stack with no external API calls, and compare it to hosted alternatives.
You buildA retrieval stack with no external calls
Six weeks. Cross-functional teams. Working prototypes, judged, with adoption decided on the day.
A build competition run across the organisation. Teams take a real business problem to a working AI prototype over six weeks, supported by four facilitated sessions and mentoring in between. It closes with a demo day where each prototype is judged and a live adopt, iterate or stop decision is taken. It is the part of the programme that turns training into something the business can point at.
Problem framing against real business pain, team formation, and scoping down to something buildable in six weeks. Most teams leave with a smaller problem than they arrived with.
Teams build. Stennir runs weekly office hours and is reachable between them.
Mentored review of each team's first working version. Scope corrections happen here, and some teams are told to cut half of what they planned.
Teams harden. Office hours continue, now weighted towards evaluation and failure modes.
Evaluations, guardrails, cost and the security questions each team must be able to answer on demo day. Teams attack each other's prototypes.
Final build, evidence gathering and rehearsal.
Each team demonstrates live to a judging panel of sponsors and leadership, then takes questions. Judging is scored against a published rubric.
Everyone in the organisation
The cohort walks out withA completed data-classification decision tree and a personal three-task AI plan
Anyone past ground school
The cohort walks out withA versioned team prompt library with named owners
Software engineers
The cohort walks out withA merged pull request produced with an agent, plus the team's written engineering standard
Engineers and their product partner
The cohort walks out withA deployed feature behind a flag, with an eval set and a cost model
Engineers working with company knowledge
The cohort walks out withA grounded assistant over the client's own corpus, with a published retrieval score
Engineers building systems that take action
The cohort walks out withA working agent connected to an internal system through a reviewed MCP server
Engineers, PMs and data scientists on AI features
The cohort walks out withA 100-case eval set with a validated judge, running as a CI gate
Security engineers, senior developers, architects
The cohort walks out withA written red-team report with severity ratings and assigned fixes
Platform, SRE and senior engineering
The cohort walks out withA gateway design, a unit-economic model and a tested incident runbook
Product managers and product owners
The cohort walks out withA complete PRD whose acceptance criteria are an executable eval set
Product designers, UX researchers, content designers
The cohort walks out withA tested prototype covering the confident, uncertain and failed states
CEO, C-suite, functional heads, board members
The cohort walks out withA scored portfolio on the wall and three named 90-day commitments with owners
Risk, compliance, legal, internal audit, security
The cohort walks out withA populated AI inventory, a risk classification and a one-page policy people will read
Anyone standardising on Anthropic's stack
The cohort walks out withA configured Claude environment, a packaged Agent Skill and a working MCP integration
Operations, process owners, function leads — no code required
The cohort walks out withA live automation replacing a real manual routine, with error paths and an owner
Analysts, BI teams, finance analysts
The cohort walks out withOne real analysis delivered end to end, with its verification log attached
Sales, marketing and customer success
The cohort walks out withThree live workflows across research, outreach and support, with honesty rules agreed
Finance, FP&A, legal and contracting
The cohort walks out withTwo document workflows with their control steps and audit trail documented
HR, talent acquisition, L&D, people operations
The cohort walks out withA hiring workflow that passes a bias review, plus an internal support agent design