Agent Engineer: a 19-lesson course that teaches agent concepts and points at Google Cloud docs for the code

The gap Agent Engineer is aimed at: engineers who can write Python but cannot reason about an agent loop

The README states the audience directly: software engineers who want to understand what AI agents are, how they work, and how to build them, with no prior AI or ML experience required. The stated prerequisites are basic Python (functions, classes, HTTP requests), a Google Cloud account, and familiarity with REST APIs and JSON. That is a narrower and more honest entry bar than most agent material, which tends to assume either nothing at all or a working knowledge of transformer internals. The problem being solved is a vocabulary and mental-model problem. An engineer who has shipped services can read an API reference, but the reference will not explain why a planning step exists, when a second agent earns its cost, or what a context window does to a multi-turn tool call. The course positions itself against that gap rather than against a specific framework. The README's philosophy section puts it as fundamentals over frameworks, with the argument that frameworks change but the core ideas stick around. That is a defensible editorial line, and it also happens to be the cheapest kind of course to keep alive, which matters for the maintenance discussion later.

Three parts, nineteen lessons, and a clear split between platform-neutral theory and Google Cloud practice

The curriculum is divided into three parts. Part 1, Fundamentals (101), covers ten lessons and is described as platform-agnostic and focused on building a mental model. The lesson list runs from what agents are, through how they think, tools and function calling, agentic design patterns, memory and context, planning and reasoning, multi-agent systems, agentic RAG, evaluation and testing, and finally guardrails and safety. Part 2, Building and shipping (201), has four lessons and introduces the vendor-specific stack: prototype to production, getting started with Vertex AI and ADK, building a first agent, and agent protocols covering MCP and A2A. Part 3, Deep dives (301), adds five more: AGENTS.md, an MCP deep dive, agent skills, orchestrators, and a closing resources lesson. The shape is conventional and that is fine. What is more interesting is where the platform boundary sits. Everything conceptual is in Part 1, so an engineer who decides mid-course that they would rather build on a different stack still gets ten lessons of value. The Google Cloud coupling only begins at lesson 12, and the deep dives in Part 3 are mostly protocol-level rather than vendor-level, which means MCP, A2A and AGENTS.md content stays relevant regardless of which cloud you use.

How the course actually works: prose lessons that delegate all code and setup to external documentation

There is no runtime, no package to install, and no build step. The mechanism is a directory-per-lesson layout, with each row in the README tables linking to a README.md inside a numbered folder such as ./01-what-are-ai-agents/README.md or ./13-building-your-first-agent/README.md. The repository also carries a CONTRIBUTING.md and a LICENSE file at the root. The stated philosophy is link, don't duplicate: for API references, code samples and setup instructions, the course points to official Google Cloud docs and codelabs. The README gives the reason plainly, that this keeps content focused on concepts and ensures readers see up-to-date information rather than duplicating API docs or code samples that go stale. The resources section lists where those links go: Google Cloud AI documentation, Vertex AI documentation, the Agent Development Kit documentation at adk.dev, Google Cloud AI codelabs, and the Gemini API documentation. So the data flow of the course is reader to lesson prose to external doc to codelab. Every practical step in the course, from provisioning a Google Cloud project to calling an ADK primitive, happens on someone else's site. That is the single most consequential design decision in the repository and it cuts both ways, which the next sections take up.

Getting started: clone the repository, read in order, and expect the setup commands to live outside it

Because the course ships no code, the getting-started path is shorter than for a typical framework repository and also less self-contained. You clone the repository, then open the README and follow the lesson tables. The README offers two reading modes: read in order if you are new to agents, since each lesson builds on the previous one, or jump around if you already know the basics, since each lesson is described as self-contained enough to read on its own. Those two claims sit in mild tension. A lesson on multi-agent systems that assumes the vocabulary from the tools and planning lessons will not read cleanly as a standalone piece for someone who skipped ahead, and the README does not mark per-lesson dependencies. The prerequisites you must satisfy before lesson 12 are a Google Cloud account (the README links a free trial) and Python knowledge, but the actual project setup, authentication and SDK installation commands are not in this repository. They are in the linked Vertex AI and ADK documentation. If you want a concrete first action, it is this: read lesson 12, Getting started with Vertex AI and ADK, and follow its outbound links before you commit to Part 2, because that lesson is the hinge where the course stops being platform-neutral.

The link-out policy is the main limitation, and it is a real one for hands-on learners

The course's own philosophy is the source of its biggest weakness. If you learn by typing code and watching it fail, this repository will not satisfy you. There is no sample agent to run, no failing test to fix, no local environment to break. The README is explicit that this is intentional, but intention does not change the experience. Three consequences follow. First, the course's accuracy is partly outside its control: if a linked codelab is retired or a Vertex AI console flow changes, the lesson prose may still describe the concept correctly while the path to practice is broken, and the repository has no test that would catch that. Second, the prerequisites are stated as a Google Cloud account, which means the practical half of the course is gated behind billing setup and a cloud console, not just curiosity and Python. Third, the README's claim that each lesson is self-contained enough to read on its own is doing more work than the structure supports, since the lessons are prose that assume prior vocabulary. None of this makes the course wrong. It makes it a book rather than a workshop, and you should decide which of those you need before you start.

Where Agent Engineer sits against build-it-yourself agent tutorials and vendor quickstarts

The obvious alternative is a vendor quickstart, the kind Google publishes for ADK or that other agent frameworks publish for their own SDKs. The difference in approach is stark. A quickstart is a runnable path: install the SDK, paste a key, run a command, see an agent answer. It optimises for time-to-first-output and assumes you will absorb the concepts by building. Agent Engineer inverts that. It front-loads ten platform-agnostic lessons on reasoning, memory, planning, evaluation and guardrails before you touch an SDK, and it deliberately declines to provide the runnable path. The trade-off is time-to-first-output versus durability of what you learn. A quickstart teaches you one framework's idioms and goes stale when the framework changes; a concepts course survives a framework change but can leave you unable to debug a real agent because you have never seen one fail. A second alternative is a full reference implementation you clone and modify, which gives you both concepts and code but usually only for one architecture and one vendor. Agent Engineer's honest position is that it is the first of those three things and not the other two, and the README says so rather than pretending otherwise.

Maintenance, contribution and what Apache-2.0 means for reuse in your own material

The repository is licensed under Apache-2.0, with the README pointing to the LICENSE file. That is a permissive licence that allows reuse and modification with attribution and the inclusion of the licence text, and it includes an explicit patent grant, which matters if you intend to adapt the lessons inside a company. This is not legal advice; read the LICENSE file and your own organisation's policy before republishing or remixing the content. The maintenance picture is unusual for a code repository because there is no code to break. The stated cost of keeping the course current is link checking and prose revision when the underlying concepts shift, not dependency upgrades or CI runs. The README's contributing section says typos and suggestions are welcome via PRs and issues, with guidelines in CONTRIBUTING.md, which suggests a low-friction, documentation-style contribution model rather than a code-review one. The practical upgrade risk is therefore concentrated in Part 2 and the MCP lesson, where the course depends on external services and evolving protocols. The repository metadata shows the default branch as main and no releases retrieved, which is consistent with a course that ships prose on a branch rather than versioned artefacts. If you fork it for internal training, budget for periodic link audits in lessons 12 through 16; that is where drift will show up first.

Who should read it, who should not, and the one check to run first

Read it if you are a software engineer with Python and REST experience who wants a structured mental model of agents before choosing a framework, and if you are comfortable learning concepts from prose and then finding your own hands-on practice. The platform-agnostic first ten lessons are the part with the widest audience, and the Part 3 deep dives on MCP, A2A, AGENTS.md and agent skills address questions that come up in real projects regardless of vendor. Do not read it if you need runnable code today, if you are not willing to open a Google Cloud account, or if you are looking for a reference implementation to fork and deploy. The course will not give you any of those. Before you invest the time, open lesson 13, Building your first agent, and lesson 16, MCP deep dive, and follow their outbound links. If the ADK and MCP documentation those lessons point to is live and still matches the concepts described, the course is doing its job. If the links are dead or the material has moved on, you are reading a map to a road that has been rebuilt, and the README's link-don't-duplicate policy gives you no fallback inside the repository.

Editorial conclusion

Adopt it if you are a working software engineer who wants a conceptual map of agents before touching a framework, and you are willing to follow the outbound links to Google Cloud codelabs for the hands-on parts. Skip it if you learn by running code, if you are not on Google Cloud, or if you want a reference implementation to fork. Before starting, open lesson 13 and lesson 16 and check that the linked ADK and MCP material is still live and matches the concepts described, because the course itself carries no code to fall back on.

Official sources

1. addyosmani/agent-engineer on GitHub
2. Issues
3. License: Apache-2.0
4. README