Skip to programme

GYANHQ SUPER 30 / THE PROGRAMME

Build agents.
Deliver real work.

Three months of applied Agentic AI engineering. Build with Python, Google ADK 2.x and LangChain, deploy on Google Cloud, and practise the customer work of a Forward Deployed Engineer.

Request Super 30 Invite Explore the 12 weeks

30 builders. Practical work, reviewed decisions and one evolving capstone.

12 weeks
across three months
24 classes
two teaching classes per week
12 labs
one 2.5-hour lab per week
30 lab hours
plus teaching & project practice

THE WEEKLY RHYTHM

Understand it.
Build it. Test it.

Each week connects a clear engineering idea to working code. Bring questions, work through failures and leave with something you can demonstrate.

TEACHING CLASS 1

Understand the decision.

Concepts, architecture and a worked example. Learn when the technique helps and where it fails.

TEACHING CLASS 2

See the implementation.

Code walkthroughs, debugging and design tradeoffs. Prepare the interfaces and tests for the lab.

WEEKLY LAB / 2.5 HOURS

Make it work yourself.

Build, inject a failure, review the result and commit the work. Pair debugging supports an individual project trail.

The labs use synthetic business data and real application code. Teaching-class timings, independent study expectations and cloud-lab arrangements are discussed before you join.

THE 12-WEEK CURRICULUM

A learning path.
A growing system.

The shared build is a support and knowledge agent. Start with a small API; add retrieval, tools, state and approvals; then deploy and adapt it to a customer brief.

Primary build path

Google ADK 2.x → Gemini Enterprise Agent Platform.

Compare through code

LangChain agents + LangGraph for explicit durable workflows.

Shared engineering base

Python, Pydantic, FastAPI, common tool contracts and evaluation cases.

Open a week to see both teaching classes, the 2.5-hour lab and the review checkpoint.

MONTH 01 / WEEKS 01–04

Build the foundation.

Turn model calls and documents into a tested Python application.

WEEK 01Build the Python foundationPython · Pydantic · FastAPI

TEACHING CLASS 1

Understand the model before using it

  • Why conversational AI changed in 2022; tokens, context windows and model limitations.
  • Prompting, retrieval and fine-tuning: choose the right approach for a task.
  • Turn a fictional support-team problem into a one-page brief and acceptance criteria.

TEACHING CLASS 2

Give the application a reliable boundary

  • Typed Python, modules, virtual environments, async/await and error handling.
  • Pydantic models, field constraints and validation errors; validation is not authorization.
  • FastAPI request/response models, dependency injection and pytest API tests.

HANDS-ON LAB / 2.5 HOURS

Create a typed support API

Build request and response schemas, a health endpoint and a ticket lookup backed by synthetic fixtures. Start with a deterministic model stub.

You leave with
A runnable FastAPI repository, five API tests and a one-page customer brief.
Review checkpoint
Reject malformed requests; return a valid response; explain the problem your API solves.
WEEK 02From model calls to a tool-using agentGemini · Structured outputs · Tool loop

TEACHING CLASS 1

Make model responses usable

  • Call Gemini from Python; separate instructions, user input and external data.
  • Prompt versions, few-shot examples, structured outputs and Pydantic validation.
  • Streaming, token usage, timeouts and bounded retries; measure real API usage.

TEACHING CLASS 2

Build the agent loop in plain Python

  • Follow the request → tool proposal → validation → execution → result cycle.
  • Design narrow tool schemas and distinguish a workflow from an agent decision.
  • Apply tool allowlists, iteration limits and read-only permissions.

HANDS-ON LAB / 2.5 HOURS

Build a read-only ticket assistant

Let the model choose a ticket lookup tool, validate its arguments and produce a structured answer. Trace the actual calls and stop an unproductive loop.

You leave with
A bounded tool loop, versioned prompt and a trace with measured latency and usage.
Review checkpoint
Reject unknown tools and invalid arguments; stop at the configured limit; handle a timeout.
WEEK 03Make retrieval measurableEmbeddings · Chunking · Search

TEACHING CLASS 1

Understand what search retrieves

  • Embeddings, cosine similarity, lexical versus dense search and approximate indexes.
  • Document IDs, metadata, token budgets and the ingestion/query boundary.
  • Build a small question set with expected supporting passages.

TEACHING CLASS 2

Choose chunk boundaries deliberately

  • Compare fixed-size, recursive and heading-aware chunks; tune overlap.
  • Preserve tables, code and document structure; understand parent-child retrieval.
  • Explore semantic and agentic chunking as tradeoffs, not automatic upgrades.

HANDS-ON LAB / 2.5 HOURS

Run a chunking experiment

Index a small document corpus with three splitting strategies. Inspect the returned passages for ten fixed questions and record quality, chunk count and indexing cost.

You leave with
A reproducible chunking benchmark and a short decision record.
Review checkpoint
Explain a missed passage and choose a strategy using your measurements, not the visual demo’s sample scores.
WEEK 04Build a grounded knowledge assistantLangChain retrieval · Citations · Access

TEACHING CLASS 1

Assemble the retrieval pipeline

  • LangChain document loaders, splitters, embeddings and retriever interfaces.
  • Connect retrieval to answer generation; add source IDs and a context budget.
  • Compare a simple baseline with hybrid search or reranking.

TEACHING CLASS 2

Test the boundary of an answer

  • Permission-aware retrieval: enforce access in application code before model context.
  • Citations, missing evidence, conflicting sources and indirect prompt injection.
  • Evaluate retrieval separately from answer quality; keep a fixed regression set.

HANDS-ON LAB / 2.5 HOURS

Ship a cited, permission-aware answer

Extend the support assistant with a knowledge corpus for two fictional teams. Answer from permitted sources and decline unsupported questions.

You leave with
A grounded assistant and a 15-case evaluation set with expected evidence and access rules.
Review checkpoint
Cite the supporting passage; keep restricted documents out of context; handle missing evidence.

MONTH 1 MILESTONEA typed, grounded support assistant.

MONTH 02 / WEEKS 05–08

Engineer the agent.

Add state, controlled execution and dependable business-system tools.

WEEK 05Build your first ADK 2.x agentGoogle ADK 2.x · Sessions · Tools

TEACHING CLASS 1

Move the working task into ADK

  • ADK agents, tools, runner and events; use Gemini with typed Python functions.
  • Expose the existing retrieval and ticket functions as narrow tools.
  • Inspect executions locally and keep application logic separate from framework wiring.

TEACHING CLASS 2

Manage context and state

  • Sessions, application state, artifacts and memory: what belongs where.
  • Separate users and sessions; decide what to persist and what to discard.
  • Callbacks, tool errors and evaluation of the same 15 cases from week 4.

HANDS-ON LAB / 2.5 HOURS

Rebuild the assistant with ADK

Use the same schemas, tools and questions in an ADK 2.x agent. Add two isolated sessions and inspect the tool events.

You leave with
An ADK agent, a session-isolation test and a baseline comparison.
Review checkpoint
Complete the same task through ADK; show that one user’s state is not visible to another.
WEEK 06Control agent workflowsADK graphs · Human approval · Recovery

TEACHING CLASS 1

Make the execution path explicit

  • ADK 2.x graph nodes, routing and typed data flow.
  • Sequential work, bounded loops and parallel branches; when one agent is enough.
  • Compare a coordinator/specialist design with a deterministic route.

TEACHING CLASS 2

Pause, approve and recover

  • Human input and resumption around a consequential action.
  • Timeouts, retry policies and idempotent operations; avoid masking runtime errors.
  • Inspect failed steps and keep reviewer loops bounded.

HANDS-ON LAB / 2.5 HOURS

Build an approval-gated workflow

Route a support request to retrieval or escalation. Pause before a simulated ticket update, then approve or reject it. Inject a failure and resume safely.

You leave with
A workflow graph, approval record and recovery test.
Review checkpoint
No update without approval; rejection leaves state unchanged; retry does not duplicate the action.
WEEK 07Build the comparison in LangChaincreate_agent · LangGraph · Persistence

TEACHING CLASS 1

Use the modern LangChain agent interface

  • Build with create_agent, model adapters, typed tools and structured responses.
  • Use middleware to shape context and tool behavior.
  • Reuse the ADK task, tool schemas and regression questions.

TEACHING CLASS 2

Add explicit durable orchestration

  • LangGraph state, nodes, conditional edges and checkpointers.
  • Interrupts and human-in-the-loop resumption with side-effect discipline.
  • Compare control, state handling, observability and maintenance across the two paths.

HANDS-ON LAB / 2.5 HOURS

Port one workflow, compare the evidence

Implement the approval path with LangChain/LangGraph, restart it at a checkpoint and run the same evaluation cases. Choose a framework for your capstone.

You leave with
A second implementation and a framework decision record backed by test results.
Review checkpoint
Resume without repeating the write; explain which framework you chose and why.
WEEK 08Connect agents to business systemsMCP · Identity · Safe integration

TEACHING CLASS 1

Expose a useful MCP tool

  • MCP host/client/server roles, tool discovery and calls; distinguish MCP from REST and A2A.
  • Wrap the existing ticket API using the cohort’s pinned Python MCP SDK.
  • Authentication, authorization and transport choices; validate on the server.

TEACHING CLASS 2

Make integration dependable

  • Caller identity, scoped access, secrets and audit events.
  • Idempotency keys, rate limits, timeouts and useful error contracts.
  • Test tool injection and cross-user access; introduce A2A as an optional interoperability demonstration.

HANDS-ON LAB / 2.5 HOURS

Integrate a controlled ticket update

Connect the agent to your MCP ticket tool. Bind the authenticated caller to the action, require approval and record the result without exposing secrets.

You leave with
An MCP integration, access tests and an audit trail for the simulated update.
Review checkpoint
Reject a forbidden caller; require approval; replay the request without creating a duplicate ticket.

MONTH 2 MILESTONEAn approval-gated agent with a framework decision.

MONTH 03 / WEEKS 09–12

Deploy. Deliver. Defend.

Operate on Google Cloud and deliver a capstone through an FDE simulation.

WEEK 09Deploy on Google CloudAgent Platform · Agent Runtime · Cloud Run

TEACHING CLASS 1

Map the application to managed services

  • Gemini Enterprise Agent Platform: model access, Agent Runtime and its operational boundaries.
  • Package the ADK agent; pin dependencies and configure identities and sessions.
  • Connect FastAPI on Cloud Run to the agent and its data/tool services.

TEACHING CLASS 2

Prepare a controlled release

  • Service accounts, IAM, Secret Manager, Cloud Storage and retrieval configuration.
  • Artifact Registry and repeatable deployment; health checks and access tests.
  • Set usage budgets, inspect charges and prepare cleanup and rollback instructions.

HANDS-ON LAB / 2.5 HOURS

Deploy and invoke the agent

Deploy the ADK baseline to Agent Runtime and its FastAPI interface to Cloud Run in the agreed lab project. Invoke it with an authenticated client and inspect a trace.

You leave with
A cloud deployment record, architecture diagram and teardown checklist.
Review checkpoint
An authorized call succeeds; an unauthorized call fails; credentials stay out of the repository.
WEEK 10Evaluate, observe and operateRegression tests · Traces · Release gates

TEACHING CLASS 1

Turn quality into a release decision

  • Expand the evaluation set to 30 cases covering task success, evidence, tool use and failures.
  • Use deterministic checks plus reviewed model-based judgments where useful.
  • Measure latency and cost per task; set acceptance thresholds for the specific brief.

TEACHING CLASS 2

Debug the system after deployment

  • Agent Platform evaluation and Cloud Logging/Trace; redact sensitive content.
  • Prompt/model version changes, bounded retries, CI checks and rollback.
  • Understand sessions, Memory Bank and governance controls through an instructor demonstration.

HANDS-ON LAB / 2.5 HOURS

Find a regression before release

Introduce a prompt or tool regression, detect it with the evaluation suite, trace the failure and restore the last acceptable version.

You leave with
A measured evaluation report, release checklist and incident note.
Review checkpoint
Identify the failing cases and their cause; demonstrate rollback; distinguish observed results from assumptions.
WEEK 11Work like a Forward Deployed EngineerDiscovery · Scope · Customer pilot

TEACHING CLASS 1

Discover the problem behind the request

  • Interview a role-play customer; map the workflow, users, constraints and data access.
  • Define baseline behavior, success measures, non-goals and an acceptance test.
  • Choose an agent, a deterministic workflow or a simpler solution based on the need.

TEACHING CLASS 2

Deliver through changing requirements

  • Write an architecture decision, delivery plan and risk/assumption log.
  • Handle a change request without losing the acceptance criteria.
  • Explain measured cost and value assumptions; run a pilot and collect feedback.

HANDS-ON LAB / 2.5 HOURS

Run the customer pilot

Apply your chosen framework to a scoped capstone brief. Conduct a discovery role-play, implement one change and demo the pilot to a peer acting as the customer.

You leave with
A discovery brief, pilot build, change record and customer feedback.
Review checkpoint
Trace each committed requirement to a test or demonstration; explain an explicit scope tradeoff.
WEEK 12Ship, hand over and explain your workCapstone · UAT · Portfolio

TEACHING CLASS 1

Prepare the handover

  • User acceptance testing, deployment runbook and support boundaries.
  • Access setup, known limitations, cleanup and rollback rehearsal.
  • Teach the customer how to use the agent and how to escalate a failure.

TEACHING CLASS 2

Make the engineering evidence interview-ready

  • Walk through architecture, a failed experiment and the resulting improvement.
  • Practice a debugging interview and explain your own code and decisions.
  • Write a factual project case study and CV entry tied to your contribution.

HANDS-ON LAB / 2.5 HOURS

Demonstrate and defend the capstone

Run the acceptance cases, present the customer handover and complete a technical walkthrough. Use peer review and rotating demos to surface gaps before the final revision.

You leave with
A reproducible repository, deployment evidence, evaluation report, demo and handover pack.
Review checkpoint
Another learner can run the project; you can explain a failure, a tradeoff and the evidence behind the result.

MONTH 3 MILESTONEA cloud deployment and a customer handover.

Depth before breadth.

Advanced chunking, A2A and additional agent patterns are extension topics once the core works. GPU training, Kubernetes administration, fine-tuning and multi-cloud infrastructure are later specialisms, outside this three-month core.

FROM LOCAL CODE TO GOOGLE CLOUD

A place for every
part of the system.

Learn the Google Cloud Gemini Enterprise Agent Platform through a concrete deployment. Understand the agent runtime, application boundary, data services and operating controls.

  1. CLIENTAuthenticated request

    A user or test client invokes the application.

  2. APPLICATIONFastAPI on Cloud Run

    Validate the request and enforce the caller’s access.

  3. AGENTAgent Runtime

    Run the ADK agent with its session and tool contracts.

  4. CONTEXT & ACTIONGemini + permitted tools

    Retrieve evidence, call approved services and return a result.

BUILD IN THE LAB

Model & execution

Access Gemini through Google Cloud. Package the ADK baseline for Agent Runtime; connect the FastAPI service on Cloud Run. Keep dependency versions and configuration reproducible.

BUILD IN THE LAB

Data & retrieval

Use Cloud Storage for the synthetic corpus and RAG Engine for managed retrieval. Select permitted corpora in trusted application code and carry source IDs into citations. Compare Vector Search in the architecture walkthrough.

BUILD IN THE LAB

Identity & delivery

Use service accounts, least-privilege IAM and Secret Manager. Package the API with Artifact Registry, test access and document deployment, rollback and cleanup.

BUILD + MEASURE

Quality & operations

Run an offline regression suite and inspect Cloud Logging/Trace. Use Agent Platform evaluation in the enabled lab project. Track actual latency, failures and cost per task.

INSTRUCTOR WALKTHROUGH

Sessions & memory

Separate session state from persistent memory. Explore managed Sessions and Memory Bank, including identity boundaries, retention and the information an agent should avoid storing.

INSTRUCTOR WALKTHROUGH

Enterprise governance

See where Agent Registry, Agent Identity, Agent Gateway and Model Armor fit. Availability depends on the project, permissions and service release stage.

Cloud and model usage can incur charges. Project access, region, usage budget and any credits are confirmed before the cloud labs. Guided local exercises remain available while access is being arranged; a cloud deployment is required for the cloud checkpoint.

Platform reference: Google Cloud platform overview · Agent Runtime deployment

THE FORWARD DEPLOYED ENGINEER PATH

Deliver the solution.
Explain the decisions.

An FDE works at the boundary between customer needs and engineering. Practise that work from the first problem brief to the final handover.

01 / DISCOVER

Find the useful problem.

Interview a role-play customer, map the workflow and define what success would look like.

Evidence: discovery brief + acceptance cases
02 / DESIGN

Make a defensible choice.

Choose the simplest suitable architecture, tool boundaries and framework. Explain the tradeoffs.

Evidence: architecture + decision record
03 / DELIVER

Turn a pilot into a release.

Integrate the system, measure its behavior and manage a change request against agreed scope.

Evidence: tests + deployment + pilot feedback
04 / ENABLE

Leave the customer capable.

Demonstrate the workflow, document limitations and show how to support or roll back the system.

Evidence: demo + runbook + handover

ONE CAPSTONE, YOUR CONTRIBUTION

A customer brief.
A working agent.
A clear account of your work.

Choose a scoped support agent, permission-aware knowledge assistant or engineering triage assistant. Reuse the course foundation and build with your selected framework.

Peer reviews and pair debugging support the work. Your repository history, tests and technical walkthrough must show what you personally understand and built.

Your portfolio evidence

  • Reproducible Python repository and API contract
  • Tool boundaries, approval path and access tests
  • Architecture diagram and framework decision
  • Cloud deployment evidence and cleanup instructions
  • Evaluation report with actual results and failures
  • Customer brief, demo and operating runbook
  • A factual project case study and CV entry

What the final review looks for

Working code is the starting point. You also need evidence that it meets the brief and that you can explain it.

20%Problem & architecture
30%Implementation & integration
25%Evaluation & safe operation
15%Deployment & handover
10%Technical communication

Review requires revision if the project exposes credentials, bypasses access/approval checks or cannot be reproduced. Career preparation includes project explanations, architecture discussions and debugging practice. Hiring depends on your skills, experience and the employer’s process; completion does not guarantee a job.

BEFORE YOU JOIN

Start with a foundation.
Bring the curiosity.

The pace suits learners who can already write basic Python. The course develops application engineering and agent skills on top of that foundation.

A useful readiness check

  • Write a Python function using lists, dictionaries and exceptions.
  • Read and write JSON; explain a simple HTTP request.
  • Use a terminal, virtual environment and Git commit.
  • Run a small script and describe why it failed.
  • Have a laptop that can run Python, Git and a browser.

New to these basics? Use the invitation conversation to agree preparation before committing to the cohort.

How is the week organised?

Two live teaching classes plus one 2.5-hour hands-on lab, every week for 12 weeks. That is 24 teaching classes and 30 hours of labs. Class timings and independent study expectations are confirmed before the cohort.

Do I need to know ADK or LangChain already?

No. We introduce both through a task you have already built in Python. The same schemas and test cases help you see what the framework changes.

Will I train a foundation model?

The core focuses on building and operating agents with existing models. Training, GPU infrastructure and fine-tuning are optional later specialisms.

Are cloud usage and course fees included together?

Fees, cloud-lab access, usage budgets and any credits are discussed explicitly in the 30-minute one-to-one session with selected candidates. Do not assume cloud or model usage is free.

When does the next cohort start?

The start date, class schedule and live-session timezone are confirmed during the invitation process. Each request is reviewed before a place is agreed.

Learn with the source documentation.

Framework lessons are based on the current official documentation; dependencies are pinned and checked for each cohort.

ADK 2.xLangChainLangGraphPydanticFastAPIMCP

GYANHQ SUPER 30 / BUILD YOUR NEXT CHAPTER

Bring the question.
Learn to deliver the answer.

Three months of building, reviewing and explaining an agentic system.

Request Super 30 Invite

Selected candidates join a 30-minute one-to-one conversation to discuss fit, logistics and next steps.

Meet your instructor