12 phases. 45+ modules. Everything from "what is Python" to "deploy a 10-agent production system". Click any phase to see the full breakdown.
At 10 hours/week: 6 months to first working agent, 12–18 months to expert level. But you don't need to finish everything before you're useful. Most developers become productive enough to build real things after just Phase 5. DRONA adapts your path to your goals — you decide how deep to go.
The foundation. Before learning AI, you need two things: Python programming basics and some mathematics. Don't skip this — it's what makes everything else make sense.
Learn Python specifically for AI work: variables, loops, functions, classes, list comprehensions, generators, file handling, and API calls.
The math that AI is built on: vectors and matrices (linear algebra), rates of change (calculus), and uncertainty (probability). Each explained from scratch with real examples.
Working with data before feeding it to a model: cleaning, transforming, visualizing, and understanding what your data is telling you.
The core ideas that all of modern AI is built on. How machines learn from examples. Why training works. What can go wrong and how to fix it.
Understand the different types of learning (supervised, unsupervised, reinforcement), the training loop, and the fundamental problem of overfitting.
The classic algorithms: linear regression, logistic regression, decision trees, random forests, XGBoost. Build each from scratch, then use the library version.
Find patterns without labels: K-Means clustering, PCA (dimensionality reduction), t-SNE (visualization). Essential for real-world data.
The science of testing whether your model is actually good: cross-validation, precision/recall, ROC curves, hyperparameter tuning.
Neural networks. The technology behind everything from image recognition to ChatGPT. Build one from scratch in numpy, then learn PyTorch, then understand CNNs and RNNs.
Build a complete neural network using only numpy. Understand every line: forward pass, loss calculation, backpropagation, gradient descent.
Master PyTorch: tensors, automatic differentiation, nn.Module, custom layers, GPU acceleration, training loops, model saving.
How computers see images. Convolution, pooling, the famous architectures (ResNet, VGG), transfer learning.
How AI processes sequences (text, time series, audio). LSTM, GRU, the vanishing gradient problem and how to solve it.
Keep your model from memorizing instead of learning: dropout, batch normalization, learning rate scheduling, mixed precision.
The breakthrough that created ChatGPT, GPT-4, and everything like them. Understand attention — the single most important idea in modern AI.
The core idea: instead of reading text left-to-right, allow every word to 'attend' to every other word. Build scaled dot-product attention from scratch.
The full architecture of the paper 'Attention is All You Need' (2017). Encoder, decoder, positional encoding. Build a complete transformer.
BERT and its family: how to use pre-trained language models for classification, named entity recognition, question answering.
How GPT and ChatGPT work: autoregressive language modeling, sampling strategies (temperature, top-p), few-shot learning.
LLaMA, Mistral, Phi, Gemma: what makes them different. Grouped query attention, RoPE positional embeddings, Flash Attention, KV cache.
How to make an LLM do what you want. Fine-tuning, RLHF (how ChatGPT was created), and the revolutionary LoRA technique that makes it affordable.
Full fine-tuning vs LoRA vs QLoRA. When to fine-tune vs prompt engineer. The trade-offs between cost, quality, and speed.
How ChatGPT was created from GPT-3.5. Reward modeling, PPO optimization, DPO (the simpler alternative). The alignment problem.
Every prompting technique: zero-shot, few-shot, chain of thought, tree of thoughts, ReAct, self-consistency, JSON mode.
The shift from AI that answers questions to AI that does tasks. The agent loop, tool use, memory, and planning — the four pillars of agentic AI.
The difference between a chatbot and an agent. The OODA loop. The four pillars: perception, reasoning, action, memory. When agents are worth using.
How agents interact with the world: OpenAI function calling, Anthropic tool use, JSON schema design, parallel tool calling, error handling.
The four types of memory in agents: working (context window), episodic (vector stores), semantic (LLM knowledge), procedural (tools).
How agents break down complex tasks: chain-of-thought planning, Plan-and-Execute, Tree of Thoughts, recursive decomposition.
The tools that make building agents faster. Deep dives into LangChain, LangGraph, AutoGen, and CrewAI — when to use each and why.
The most popular agent framework: chains, agents, tools, memory, LCEL. Build a full RAG pipeline with a tool-using agent.
For complex, production-grade agents: state machines, conditional branching, checkpointing, human-in-the-loop, streaming.
Microsoft's framework: agents that talk to each other. AssistantAgent, UserProxy, GroupChat, code execution sandboxes.
Define an AI team with roles (researcher, writer, analyst). Assign tasks. Watch them collaborate. Sequential and hierarchical workflows.
Retrieval Augmented Generation: how to make an LLM answer questions about YOUR documents, data, and knowledge bases. The most used agent pattern in production.
The core pipeline: load documents → chunk them → embed → store → retrieve → answer. Build it from scratch, then with LangChain.
The storage layer of RAG: Chroma (local), FAISS (fast), Pinecone (cloud), Weaviate (graph+vector), Qdrant (production).
HyDE, multi-query retrieval, re-ranking, self-RAG, RAPTOR, GraphRAG. Go from 60% to 90% retrieval accuracy.
Graph-based memory for agents: Neo4j, GraphRAG, entity extraction. When graphs beat vectors.
Multiple AI agents working together. How to design teams of agents, make them communicate, handle failures, and produce better results than any single agent.
Supervisor-worker, peer-to-peer, hierarchical, swarm. The trade-offs of each topology. When multi-agent is worth the extra complexity.
How agents talk to each other: message passing, shared state, A2A (Google's protocol), MCP (Anthropic's protocol).
Debate agents, majority voting, speculative execution, self-play for improvement. Patterns that only work with multiple agents.
Making agents reliable in production: state machines, human oversight, error handling, retry logic, and professional workflow tools.
Sequential, parallel, conditional, event-driven workflows. DAG design. How to structure complex multi-step agent processes.
When agents must pause and ask a human: approval gates, correction loops, confidence-based escalation. Implementation in LangGraph.
Every way agents fail and how to prevent it: retry, circuit breakers, fallback strategies, timeouts, idempotency.
Prefect, Temporal.io, Celery for durable agent execution. When to use a dedicated orchestration tool.
Taking agents from demo to production. Evaluation, monitoring, cost optimization, safety, and scaling. The difference between a toy and a real system.
How to know if your agent is actually good: AgentBench, GAIA, SWE-bench, LLM-as-judge, regression testing. Build your own eval framework.
Trace every agent step, track cost per run, monitor latency and error rates. What to alert on and what to ignore.
Prompt injection attacks, privilege escalation, content filtering, guardrails. How to build agents that can't be manipulated.
Stateless design, horizontal scaling, message queues for agent workers, Kubernetes for agent pools, cost optimization.
Build 5 complete production systems: customer support, code review, research assistant, document processor, data analyst.
The frontier. What's happening right now in AI research and why it matters. These concepts will define the next 5 years.
Mixture of Agents (MoA), Reflexion (agents that learn from mistakes), SELF-REFINE, Voyager (lifelong learning). The next wave.
SWE-agent, Devin-style architecture, sandboxed code execution, test-driven agents, GitHub integration.
Claude Computer Use, browser automation, desktop agents. AI that can operate any software.
Vision + language agents, document understanding, audio agents, image generation as a tool.
A2A and MCP protocols, self-improving agents, the 50-year view. What to learn now to stay relevant.
DRONA contains 100 numbered examples — real, concrete illustrations of every key concept. Here are 12 examples from across the curriculum to show you the depth.
Copy DRONA, paste it into Claude, and type /examples [any topic] to see 5 examples for any concept.