Mohammad Dahab
Serial Entrepreneur · Product Builder · Munaaseb CTO (PropTech)
← Use arrow keys or scroll to navigate →
Agenda
From ML fundamentals to autonomous agents — a 30-minute introduction
1. Fundamentals of ML
What is machine learning? Types, core concepts, and why it matters.
2. The Agentic Loop
Agents, tools, harnesses — how an agent reasons, acts, and observes.
3. Autonomous Agents
Where ML meets the agentic loop — what makes an agent truly autonomous.
4. Conclusion & Q&A
Key takeaways, open questions, and discussion.
🧠 Fundamentals of Machine Learning
The core idea: teaching computers to learn from experience, not rules.
Classic programming: Rules + Data → Answers
Machine learning: Data + Answers → Rules (the model learns the rules itself)
Supervised Learning
Learn from labelled examples (input → output pairs). Like studying with answer keys.
Regression · ClassificationUnsupervised Learning
Find hidden patterns in unlabeled data. Clustering, dimensionality reduction.
Clustering · Anomaly DetectionReinforcement Learning
Learn by trial and error — agent takes actions, gets rewards, improves policy.
Games · Robotics · ControlKey ingredients: Data (representative, clean) · Model (the learnable function) · Loss (measure of error) · Optimization (minimising the loss)
🧠 How Models Learn
Training = the process of adjusting a model to reduce error on data.
📦 Training Data
Split into training (the textbook), validation (practice exams), and test (final exam) sets. The model never sees the test set during training.
⚖️ Overfitting vs Underfitting
Overfitting: memorising the data, failing on new inputs.
Underfitting: too simple to capture real patterns. Balance is everything.
📈 The Loss Function
A mathematical measure of "how wrong the model is." Training = minimizing this number across all examples.
🔄 Gradient Descent
The engine of learning — take small steps downhill on the loss surface. Each step adjusts model parameters slightly.
Key insight: ML models don't "understand" — they approximate statistical patterns. An LLM is a very large function that predicts the next token based on trillions of observed examples.
🔄 The Agentic Loop
What separates an "agent" from a plain LLM? The loop: Perceive → Reason → Act → Observe.
LLM as the Brain
The model decides what to do next — write an answer, call a tool, ask for clarification. It's not just generating text; it's reasoning about actions.
Tools
Functions the agent can call: search the web, read files, run code, send messages. Tools give the agent agency over the real world.
The Harness
The runtime that orchestrates the loop: parse the LLM's tool request → execute → return result → let LLM continue. This loop is what makes it an agent.
Definition: An agent = LLM + Tools + Loop. Without the loop and tools, you just have a chatbot.
🤖 Autonomous Agents
Bridging ML fundamentals and the agentic loop → a system that acts independently toward goals.
Goal-Oriented
Given a high-level goal, the agent decomposes it into sub-tasks and executes them autonomously — deciding tool calls, order, and when to stop.
Memory & Context
Persistent memory (from ML's learned representations) + session context (from the agentic loop) = the agent remembers across turns, sessions, and restarts.
Skills & Tooling
Reusable workflows (skills) and diverse tools (file I/O, web, code execution, API calling) let the agent operate across domains without human hand-holding.
Self-Correction
When a tool call fails or returns unexpected data, the agent re-evaluates and tries a different approach — closed-loop feedback, just like gradient descent in ML.
The synthesis: ML gave us models that can learn patterns from data. The agentic loop gave us action and feedback. An autonomous agent is both — it learns from its environment and acts upon it, independently.
🏗️ Anatomy of an Autonomous Agent
What happens when you give a trained LLM the keys to its own toolset?
LLM Core
Trained on vast data (ML step). Generates reasoning and decides next action.
PlanningTool Registry
Every tool is described to the LLM as a function with name, inputs, outputs.
APIsOrchestrator
The harness that runs the loop: parse → execute → observe → loop/respond.
RuntimeMemory Store
Facts, user preferences, learned skills — persists across sessions.
PersistenceSkills
Procedural knowledge — reusable instructions for the agent to follow.
ReusabilityScheduling
Cron jobs, watchdogs — the agent acts without being asked.
ProactivityMulti-Channel
Speaks over Telegram, WhatsApp, Discord, Slack, email — meets users where they are.
ConnectivityDelegation
Spawns sub-agents for parallel work — coordination at scale.
ScaleThank You ✨
Questions & Discussion
📌 Key Takeaways
- ML is about learning patterns from data — not writing rules
- An agentic loop adds action + feedback to a model
- Autonomous agents = ML + Agentic Loop + Tools + Memory
- The harness is what makes it all run in a closed loop
💬 Open Questions
- How autonomous is too autonomous? (safety, alignment)
- Where does the model end and the tooling begin?
- Do agents "understand" or just pattern-match at scale?
- What happens when agents delegate to other agents?