{"slug": "show-hn-ai-agents-zero-to-hero-learn-ai-agents-from-scratch-in-pure-python", "title": "Show HN: AI Agents: Zero to Hero – Learn AI Agents from Scratch in Pure Python", "summary": "Tanmay Sah released \"AI Agents: Zero to Hero,\" a source-available educational repository that teaches AI agent internals in pure Python with no API key, no framework, and no dependencies, requiring Python 3.11+. The curriculum runs from a chatbot-versus-workflow-versus-agent comparison through a pure Python Observe-Decide-Act loop to a complete multi-step agent, and frames an agent system as a composite of a model policy, an execution control loop, state management, and tools interacting with an environment.", "body_md": "**A publicly accessible, source-available educational framework by Tanmay Sah.**\n\nEveryone is talking about AI agents.\n\nBut what actually makes something an agent?\n\nIs ChatGPT an agent? Is a deterministic workflow an agent? What happens between an LLM deciding to call a tool and that tool actually executing? Where does memory live? Who controls the loop? Who decides when the agent stops? And what happens when an agent makes the wrong change?\n\nThis repository answers those questions from **first principles**.\n\nNo magic. No framework-first abstractions.\n\n**What about AI agents confuses you?**\n\nHave a question or a concept you want demystified? Check out [QUESTIONS.md](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/QUESTIONS.md) or [submit a question via GitHub Issues](https://github.com/tradertanmay/ai-agents-zero-to-hero/issues/new?template=question.md). Questions from the community directly shape upcoming modules in this series!\n\n- **New to agents?** Start here →**[01 — What Is an Agent?](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/01-what-is-an-agent/README.md)**\n- **Want to build one from scratch?**\n- **Want to understand what frameworks hide?**\n\nClone and run the complete agent loop immediately with Python 3.11+:\n\n```\ngit clone https://github.com/tradertanmay/ai-agents-zero-to-hero.git\ncd ai-agents-zero-to-hero\n\n# 1. Compare Chatbot vs Workflow vs Agent\npython3 01-what-is-an-agent/example.py\n\n# 2. Run the pure Python Observe-Decide-Act loop\npython3 02-agent-loop/example.py\n\n# 3. Run your first complete multi-step agent\npython3 04-build-your-first-agent/example.py\n```\n\n**No API key. No framework. No dependencies. Just Python.**\n\nA practical, progressive, code-first curriculum designed to take you from:\n\n*\"I understand LLMs and APIs, but I don't really understand what people mean by an AI agent.\"*\n\nto:\n\n*\"I understand how agents work internally and can build, debug, evaluate, and reason about production agent systems.\"*\n\nThis repository is built for **everyone who wants to understand and build AI agents** — whether you are a software engineer, technical lead, researcher, product builder, student, or curious developer.\n\nIt is especially designed for you if you:\n\n- Want to move beyond prompt engineering and understand how autonomous agent systems actually work\n- Know basic Python (or can follow readable standard code)\n- Have used ChatGPT or called LLM APIs, but want to see the underlying machinery behind tools, memory, and loops\n- Hear industry buzzwords like *ReAct, Function Calling, Memory, Agent Harness, Multi-Agent, MCP* and want a crystal-clear, framework-independent mental model\n\nA common beginner assumption is:\n\nIn reality, a base LLM inference call does not itself maintain persistent application state across turns. An **Agent System** is a composite computational system comprising a model policy, an execution control loop, state management, and tools, which observes and acts upon an external **Environment**.\n\n```\nflowchart TD\n    subgraph AgentSystem[\"AGENT SYSTEM\"]\n        M[\"Model / Policy (Decision Engine)\"]\n        R[\"Runtime / Control Loop (Supervisor)\"]\n        S[\"State & Memory\"]\n        T[\"Tools & Actions\"]\n        \n        R <--> M\n        R <--> S\n        R <--> T\n    end\n\n    AgentSystem <-->|Act / Observe| E[\"ENVIRONMENT<br/>(APIs, Filesystem, DB, User)\"]\n\n    style AgentSystem fill:#f8f9fa,stroke:#333,stroke-width:2px\n    style M fill:#f3e5f5,stroke:#7b1fa2\n    style R fill:#fff3e0,stroke:#e65100,stroke-width:2px\n    style S fill:#ede7f6,stroke:#4527a0\n    style T fill:#e8f5e9,stroke:#2e7d32\n    style E fill:#e1f5fe,stroke:#0288d1,stroke-width:2px\n```\n\nAt the heart of every agent is the cyclic feedback loop with its environment:\n\n``` php\nflowchart LR\n    O[\"1. Observe\"] --> D[\"2. Decide\"]\n    D --> A[\"3. Act\"]\n    A --> O\n\n    style O fill:#e1f5fe,stroke:#0288d1\n    style D fill:#f3e5f5,stroke:#7b1fa2\n    style A fill:#e8f5e9,stroke:#388e3c\n```\n\n1. **Observe** : Read the current state of the world, conversation history, and tool feedback.\n2. **Decide** : The model reasons over the observation and chooses an action or final response.\n3. **Act** : An execution layer performs the action on the environment.\n4. **Observe Again** : The environment output becomes a new observation fed back to the model.\n\n**Key Rule**: The model chooses or requests an action; an **execution layer** performs it. In a from-scratch agent like the one in this course, that execution layer is our Python runtime. In hosted platforms, the provider may execute certain hosted tools on the application’s behalf.\n\nThere is no universally agreed boundary across industry and research for what counts as an \"agent.\" In this course, we use the following operational spectrum to make the architectural differences explicit:\n\n``` php\nflowchart LR\n    LLM[\"1. Raw LLM\"] --> Chat[\"2. Chatbot\"]\n    Chat --> RAG[\"3. RAG Pipeline\"]\n    RAG --> Work[\"4. Workflow\"]\n    Work --> ToolLLM[\"5. Tool-Using LLM\"]\n    ToolLLM --> Agent[\"6. Iterative Autonomous Agent\"]\n    Agent --> Multi[\"7. Multi-Agent System\"]\n\n    style LLM fill:#f5f5f5,stroke:#9e9e9e\n    style Chat fill:#e1f5fe,stroke:#0288d1\n    style RAG fill:#e0f7fa,stroke:#0097a7\n    style Work fill:#fff8e1,stroke:#f57f17\n    style ToolLLM fill:#f3e5f5,stroke:#7b1fa2\n    style Agent fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px\n    style Multi fill:#ede7f6,stroke:#4527a0\n```\n\n| Stage | Paradigm | How Decisions Are Made | Can it take actions? | Closed Feedback Loop? | Agentic characteristics | \n|---|---|---|---|---|---|\n| **1** | **Raw LLM** | Predicts next tokens based on prompt | No | No | **None** | \n| **2** | **Chatbot** | Appends user/assistant turns to history | No | Only via user | **Low** | \n| **3** | **RAG Pipeline** | Hardcoded retrieval | No | No | **Low** | \n| **4** | **Workflow / Chain** | Fixed code sequence ( | Fixed actions | Fixed error handling | **Predetermined control** | \n| **5** | **Tool-Using LLM** | Model selects 1 tool | Yes 1-shot action | No iterative retry | **Some** | \n| **6** | **Iterative Autonomous Agent** | Dynamic Observe | Yes Dynamic actions | Yes Closed runtime feedback | **High** | \n| **7** | **Multi-Agent System** | Multiple agents with handoffs & roles | Yes Distributed actions | Yes Inter-agent feedback | **Multiple interacting agents** | \n\n| Term | What It Actually Is | Lifespan | \n|---|---|---|\n| **Prompt** | The static text template or instruction formatted for a single inference call. | Single API call | \n| **Context** | The exact collection of tokens passed into the model's attention window at time | Single API call | \n| **History** | The ordered sequence of prior user/assistant turns and tool observations. | Conversation | \n| **State** | The full operational data structure (variables, step count, budget, artifacts, scratchpad). | Task execution | \n| **Memory** | Knowledge persisted across tasks/sessions (vector indices, key-value stores, user profiles). | Persistent / Multi-session | \n\n| Component | Primary Responsibility | Example | \n|---|---|---|\n| **Model** | Probabilistic decision-maker and text generator. | GPT-4o, Claude 3.5 Sonnet, Gemini 2.0 | \n| **Tool** | A callable capability that inspects or mutates the environment. | `calculator()` ,`read_file()` ,`sql_query()` | \n| **Environment** | The external world the agent observes and acts upon. | Filesystem, REST API, Database, Shell | \n| **Runtime / Harness** | The supervisor controlling loops, step limits, permissions, and tool execution. | Python loop, LangGraph runtime | \n| **Agent System** | The complete composite system (Model + Runtime + Tools + State). | Minimal Agent, Coding Assistant | \n\nEvery module is labeled with a difficulty level so you can track your progression:\n\n```\nLevel 1: Beginner → Level 2: Builder → Level 3: Systems → Level 4: Production → Level 5: Research\nflowchart TD\n    subgraph L1[\"Level 1 — Beginner\"]\n        M00[\"00-introduction<br/>(Prerequisites & Setup)\"]\n        M01[\"01-what-is-an-agent<br/>(Operational Taxonomy)\"]\n        M02[\"02-agent-loop<br/>(Observe-Decide-Act Mechanics)\"]\n        M00 --> M01 --> M02\n    end\n\n    subgraph L2[\"Level 2 — Builder\"]\n        M03[\"03-tools-and-function-calling<br/>(Tool Schemas & MCP)\"]\n        M04[\"04-build-your-first-agent<br/>(The Complete End-to-End Agent)\"]\n        M05[\"05-state-and-memory<br/>(State, History & Memory Stores)\"]\n        M02 --> M03 --> M04 --> M05\n    end\n\n    subgraph L3[\"Level 3 — Systems\"]\n        M06[\"06-planning-and-reasoning<br/>(ReAct & Task Decomposition)\"]\n        M07[\"07-context-engineering<br/>(Window Budgets & Pollution)\"]\n        M08[\"08-agent-runtime-and-harness<br/>(Middleware, Budgets & Limits)\"]\n        M09[\"09-multi-agent-systems<br/>(Handoffs & Supervisor Patterns)\"]\n        M05 --> M06 --> M07 --> M08 --> M09\n    end\n\n    subgraph L4[\"Level 4 — Production\"]\n        M10[\"10-agent-failures<br/>(Taxonomy & Defense Patterns)\"]\n        M11[\"11-agent-evaluation<br/>(Trajectory Evals & Benchmarks)\"]\n        M12[\"12-agent-safety-and-verification<br/>(Sandboxing & Approvals)\"]\n        M13[\"13-production-agents<br/>(Observability & Persistence)\"]\n        M09 --> M10 --> M11 --> M12 --> M13\n    end\n\n    subgraph L5[\"Level 5 — Research\"]\n        M14[\"14-coding-agents<br/>(Repo Search, Patching & Evals)\"]\n        M15[\"15-self-improving-agents<br/>(Meta-Learning & Evolution)\"]\n        M13 --> M14 --> M15\n    end\n\n    style L1 fill:#e8f5e9,stroke:#2e7d32\n    style L2 fill:#e1f5fe,stroke:#0288d1\n    style L3 fill:#fff8e1,stroke:#f57f17\n    style L4 fill:#fbe9e7,stroke:#d84315\n    style L5 fill:#f3e5f5,stroke:#6a1b9a\n```\n\n| Module | Level | Status | What You Will Learn | \n|---|---|---|---|\n| **[00-introduction](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/00-introduction/README.md)** | Level 1 | Ready | Course architecture, prerequisites, mental models | \n| **[01-what-is-an-agent](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/01-what-is-an-agent/README.md)** | Level 1 | Ready | LLM vs Chatbot vs Workflow vs Agent; operational taxonomy | \n| **[02-agent-loop](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/02-agent-loop/README.md)** | Level 1 | Ready | The cyclic Observe-Decide-Act execution loop | \n| **[03-tools-and-function-calling](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/03-tools-and-function-calling/README.md)** | Level 2 | Ready | Tool lifecycle, schemas, validation & **MCP Deep Dive** | \n| **[04-build-your-first-agent](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/04-build-your-first-agent/README.md)** | Level 2 | Ready | Assembling the first complete agent + 10-case regression scorecard | \n| **[05-state-and-memory](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/05-state-and-memory/README.md)** | Level 2 | Ready | Working state, SQLite persistent memory & history compaction | \n| **[06-planning-and-reasoning](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/06-planning-and-reasoning/README.md)** | Level 3 | Ready | ReAct, decomposition, reflection, and limits of reasoning | \n| **[07-context-engineering](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/07-context-engineering/README.md)** | Level 3 | Ready | Context budgets, compression, and anti-pollution | \n| **[08-agent-runtime-and-harness](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/08-agent-runtime-and-harness/README.md)** | Level 3 | Ready | Harness as the OS: step limits, budgets, middleware & aborts | \n| **[09-multi-agent-systems](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/09-multi-agent-systems/README.md)** | Level 3 | Ready | Supervisor-worker, handoffs, and when NOT to use multi-agent | \n| **[10-agent-failures](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/10-agent-failures/README.md)** | Level 4 | Ready | Failure taxonomy, loops, ambiguous writes & reconciliation | \n| **[11-agent-evaluation](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/11-agent-evaluation/README.md)** | Level 4 | Ready | Advanced trajectory evaluation, multi-dimensional metrics & frozen benchmarks | \n| **[12-agent-safety-and-verification](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/12-agent-safety-and-verification/README.md)** | Level 4 | Ready | Capability gating, blast radius, invariants & postconditions | \n| **[13-production-agents](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/13-production-agents/README.md)** | Level 4 | Ready | Durable queues, worker leases, crash recovery, telemetry & health checks | \n| **[14-coding-agents](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/14-coding-agents/README.md)** | Level 5 | Ready | Repo search, AST navigation, sandboxed test execution & patch repair loops | \n| **[15-self-improving-agents](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/15-self-improving-agents/README.md)** | Level 5 | Ready | The 5 adaptation surfaces, isolated candidate evals, multi-dimensional gates & rollback | \n\nWe believe you should understand how agents work even if every agent framework disappeared tomorrow.\n\n- **Zero Mandatory Third-Party Packages** : Everything runs on standard Python 3.11+.\n- **Zero Required API Keys** : All core lessons include deterministic simulators and mock LLMs for 100% offline learning and automated testing.\n- **Pluggable Real Providers** : Want to use a real model? Drop in your API key for OpenAI, Anthropic, Gemini, or local Ollama instances in`examples/minimal_agent/` .\n\nOnce you master the mechanics in this repo, you will understand how modern tools and frameworks organize these responsibilities:\n\n- **LangGraph** — maps many of these concepts into a graph-oriented orchestration/runtime model with explicit state, nodes, durable execution, and human-in-the-loop control.\n- **AutoGen** — provides abstractions for agents, teams, messaging, and event-driven multi-agent orchestration.\n- **OpenAI Agents SDK** — provides an agent runtime with a built-in agent loop, function tools, handoffs, guardrails, sessions, and tracing.\n- **MCP (Model Context Protocol)** — an open protocol for connecting AI applications to external capabilities and context providers. MCP servers can expose tools, resources, and prompts through a standardized protocol.\n\n```\nai-agents-zero-to-hero/\n├── README.md # Main course landing page\n├── LICENSE # Proprietary License (Tanmay Sah)\n├── CONTRIBUTING.md # Contribution & pedagogical standard\n├── ROADMAP.md # Curriculum milestone checklist\n├── QUESTIONS.md # Community Q&A hub\n├── pyproject.toml # Standard Python packaging config\n├── .github/ # Issue templates\n│\n├── 00-introduction/ # Module 0: Prerequisites & mental models\n├── 01-what-is-an-agent/ # Module 1: Operational spectrum & agent architecture\n├── 02-agent-loop/ # Module 2: The Observe-Decide-Act loop\n├── 03-tools-and-function-calling/ # Module 3: Tool schemas, execution lifecycle & MCP\n├── 04-build-your-first-agent/ # Module 4: Assembling your first complete agent\n├── 05-state-and-memory/ # Module 5: Working State, SQLite Memory & Compaction\n├── 06-planning-and-reasoning/ # Module 6: ReAct, Planning & Dynamic Replanning\n├── 07-context-engineering/ # Module 7: Token Budgets & Observation Pruning\n├── 08-agent-runtime-and-harness/ # Module 8: The Agent Harness / Operating System\n├── 09-multi-agent-systems/ # Module 9: Supervisor-Worker & Review Loops\n├── 10-agent-failures/             # Module 10: Failure Taxonomy, Ambiguous Writes & Reconciliation\n├── 11-agent-evaluation/            # Module 11: Advanced Trajectory Evaluation & Benchmarks\n│   ├── README.md                   # Core guide, 5 evaluation levels & commands\n│   ├── concepts.md                 # Comprehensive deep-dive & metric formulas\n│   ├── eval_cases.json             # Frozen 20-case benchmark test suite\n│   ├── example.py                  # Runnable comparative regression benchmark (V1 vs V2)\n│   └── exercise.md                 # Production incident reproduction exercise\n├── 12-agent-safety-and-verification/ # Module 12: Capability Gating, Blast Radius & Compensation\n│   ├── README.md                   # Core guide, 4 layers, 6 controls & commands\n│   ├── concepts.md                 # Deep-dive: blast radius formula, 6 invariants & compensation\n│   ├── example.py                  # Runnable adversarial safety suite (40+ attack vectors)\n│   └── exercise.md                 # Edit comment capability & compensation exercise\n├── 13-production-agents/            # Module 13: Durable Queues, Worker Leases & Telemetry\n│   ├── README.md                   # Core guide, 6 production concerns & commands\n│   ├── concepts.md                 # Deep-dive: durable state machine, reconciliation & health\n│   ├── example.py                  # Runnable demo: worker leases, crash recovery & trace waterfalls\n│   └── exercise.md                 # Incident root-cause analysis & graceful SIGTERM drain\n├── 14-coding-agents/               # Module 14: Repo Search, AST Navigation & Sandboxed Repair\n│   ├── README.md                   # Core guide, 9-stage loop, invariants & scorecard\n│   ├── concepts.md                 # Deep-dive: AST slicing, execution sandboxes & test immutability\n│   ├── example.py                  # Component walkthrough: AST slicing, safety linting & sandboxed repair\n│   ├── exercise.md                 # Call-graph extraction, forbidden-pattern security & modulo repair\n│   └── demo_repo/                  # Deliberately broken mini-repository (calculator & parser bugs)\n├── 15-self-improving-agents/        # Module 15: Self-Improving Agents & Governance\n│   ├── README.md                   # Core guide, 5 adaptation surfaces, architecture & commands\n│   ├── concepts.md                 # Deep-dive: evaluator isolation, multi-dimensional gates & rollback\n│   ├── example.py                  # Walkthrough: holdout boundary, multi-dimensional evals & rollback\n│   ├── exercise.md                 # Eval dataset tamper-proofing, AST scanner & canary rollback\n│   └── evals/                      # Quarantined eval datasets (development, regression, holdout)\n│\n├── examples/\n│   ├── self_improving_agent/       # Capstone: Versioned Self-Improvement & Rollback Subsystem\n│   │   ├── versions.py             # Version registry, promotion statuses & immutable audit trail\n│   │   ├── mutation.py             # 5 adaptation surfaces, risk hierarchy & protected verifier guard\n│   │   ├── proposer.py             # Failure log analysis & adaptation proposal (holdout isolated)\n│   │   ├── candidate.py            # Candidate workspace cloning & isolated patch application\n│   │   ├── baseline.py             # Baseline naive agent & candidate AST-localized agent\n│   │   ├── evaluator.py            # Frozen regression & holdout benchmark scoring\n│   │   ├── promotion.py            # Multi-dimensional gate (zero tolerance on unsafe) & human approval\n│   │   ├── rollback.py             # Production rollback manager & ancestor restoration\n│   │   └── main.py                 # Flagship end-to-end runnable demonstration\n│   ├── coding_assistant/           # Applied Coding Agent: Sandboxed Repair & Verification Subsystem\n│   │   ├── repo.py                 # Repository discovery, language detection & tree mapping\n│   │   ├── search.py               # Fast code grep & symbol definition lookup\n│   │   ├── ast_tools.py            # AST symbol extraction & targeted function slicing\n│   │   ├── patch.py                # Unified diffs, targeted replacements & syntax validation\n│   │   ├── sandbox.py              # Isolated tempdir cloning, command execution & repo sync\n│   │   ├── verifier.py             # Test execution, traceback parsing & safety linter\n│   │   ├── agent.py                # Autonomous coding agent loop & verification scorecard\n│   │   └── main.py                 # End-to-end runnable demo on demo_repo\n│   ├── minimal_agent/              # Modular, runnable showcase agent\n│   │   ├── README.md\n│   │   ├── llm.py                  # Pluggable LLM interface (Mock, OpenAI, Anthropic, Gemini, Ollama)\n│   │   ├── state.py                # State representation & history\n│   │   ├── tools.py                # Tool definitions & registry\n│   │   ├── runtime.py              # Step controller & budget enforcement\n│   │   ├── agent.py                # Pure agent logic\n│   │   └── main.py                 # Runnable demo script\n│   └── reddit_comment_agent/       # Capstone: Human-in-the-Loop Reddit Comment Agent (Modules 01-09)\n│       ├── README.md               # Architecture, module mapping & user guide\n│       ├── mock_reddit.py          # Offline simulated Reddit environment\n│       ├── reddit.py               # Reddit client interface (Mock + optional PRAW)\n│       ├── state.py                # SQLite persistent memory & duplicate prevention\n│       ├── tools.py                # Permission-gated tool registry\n│       ├── evaluator.py            # 5-criterion quality scorecard\n│       ├── approval.py             # Human-in-the-loop review gate & HMAC tokens\n│       ├── safety.py               # 4-layer defense, blast limiter, verifiers & compensation\n│       ├── runtime.py              # OS harness & rate limits\n│       ├── agent.py                # Central coordinator (observe, decide, act)\n│       ├── main.py                 # Standalone runnable demo script\n│       ├── evals/                  # Benchmark evaluation harness (Module 11)\n│       │   ├── cases.json          # Frozen 20-case test suite\n│       │   ├── metrics.py          # Multi-dimensional metric calculations\n│       │   ├── judges.py           # Deterministic, Heuristic & LLM Judges\n│       │   ├── runner.py           # Benchmark execution harness\n│       │   └── report.py           # Regression reporting & delta tables\n│       └── production/             # Production subsystem (Module 13)\n│           ├── config.py           # Configuration, secrets & redaction\n│           ├── jobs.py             # State machine & transition validation\n│           ├── checkpoints.py      # Durable SQLite queue & worker leases\n│           ├── telemetry.py        # Structured JSONL, metrics & tracer\n│           ├── health.py           # Liveness, readiness & dependency health\n│           ├── recovery.py         # Crash recovery & post-commit reconciliation\n│           └── worker.py           # Worker loop & graceful shutdown\n└── tests/                          # Unittest verification suite (88 tests)\n    ├── test_module_01.py\n    ├── test_module_02.py\n    ├── test_module_03.py\n    ├── test_module_04.py\n    ├── test_module_05.py\n    ├── test_module_06.py\n    ├── test_module_07.py\n    ├── test_module_08.py\n    ├── test_module_09.py\n    ├── test_module_10.py\n    ├── test_module_11.py\n    ├── test_module_12.py\n    ├── test_module_13.py\n    ├── test_minimal_agent.py\n    └── test_reddit_comment_agent.py\n```\n\nRun the zero-dependency test suite using standard Python:\n\n```\npython3 -m unittest discover -s tests -v\n```\n\nCopyright (c) 2026 Tanmay Sah. All rights reserved.\n\nThis work is published under a [Proprietary / Source-Available License](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/LICENSE). No part of the written curriculum, diagrams, code implementations, exercises, or related expressive materials may be reproduced, distributed, modified, or used for commercial, corporate training, or derivative purposes without prior written permission. See [LICENSE](https://github.com/tradertanmay/ai-agents-zero-to-hero/blob/main/LICENSE) for full terms.", "url": "https://wpnews.pro/news/show-hn-ai-agents-zero-to-hero-learn-ai-agents-from-scratch-in-pure-python", "canonical_source": "https://github.com/tradertanmay/ai-agents-zero-to-hero", "published_at": "2026-10-06 01:49:42+00:00", "updated_at": "2026-10-06 02:19:34.485041+00:00", "lang": "en", "topics": ["ai-agents", "artificial-intelligence", "large-language-models", "ai-tools", "developer-tools"], "entities": ["Tanmay Sah", "AI Agents: Zero to Hero", "GitHub", "Python", "ChatGPT"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/show-hn-ai-agents-zero-to-hero-learn-ai-agents-from-scratch-in-pure-python", "markdown": "https://wpnews.pro/news/show-hn-ai-agents-zero-to-hero-learn-ai-agents-from-scratch-in-pure-python.md", "text": "https://wpnews.pro/news/show-hn-ai-agents-zero-to-hero-learn-ai-agents-from-scratch-in-pure-python.txt", "jsonld": "https://wpnews.pro/news/show-hn-ai-agents-zero-to-hero-learn-ai-agents-from-scratch-in-pure-python.jsonld"}}