A leader at MagmaLabs opened Slack one morning and read a brief their virtual employee had written for them. Same headers as always. Same voice. Risks at the top, KPIs in the middle, meeting prep at the bottom.

The last line ended mid-sentence.

The model had hit its output ceiling. The API returned stop_reason: "max_tokens", and our system rendered the response and posted it anyway. No exception. No retry. The dashboard showed a clean delivery. The only thing in the whole stack that noticed was a human reading carefully.

That half-sentence is the first page of my first book, The Agentic Engineer. It’s out now.

Why I wrote it

I’ve spent the last year shipping systems with LLMs in load-bearing paths: Forge, our virtual-employee platform at MagmaLabs, a handful of MCP servers, a CRM, a desktop agent GUI, a Chrome extension. The same thing kept happening. Bugs that didn’t raise. Output that was structurally perfect and semantically wrong. Features that were “done” in every way the runtime could see and broken in the one way that mattered.

My normal engineering instincts weren’t wrong. They were built for the deterministic side of the stack, and the failures were living at the seam.

Most AI books don’t help with that, because they teach the surface: the model that’s strongest this quarter, the SDK with the cleanest tutorial, the prompt that worked in a demo. Twelve months later the book is wallpaper.

So this one makes the opposite bet.

The bet: durable body, dated appendix

The book is split in two on purpose:

• The body holds what should survive the next few model generations: mental models, decision frameworks, named failure patterns, and the war stories that earned them. No model names. No SDK tutorials.
• The appendix holds the dated specifics: model landscape, SDK notes, harness limits, recipes. It’s public on GitHub, versioned, and it changes when the field does.

Every chapter had to pass one test: would this still be useful if every model and SDK got rewritten tomorrow?

What’s inside

Twelve chapters, each built around one named principle:

1. Valid-looking invalid output. The failure shape the whole field runs on.
2. The Reader Contract. Trust the shape, verify the specifics.
3. Context is a budget, not capacity.
4. The contract enforced at the agent boundary is the real contract.
5. The audit is the eval.
6. State opacity. Most failures live between layers that disagree.
7. The orchestrator owns the seams.
8. Log the claim, not the call.
9. Match the executor to the work. Agent, script, or human.
10. Treat approval as a side-effect, not the terminal state.
11. The structure is the team.
12. An injected model can’t exceed the authority you enforce outside it.

Each one is anchored to something that actually happened in a system I shipped: a prompt cache the SDK accepted and the provider silently ignored, an MCP tool that handed out URLs that died with the session, a review wave that called a cleanup complete while dead code with the same prefix was still in the tree, an agent that spawned 106 subagents for one web search. Forty of those incidents are written up in full in the appendix.

Who it’s for

Working engineers and tech leads shipping agentic systems in production. Not researchers, not prompt collectors. People who get paged when this stuff breaks and want a vocabulary for what they’re looking at, and a way to decide, before the next incident, where the checks have to live.

If you’ve ever debugged an LLM-in-the-loop system and felt like your usual tools were aimed at the wrong layer, this book is for you.

Thank you

A first book doesn’t happen alone. Thank you to Ozmi and Trino, who read the early drafts and pushed on every claim. To MagmaLabs, where all of this work happened. And to my wife, Estefanía, who wrote her first novel alongside this one, and to my son, Ebani. Everything I build, I build for the two of you.

Get it

The Agentic Engineer is on Leanpub as a DRM-free PDF and EPUB: leanpub.com/theagenticengineer. The minimum is $14.99 and the suggested price is $29; pay what feels right. Every future update is free.

The appendix and all forty war stories are free on GitHub, whether you buy the book or not.

And if you read it, I’d love to hear what held up for you and what didn’t. That’s how the next version gets better.