Cursos en esta ruta
How Coding Agents Work
Understand the conceptual and practical fundamentals of how coding agents work: from LLM mechanics to the workflow that separates productive developers from the ones who lose time with AI. This isn't a guide about building production agents — that's AI Engineering — it's about understanding how they think, act, and fail, so you can direct them with professional judgment using any tool: Claude Code, Cursor, Copilot, Cline, or whatever comes next. The seven modules move from the paradigm shift in software development, to LLMs explained for developers (not researchers), to the agentic loop and tool calling that turn a model into an agent, to the toolbox an agent uses to interact with your code, to the mental models for directing human-agent collaboration, and to the Research → Plan → Execute → Validate workflow. It closes with a hands-on project: building a mini coding agent from scratch to understand the agentic loop from the inside.
33 lecciones
Cursor Essentials
Learn to direct Cursor with judgment on a real repository, not just to know its buttons. Cursor is Anysphere's fork of Visual Studio Code that puts AI at the center of the editor — not as just another extension — and this guide teaches the mental model "familiar editor + an agent that acts inside the open project" across eight modules, all built on the same case: Reservo, a coworking room-booking backend. You go from Tab (predictive autocomplete) to Cmd-K (inline editing), to Agent mode and Plan mode (goal-driven multi-file editing), to the context an agent uses before it acts (@-mentions and project rules in `.cursor/rules`), to MCP inside Cursor as an external context source, to the discipline of reviewing production diffs, and close with a project that chains all seven surfaces together on a new, unsolved feature. Every claim about Cursor's behavior is verified against `cursor.com/docs`; all the code presented as a result actually runs, with Python 3.14.
64 lecciones
Agent Fundamentals And Tool Calling
This is the foundation of the whole agentic engineering ecosystem: it teaches, from scratch, what an AI agent is and how tool calling actually works. You build an agent for Reservo (a coworking room booking system) with four canonical tools — `list_rooms`, `get_quote`, `book_room`, `cancel_booking` — and use that case to take apart the line between an LLM that only answers and an agent that acts: the tool contract in JSON Schema, the real `tool_use`/`tool_result` protocol of Claude's Messages API, the agent loop (`while`) that asks-executes-feeds-repeats with an iteration cap, selecting among multiple tools with parallel tool calls, managing state inside the loop, and error robustness with retries and timeouts. The engineering (the tools, the loop runner, dispatching, retries) actually runs on Python 3.14 with real cited output; the model's decision is honestly treated as a concept (realistic examples with `claude-sonnet-5`), verified against the official Claude documentation. This is not a tutorial for any particular framework — the patterns it teaches are the same with any of them.
64 lecciones
Mcp Deep Dive
This guide is the direct continuation of the Agent Fundamentals and Tool Calling Guide: it takes the Reservo tools already built there (`get_quote`, `list_rooms`, `book_room`, `cancel_booking`) and exposes them through the Model Context Protocol (MCP), the open standard Anthropic published in November 2024 to solve the M×N integration problem (every agent reimplementing its own adapter for every tool) with an M+N solution instead (a single MCP server, reusable by any compatible client). You build a real Reservo MCP server and client: the wire protocol — JSON-RPC 2.0 over stdio — implemented by hand with Python 3.14 and its standard library (`subprocess`, no official SDK installed, $0, no network), the `initialize`/`initialized` handshake, and the protocol's three primitives: tools, resources, and prompts. It closes by connecting the server to a real `.mcp.json`, the kind Claude Code would use. The guide anchors its teaching to the stable `2025-06-18` revision (the one actually deployed across the ecosystem today) and honestly names, without reimplementing it, the modern stateless `2026-07-28` revision as the protocol's direction. Which tool/resource/prompt an LLM would decide to use is treated as a concept; the wire protocol itself actually runs and is verified against the official specification.
64 lecciones
Production Rag And Document Ingestion
This guide builds the data plumbing of a production RAG system on top of real Reservo documents — thirteen documents across three raw formats: markdown, HTML, and a deliberately "dirty" `.txt` file that simulates a PDF/OCR extraction — and wires it up to an agent as just another tool. It covers the full ingestion pipeline: parsing each raw format, cleaning real artifacts (repeated headers/footers, broken hyphenation, page breaks), chunking with actual criteria, and attaching the metadata needed to cite the source later. Those chunks get indexed with a BM25 index built from scratch ($0, deterministic, always labeled as real lexical retrieval — the same algorithm behind Elasticsearch/OpenSearch — and never as semantic search), and search is exposed as the `search_docs(query, k)` tool that the agent calls from inside its own loop: agentic retrieval, not a monolithic single-pass RAG pipeline, with the agent deciding when to search and combining that search with Reservo's business tools in the same turn. The guide also covers incremental, idempotent ingestion (re-ingesting changed documents without duplicating them, detecting additions/changes/deletions by content hash), evaluating retrieval quality with a fixed ground-truth query set and form-based metrics — recall@k, precision@k, never a semantic judge — and operating the system: citing sources, handling zero results without hallucinating, filtering irrelevant chunks, and estimating pipeline cost. All the engineering actually runs on Python 3.14 and `numpy`; the LLM's decision is treated as a concept. It doesn't teach embedding theory or build a vector database — that's named as the next step in AI Engineering.
64 lecciones
Context Engineering
This guide treats a model call's context window for what it actually is: a finite resource to budget, not a canvas for writing the perfect prompt. The driving case is Reservo's Support Assistant, a question-answering assistant (no tools, no loop) that answers member questions about cancellations, pricing, room specs, and membership using documents that are already retrieved by a deterministic mock function — real retrieval belongs to a different guide. With that case, the guide covers the system prompt as a versioned, auditable component (never free-form writing), the structure of the payload (block order, delimiters), selecting content under a fixed token budget when there are more candidates than fit, compacting the conversation history (compressing while preserving what matters, in two stages), few-shot examples treated as just another budget line item, context rot (more input tokens degrade performance, citing real research) with isolation as a conceptual mitigation, and measuring the effect of every change by form — never semantically. All the engineering (counting, selecting, structuring, compressing, measuring) actually runs on Python 3.14; the model's response is honestly treated as a concept. Token counting always uses an order-of-magnitude estimate (`len(text) // 4`), labeled as such, never a real third-party tokenizer.
64 lecciones
Multi Agent Orchestration
This guide is the direct continuation of the Agent Fundamentals and Tool Calling Guide: it takes Reservo's single agent and turns it into a system of several specialized agents working together — with no orchestration framework (LangGraph, CrewAI, AutoGen), built by hand with Python 3.14 and its standard library. The entire first module is a decision framework, measured for real — counting concept-level model calls and message "hops" — for when sub-tasks are genuinely separable with distinct expertise (multi-agent) versus when a single agent with more tools is already enough; the bar to clear isn't "I can implement the pattern," it's "I can decide whether it's needed." From there, the guide covers five coordination patterns, each in its own fully executed module: supervisor/router, sequential pipeline, parallel fan-out with aggregation whose result never depends on thread completion order, handoff/delegation mid-task, and shared state via a blackboard. The driving case is three Reservo specialists with genuinely distinct tools — `booking_agent`, `policy_agent` (over a minimal policy-search stub), and `pricing_agent` — coordinated by a supervisor. The orchestration itself — the router, message passing, the blackboard, fan-out and its aggregation — actually runs and its real output is cited; each agent's decision remains a concept, as throughout the rest of the ecosystem. It doesn't cover memory that persists across sessions, fine-grained context-window budgeting per agent, exposing tools over MCP, or security hardening — all of that is named and pointed to the matching sibling guide.
64 lecciones
Agent Memory And State
This guide gives a Reservo agent memory that survives the end of a session — and directly resolves the limitation left open by the Agent Fundamentals and Tool Calling Guide: there, Ana would book Focus pro, and in a new session the agent remembered nothing because the history only lived as long as the process did. This guide separates that working/short-term memory (already built) from long-term/persistent memory, its actual subject, and within long-term memory distinguishes episodic memory (what happened, dated events) from semantic memory (stable facts and preferences), grounded in real research (Generative Agents, Park et al. 2023; MemGPT, Packer et al. 2023) as its conceptual framework. You build a real persistent store with `sqlite3` (a file on disk, never `:memory:`), extract facts and episodes from an already-run session — never the raw transcript — retrieve relevant memory by user key, recency, and lexical keyword matching (deliberately without embeddings or semantic search, which are named as the production option covered by other guides), update and expire facts that change, and let a member's memory be forgotten entirely on request. Persistence is demonstrated between genuinely separate Python processes, not a variable cleared within the same process. All the engineering runs on Python 3.14 and its standard library; the LLM call is treated as a concept with realistic examples.
64 lecciones
Evaluation Frameworks Guide
Master the evaluation of AI systems — from metrics for chat, RAG, and agents to LLM-as-judge, RAGAS, TruLens, and production evaluation pipelines. Learn to build golden datasets, implement domain-specific evaluation for chatbots, RAG pipelines, and AI agents, automate evaluation with calibrated LLM judges, and deploy continuous monitoring with CI/CD integration and regression detection.
64 lecciones
Agent Security And Sandboxing
Learn to secure an agent that takes real actions with tools over a system. This guide covers an agent's threat model, direct and indirect prompt injection, the tool contract and least privilege, sandboxing tool execution, permission models and human-in-the-loop, input and output guardrails, and secrets handling and blast radius. The case that runs through the whole guide is a Reservo agent (a coworking room-booking backend) with tools like `search_rooms`, `book_room`, and `cancel_booking`. You come out knowing how to design an agent that can't be manipulated into causing harm or leaking data, even when the model or the user input is hostile. All the security engineering — the tool validator, the sandbox, the permission gate, the guardrails, the audit log, and the injection demo with its defense — actually runs with Python 3.14 (stdlib); the LLM's decision is presented as a concept, with realistic examples.
64 lecciones
Agents In Production
This guide takes the Reservo agent already built in the Agent Fundamentals and Tool Calling Guide — its capstone (M8) is the literal starting point — and runs it in production. It doesn't build an agent or teach it to handle a one-off error (that already exists); it instruments it, measures it, and gates it so it survives real traffic. It covers observability with structured logging of every loop step and a deterministic `trace_id` that correlates an entire run; measuring cost per run with an honest token estimate (`len(text) // 4`) and `claude-sonnet-5`'s cited list pricing; measuring latency per tool and total using an explicitly declared latency model — never the real clock, with explicit honesty about that limitation; a regression eval harness that checks form, deterministically, as a CI-style gate before a change (never a semantic judgment or LLM-as-judge); handling failures at scale with modeled backoff and a per-tool circuit breaker that persists across runs, including Claude's own API 429; and versioning the system prompt/tools/schemas with a rollout that compares the new version against the old one under the same gate before deciding GO/NO-GO. All the operations engineering actually runs on Python 3.14; the LLM call remains a concept, as throughout the rest of the ecosystem.
64 lecciones