The Roles This Book Trains
The market is inventing titles faster than it can define them. Most of those titles are the same discipline at different depths: the discipline this book teaches. Here is the map, and exactly how far the book carries you toward each role.
Here we define the roles of the new agentic AI era — the jobs that exist because companies now manufacture, run, and govern AI Workers. The entries are sorted by how the work actually clusters, and the verdict beside each one is the honest scope line: how far this book carries you toward it, and where the certification tracks take over. The verdicts matter more than the names. Where the book stops, it says so.
The book trains in both modes of general agent use. Mode 1 is using a general agent to do your own work faster — a proficiency every reader needs, not a job title. Mode 2 is manufacturing AI Workers that do the work for you, and that is where the job titles live. The map below opens with the Mode 1 baseline, then turns to the Mode 2 roles — which are almost all of it.
New to the vocabulary (Digital FTE, SKILL.md, Agent Factory)? Start with the Thesis and the Glossary; this page assumes them.
The whole map at a glance — the core pipeline, what extends and supports it, where the book stops, and the baseline beneath it all.
The baseline everyone starts from
Mode 1 Practitioner — not a title, a proficiency. Before you ever manufacture a Worker, you use a general agent to do your own work faster: to reason, write, code, analyze, plan, ship an outcome, and close the session. This is Mode 1, and the book trains it for everyone — engineers through Claude Code or OpenCode, domain experts through Claude Cowork or OpenWork — under the Seven Principles of General Agent Problem Solving. It is the on-ramp every reader walks before the Mode 2 roles below, and it makes you sharper at the job you already hold rather than handing you a new one. The floor everyone stands on, not a title you hold.
The generalist core
These core roles run as a single pipeline, from intent to production: Outcome Architect (what) → Digital FTE Builder (build) → AI-Native Company Architect (system) → Cloud AI Engineer (run). Run it inside your own company and it is these four roles; run it inside a client's, carried end to end by one embedded, vendor-neutral engineer, and it is the Forward Deployed Engineer. Everything else on the map supports, extends, or bounds this line.
Four roles run the line inside your own company; one embedded engineer carries the same line inside a client's.
Outcome Architect: owns the intent, not the execution. Work in the agent era splits three ways — intent, execution, verification. The Worker owns execution; this role owns intent. It decides what a Worker should achieve, authors the spec that pins it down, sets what "correct" means, and prioritizes which Workers get built at all — the human who answers what and why before the Builder answers how. Where the Strategist track owns client-facing discovery and ROI, the Outcome Architect owns the internal Worker roadmap and the specs behind it. The book trains this directly: spec-driven development is, at its core, the discipline of writing intent a Worker can be held to. Trains it — the discipline the whole method rests on.
Digital FTE Builder: the unit product, built end to end. The market calls this the AI Engineer — its catch-all for someone who builds applications out of AI components and drives AI coding agents. This book's name is sharper, because the thing you build is sharper: the Digital FTE, the unit the whole company is assembled from. This is the book's primary graduate. It trains the full spine: spec-driven development, SKILL.md authoring, agent architecture, tool and MCP interfaces, evaluation, and human oversight — with enough deployment to ship, and the depth left to the Cloud AI Engineer. Trains it, end to end.
AI-Native Company Architect: designs the company, not the single Worker. The whole enterprise — the Two-Layer Model, the management layer, the workforce, the nervous system that carries events between them, and the system of record it all runs against. The Agent Factory is the process this architect practices; the AI-Native Company is the product they ship. The book is its canonical source. The five-quarter Certified Agentic AI Architect program is its credential. Trained in full; certified by the Architect track.
Cloud AI Engineer: the one who runs the AI Worker and the AI-Native company in production. Building a Digital FTE is one half of the work; running it reliably is the other — and so is running the whole AI-Native company it belongs to. Where the AI-Native Company Architect designs the enterprise, this role operates it: deploying and scaling the Workers, the management layer, and the nervous system on real cloud infrastructure — Azure Container Apps to ship, Inngest for durable execution, Dapr and Kubernetes to scale. It is where the system stops being a prototype and becomes a company an organization can depend on. Trains it, end to end.
The two roles only this book trains
Subject Matter Expert as Skill Author: the role the market hasn't named yet. The accountant, lawyer, or supply-chain expert who encodes judgment into SKILL.md and becomes the knowledge engine of a Digital FTE. Most market lists miss this role because they still picture AI work as engineering-only. This book treats domain judgment itself as something to be authored, tested, and deployed. It is one of two roles only this book trains. Trains it in full: judgment in, working agent out.
Forward Deployed Engineer (FDE): the vendor-neutral version the market can't find. Palantir pioneered the FDE; AI vendors are reviving it now, embedding engineers inside client organizations to fit agentic workflows to a client's reality. That technical half is Agent Factory work, and the book trains it fully. The twist is vendor neutrality. As Andrew Ng has noted in The Batch, clients struggle to find FDEs who aren't tied to a single vendor — the role exists to wire one vendor's product deep into the company. That erodes the freedom to switch later. The method here is bound to no vendor, so the book produces the FDE the market keeps failing to find, with that optionality intact. That is the second role only this book trains. The other half of the job belongs to the Certified Agentic AI Business Strategist track, not the core book: client discovery, prioritization, ROI framing, and the discipline to push back on an unrealistic ask. Trains the technical core; the consulting layer lives in the Strategist track.
The supporting roles
Evals Engineer: the verification specialist. Verification is not an afterthought here; it is a survival standard. Core curriculum, not an add-on.
AI Governance Officer: authors the rules the workforce runs under. Every AI Worker operates inside an authority envelope — what it may decide alone, what must escalate, what it may never touch. This role writes that envelope at the institutional level: risk tiers, escalation and approval policy, audit and liability rules, and the mapping to whatever the company must answer to — model risk and fair lending in a bank, data residency elsewhere. The AI-Native Company Architect builds the mechanism that enforces an envelope; the Governance Officer decides what it should say. The Digital FTE Supervisor answers for one deployed Worker; the Governance Officer sets the rules every Worker and supervisor works within. The book trains this framework discipline directly; your industry's specific regulations are the inputs you bring. Trains the governance framework; your jurisdiction's rules are yours to supply.
Digital FTE Supervisor: the accountable human, Worker by Worker. The human who owns accountability for a deployed AI worker: the human-in-the-loop, the reviewer, the name the audit trail points to. It is the operator's job made into a title — running the work, not building the worker. Trains it.
Where the book deliberately stops
LLMOps Engineer: up to the model, not the model itself. Running agents in production is the Cloud AI Engineer's job, and the book trains it. The book also trains fine-tuning hands-on — but as a last resort, not a default. A fine-tune binds your system to one model snapshot and costs the optionality the whole method protects, so you reach for it only when prompting, context, tools, and retrieval genuinely fall short. The hard stop is building the model itself: pre-training a foundation model from scratch stays out of scope, because that capability is commoditizing. Trains fine-tuning and the ops around the model, not the building of foundation models.
Harness Engineer: the runtime you use, not the one you build. The harness is the agent runtime — OpenAI Agents SDK, Claude's managed agents, and the like — that runs the agent loop, manages state, and executes tool calls. The book trains you to use these fluently and to stay portable across them, since your discipline outlives whichever runtime wins. Building the runtime itself is not the job. Trains the operator who uses any runtime, not the engineer who builds one.
AI Data Engineer: the agent-facing data layer. The system-of-record work touches the agent-facing data layer: Postgres, pgvector, and MCP as the spine an agent reads from. Classic pipeline and warehouse engineering is adjacent, not central. Trains the agent-facing data layer, not general data engineering.
The pattern is the tell. The agent era fans work out into many roles, not one — building Workers, running and governing them, teaching them judgment. The map is the point: find where you already stand, and how far this book carries you from there.