Cover the computing ideas agents rely on: programs, files, data types, state, events, and errors. You will see why agents need memory, tools, and clear boundaries to act reliably.

Write small Python scripts that read input, call functions, handle errors, and save results. These skills let you build and test the moving parts of an agent one at a time.

Use the command line, virtual environments, Git, environment variables, and secret files safely. You will set up projects so another person can run them and trust what changed.

Send and receive data through HTTP, JSON, webhooks, and APIs. You will connect code to real services without treating the internet as magic.

Trace the path from rule-based expert systems and robotic planners to machine learning, chatbots, transformers, and modern LLM agents. This history explains why today’s agents combine language, tools, retrieval, evaluation, and guardrails.

Work with uncertainty, confidence, false positives, false negatives, and tradeoffs. Agentic systems often fail in partial ways, so this chapter builds the judgment needed to measure and reduce risk.

See how text becomes tokens, chunks, vectors, and similarity scores. These ideas power search, memory, retrieval, and many modern agent features.

Build a plain-language picture of neural networks, attention, transformers, pretraining, instruction tuning, and alignment. You will know what LLMs are good at, where they are brittle, and why bigger is not always better.

Work with context windows, sampling settings, hallucinations, refusals, latency, and cost. You will make better model calls by knowing how an LLM produces each response.

Write prompts as clear interfaces: role, task, constraints, examples, output shape, and checks. You will practice prompts that support repeatable work instead of one-off clever wording.

Manage chat history, system messages, developer instructions, user messages, summaries, and context limits. You will decide what an agent should remember, forget, compress, or ask again.

Make models return JSON, typed fields, citations, tool arguments, and validation-friendly data. Structured outputs turn language into something software can safely process.

Give models functions, APIs, databases, calculators, calendars, and internal services they can request. You will design tool names, parameters, descriptions, permissions, and error messages that reduce bad calls.

Build a working single-agent assistant that receives a request, chooses a tool, returns a structured answer, and logs what happened. This project ties together prompts, model calls, APIs, state, and error handling.

Add your own documents, policies, tickets, or notes to an agent through retrieval-augmented generation. You will build a pipeline that retrieves evidence before the model answers.

Create chunking rules, metadata, keyword search, vector search, hybrid search, reranking, and freshness checks. Better retrieval helps agents answer from the right source instead of the loudest source.

Design short-term memory, long-term memory, user preferences, summaries, episodic records, and forgetting rules. You will avoid the common trap of saving everything and making the agent worse.

Use decomposition, checklists, scratchpads, self-checks, tree search ideas, and plan-revise loops. You will choose planning patterns that fit the task instead of adding “reasoning” everywhere.

Build agent flows as graphs, state machines, routers, and reusable nodes. This chapter covers the orchestration style behind many current agent frameworks without locking you to one vendor.

Handle retries, timeouts, queues, scheduled runs, resumable tasks, and idempotent actions. These patterns let agents do real work that takes minutes or hours instead of one chat turn.

Add approval steps, review queues, escalation paths, and human handoffs. You will design agents that know when to pause, ask, or transfer responsibility.

Build browser and desktop agents that read pages, fill forms, click buttons, and verify results. You will handle screenshots, accessibility trees, brittle interfaces, login flows, and safe stopping rules.

Create coding agents that read a repository, propose changes, run tests, and open reviewable patches. You will manage context, tool permissions, test feedback, and developer trust.

Work with agents that process images, audio, PDFs, scanned forms, diagrams, and video frames. You will combine OCR, vision-language models, transcription, and document structure for real workflows.

Coordinate specialist agents, debate patterns, supervisor agents, shared memory, and message protocols. You will also see when multi-agent designs add cost and confusion instead of value.

Choose models by task, latency, price, context length, privacy, tool use, and accuracy. You will build routing rules that send easy work to cheaper models and hard work to stronger ones.

Adapt models with examples, supervised fine-tuning, adapters, preference data, and behavior tests. You will know when tuning helps an agent and when better prompts, tools, or retrieval are the smarter fix.

Generate task examples, edge cases, conversations, tool traces, and labeled failures for training and testing. Synthetic data becomes useful when it is checked, diverse, and tied to real workflows.

Measure factual quality, tool choice, task completion, safety, latency, cost, and user satisfaction. You will build eval sets, rubrics, golden tasks, judge models, and regression tests for agent releases.

Trace prompts, tool calls, retrieved documents, model outputs, errors, and costs across a full run. Observability turns agent failures from mysteries into fixable engineering problems.

Test agents against prompt injection, data exfiltration, unsafe tool use, jailbreaks, hidden instructions, and malicious documents. You will practice attacks so you can design defenses before deployment.

Design scopes, permissions, sandboxes, allowlists, rate limits, policy checks, and reversible actions. Safe tool design limits damage when the model is confused or manipulated.

Handle personal data, retention, consent, audit logs, vendor review, model disclosures, and regulated workflows. You will create records that help teams prove what the agent did and why.

Package an agent behind an API, worker, chat interface, or internal app. This chapter covers configuration, secrets, deployment targets, release gates, and rollback plans.

Run agents after launch with monitoring, alerts, incident response, feedback loops, drift checks, and cost reviews. You will treat an agent as a living service, not a demo that ends at launch.

Follow a complete build from stakeholder request to workflow map, prototype, retrieval, tools, evaluation, security review, deployment, and post-launch monitoring. This chapter shows how the pieces fit into one professional delivery cycle.

Build agents for triage, ticket drafting, knowledge lookup, refunds, scheduling, and back-office operations. You will focus on accuracy, escalation, auditability, and customer trust.

Build agents that search literature, summarize evidence, clean datasets, run notebooks, produce reports, and cite sources. You will keep research workflows reproducible and separate evidence from speculation.

Connect agentic software to robots, sensors, smart devices, and edge systems. You will handle real-world constraints like latency, safety zones, physical failure, and local fallback behavior.

Compare open-source frameworks, managed agent platforms, model APIs, vector stores, observability tools, and deployment options. You will make build-versus-buy decisions based on workflow risk, team skill, cost, and lock-in.

Plan your next steps with roles, portfolio projects, open-source contributions, interview signals, security habits, and ways to track fast-moving research. You will leave with proof-of-skill ideas and a realistic path into agentic engineering work.