← Back to Work with us

Agentic AI: Concepts, Practice & Strategy

Bring your code. Leave with an agent embedded in your product, or a new offering you can sell.

For experienced tech leads who have to do both: build agentic systems, and decide where they belong in the business.

Two things you won’t find elsewhere

You work on your own product, start to finish. Every hands-on exercise and the capstone point at your real product, or a new offering you want to build. Not a handed-out template. This is BYOP (bring-your-own-project), and it isn’t a slogan; there’s machinery behind it:

1. Before the first session, you submit the Agent Opportunity Brief: a one-page brief on your product, from “why agentic, not plain software” through build, buy, or defer.
2. We review it and reply with tailored suggestions before you arrive.
3. Every exercise is re-pointed at what you submitted.
4. The capstone ships into your product, or stands up an offering you can sell.

Confidential work stays confidential: Chatham House norm inside the cohort (what’s said in the room stays there; what’s learned travels), and bring-your-own-key or local models for proprietary data.

You learn to build, and to decide. Most courses teach you to build an agent. We teach tech leads to build one and decide where it belongs in the business. Practice and strategy run sequentially, so everyone in the mixed room sees both. The first working agent is low-code, so the first build excludes no one. Engineers rebuild it properly in code later.

The model is the least important part; the system is the product.

Who it’s for

Experienced engineers, architects, engineering leaders, and the tech leads who are all three. The room is deliberately mixed: building and deciding are taught to the same people, in sequence.

Designed for experienced professionals; we confirm fit before the cohort.

What you leave with

The outcome is twofold: a capstone that ships – a working agent in your own product, or a new offering you can sell – and the skill of having built it, on your real product the whole way through. Real-world ready, not classroom-ready. That outcome is the proof.

You also keep the working kit:

• Decision aids. The tests, checklists, and briefs used as gates through the course: is this actually an agent, should it be one, is it ready for production, build or buy or defer. Yours to reuse on the next ten decisions.
• Working example code. A complete reference implementation (agents, tools, retrieval, evaluation, tests, CI) to crib from long after the course ends.
• A production-ready setup. Your own toolchain for tracing, evaluation, and cost control, stood up during the course on your own accounts. Free tiers get you started; beyond that you pay the providers, not us.
• The people. You leave with a cohort, not just content. Your first year in the alumni community is included.

How it’s taught

One case grows across the whole course: a legal-document agent that progresses from clause summary, to precedent retrieval, to whole-contract review, to hardening, to business fit, to a packaged offering, instead of disconnected toy projects. Satellite examples run alongside it: customer support, software engineering, incident response, fintech, healthcare, education. And you’ll meet ClauseBot v0, a deliberately broken agent you debug: it fails a new way at every stage.

Assessment is applied, not quizzes: broken-agent debugging, an architecture design sprint, code review.

The six parts

Part	Title	What it covers	Who
1	Foundations	Concepts to your first working agent; everyone builds it	Everyone
2	Core concepts & building blocks	Context engineering, RAG, and the protocols (MCP & A2A)	Everyone
3	Building agents	Single-tool to multi-agent orchestration, in code	Engineers & tech leads
4	Evaluation, AgentOps & production trust	Evals, observability, cost, security labs, deployment	Engineers & architects
5	Strategy	Where should agents belong, and under what operating model?	Architects (tech) & leaders (mgmt)
6	Productize & capstone	Package the capability; ship into your own product	Everyone

The depth behind those titles, stated plainly:

• Evaluation as a first-class discipline, and AgentOps (DevOps for agents: tracing, evals, cost control, CI/CD, guardrails), taught to the depth of the best programs
• One framework deep (LangGraph), with the rest mapped: LangChain, OpenAI Agents SDK, Google ADK, AWS Strands, CrewAI, AutoGen, LlamaIndex, and low-code tools. Everything is written against patterns, so your stack can swap in underneath.
• The two protocols of 2026: MCP (how agents talk to tools) and A2A (how agents talk to each other)
• Security, hands-on: live prompt-injection and data-exfiltration labs, over-permissioned tools, guardrail libraries, sandboxing
• Cost discipline: token budgets, tracking, alerts. From Part 2 on, every design exercise carries a latency, cost, retry, fallback, and escalation budget
• Where RL and RLHF fit, and where they don’t

Formats

The flagship: a multi-week cohort. Approximately 40 hours over 10–12 weeks. Evaluation, AgentOps, and your own project get the time they need; the capstone actually ships. Short courses in this category can’t honestly deliver production-readiness. The cadence is the answer to that.

Also available: a two-day in-person intensive. The premium overview; kicks off your Agent Opportunity Brief and the first build.

For teams: any module lifts out as a session or custom training; AWS and Azure productionization tracks extend the base. Enquire.

Common questions