12-week live cohort
Production Agentic AI
A 12-week live cohort on the part of agent work that happens after the demo.
Requesting a seat costs nothing and commits you to nothing. No payment is taken on this site.
What this cohort is
Most LLM projects stall between the demo and the deploy. The prototype answers well enough in a notebook, and then nobody can say whether it is correct, what it costs per request, or why it fell over overnight. This cohort is about that second half: evaluation, observability, guardrails, and cost engineering, taught by building the systems rather than by reading about them.
Twelve weeks, one live session a week, and every session ends with code committed. You write the agent loop in plain Python first so the abstractions mean something, then move to LangGraph and stay there: durable state and human-in-the-loop, MCP servers you write yourself, A2A interoperability, supervisor and sub-agent orchestration, fine-tuning and serving an open model, and deployment behind an explicit latency and cost budget. The stack is version-pinned per cohort — LangGraph, current frontier and open models, Qdrant, Langfuse, Ragas and DeepEval, FastAPI and Docker — so the labs run rather than rot.
You finish with three deployed systems, the eval suites that prove they work, and the vocabulary to defend the tradeoffs behind them. That is close to what an interview for an agentic AI role is actually testing.
What you will be able to do
- Design and build agent loops from first principles, then in LangGraph, with step limits, timeouts, and sane tool-error surfaces.
- Ship retrieval that measurably works: hybrid search, reranking, and agentic retrieval over a real corpus.
- Write eval suites that run in CI, with golden datasets and LLM-as-judge used where it is defensible.
- Instrument every run — traces, cost, and latency per node — and alert on quality drift rather than discovering it from users.
- Build and consume MCP servers, and make two agents interoperate over A2A.
- Orchestrate multi-agent systems, and recognise the cases where one good agent is the better answer.
- Decide when fine-tuning is the right tool, then do it: LoRA/QLoRA, quantisation, and serving the adapter.
- Deploy a containerised agent against a latency budget, with caching, model routing, fallbacks, and a cost dashboard.
- Defend prompt injection, handle PII, and red-team your own deployment before someone else does.
Week by week
Open a week for its topics and lab. Every week ends with something committed.
1LLM fundamentals and context engineeringCall several providers reliably, get structured output you can parse, and treat context as an engineering budget.
- The current model landscape — Frontier and open models compared on cost, latency, and capability — and how to choose without guessing.
- Context engineering — System prompts, long context windows, and deciding what to place in context, what to retrieve, and what to leave to a tool.
- Structured outputs — JSON Schema and Pydantic, tool-calling as extraction, and why 'respond in JSON' fails under load.
- Prompt caching and token economics — Cache breakpoints, when caching pays for itself, and how to measure it rather than assume it.
- Reasoning and extended thinking — When to enable it, which effort level, and what it costs you.
Lab
Build a provider-agnostic LLM client and a structured-extraction pipeline that reports its own cost.
Builds toward: Smart Assistant
2Tool use and your first agent loopSee what an agent actually is — a loop, tools, and state — by writing one from scratch before touching a framework.
- Tool and function calling — Schemas, parallel tool calls, and the agent loop written in raw Python so nothing is hidden.
- LangGraph fundamentals — Nodes, edges, and state, and the cases where a graph is clearer than a chain.
- ReAct versus plan-then-act — Tool design as interface design: idempotency, error surfaces, and descriptions that function as prompts.
- Guarding the loop — Step ceilings, timeouts, and what to do with a tool that fails halfway.
Lab
Give your assistant three real tools, with step limits and explicit error handling.
Builds toward: Smart Assistant
3RAG, vector databases, and retrieval that holds upBuild retrieval you can measure: hybrid search plus reranking plus agentic retrieval on Qdrant.
- Chunking and embeddings — Indexing strategy, embedding choice, and the chunk decisions that quietly set your ceiling.
- Qdrant in production — Collections, metadata filtering, native hybrid search, and reciprocal rank fusion.
- Reranking — Cross-encoder reranking, and measuring retrieval quality instead of eyeballing it.
- Agentic retrieval — Letting the agent decide whether and what to retrieve, multi-hop questions, and where GraphRAG earns its complexity.
Lab
Index a real corpus, add hybrid search and reranking, and expose retrieval to the agent as a tool.
Builds toward: Smart Assistant
4Memory, evaluation, and deploying project oneAdd memory, prove the system works with evals, and put it behind a real API.
- Agent memory — Short-term state against long-term stores, and the honest test for whether you need the latter at all.
- Evaluation — Why 'it looks good' is not an answer: Ragas for retrieval, DeepEval as pytest for LLM behaviour.
- LLM-as-judge — Where judging is defensible, where it is not, and building a small golden dataset.
- Deploying an agent — A FastAPI service with streaming, secrets handling, and a Dockerfile that works on someone else's machine.
Lab
Ship project one: a deployed URL, an eval suite running in CI, a demo video, and a write-up.
Builds toward: Smart Assistant
5LangGraph in depth and the framework landscapeWork with durable graphs — checkpointing, interrupts, replay — and place LangGraph among the alternatives.
- State, checkpointing, and durability — Reducers, durable execution, and replaying a run instead of reproducing it by hand.
- Human in the loop — Interrupts, approval gates, and time-travel debugging.
- Streaming and subgraphs — Fan-out and fan-in, and streaming partial state to a caller.
- Framework comparison — CrewAI, the Microsoft Agent Framework, the OpenAI Agents SDK, and Google ADK — what each is good at, and why the cohort standardises on one.
Lab
Refactor a fragile agent into a durable graph with checkpointing and a human approval step.
Builds toward: Agent Mesh
6MCP and agent SDKsWrite your own MCP server, consume MCP tools, and package capability as reusable skills.
- The MCP specification — Tools, resources, and prompts; client and server architecture; the registry and what it is for.
- Build an MCP server — FastMCP in Python — expose your retrieval layer and a real API as MCP tools.
- Newer capabilities — Elicitation, sampling, async tasks, and OAuth 2.1 for remote servers.
- Agent SDKs and skills — Packaging instructions, scripts, and resources so an agent can invoke them without bespoke glue.
Lab
Convert your project's tools into an MCP server that another agent can call.
Builds toward: Agent Mesh
7Multi-agent orchestration, sub-agents, and async workDesign multi-agent systems that hold together — supervisor, hierarchy, delegation, and long-running tasks.
- Supervisor and router patterns — When several agents beat one good agent, and the more common case where it is over-engineering.
- Hierarchical and plan-and-execute — The deep-research pattern, and how planning failures show up downstream.
- Sub-agents and delegation — Context isolation per sub-agent, and what to hand back up.
- Long-running and async agents — Background tasks, task IDs, start/check/cancel, and durability across an hour-long run.
Lab
Build a supervisor over three sub-agents with delegation and one asynchronous research task.
Builds toward: Agent Mesh
8A2A, observability, and shipping project twoMake agents interoperate over A2A and instrument the whole system with tracing and online evals.
- The A2A protocol — Agent cards, discovery, and the task lifecycle — and how MCP and A2A sit alongside each other.
- Interoperability in practice — Expose one of your agents over A2A and consume an external one.
- Observability — Langfuse, LangSmith, and Phoenix — a trace per node, with cost and latency attached.
- AgentOps — Online against offline evals, regression suites in CI, and alerting on quality drift.
Lab
Ship project two: a multi-agent system with your own MCP server, A2A interop, and full tracing.
Builds toward: Agent Mesh
9Fine-tuning and model customisationDecide whether fine-tuning is the right tool, then do it end to end: LoRA/QLoRA, quantisation, and serving.
- When to fine-tune — Prompt, then retrieval, then tools, then tuning — and why tuning is for style, format, latency, and cost rather than fresh knowledge.
- PEFT, LoRA, and QLoRA — How the adapters work, the defaults worth starting from, and building the dataset that decides the result.
- Running a tune — Fine-tune a small open model on rented GPU — no local hardware required.
- Quantise and serve — GGUF, AWQ, and GPTQ, serving the adapter on vLLM, and evaluating tuned against base.
Lab
Fine-tune and serve a model, and produce a base-versus-tuned evaluation report.
Builds toward: Capstone
10Production deployment and LLMOpsTake an agent from a notebook to a service with a stated cost and latency budget.
- Packaging — FastAPI and Docker, async and streaming, concurrency limits, and structured logging you can query.
- Orchestration — Enough Kubernetes for an LLM service: health checks, autoscaling, and secrets.
- Cost engineering — Prompt caching, batching, model routing, token budgets, and a dashboard someone actually reads.
- Service levels — Latency budgets and P95, plus fallbacks, timeouts, and circuit breakers for when a provider degrades.
Lab
Deploy a containerised agent with caching, model routing, a stated SLO, and a working fallback path.
Builds toward: Capstone
11Voice, multimodal, safety, and frontier patternsAdd voice, vision, and document handling, harden the deployment, and survey what is real at the frontier.
- Voice and speech-to-speech — Realtime APIs with tool access, and the latency constraints that shape the design.
- Vision and document AI — Multimodal input, and document workflows that produce structured results rather than prose.
- Safety — Prompt-injection defences, output guardrails, basic red-teaming, and PII handling.
- Frontier patterns — Deep research, computer-use and browser agents, and reasoning inside loops — separating the working parts from the demos.
Lab
Build a voice agent that calls an MCP tool, then red-team a deployed agent and add the guardrails it needed.
Builds toward: Capstone
12Capstone, demo day, and the interviewShip the capstone, present it, and turn the portfolio into interview material.
- Capstone polish — README, demo video, write-up, deployment, and an evaluation report a reviewer can follow.
- Demo day — Every participant presents to the cohort and invited guests.
- The agentic AI interview — Agent system design, evals, cost, and debugging — plus resume and profile positioning.
- Certification and what comes next — The assessed credential, the alumni community, and where to take the work afterwards.
Lab
Ship the capstone, present it at demo day, and sit the certification assessment.
Builds toward: Capstone
What you ship
Smart Assistant
Weeks 1-4. A single tool-using agent with production retrieval on Qdrant — hybrid search and reranking — plus memory, an eval suite in CI, and a streaming FastAPI deployment. The proof that you can build a real LLM application rather than a notebook.
Agent Mesh
Weeks 5-8. A multi-agent system: a supervisor over specialist sub-agents, an MCP server you wrote, A2A interoperability with an external agent, and end-to-end tracing with cost and latency per node.
Capstone
Weeks 9-12. A production-grade agentic application in a domain you choose, with evaluation, guardrails, a cost and latency SLO, and a real deployment. This is the piece you talk about in interviews.
What comes with it
- Assessed certification. The credential is earned, not issued on completion: you ship all three projects, pass the rubrics, and clear the capstone bar.
- Mock interviews. Two per participant in the closing weeks — agent system design, evaluation, cost, and debugging — with written feedback.
- Portfolio review. At least one 1:1 review of the portfolio and resume, plus asynchronous feedback after the first project.
- Guest sessions. Live sessions from working practitioners: a framework engineer, an evaluation specialist, and a hiring manager.
- Lifetime community. Permanent access to the cohort community — alumni, job leads, and perks on later cohorts.
- Office hours. Group office hours every week of the cohort, plus 1:1 time depending on tier.
Who teaches it
Vivek Tripathi
Principal AI Architect
Vivek builds agents that businesses depend on. He architected an enterprise agent platform — specialised LangGraph agents serving thousands of enterprise users across three regions — and LLM systems that surfaced tens of millions in previously unidentified revenue across a large multinational customer base. He has roughly halved agent running costs in production, holds a CTO Excellence Award, and has mentored hundreds of engineers.
- Around twelve years in enterprise software, consulting, and applied AI
- Architect of a production agent platform running across three regions
- Roughly halved agent running costs under production latency budgets
- CTO Excellence Award; certified on MCP and LangGraph
Tiers
Two ways in. Pick one on the request form — you can change it before you are invoiced.
Builder
The cohort, the projects, and the feedback loop around them.
₹49,999 standard · $649 international · prices include 18% GST
- All 12 live sessions, with recordings
- Three portfolio projects with rubric feedback
- Weekly group office hours
- Lifetime access to the cohort community
- Assessed certification and profile badge
- One 20-minute 1:1 with the instructor
- Two panel mock interviews
- One portfolio and resume review
Listed for reference. Nothing is charged here — request a seat below and we invoice separately once the cohort is confirmed.
Career
For people changing roles, who want the access as well as the curriculum.
₹74,999 standard · $899 international · prices include 18% GST
- Everything in Builder, plus:
- Three 30-minute 1:1s with the instructor
- An additional mock interview with the instructor
- In-depth portfolio review and profile rewrite
- Small-group mentorship pod
- Referral introductions for participants who finish with distinction
Listed for reference. Nothing is charged here — request a seat below and we invoice separately once the cohort is confirmed.
Questions
Who is this for?
Software engineers with roughly three to five years of experience who are comfortable in Python but have built little or nothing on top of LLMs. If you can build a REST API and use Git, you are ready.
What are the prerequisites?
Two or more years writing Python, including classes, async, and type hints; comfort with Git and the command line; at least one REST API you have built; and basic Docker literacy. No JavaScript, no heavy mathematics, and no local GPU.
What is the time commitment?
Around five to six hours a week for twelve weeks: one two-hour live session, optional midweek office hours, and roughly three hours on that week's lab.
Are the sessions recorded?
Yes. Every live session and office hour is recorded, so a missed week or an awkward timezone does not cost you the material.
What do I have at the end?
Three deployed agentic systems with live URLs, repositories, demo videos, and write-ups; an assessed certification; and enough grounding in evaluation, cost, and failure modes to interview for agentic AI roles.
How does enrollment work, and how do I pay?
You send an enrollment request from this page. No payment is taken on this site and there is no card field on it. We reply with cohort dates and seat availability, and invoice separately once you confirm. EMI and scholarship options exist and are arranged on request.
Is there a job guarantee?
No. You get a real portfolio, mock interviews, a resume and profile review, and referral introductions for the strongest finishers. The work is what gets you hired; the cohort is set up so you do the work.
What is the refund policy?
A full refund within seven days of the cohort start, no questions asked. After day seven there are no refunds. Early-bird, instalment, and scholarship seats are non-refundable, and the terms are restated on the invoice before you pay anything.
Enroll
This is a request, not a checkout. Nothing is charged now, and you are not enrolled until we confirm your seat and you settle the invoice we send.
Request a seat
Enrollment is by request. Send the form and we reply with cohort dates, seat availability, and an invoice — no payment is taken on this site. Listed prices include 18% GST; EMI and scholarship options are arranged on request.