Agentic AI Certificate Program in Jalandhar
Learn AI systems that plan, use tools and complete multi-step work on their own, taught on live client work at techcadd Jalandhar rather than from slides.
- Live client projects
- Practitioner trainers
- Placement support
- Certificate + internship

- Duration
- 3, 6 or 9 Months
- Mode
- Classroom, Weekend & 1-on-1
- Eligibility
- 12th Pass Onward
- Includes
- Internship Letter
- Students trained
- 25,000+Students trainedsince 2016
- Google rating
- 4.9★Google rating556+ reviews
- Practical training
- 100%Practical traininglive client work
Course overview
Agentic AI is software that pursues a goal on its own instead of answering a single prompt. A language model answers a question; an agent decides what to do next. Give it an outcome and it plans its own next step, calls a real tool — an API, a database, a browser, code — reads back what happened, and repeats until the goal is met, the budget runs out, or it needs a human. Four properties define an agent: goal-directedness, tool use, memory and autonomy. This programme in Jalandhar teaches you to build, evaluate, secure and operate systems with those properties.
The most valuable judgement in this field is knowing when not to build an agent at all. A deterministic workflow runs the same steps every time and is cheaper, faster and easier to debug; an agent chooses its own path, which is powerful but harder to predict. That decision framework is taught in Module 02, before you write a line of agent code, because recognising which problems genuinely need planning and tool selection — and which just need a well-written function calling an API — is the senior skill here.
The syllabus is a single ladder of thirty-three modules with exit points at three, six and nine months, taught with live client work rather than slides. Module 01 starts at Python from the first line, so no programming background is required going in. From Module 02 onward every session is agent engineering: prompting and structured output, tool calling and MCP servers, retrieval-augmented generation with citations, memory and state, graph orchestration with human-in-the-loop approval, then evaluation, guardrails and a deployed capstone. The six-month stage adds async engineering, model routing and self-hosted serving, DSPy optimisation, production MCP gateways, GraphRAG, durable execution, multi-agent systems, browser and coding agents, red teaming, and Kubernetes deployment with cost engineering. The nine-month stage moves from building an agent to owning the platform around it: CDC ingestion with ACL propagation, billion-scale vector infrastructure, A2A interoperability, an evaluation service, fine-tuning and reinforcement-learning post-training, voice and multimodal agents, AgentOps and FinOps, and governance mapped to the EU AI Act and NIST AI RMF.
Once the fundamentals are in place, the programme moves into the parts that make a system genuinely agentic: architectures and planning loops, tool use and function calling, memory, context and state management, and multi-agent coordination with LangGraph. Retrieval and knowledge grounding are covered so agents can work from your own data, and a full module is dedicated to evaluation and guardrails, because an agent that fails quietly is worse than one that fails loudly. You build in Python with LangChain, the Claude and OpenAI APIs, vector databases and FastAPI, and the final stage covers deployment, cost control and observability. Work runs on real briefs with a trainer reviewing your design decisions, and you finish with a deployed agent you can explain end to end.
From answering questionsto getting work done
A chatbot answers a question. An AI agent is given a goal and works towards it: it decides the next step, uses real tools such as a database, an API or a browser, checks what happened and carries on until the job is finished or it needs a person to approve something. Agentic AI is the engineering of those systems so they are useful, safe and affordable.
Think of the difference between a helpful shop assistant who answers your questions and a manager you can hand a task to: “find three suppliers, compare prices, draft the order and send it to me for approval”. Agents are the second kind. Building them well draws on several fields (software engineering, retrieval, evaluation, security and cloud operations), and this programme covers each of them to a different depth depending on whether you take the 3, 6 or 9-month track. Each field below shows how much of it this course covers.
- Job-ready focus3 fields
- The course trains you for entry-level work in this field.
- Strong foundation3 fields
- You learn the base skills here; one specialised course makes you job-ready.
- Introduced
- You will use it in the course, but it is not a specialisation.
- Not covered
- Not part of this course; available as a separate techcadd course.
What this course makes you job-ready for
Job-ready focusAI Agent Development & Tool Calling
Building agents that call tools (APIs, databases, other software) in a controlled loop, including MCP servers that expose a business's systems to an AI model safely.
An agent that reads incoming purchase enquiries for a Jalandhar hand-tool exporter, checks stock and pricing, drafts a quotation and waits for a manager to approve it.
- Agentic AI tools used
- PythonClaude APIOpenAI APIModel Context ProtocolLangGraphLangChainPydantic
- Job roles
- AI Automation EngineerAgentic AI DeveloperSolutions Engineer
Stage 1, Modules 2, 3 and 6 (structured output, tool calling and MCP, graph orchestration with human-in-the-loop). Projects: Published MCP Server, Human-in-the-Loop Approval Agent, Deployed Support Agent.
RAG & Knowledge Assistants
Connecting an AI to a company's own documents and data so its answers are grounded and come with a citation to the source.
A compliance assistant for a hospital that answers staff questions and points to the exact clause in the policy manual.
- Agentic AI tools used
- LlamaIndexQdrantpgvectorRAGASHugging Face
- Job roles
- Agentic AI DeveloperLLM Application Engineer
Stage 1, Module 4 (hybrid search, reranking, clause-level citations). GraphRAG and advanced retrieval in the 6-month track; retrieval at scale in the 9-month track. Projects: Cited Compliance Copilot, GraphRAG Retrieval Service.
LLM / AI Engineering in Production
Making AI systems work reliably for many users at a sensible cost: testing, model routing, caching, monitoring and handling failures.
Routing simple customer questions to a cheap model and hard ones to a stronger model, so a support bot costs half as much per conversation.
- Agentic AI tools used
- FastAPILangSmithLangfuseDSPyvLLMOllamaRedisPostgreSQL
- Job roles
- AI EngineerLLM Application EngineerAgent Platform Engineer
Evaluation and deployment basics in Stage 1 (Module 7); production engineering, model serving, durable orchestration and cost engineering in the 6-month track (Modules 8–20). Projects: Async LLM Client Library, Multi-Provider Model Router, Durable Procurement Agent.
What this course lays the foundation for
Strong foundationAI Evaluation, Safety & Red Teaming
Measuring whether an AI system is actually good, and attacking it on purpose to find weaknesses such as prompt injection before real users do.
Trying hundreds of trick inputs against a bank's AI assistant to check it never reveals another customer's details.
- Agentic AI tools used
- RAGASLangSmithpromptfooGarakPyRITguardrail libraries
- Job roles
- AI Engineer (evaluation focus)AI Red-Team / Safety Engineer (with experience)
Evaluation and guardrails in Stage 1; a full red-teaming module in the 6-month track; security architecture and evaluation science in the 9-month track. Project: 200-Attack Red-Team Report.
Cloud Deployment & Agent Platforms
Packaging agents as services, running them on cloud infrastructure, scaling them and keeping them observable.
Running a company's support agent in containers that scale up during a sale and roll back automatically if a new version misbehaves.
- Agentic AI tools used
- DockerKubernetesFastAPITemporalPostgreSQLRedis
- Job roles
- Agent Platform EngineerAI Engineer
Docker and a containerised FastAPI service from Module 1; Kubernetes deployment in the 6-month track; full platform design, AgentOps and FinOps in the 9-month track. Projects: Containerised API Service, Kubernetes Agent Deployment, Enterprise Agent Platform.
Fine-Tuning, Voice & Multimodal Agents
Adapting open models for a specific job, and building agents that talk on the phone or read documents, charts and images.
A voice agent that answers a clinic's appointment calls in real time and hands over to staff when needed.
- Agentic AI tools used
- Hugging FacevLLMLoRA / QLoRAvoice and speech-to-text services
- Job roles
- Applied AI EngineerVoice AI Developer
9-month track only: fine-tuning and distillation, reinforcement-learning post-training, and voice, vision and multimodal agents. Projects: Post-Trained Agentic Model, Production Voice Agent.
Clearing up common confusions
Is an AI agent just a chatbot?
No. A chatbot replies to a message and stops. An agent takes actions: it can look things up, update a record or send an email as part of reaching a goal. That is why agents need approvals, budgets and security checks that a simple chatbot does not.
Does this make me a cybersecurity professional?
Not on its own. You learn the security risks specific to AI agents, such as prompt injection and over-powerful tools. General cybersecurity (networks, servers, ethical hacking) is a separate field, taught in techcadd's Cybersecurity and Ethical Hacking courses.
Agentic AI is also used in…
Software teams (coding agents that fix bugs), finance (research agents), healthcare intake, legal contract review, e-commerce merchandising and IT operations. These are applications of the same agent skills; the capstone in the 6-month track lets you pick one of them.
At a glance: what this course covers
| Field | Coverage in this course | Where you learn it | Next step at techcadd |
|---|---|---|---|
| Agent development & tool calling | Job-ready focus | Stage 1, Modules 2, 3, 6 | Ready to apply |
| RAG & knowledge assistants | Job-ready focus | Module 4; Modules 12, 22–23 | Ready to apply |
| LLM / AI engineering in production | Job-ready focus | Module 7; Modules 8–20 (6 months) | Ready to apply |
| AI evaluation & red teaming | Strong foundation | Modules 7, 17–18, 27–28 | Experience on the job |
| Cloud deployment & platforms | Strong foundation | Modules 1, 19, 32 | Docker & Kubernetes, DevOps Engineering |
| Fine-tuning, voice & multimodal | Strong foundation | Modules 29–31 (9 months) | — |
| Training predictive models (ML / Data Science) | Not covered | — | Machine Learning, Data Science |
| Front-end web development | Not covered | — | Full Stack Development |
Which Agentic AI pathsuits you?
You do not need to pick a specialism before you join. Everyone climbs the same ladder from Module 01, and most students find their direction while building the Stage 1 projects. If you already have a leaning, this guide helps:
| If you… | You will probably enjoy | Typical first job |
|---|---|---|
| Like connecting software together and automating business tasks | Agent Development & Tool Calling | AI Automation Engineer |
| Enjoy organising knowledge and getting precise answers from documents | RAG & Knowledge Assistants | Agentic AI Developer |
| Care about reliability, speed and cost | Production AI Engineering (6-month track) | AI Engineer, LLM Application Engineer |
| Like finding weaknesses and breaking things on purpose | AI Evaluation & Red Teaming | AI Engineer with an evaluation focus |
| Want to design systems many teams depend on | Agent Platforms (9-month track) | Agent Platform Engineer, later Architect |
| Want agents at work but do not want to code | AI tools and no-code automation | Consider ChatGPT & AI Tools or AI for Managers instead |
| Are not sure yet | Start with the 3-month Practitioner track | Decide with your trainer once Stage 1 is done, then extend |

Industry-Ready Training in Agentic AI
- 100% practical, project-based learning
- AI tools integrated into every module
- Live client projects under trainer supervision
- Internship letter and placement support
- Small batches with daily doubt clearing
What you will
actually build
The programme runs as a single ladder of 33 modules with three exit points. Module 01 teaches Python, the command line, Git, HTTP and SQL from zero, so no programming background is assumed; from Module 02 onward every session is agent engineering. Every module is specified the same way — topics, the named tool stack, the commercial problem it solves, and a graded deliverable that goes into your portfolio — and you advance when a deliverable passes review rather than when the calendar says so.
Foundation: Agent Practitioner
- Programming Foundations — From Absolute Zero
Python from the first line through the command line, Git and GitHub, HTTP and SQL, ending in a containerised FastAPI service with a database and tests passing in CI.
- LLM Foundations, Prompting & Structured Output
Tokenization, context windows and temperature alongside the workflow-versus-agent decision framework, plus forcing schema-valid JSON out of a model with Pydantic repair loops.
- Tool Calling, Function Execution & MCP
Tool schemas, parallel versus sequential calls, retries and idempotency, a ReAct loop written from scratch, and building real Model Context Protocol servers and clients.
- Retrieval-Augmented Generation & Knowledge Grounding
Embeddings, chunking, PDF and scan parsing, hybrid BM25-plus-dense search and reranking, built into a service that cites the exact clause it answered from.
- Memory, State & Context Management
Short-term, long-term and episodic memory, rolling summarisation and checkpointing, plus the multi-tenant isolation and PII rules a real deployment can't skip.
- Agent Frameworks, Graph Orchestration & Delegation
Agents as LangGraph state machines with conditional routing, streaming and human-in-the-loop interrupts, then splitting one agent into a supervisor coordinating workers.
- Evaluation, Guardrails, Deployment & Capstone
Gold datasets from real traffic, LLM-as-judge scoring, CI regression gates and input/output guardrails against prompt injection, packaged into a deployed streaming service.
Useful for: AI Automation Engineer, Agentic AI Developer and Solutions Engineer roles: building, grounding and deploying a first production agent.
Agentic AI Is Powering the Next Generation of Industry Leaders
- Live client work from week one, supervised by a trainer, not slides, not simulations.
- AI Engineer roles in Punjab start around ₹25,000 – ₹50,000 a month for a fresher with a working portfolio.
Reviewed by mentors. Built for interviews.Who can dothis course
The Agentic AI programme is built for people at six different starting points, and the batch is deliberately mixed. What matters far more than your background is turning up consistently and finishing what each module asks you to build.
Students after 12th
Join from any stream. You start from fundamentals with no assumed knowledge, and most students run the programme alongside a degree at a Jalandhar college using the weekday or weekend batch.
Graduates and final-year students
If you are finishing a BA, BBA, B.Com, BCA or B.Tech, this is the shortest route from degree to salary. Enter placement season with project work in hand instead of a blank CV.
Working professionals
The weekend batch exists for people already earning. Career switchers typically become interview-ready for AI Engineer roles within five to six months without leaving their current job.
Business owners and freelancers
Owners take this programme to stop outsourcing work they cannot judge. Freelancers take it to bill clients beyond Punjab, since location does not limit remote work in this field.
Career restarters
A gap on the CV counts for less than work you can point at. The programme starts at zero and finishes with a portfolio and a documented internship letter, which is what an interviewer asks about after a break.
Self-taught learners
If free videos left you with notes but nothing built, what changes here is a trainer who reviews what you produced this week and a deadline attached to every module.
One course.A mesh of real tools.
Everything below is installed on the lab machines and used on live client work, not shown once in a slide and forgotten.
- Python
- The language every agent in the programme is written in
- LangGraph
- Builds agents as step-by-step graphs with approvals and recovery
- LangChain
- Connects models, prompts, tools and data into one pipeline
- Claude
- Anthropic's language model, called through its API
- OpenAI API
- Access to OpenAI's GPT models from your code
- Gemini
- Google's language models, used through their API
- Model Context Protocol
- The open standard for giving AI models access to tools
- FastAPI
- Turns your agent into a web service other apps can call
- Pydantic
- Checks that model output matches the exact shape you expect
- Qdrant
- A vector database for searching documents by meaning
- pgvector
- Vector search inside a normal PostgreSQL database
- LlamaIndex
- Framework for building retrieval over your documents
- RAGAS
- Scores how faithful and relevant a RAG system's answers are
- LangSmith
- Traces, tests and evaluates agent runs
- Langfuse
- Open-source tracing and monitoring for LLM apps
- DSPy
- Optimises prompts automatically against a labelled task
- CrewAI
- A framework for teams of cooperating agents
- Playwright
- Lets an agent control a real web browser
- vLLM
- Runs open-source models fast on your own servers
- Ollama
- Runs open-source models locally on your own machine
- Hugging Face
- Hub of open models, plus training and fine-tuning libraries
- Temporal
- Keeps long workflows running correctly even after a crash
- Docker
- Packages a service so it runs the same anywhere
- Kubernetes
- Runs and scales containers in production
- Neo4j
- A graph database for knowledge graphs and GraphRAG
- Redis
- Fast in-memory store for caching, queues and short-term memory
- PostgreSQL
- The relational database behind most services in the course
- Streamlit
- Quick web interfaces for demos and internal tools
Get Certified in
Agentic AI
Complete the course with a portfolio of live projects and receive an industry-recognised certificate, plus a documented internship letter accepted by Punjab universities.


Two certificates on completion — the course certificate and a separate capstone project certificate.
Where this coursetakes you
The roles this opens, what they pay in Punjab and beyond, and who is hiring for them — the same figures our free Salary Estimator publishes, not a brochure number.
AI / ML Engineer
Builds and deploys machine learning models and AI systems.
- Starting package
- ₹3–5.5LPA
- After 2 years
- ₹6–12LPA
Indicative ranges for AI / ML Engineer roles, compiled from public job-market listings and drawn on the same scale in every market. Actual offers vary by employer, skillset and interview performance — Punjab pay typically reaches 2.2× the fresher ceiling within two years of delivery experience.
Open the salary estimatorWhere AI / ML Engineer graduates get hired
- AI startups and research labs (Bangalore, NCR, remote)
- Product companies building AI features
- Analytics and consulting firms
- Global remote positions via freelance platforms
What job roles open up after Agentic AI?
Agent roles are graded by seniority, and the track length you finish decides which level you can apply for. Roles outside agent engineering need one more course:
- AI Automation Engineer (3-month track)
- Agentic AI Developer (3-month track)
- Solutions Engineer (3-month track)
- AI Engineer / LLM Application Engineer (6-month track)
- Agent Platform Engineer (6-month track, secured at 9 months)
- Freelance AI Automation Developer
- Agentic AI Architect (9-month track plus delivery experience)
- Full-Stack AI Developer (with Full Stack Development course)
- Machine Learning Engineer (with Machine Learning course)
- Data Scientist (with Data Science course)
What does an AI Automation Engineer interview test?
This is the entry-level role Stage 1 prepares you for. Interviews test whether you can wire tools reliably, handle failures gracefully and show a working deployed demo. What you show them: your published MCP server, the cited RAG assistant and the deployed capstone.
What does an Agentic AI Developer interview test?
The early-career role that Stage 1 opens and Stage 2 secures. Interviews test framework fluency, RAG quality debugging and human-in-the-loop design. What you show them: the approval-gated graph agent, the document extraction engine and an evaluation gate running in CI.
What does an AI Engineer or LLM Application Engineer interview test?
The mid-level role Stage 2 prepares you for. Interviews test evaluation methodology, cost control, and production incidents you have personally handled. What you show them: the multi-provider model router, the 200-attack red-team report and a Kubernetes deployment with a published SLO.
What does an Agent Platform Engineer interview test?
The senior role that Stage 2 opens and Stage 3 secures. Interviews test multi-tenancy, durable execution, gateway design and observability at scale. What you show them: the durable procurement agent, the OAuth-protected MCP gateway and the multi-tenant evaluation service.
What does an Agentic AI Architect interview test?
The lead or staff role Stage 3 prepares you for. Interviews test system design under constraints, security threat modelling, governance and defending a total cost of ownership. What you show them: the enterprise agent platform, the CISO-grade security package and the governance pack.
What does an Applied AI Engineer (research-adjacent) interview test?
The specialist route out of Stage 3. Interviews test post-training, benchmark design and honest measurement of agent capability. What you show them: the SFT and reinforcement-learning post-trained model, and an evaluation-science portfolio.
What job roles open up after Agentic AI?
Graduates move into AI Engineer, Agent Developer, Automation Architect, AI Consultant and similar roles. Agentic systems are where AI budgets are moving, and practitioners are genuinely rare in North India.
What can I earn, and how fast does it grow?
A fresher with a working portfolio starts around ₹25,000 – ₹50,000 a month in the Jalandhar market. With two years of delivery experience that typically doubles, and specialists who keep learning move well beyond it.
Can I freelance or work remotely with this skill?
Yes. A Jalandhar address costs you nothing on a remote brief. Students bill clients in Delhi, Dubai and Canada. The programme covers client handling, proposals and reporting so you can price and defend your work, not just do it.
Which industries hire for this in Punjab?
Beyond IT companies, the export houses, sports goods and hand tool manufacturers, immigration consultancies, hospitals, schools and real estate firms across Jalandhar all now hire for these skills directly.
Can I continue to higher studies or a specialisation later?
The certificate and portfolio stand on their own, and they stack. Most students move on to an adjacent techcadd track. The tools overlap, so the second programme is faster than the first.
Your Agentic AI careerroadmap
The 3-month track is enough to apply for entry-level agent roles; the 6 and 9-month tracks continue on the same ladder for senior ones. For roles outside agent engineering you add one focused course. Here is how each path looks:
| Goal | Step 1 | Step 2 | Where you arrive |
|---|---|---|---|
| AI Automation Engineer | Agentic AI Certificate Program | Ready to apply after the 3-month track | AI Automation Engineer |
| Agentic AI Developer | Agentic AI Certificate Program | Ready to apply (6-month track makes it stronger) | Agentic AI Developer |
| AI / LLM Application Engineer | Agentic AI Certificate Program | Continue to the 6-month Engineer stage | AI Engineer, LLM Application Engineer |
| Agent Platform Engineer / Architect | Agentic AI Certificate Program | Continue to the 9-month Architect stage | Agent Platform Engineer, Agentic AI Architect (with experience) |
| Full-stack AI product builder | Agentic AI Certificate Program | Full Stack Development | Full-Stack AI Developer |
| ML Engineer / Data Scientist | Agentic AI Certificate Program | ML Engineer, Data Scientist |
Hands-on projectsyou will ship
Containerised API Service
A FastAPI service backed by Postgres, typed and tested, shipped in Docker with CI running on every push.
Field: Backend Engineering, Deployment
Document Extraction Engine
Unstructured invoices and contracts converted into schema-valid JSON, with under 2% validation failure across 100 documents.
Field: Structured Output, Business Automation
Published MCP Server
Five or more scoped tools with full schema documentation, integration tests, and a hand-written ReAct loop that uses them without a framework.
Field: Tool Calling, Agent Development
Cited Compliance Copilot
A hybrid-search RAG assistant with clause-level citations, scoring 0.85+ faithfulness on a 50-question gold set.
Field: RAG, Knowledge Assistants
Human-in-the-Loop Approval Agent
A stateful graph agent that pauses for underwriter sign-off, streams every step, and resumes cleanly after a crash.
Field: Agent Orchestration, Human Approval
Deployed Support Agent
A publicly reachable capstone with CRM write-back, human escalation, a CI regression gate and a cost-per-conversation figure.
Field: Agent Development, Evaluation, Deployment
Async LLM Client Library
Rate-limited, retried, cached and fully typed, with 90%+ test coverage and a resumable 100,000-record enrichment run behind it.
Field: Production AI Engineering
Multi-Provider Model Router
A cascading router with automatic fallback and a self-hosted vLLM endpoint, benchmarked across five models on cost, quality and latency.
Field: Model Serving, Cost Engineering
GraphRAG Retrieval Service
Hybrid search plus reranking plus a knowledge graph, with an ablation study quantifying what each component actually contributed.
Field: Advanced Retrieval, Knowledge Graphs
Durable Procurement Agent
A multi-day workflow that survives a forced restart mid-execution and correctly compensates a partially completed order.
Field: Durable Orchestration, Business Automation
Browser & Coding Agent Pair
A 10-step authenticated portal workflow at 90%+ reliability over 20 runs, alongside a coding agent that closes three real GitHub issues.
Field: Browser Automation, Coding Agents
200-Attack Red-Team Report
A full threat model with an automated injection suite and a measured before-and-after mitigation result, plus an incident runbook.
Field: AI Security, Red Teaming
Kubernetes Agent Deployment
An autoscaled, canary-released platform defined in Terraform, with a load-test report and a published SLO and error budget.
Field: Cloud Deployment, Scaling
CDC Ingestion Backbone
An incremental pipeline across twenty source systems with ACL propagation, lineage, PII tagging and a freshness SLA dashboard.
Field: Data Engineering, Knowledge Pipelines
Twenty-Million-Document Index
Permission-filtered retrieval at sub-300 millisecond p95, benchmarked for recall and latency across three index configurations.
Field: Retrieval at Scale, Vector Infrastructure
A2A Interoperable Agent
An agent published with its own agent card, negotiating structured tasks with a second organisation's agent under cryptographic identity.
Field: Multi-Agent Interoperability
Multi-Tenant Evaluation Service
A shared eval platform with calibrated judges, significance testing, drift alarms and a portfolio quality dashboard.
Field: Evaluation Science, AI Quality
Post-Trained Agentic Model
A 7–14B model taken through supervised fine-tuning and then preference or GRPO training, beating the base model on held-out tool use.
Field: Fine-Tuning, Reinforcement Learning
Production Voice Agent
Sub-900 millisecond turn latency with barge-in, identity verification and warm handoff, evaluated over 50 real calls.
Field: Voice & Multimodal Agents
Enterprise Agent Platform
The architect capstone: control plane, registry, eval gates, auto-rollback, chargeback dashboard and a governance pack mapped to the EU AI Act.
Field: Agent Platforms, Governance
Learn it. Build it. Make it yours.
Every project moves through the same loop: understand the brief, build with guidance, then explain the decisions behind your work.
Understand
Break a real requirement into a clear plan and the right tools.
Containerised API ServiceBuild
Work hands-on with trainer feedback while the decisions are still easy to change.
Document Extraction EnginePresent
Turn the finished work into a portfolio story you can defend in an interview.
Published MCP ServerWhy students choosetechcadd
There are many places to learn this in Jalandhar and the brochure syllabus looks similar at all of them. What differs is who teaches, whether you ever touch real work, and whether anyone picks up the phone after you have paid. techcadd has trained students across Punjab since 2016 on the same model: small batches, working practitioners as trainers, client projects as coursework.
Trainers who still do the work
Your trainer is not a full-time lecturer. They deliver client projects for techcadd's services arm, so examples in class are current rather than a case study from five years ago.
Live projects, real consequences
You work on genuine client requirements under supervision. This is where a portfolio comes from, and it is the first thing an interviewer asks to see.
Small batches and open lab hours
Batches stay small enough that a trainer sees your screen daily. Lab time runs outside class hours and doubt sessions continue until the concept lands.
Internship letter and certificate
Every student finishes with an industry-recognised certificate and a documented internship on real work, accepted for university industrial training requirements.
A placement cell that persists
Mock interviews, CV reviews and drives with hiring partners across Jalandhar and Ludhiana, repeated after a rejection, not abandoned.
Since 2016, 25,000+ students
A decade of hiring relationships in Punjab is why a call from our placement cell gets answered and why local employers know what our certificate means.
What our studentsin Jalandhar say
- Google
The Agentic AI course got me interview-ready faster than I expected. My interviewer asked to see my project and that was the whole conversation.
Manpreet KaurFinal-Year Student · Hoshiarpur GoogleI travelled in for the weekend Agentic AI batch and it was worth every trip. Small batch, real work, no time wasted on theory nobody uses.
Vikas ChopraWeekend Batch · Ludhiana Googletechcadd's placement cell kept calling me for drives until I was placed. That persistence mattered more than the certificate for Agentic AI.
Neha BansalPlaced Fresher · Jalandhar GoogleThe Agentic AI course got me interview-ready faster than I expected. My interviewer asked to see my project and that was the whole conversation.
Manpreet KaurFinal-Year Student · Hoshiarpur GoogleI travelled in for the weekend Agentic AI batch and it was worth every trip. Small batch, real work, no time wasted on theory nobody uses.
Vikas ChopraWeekend Batch · Ludhiana Googletechcadd's placement cell kept calling me for drives until I was placed. That persistence mattered more than the certificate for Agentic AI.
Neha BansalPlaced Fresher · Jalandhar
- Google
I was switching careers and worried I would be behind. Half the Agentic AI batch were doing the same thing, and nobody made me feel slow.
Arshdeep SinghTrainee Engineer · Adampur GoogleI joined the Agentic AI batch with almost no background and finished with a project I could actually show. The trainers correct your work daily rather than just moving to the next slide.
Pooja RaniGraduate · Kartarpur GoogleWhat made Agentic AI click for me was the lab time. You can sit after class and someone will still explain it until you get it.
Karan MehtaB.Tech Student · Jalandhar GoogleI was switching careers and worried I would be behind. Half the Agentic AI batch were doing the same thing, and nobody made me feel slow.
Arshdeep SinghTrainee Engineer · Adampur GoogleI joined the Agentic AI batch with almost no background and finished with a project I could actually show. The trainers correct your work daily rather than just moving to the next slide.
Pooja RaniGraduate · Kartarpur GoogleWhat made Agentic AI click for me was the lab time. You can sit after class and someone will still explain it until you get it.
Karan MehtaB.Tech Student · Jalandhar
Frequently Asked Questions
Agentic AI is software that pursues a goal on its own rather than answering a single prompt. A language model answers; an agent decides. Given an outcome it plans its next step, calls a real tool such as an API, database or browser, reads what came back, and goes again — until the goal is met, the budget runs out, or it asks a human. Four properties make something an agent: goal-directedness (you give it an outcome, not a script), tool use (it reaches outside the model), memory (it carries state across steps and sessions) and autonomy (it runs the loop itself, within budgets and approval gates you set).
In a workflow you decide the path: the same steps run every time — fetch, score, write, notify — which is cheap, fast and easy to debug. In an agent, the agent decides the path, choosing its own tools and steps, which is more powerful and harder to predict. Reach for an agent only when the path genuinely cannot be known in advance, meaning the next step depends on what the last one returned. Knowing which one a problem needs is the most valuable judgement in this field, and it is taught in Module 02 before you write a line of agent code.
There are three exit points on one 33-module ladder: 3 months (Practitioner, Modules 1–7), 6 months (Engineer, Modules 8–20) and 9 months (Architect, Modules 21–33). They are nested, not parallel — the 6-month programme contains the 3-month one and continues from Module 08, and the 9-month contains both and continues from Module 21 — so a shorter programme costs you scope, never depth, and you can return later without repeating a module.
No. Module 01 teaches Python from the first line, along with the command line, Git and GitHub, HTTP and REST, and SQL, and ends with a containerised FastAPI service that has a database and passing tests in CI. Everything after it assumes you can do that unaided, which is why the programme is open to career changers and to graduates from any stream.
The named stack includes Python, FastAPI and Pydantic; the Claude, OpenAI and Gemini APIs with Ollama for local models; LangGraph, LangChain, CrewAI and the OpenAI Agents SDK for orchestration; the Model Context Protocol SDK for tools; Qdrant, Chroma, pgvector and Neo4j for retrieval and graphs; LangSmith, Langfuse, RAGAS and promptfoo for evaluation; Garak and PyRIT for red teaming; Playwright and Browser Use for browser agents; and Docker, Kubernetes, Terraform and Temporal for production. Tools are taught one per layer, deeply, because the pattern outlives the library.
Every module ends in a graded artefact. Stage 1 produces a containerised API service, a document-extraction engine, a published MCP server, a cited compliance copilot, a human-in-the-loop approval agent and a deployed support agent. Stage 2 adds an async LLM client library, a multi-provider model router, a GraphRAG retrieval service, a durable procurement agent, a browser-and-coding agent pair, a 200-attack red-team report and a Kubernetes deployment with a published SLO. Stage 3 adds a CDC ingestion backbone, a twenty-million-document index, an A2A interoperable agent, a multi-tenant evaluation service, a post-trained model, a production voice agent and an enterprise agent platform.
Stage 1 prepares you for AI Automation Engineer, Agentic AI Developer and Solutions Engineer roles. Stage 2 prepares you for AI Engineer, LLM Application Engineer and Agent Platform Engineer. Stage 3 prepares you for Agentic AI Architect, Staff AI Engineer and Head of AI Engineering. Interviews test different things at each level — reliable tool wiring and a working deployed demo early on; evaluation methodology, cost control and production incidents in the middle; and system design, threat modelling and total cost of ownership at architect level.
Tool calling, retrieval and long context turned a research idea into deployable software in about two years. Companies now have agents in production and almost nobody who can evaluate, secure and operate them, and that gap is what this certificate programme is built to fill. The hiring signal is evidence rather than demos: a labelled evaluation set, a measured before-and-after, a red-team report and a cost-per-task number.
techcadd runs Agentic AI over 3 to 9 months depending on the track you choose. Weekday, evening and weekend batches cover the same syllabus, and 1-on-1 training is available if you would rather set your own pace. Every class runs for 2 hours, whichever format you choose.
Fees depend on the course length and subject. techcadd counsellors share the exact fee for the length you choose and EMI options on request, and a demo class is free.
Students after 12th, graduates and final-year students, working professionals switching careers, and business owners all join this programme. You start from fundamentals, so a technical background helps but is not required.
Graduates typically move into roles such as AI Engineer, Agent Developer, Automation Architect or AI Consultant. Agentic systems are where AI budgets are moving, and practitioners are genuinely rare in North India.
A fresher with a working portfolio typically starts around ₹25,000 – ₹50,000 per month in the Jalandhar market, rising substantially within two years of experience. Freelancers handling multiple clients often earn more, since remote work is not limited by location.
No training provider can honestly guarantee a job, and you should be cautious of anyone in Jalandhar who claims one. techcadd guarantees placement support: CV reviews, mock interviews, portfolio preparation and repeated drives with hiring partners across Jalandhar and Ludhiana.
You will work hands-on with Python, LangChain, LangGraph, Claude, OpenAI API, Vector DBs and the supporting toolchain used on live projects. All practice happens in the lab on licensed software, not on demo screenshots.
Yes. Every student receives an industry-recognised certificate on completion plus a documented internship letter based on live client work. The internship satisfies the industrial training requirement at most Punjab universities.
Every module ends with something you built. The Best Agentic AI Certificate Program in Jalandhar finishes with a live project drawn from techcadd's own client delivery work, supervised by a trainer, which becomes the portfolio you take to interviews.
Yes. techcadd Jalandhar runs weekday, evening and weekend batches in parallel so working professionals and college students can both attend, and 1-on-1 training is available for a fully personal schedule. Every class (batch or 1-on-1) runs for 2 hours; book a free demo class to see the lab and meet the trainer before enrolling.
Generative AI creates content (text, images, answers) when asked. Agentic AI uses the same language models to take actions: it plans steps, calls tools and finishes a task, often pausing for human approval. This programme teaches the generative basics it needs (prompting, structured output, RAG) and then focuses on agents.
No. Zapier-style automation follows fixed steps you set up in advance. An agent chooses its own steps based on what it finds. This is a coding programme in Python. If you want no-code automation with AI tools, techcadd's ChatGPT & AI Tools course is the better fit.
It is designed to be. Stage 1 ends with a deployed agent, a published MCP server and a cited RAG assistant, which is what entry-level AI Automation Engineer and Agentic AI Developer interviews ask to see. The 6 and 9-month stages are for mid-level and senior roles.
No. You work with existing language models and build systems around them; you do not train predictive models from spreadsheets of data. The 9-month track does include fine-tuning language models, but for classic machine learning and data science, take techcadd's Machine Learning or Data Science course.
You build simple interfaces with Streamlit and the backend with FastAPI. Full web front-ends in HTML, CSS and JavaScript frameworks are not part of this programme; add techcadd's Full Stack Development or Web Development course for that.
Choose the rightduration for you
Thirty-three modules in one numbered ladder with three exit points, taught in Jalandhar. Module 01 begins with Python, the command line, Git, HTTP and SQL from the ground up, so no programming background is assumed; from Module 02 onward every session is agent engineering. Progression is capability-gated — you advance when a deliverable passes review, not when the calendar says so. Every module is specified the same way: the topics covered, the named tool stack you actually run, the commercial problem the pattern is built to solve, and a graded artefact that goes into your portfolio.
Practitioner
Modules 1 – 7
Build and deploy your first production agent — starting from no programming experience. Prepares you for AI Automation Engineer, Agentic AI Developer and Solutions Engineer roles.
Engineer
Modules 8 – 20
Make it work every time, for many users, at a defensible cost. Prepares you for AI Engineer, LLM Application Engineer and Agent Platform Engineer roles.
Architect
Modules 21 – 33
Own the platform ten teams build agents on, not just one agent. Prepares you for Agentic AI Architect, Staff AI Engineer and Head of AI Engineering roles.
| Module | 3 Months | 6 Months | 9 Months |
|---|---|---|---|
| 01Programming Foundations — From Absolute ZeroPython from the first line, the command line, Git and GitHub, HTTP and REST, and SQL, all taught from zero. Tools: Python 3.12, uv, VS Code, httpx, FastAPI, PostgreSQL, Redis, Docker. Deliverable: a containerised FastAPI service with a database, typed models and tests passing in GitHub Actions. | Included | Included | Included |
| 02LLM Foundations, Prompting & Structured OutputTokenization, context windows, temperature and the four agentic properties; the workflow-versus-agent decision framework; structured output through JSON schema and Pydantic repair loops. Tools: Claude API, OpenAI API, Gemini API, Ollama, Pydantic v2, Instructor, promptfoo. Deliverable: a model-comparison notebook plus an extraction service returning schema-valid JSON on 100 documents with under 2% validation failures. | Included | Included | Included |
| 03Tool Calling, Function Execution & MCPTool schemas and parameter design, parallel versus sequential calls, retries, idempotency and timeouts, the ReAct loop written from scratch, and Model Context Protocol servers, clients and transports. Tools: MCP Python SDK, MCP Inspector, FastAPI, Tenacity, E2B, Tavily. Deliverable: a published MCP server with five or more tools and a framework-free ReAct loop that uses it. | Included | Included | Included |
| 04Retrieval-Augmented Generation & Knowledge GroundingEmbeddings, chunking strategies, document parsing for PDFs and scans, hybrid BM25-plus-dense search, reranking and clause-level citation. Tools: LlamaIndex, LangChain, Qdrant, Chroma, pgvector, Docling, Cohere Rerank, RAGAS. Deliverable: a hybrid-search RAG service scoring at least 0.85 faithfulness and 0.80 context precision on a 50-question gold set. | Included | Included | Included |
| 05Memory, State & Context ManagementShort-term, long-term and episodic memory, rolling summarisation, checkpointing, multi-user isolation, and PII and retention rules. Tools: LangGraph checkpointers, Mem0, Zep, Redis, PostgreSQL with pgvector, Presidio. Deliverable: a multi-tenant memory layer with a documented eviction policy, a GDPR-style delete endpoint and a test proving cross-tenant isolation. | Included | Included | Included |
| 06Agent Frameworks, Graph Orchestration & DelegationAgents as state machines — LangGraph nodes, conditional routing, typed state, streaming, human-in-the-loop interrupts and time-travel debugging — then splitting one agent into a supervisor and workers. Tools: LangGraph, LangGraph Studio, CrewAI, Pydantic AI, OpenAI Agents SDK, LangSmith. Deliverable: a stateful agent with an approval interrupt, step streaming and a resume-after-crash demo. | Included | Included | Included |
| 07Evaluation, Guardrails, Deployment & CapstoneGold datasets from real traffic, deterministic assertions versus LLM-as-judge, CI regression gates, prompt-injection basics, input and output guardrails, and packaging an agent as a streaming service. Tools: LangSmith, Langfuse, RAGAS, Guardrails AI, FastAPI, Docker, Streamlit, GitHub Actions. Deliverable: a deployed, publicly reachable agent with an eval report, architecture diagram, demo video and cost-per-conversation analysis. | Included | Included | Included |
| 08AI Engineering Foundations & Python at ScaleAsync Python for I/O-bound LLM workloads, bounded concurrency and connection pooling, typed domain modelling, and testing non-deterministic systems with snapshots and cassettes. Tools: asyncio, Pydantic v2, pytest-asyncio, Tenacity, structlog, ruff, mypy. Deliverable: a rate-limited, retried, cached and fully typed async LLM client library with 90%+ test coverage. | Not included | Included | Included |
| 09LLM Internals, Model Landscape & ServingAttention and the KV cache, prefill versus decode latency, sampling in depth, quantisation trade-offs, self-hosting with batched inference, and model routing and cascades. Tools: vLLM, Ollama, Hugging Face Transformers, llama.cpp, LiteLLM, OpenRouter. Deliverable: a LiteLLM router with automatic fallback, a self-hosted vLLM endpoint and a five-model cost, quality and latency benchmark. | Not included | Included | Included |
| 10Advanced Prompt & Context EngineeringContext-window budgeting and compaction, prompt caching architecture, automated optimisation with DSPy signatures and teleprompters, self-refinement loops, and prompt registries with rollback. Tools: DSPy, Instructor, Outlines, promptfoo, LangSmith Prompt Hub, Langfuse. Deliverable: a DSPy-optimised module beating a hand-written baseline on a labelled task, with a versioned registry and rollback procedure. | Not included | Included | Included |
| 11Production MCP Servers & Tool EcosystemsTool design as API design, large tool catalogues and dynamic selection, permission scoping, OAuth flows, streamable HTTP transport, and safe code-execution sandboxes. Tools: MCP Python and TypeScript SDKs, FastMCP, E2B, Daytona, Composio, n8n, OAuth 2.1. Deliverable: an OAuth-protected MCP server with 12+ scoped tools, dynamic tool retrieval, audit logging and a published integration guide. | Not included | Included | Included |
| 12Advanced Retrieval, Hybrid Search & GraphRAGQuery rewriting, decomposition and HyDE, reciprocal rank fusion, cross-encoder reranking, parent-document retrieval, and knowledge graphs for multi-hop questions. Tools: Qdrant, Weaviate, Elasticsearch, Neo4j, Microsoft GraphRAG, ColBERT, Cohere Rerank, RAGAS. Deliverable: a retrieval service combining hybrid search, reranking and a knowledge graph, with an ablation study quantifying each component. | Not included | Included | Included |
| 13Memory Architecture for Long-Lived AgentsFormal memory taxonomy, write and forget policies, consolidation pipelines, conflict resolution when memories contradict, temporal knowledge graphs and memory evaluation. Tools: Letta, Mem0, Zep, Graphiti, LangGraph Store, Redis Stack, Neo4j. Deliverable: a memory subsystem with consolidation and conflict resolution, benchmarked over a simulated 100-session user history. | Not included | Included | Included |
| 14Agent Architectures & Durable OrchestrationThe pattern catalogue — ReAct, Plan-and-Execute, Reflexion, router, evaluator-optimiser, orchestrator-worker — plus durable execution that survives process death and compensates partial side effects. Tools: LangGraph Platform, Temporal, Restate, Prefect, Redis Streams. Deliverable: a durable agent workflow that survives a forced restart mid-execution and correctly compensates a failed step. | Not included | Included | Included |
| 15Multi-Agent Systems & Communication ProtocolsTopologies from hierarchical to market and debate, typed contracts between agents, consensus and adversarial critique, deadlock and infinite-handoff detection, and measuring whether multi-agent actually beats single-agent. Tools: LangGraph multi-agent, CrewAI Flows, AutoGen, Microsoft Agent Framework, Google ADK, Ray, Kafka. Deliverable: a multi-agent system with budget and loop guards and a head-to-head report against a single-agent baseline. | Not included | Included | Included |
| 16Browser Automation, Computer Use & Coding AgentsDOM-grounded versus vision-grounded web agents, resilient self-healing selectors, computer-use loops, and coding agents doing repository indexing and test-driven work. Tools: Playwright, Browser Use, Stagehand, Claude Code, OpenHands, Aider, E2B Desktop. Deliverable: a browser agent completing a 10-step authenticated workflow at 90%+ reliability over 20 runs, plus a coding agent that closes three real GitHub issues. | Not included | Included | Included |
| 17Evaluation, Benchmarking & ObservabilityDataset curation and inter-annotator agreement, LLM-as-judge calibration, trajectory evals, shadow deployment, distributed tracing and silent-regression detection. Tools: LangSmith, Langfuse, Braintrust, W&B Weave, Arize Phoenix, DeepEval, OpenTelemetry, Grafana. Deliverable: a full eval platform with a curated dataset, calibrated judge, CI gate, online A/B harness and a failure taxonomy from 100 real traces. | Not included | Included | Included |
| 18Agent Security, Guardrails & Red TeamingThe OWASP Top 10 for LLM applications, direct and indirect prompt injection, the lethal trifecta of private data, untrusted content and outbound communication, least-privilege tool design and egress control. Tools: Garak, PyRIT, promptfoo red team, Rebuff, Lakera Guard, NeMo Guardrails, gVisor. Deliverable: a threat model plus an automated red-team suite of 200+ attacks with a before-and-after mitigation report and an incident runbook. | Not included | Included | Included |
| 19Production Deployment, Scaling & Cost EngineeringHorizontal scaling of stateful agents, queues and backpressure, semantic caching, blue/green and canary releases, SLOs and error budgets, and unit economics measured as cost per successful task. Tools: Docker, Kubernetes, Helm, Terraform, Ray Serve, Modal, AWS Bedrock AgentCore, ArgoCD, Prometheus, Grafana. Deliverable: a Kubernetes-deployed agent platform with IaC, autoscaling, canary release, a load-test report, a published SLO and a fine-tuned small model with a cost comparison. | Not included | Included | Included |
| 20Engineer Capstone — Production Agent ProductProblem selection and ROI framing, architecture decision records, and one product taken from build through evaluation and hardening to launch and measurement. Choose from a multi-agent financial research platform, an autonomous DevOps incident-response agent, a healthcare intake agent, an e-commerce merchandising agent or a legal contract-review agent. Deliverable: a live multi-user product with an eval dashboard, red-team report, SLO, cost model, ADR set and a public technical write-up. | Not included | Included | Included |
| 21Data Engineering & Knowledge PipelinesSource connectors and change-data-capture across Drive, SharePoint and the warehouse, idempotent resumable ingestion, ACL propagation from source system to index, PII classification at ingest, and data contracts with lineage. Tools: Dagster, Airflow, Debezium, dbt, Docling, Iceberg, Kafka, Presidio, OpenLineage. Deliverable: an incremental CDC ingestion pipeline with ACL propagation, lineage tracking, PII tagging, a backfill runbook and a freshness SLA dashboard. | Not included | Not included | Included |
| 22Retrieval at Scale & Vector InfrastructureEmbedding model selection, ANN index internals (HNSW, IVF-PQ, DiskANN) and their recall and latency trade-offs, sharding and replication at billion scale, row-level security in vector stores, and index migration without downtime. Tools: Qdrant, Milvus, Weaviate, pgvectorscale, Vespa, Elasticsearch, ColPali, Ray Data. Deliverable: a scalable retrieval platform with permission-aware filtering and a recall/latency benchmark across three index configurations. | Not included | Not included | Included |
| 23GraphRAG, Knowledge Graphs & Agentic RetrievalQuery planning and decomposition, knowledge-graph construction with ontology design and community detection, corrective and self-RAG loops, and structured-data agents doing guarded text-to-SQL. Tools: Neo4j and Cypher, Microsoft GraphRAG, Graphiti, LightRAG, LlamaIndex Workflows, Vanna, RAGAS. Deliverable: a hybrid, graph and agentic retrieval system with an ablation study, plus a text-to-SQL agent guarded against destructive queries. | Not included | Not included | Included |
| 24Memory Architecture & Continual LearningThe full memory lifecycle, consolidation and decay policies, bi-temporal facts, self-editing memory, and procedural skill libraries an agent writes for itself. Tools: Letta, Zep, Graphiti, Mem0, LangGraph Store, Neo4j, Redis Stack, Presidio. Deliverable: a memory and skill-library architecture with a measured improvement curve over 500 simulated tasks and a compliant erasure pathway. | Not included | Not included | Included |
| 25Multi-Agent Systems, A2A & InteroperabilityCoordination theory and topology selection, market and negotiation protocols, adversarial verification, and the Agent2Agent protocol — agent cards, discovery, task lifecycle and cross-organisation identity. Tools: A2A Protocol SDK, Google ADK, Microsoft Agent Framework, LangGraph multi-agent, Ray, Kafka, SPIFFE/SPIRE. Deliverable: an A2A-compliant agent published with an agent card, interoperating with a second organisation's agent, plus a failure-mode control matrix. | Not included | Not included | Included |
| 26Computer Use, Browser Fleets & Autonomous CodingVision-grounded versus DOM-grounded control, accessibility-tree action spaces, secure credential injection without exposing secrets to the model, drift detection, and coding agents across multi-repo refactors. Tools: Playwright, Browser Use, Stagehand, Claude Code with subagents, OpenHands, E2B Desktop, HashiCorp Vault. Deliverable: a hardened browser-agent fleet with vault-based credentials and drift alerts, plus a coding agent that lands five reviewed pull requests. | Not included | Not included | Included |
| 27Evaluation Science & BenchmarkingEval as an engineering discipline: stratified dataset design, leakage control, judge calibration and position bias, statistical significance for model comparisons, simulated users, and continuous evaluation as a service. Tools: Braintrust, LangSmith, Inspect AI, W&B Weave, Arize Phoenix, DeepEval, OpenTelemetry GenAI, ClickHouse. Deliverable: a multi-tenant evaluation service with calibrated judges, significance testing, drift alarms and a portfolio quality dashboard. | Not included | Not included | Included |
| 28Security Architecture, Red Teaming & Threat ModellingSTRIDE adapted for tool-using systems, the OWASP agentic threat taxonomy, defence in depth against indirect prompt injection, multi-agent trust boundaries, MCP supply-chain security and forensics from traces. Tools: Garak, PyRIT, Lakera Guard, NeMo Guardrails, gVisor, Firecracker, Falco, Vault, Sigstore. Deliverable: a complete security package — threat model, OWASP-mapped control matrix, continuous red-team pipeline, incident runbook and residual-risk register. | Not included | Not included | Included |
| 29Fine-Tuning, Distillation & Adapter ServingWhen post-training beats prompting and retrieval, dataset construction from production traces, LoRA and QLoRA against full fine-tuning, tool-call fine-tunes, distillation from a frontier teacher, and multi-LoRA hosting. Tools: Hugging Face TRL, PEFT, Unsloth, Axolotl, DeepSpeed, vLLM multi-LoRA, Weights & Biases. Deliverable: an SFT-tuned agentic model beating the base model on a held-out tool-use benchmark, served with multi-LoRA and fully cost-modelled. | Not included | Not included | Included |
| 30Reinforcement Learning & Agentic Post-TrainingPreference optimisation with DPO, KTO and ORPO, reward models against verifiable rewards, GRPO on tool-use tasks, environment design for agentic RL, and detecting reward hacking. Tools: verl, OpenRLHF, TRL, Unsloth, DeepSpeed, vLLM rollout serving. Deliverable: a preference- or GRPO-trained checkpoint with documented reward design, a reward-hacking analysis and held-out gains over the fine-tuned baseline. | Not included | Not included | Included |
| 31Voice, Vision & Multimodal AgentsReal-time voice pipelines — voice activity detection, streaming speech-to-text, turn detection and barge-in — latency budgeting for a sub-800 millisecond feel, telephony handoff, and vision agents over documents, charts and video. Tools: LiveKit Agents, Pipecat, Deepgram, faster-whisper, ElevenLabs, Cartesia, Twilio, ColPali. Deliverable: a production voice agent with under 900 millisecond turn latency, barge-in, warm human handoff and a 50-call evaluation report. | Not included | Not included | Included |
| 32Agent Platform Design, AgentOps & FinOpsReference architecture for an internal agent platform — control plane, data plane, gateway, registry, eval service and observability — plus sandbox fleets, golden paths, eval-gated CI/CD with automatic rollback, and cost per successful task with chargeback. Tools: Kubernetes, Helm, Terraform, Temporal, Envoy, Backstage, ArgoCD, AWS Bedrock AgentCore, Vertex AI Agent Engine, OpenCost. Deliverable: an agent platform reference implementation with self-service templates, multi-tenant isolation, a DR test and a per-team cost dashboard. | Not included | Not included | Included |
| 33Governance, Compliance & Architect CapstoneThe autonomy ladder from suggest to act autonomously, EU AI Act obligations, the NIST AI Risk Management Framework and ISO/IEC 42001, sector rules including GDPR, DPDP and HIPAA, auditability and decision logging, bias testing and total cost of ownership. Tools: Open Policy Agent, Fairlearn, Credo AI, immutable log stores, Locust, Chaos Mesh, Structurizr. Deliverable: a production platform plus a governance pack mapped to the EU AI Act and NIST AI RMF, an ADR set, red-team evidence, a TCO model and a published technical article. | Not included | Not included | Included |
Nested, not parallel. The 6-month programme contains everything in the 3-month programme and continues from Module 08; the 9-month programme contains both and continues from Module 21. Choosing a shorter programme costs you scope, never depth, and you can extend later without repeating a single module.
Not sure which Agentic AI path is right for you?
One call with a counsellor is usually enough. Tell us whether you enjoy automation, documents, reliability or security, and we will show you which track length makes sense and where it leads. Book a free demo class and see the lab before you decide.
What you are reallybeing taught
Tools in this syllabus will be replaced. These ideas will not — they are what you are really being taught, and what a strong candidate can articulate under questioning.
Evidence beats demos
Anyone can show an agent that works once. A labelled evaluation set, a measured before-and-after, a red-team report and a cost-per-task number are what distinguish an engineer from an enthusiast. Half the grading weight in this programme sits on evidence for exactly that reason.
The pattern outlives the library
Frameworks change every quarter. Tool calling, retrieval, state management, evaluation and guardrails have been stable since the first agent shipped. Learn one tool per layer deeply and treat the alternatives as swappable implementations of the same idea.
Most agent failures are engineering failures
Retries, idempotency, timeouts, backpressure, permission propagation and schema discipline decide whether a system survives contact with real traffic. The model is rarely the weakest component; the plumbing around it usually is.
Prompt injection is the defining unsolved risk
Any agent that combines private data, untrusted content and the ability to communicate outward is exploitable. There is no prompt that fixes this. Defence is architectural: content isolation, least privilege, egress control and human confirmation before irreversible actions.
Know when not to build an agent
A deterministic workflow is cheaper, faster and easier to debug than an autonomous loop. The senior judgement is recognising which problems genuinely need planning and tool selection, and which just need a well-written function calling an API.
Unit economics decide whether it ships
Cost per successful task, not cost per token, is the number a business acts on. Routing, caching, distillation and small-model substitution routinely cut inference spend by more than half with no measurable quality loss — and that is often the change that makes a product viable.
Ask aboutAgentic AI
Send your question and a counsellor will call you back about batch timings, fees, EMI options, placement record, or whether this course fits your degree.
- Free counselling and demo class
- Weekday, evening, weekend or 1-on-1, all 2-hour classes
- Internship letter and placement support