Chapter 13 — AI Agents and the Future of Work

“Delegation is not abdication.” — a management maxim

”…Turn in the account of your management, for you can no longer be manager.” — Luke 16:2 (ESV)

Why This Matters

For twelve weeks you have been learning to talk to AI. You asked it a question, it answered. You gave it a document, it summarized. You handed it a prompt, it wrote you back. That is a conversation — one turn from you, one turn from the machine, and you steering every step. It is the model of AI that most people still carry in their heads, and it is already out of date.

This week the machine stops waiting for your next turn.

An AI agent does not just answer — it acts. You give it a goal, not a prompt. It makes a plan, breaks that plan into steps, reaches out into the world to use tools — searching the web, opening pages, reading your files, drafting an email, filling a spreadsheet, booking a slot on a calendar — and it does this across many steps, checking its own progress and adjusting, until the goal is met or it gets stuck. The chatbot is a very smart intern who answers when spoken to. The agent is an intern you handed a task list and let loose for the afternoon.

That is the largest shift in how professionals will work with AI, and it is why “the future of work” is in the title of this chapter. When the machine can only talk, you lose, at worst, a few minutes to a bad answer. When the machine can act — send the email, move the money, book the flight, change the record — the stakes change entirely. Speed goes up. So does the cost of being wrong. The whole game becomes: how much do I let it do without me, and where do I keep my hand on the wheel?

Here is the rule that governs every page of this chapter, the spine of this entire book, and I want it in your bones before we go one paragraph further:

You choose the tool. You own the verdict. AI drafts, generates, and accelerates; the professional decides, verifies, and is accountable. AI is an assistant, not an authority. And this week’s sharp corollary: you can delegate the work, but you can never delegate the account.

That corollary is the whole week. An agent can do the task. It cannot answer for the task. When the donor event flops, when the wrong client gets the email, when the number in the board deck is invented — nobody accepts “the agent did it.” The account comes back to the human whose name was on the job. Which is exactly the question Scripture puts to a manager: turn in the account of your management. Not “your assistant’s management.” Yours. Hold that; we will earn it by the end.

Coach’s Note — If you are tempted to skip this chapter because “I’m not going to run robots” — stop. You already use agent features and may not know it. The “Deep Research” button that goes and reads forty web pages for you is an agent. The assistant that reads your Gmail and drafts replies is an agent. This is not the future; it is the default of the tools you already pay for. The only choice is whether you supervise them on purpose or by accident.

13.1 — Agent vs Chatbot: What Actually Changed

Let us be precise, because “agent” is the most over-marketed word in AI right now and half of what gets called an agent is just a chatbot with a confident voice.

A chatbot takes one input and gives you one output. Text in, text out. It has no hands. It cannot do anything in the world except produce words on your screen. If you want those words to become an action — an email actually sent, a meeting actually booked — you are the hands. You copy, you paste, you click send. The chatbot advised; you acted.

An agent is a chatbot that has been given three new things: a goal instead of a prompt, tools it can operate on its own, and the ability to run for many steps without you between each one. You say “find me three suppliers and draft an outreach email to each.” It plans. It searches. It reads. It drafts. It may pause to ask you before it sends. Then it reports back. You gave it one instruction and it took twenty actions to satisfy it.

The difference in one table:

Read the last row twice. The upgrade from chatbot to agent is not “smarter answers.” It is hands. And the day a tool grows hands is the day your supervision stops being optional.

Coach’s Note — A useful gut check: if the tool’s mistake would only ever appear on your screen, you are using a chatbot, and you can relax a little. If the tool’s mistake could appear in someone else’s inbox, calendar, or bank account, you are using an agent, and you cannot. Same friendly interface; completely different risk. Know which one you are in.

13.2 — The Loop Under the Hood: Plan → Act → Observe

You do not need to know any code to understand how an agent thinks, because it thinks in a loop you already use every day. When you plan a dinner party, you do not execute a pre-written script. You form a goal (feed eight people Saturday), you take a step (check the fridge), you look at what happened (no chicken), and you adjust the plan (add chicken to the list). Goal, step, observe, adjust. Around and around until done.

An agent runs that same loop, fast, on your behalf. Under all the branding, it is four moves:

1. Plan. Take the goal and break it into steps. “To recommend a market, I need its size, its trend, and a competitor scan — so: research each, then compare.”
2. Act. Do the next step using a tool. Search. Open a page. Read a file. Draft a paragraph.
3. Observe. Look at what came back. Did the search return useful sources? Did the page actually contain the number?
4. Adjust and repeat. Update the plan based on what it saw, then take the next step. Loop until the goal is met — or until it hits a gate where it needs you.

This is what people mean by multi-step reasoning: the agent is not answering in one shot; it is working a problem across a sequence of moves, using the result of each move to choose the next. It is closer to how you work a task than how a search box works a query.

Two things follow from the loop, and both matter to a professional.

First, agents can recover from small mistakes — and compound big ones. Because it observes after each step, an agent can notice “that search returned nothing useful” and try again. That is genuinely powerful; it is why an agent can push through a messy, real-world task that a single prompt would fail. But the same loop means an early wrong turn gets built upon. If step 2 grabbed the wrong company’s revenue and the agent never notices, steps 3 through 10 faithfully reason on top of a bad number, and the final brief is confidently, elaborately wrong. The loop is a strength and a magnifier.

Second, agents are expensive in a way chatbots are not. Every one of those steps is the model thinking again — often many times. One goal you hand an agent can trigger dozens of model calls behind the scenes. As a mid-2026 rule of thumb, a single agent run can cost many times what one chatbot answer costs, and output tends to cost several times more than input. That is why the hard, agentic work is where you spend on a flagship model (something in the class of claude-opus-5 or gpt-5.6, mid-2026, as reasoning-strong tiers) and the trivial work stays on a cheap one. You met that “right tool for the job” ladder back in Chapter 3; agents are where the meter really runs.

Coach’s Note — When an agent “thinks for two minutes” and comes back with a beautiful report, that pause was not one thought — it was the loop turning dozens of times. Respect that. It is doing real, sequential work you could not do that fast. And it is also, dozens of times over, capable of the same confident wrongness you learned to catch in Chapter 8. More steps, more surface area for error.

13.3 — Tool Use: How an Agent Reaches Out of the Chat Box

The single feature that turns a chatbot into an agent is tool use — the ability to reach outside the conversation and do something. A model, by itself, only knows how to produce text. A tool is anything the model has been wired to operate: a search engine, a web browser, your file drive, your calendar, your email, a spreadsheet, a code runner, a company database. Give a language model a set of tools and the judgment of when to use each, and you have an agent.

What kinds of tools show up in the consumer AI you already use, as of mid-2026?

• Web search and browsing. The agent runs searches, opens pages, and reads them — the engine behind every “Deep Research” feature. It can chase a question across dozens of sources in minutes.
• Reading your files and documents. Upload a folder, a PDF, a spreadsheet; the agent opens and works from them (you saw grounded document work in Chapter 7).
• Your productivity apps. Assistants that connect to your email, calendar, and documents — reading your inbox, drafting replies, finding a meeting time. Google’s assistant reaching into Gmail and Docs, or Microsoft’s reaching into Outlook and Teams, are the mainstream examples.
• Computer use / browser control. The frontier tools can now drive a web browser or a desktop the way you would — moving the pointer, clicking buttons, filling forms. As of mid-2026 this is real but still rough; treat it as a capable, easily-confused new hire, not a reliable robot.
• Writing and running small automations. Even for non-coders, an agent can build a little script to reshape a spreadsheet or rename a batch of files. It writes the code; the machine runs it; you check the result.

Here is the professional’s mental shift. The moment you connect a tool, you have granted a permission. An agent with your email tool can read every email you have. An agent with browser control can click any button you could — including “Confirm purchase” and “Delete.” Connecting a tool is exactly like handing someone your keys: convenient, and only as safe as your judgment about what they may unlock. The first question before you enable any tool is not “can it?” It is “should it be able to, unsupervised?”

Coach’s Note — Notice that tools are also where the privacy stakes live. An agent that reads your inbox to be helpful is also an agent that has read your inbox. Before you point a consumer agent at anything confidential — client data, patient information, the unannounced deal — stop and check Chapter 14 and Appendix C. “It was just being helpful” is not a defense you want to give your compliance officer.

13.4 — Memory: What the Agent Carries From Step to Step

For an agent to work a multi-step task, it has to remember what it already did — otherwise every step starts from scratch and it goes in circles. Memory comes in two flavors, and the difference matters to you.

Short-term (working) memory is the agent’s scratchpad for this one task. As it loops, it keeps notes: the goal, the plan, what each step found, what is left to do. This lives inside the model’s context window — the amount of text it can hold in mind at once, which reached roughly a million tokens on flagship models as of mid-2026 (you met that idea in Chapter 2). Big, but not infinite. On a long task an agent can lose the thread — drop a constraint you set early, or forget a fact it found ten steps ago — simply because the task overran what it could hold. When an agent late in a job “forgets” something you told it at the start, this is usually why.

Long-term memory is what the tool remembers about you across tasks and sessions — your name, your role, your preferences, that you like bullet points and hate exclamation marks. The consumer tools now ship this as a “memory” feature: ChatGPT’s memory, Claude’s projects, Gemini’s saved context. It is genuinely useful — your agent stops re-learning who you are every morning. It is also a quiet accumulation of a profile of you. Two disciplines follow: know how to view and clear what a tool has saved about you, and never let convenience talk you into feeding a long-term memory things that should not persist — a client’s private number, a colleague’s salary, the password you typed once “just so it could help.”

Coach’s Note — Long-term memory is a genuine loyalty feature and a genuine liability in the same breath. The rule is simple: memory is for preferences, not secrets. Teach it that you write in British English and sign off “Best.” Do not teach it anything you would not want surfaced in a future chat you have forgotten you left open. Go find the memory settings in whatever tool you use today — before Chapter 14 makes you.

13.5 — Autonomous Workflows and the Human-in-the-Loop

Now the decision the whole chapter has been circling: how much do you let the agent do without you? This is not one setting; it is a dial, and the professional’s skill is knowing where to set it for a given task.

Picture a ladder of autonomy — you saw a version of this idea threaded through the book, and here is the plain-language rung set for your work:

Most valuable professional work lives at rung 2: the agent does the tedious middle — the searching, the drafting, the collating — and stops at a gate whenever it is about to do something you cannot easily undo. This pause is called a human-in-the-loop approval gate, and it is the single most important control you have. A well-built agent will stop and ask before it sends an email, spends money, deletes anything, books something, or shares a file outside your walls. Your job at that gate is a two-second judgment: should this actually happen? That two seconds is worth more than the twenty minutes the agent saved — because it is the exact moment the machine’s speed meets your accountability.

The dangerous move is to slide the whole dial to rung 3 because gating is annoying. It feels efficient. It is efficient — right up until the agent, working confidently on a wrong turn from step 2, sends forty personalized apology emails to the wrong list, or “cleans up” a folder you needed. Reserve full autonomy for tasks that are reversible, bounded, and low-stakes: sorting your own downloads, tagging your own notes, drafting into a scratch doc. The more irreversible and outward-facing the action, the lower you keep the dial.

There is a hard version of this that is worth naming, because agents make it newly urgent: money movement and anything sent on your behalf must default to a human gate — and, for money, to out-of-band verification. The now-canonical warning is the January 2024 Hong Kong case in which a finance worker at the firm Arup was deceived by a video call full of deepfaked colleagues, including a fake chief financial officer, and paid out roughly US$25.6 million. The lesson generalizes straight to agents: when the action is a payment or an external commitment, “the system told me to” is not enough. A human confirms through a second channel — a known phone number, a code word, a second approver — before value leaves the building. Speed is the agent’s gift; it is never a reason to remove that gate.

Coach’s Note — “Human-in-the-loop” is a slogan until you can say which loop and which human. The loop is the approval gate — the specific moment the agent pauses. The human is you, by name, deciding. If you cannot point at the gate and name the person who owns the decision, you have not designed a workflow; you have just crossed your fingers and called it automation.

13.6 — Personal Agents vs Enterprise Agents

The agent on your phone and the agent your employer is buying are cousins, not twins, and the differences decide what you are allowed to do.

A personal agent is yours. It runs on your accounts — your email, your calendar, your files — and it answers to you alone. Setup is a few clicks; the guardrails are whatever you set (which, honestly, is often none). It is fantastic for the friction of your own day: triaging your inbox, planning your week, doing the research you never have time for. The risk is also all yours. If your personal agent pastes a client’s confidential figures into a consumer tool, there is no corporate safety net; there is just you, and possibly your employer’s policy, which you may have just broken.

An enterprise agent is deployed across an organization, and it is a different animal by design. It comes wrapped in governance: permission controls (which data may it touch), audit logs (every action recorded), approval workflows (who signs off), data agreements (a contract that the vendor will not train on your company’s data), and a named owner accountable for it. Enterprise agents are slower to set up and less freewheeling on purpose — because when an agent acts on behalf of a whole company, “move fast” and “unlogged” are how you end up in front of a regulator.

The professional lesson is not “which is better.” It is know which one you are in, and honor its rules. The most common way a smart employee gets into real trouble in 2026 is by doing personal-agent things — casual, ungated, pasting whatever is handy — with company data that belonged behind the enterprise guardrails. Your organization almost certainly has (or soon will have) a policy about which agent may touch what. Chapter 14 is where we make you write your own; Appendix C is the standing reference.

13.7 — Multi-Agent Systems and “Digital Coworkers”

Here is where it starts to feel like science fiction, so let us keep it plain. If one agent is an intern with a task list, a multi-agent system is a small team: several agents, each with a specialty, coordinated by a “manager” agent that hands out the work and assembles the result.

You have run a version of this with humans. To produce a report, a manager might ask a researcher to gather sources, a writer to draft, and an editor to polish. A multi-agent system does the same with software: an orchestrator breaks the goal into parts and delegates each to a specialist agent — one that is good at searching, one at drafting, one at checking numbers — then stitches their outputs together. The appeal is that a specialist, narrowly focused, often does its slice better than one generalist juggling everything, and the parts can run in parallel.

This is the technology behind the phrase you will hear in every vendor pitch this year: “digital coworkers.” The pitch is that you will soon “manage a team” of AI agents the way you manage people. Some of that is real and already shipping in narrow domains — a research crew that produces a cited report, a support system where one agent triages and another drafts the reply. A lot of it is marketing running ahead of reality; the industry has a wry term for products that claim far more autonomy than they actually deliver, and a fair number of ambitious multi-agent projects quietly stall because coordinating agents is genuinely hard and the errors compound across the team. Treat “digital coworker” as a useful metaphor and a hype flag at the same time.

But sit with the metaphor for a second, because it reframes your career. If the future of work is managing a team of capable, fast, tireless, and occasionally confidently-wrong digital workers, then the scarce human skill is not doing the tasks. It is the manager’s skills: setting a clear goal, delegating to the right specialist, spotting the plausible-but-wrong result, and owning the team’s output when you sign it and send it up the chain. You are not being replaced by the agents. You are being asked to manage them. And a manager, as this week’s Scripture will insist, is precisely the person who has to give an account.

Coach’s Note — The multi-agent future does not abolish the org chart; it puts you higher on it. The uncomfortable news in that promotion is that a manager’s mistakes are bigger than a worker’s, and a manager cannot say “my team did it.” If AI turns every professional into a manager of digital workers, then every professional inherits a manager’s accountability — whether they wanted the promotion or not.

13.8 — Five Agents You Can Actually Meet This Week

Enough theory. Here are five agents a non-technical professional can put to work today, what each is genuinely good at, and the exact place the human must stay in the loop. None of these requires you to write a line of code.

1. The research agent. This is “Deep Research” in ChatGPT, Gemini, Perplexity, or Claude — you give it a question, it browses dozens of sources and returns a structured, cited report in minutes. It is the most immediately useful agent for most professionals and the one that saves the most hours. The human’s job: verify the citations. Deep-research agents can cite real-looking sources that say something other than what the report claims — or that do not exist. Open the links. You built exactly this muscle in Chapter 7; agents make it non-negotiable.

2. The scheduling agent. Connected to your calendar, it finds meeting times, proposes slots, and drafts the invite. Superb at the tedious back-and-forth of “when are we all free?” The human’s job: gate the send and the commitment. Let it find the time; you confirm before it books anything or emails a client a slot you cannot actually make.

3. The email agent. Reads your inbox, triages what matters, drafts replies in your voice. A real dent in the daily email tax. The human’s job: never auto-send. Read every draft before it goes. An email agent that sends on its own is one confident misread away from telling a customer the wrong price in your name.

4. The coding agent. Yes, you — the non-coder. Tools like GitHub Copilot’s coding agent, or an assistant in “build me a small script” mode, can turn “clean up this messy spreadsheet and email me the summary each Monday” into a working little automation. The mainstream ones are deliberately gated — Copilot’s agent opens its work for a human to review and is blocked from protected branches, and its results run through checks before anything ships. The human’s job: review before it runs on anything real, exactly because AI-written automation can be subtly, invisibly wrong.

5. The business-workflow agent. The enterprise animal from 13.6 — an agent wired into your company’s systems to run a repeatable process end to end: intake a request, pull the records, draft the response, route it for approval. Highest leverage, highest stakes, most governed. The human’s job: live at the approval gates and read the audit log. This is where “rung 2, with a named approver” stops being a diagram and becomes your actual Tuesday.

Notice the pattern across all five. In every case the agent eats the tedium — the searching, the scheduling back-and-forth, the first draft, the record-pulling — and in every case the human keeps the consequential decision: the send, the commitment, the recommendation, the sign-off. That is not a coincidence or a limitation of today’s tools. It is the design. The agent is built to be an assistant. You are built to be the one who answers for it.

13.x — Interactive Lab: Agent Step-Tracer

Below this chapter on the website is an interactive panel called the Agent Step-Tracer. Go use it now — it is where today’s abstractions turn into something you can watch move.

The Step-Tracer runs a multi-step agent in front of you, slowly, one move at a time, so you can finally see the plan → act → observe loop from 13.2 instead of just reading about it. Watch it take a goal, break it into steps, reach for a tool on each step, look at what came back, and decide what to do next. The loop stops being a metaphor once you have watched it turn.

Then flip the switch that makes this lab matter: the human-approval gate, which you can toggle on and off.

• Gate ON (rung 2): the agent runs until it reaches a consequential action — sending, spending, deleting — and then it stops and asks you. You approve or deny. Feel how the whole workflow waits on your one decision. That pause is the human-in-the-loop, and you are it.
• Gate OFF (rung 3): the agent runs the whole thing start to finish without you. Fast. Satisfying. And when one of its steps takes a wrong turn, watch the consequence sail straight through with no one to catch it.

Run it both ways on the same task. The lesson is not “gates good, autonomy bad” — autonomy is the right call for the reversible, low-stakes tasks from 13.5. The lesson is felt: the exact spot where the agent’s speed meets your accountability is the approval gate, and the difference between a professional and an accident is whether that gate is there on purpose. Run it until you can predict, before you toggle, which tasks you would ever let run gate-off. That instinct is the whole chapter in your hands.

In BoodleBox — meet the real thing. The Step-Tracer is a simulator; now touch orchestration on the tool Concordia actually pays for. Sign in at box.boodle.ai with your Concordia account and start a chat. Hand the default BoodleBot (@boodlebot, as of 2026) a multi-part goal and watch it orchestrate — delegating slices to specialized bots in a plan → act → observe loop you can read right in the thread. Type @ to pull a specialized Boodle Bot in for one slice, or open a Box — a shared chat that holds several bots and real people — to feel the “digital coworker” team from 13.7 firsthand. And notice the honest limit that keeps the account yours: these bots draft, plan, and research; you are still the hands that send, book, or spend, and the chat itself is your visible log — the same idea as the agent-log. (Exact bot names and menus move; look for the bot picker and the shared-chat control. Off-campus or after your license, the same exercise runs on any public agent mode.)

13.9 — Give an Account of Your Management

Now the week’s question, given its full weight. What does it mean to give an account of your management — when the work was done by an agent you delegated it to?

Jesus tells a strange little story (Luke 16:1–13). A rich man has a manager — in the Greek, an oikonomos, the steward who runs another man’s household and money. Word reaches the owner that the manager has been wasting his possessions, and the owner summons him with the line that anchors our week: “Turn in the account of your management, for you can no longer be manager” (Luke 16:2, ESV). The manager is not asked to do more work. He is asked to account for the work — to hand over the books, to answer for what was done with what belonged to another.

Sit with the shape of that, because it is the shape of your working life in the age of agents. A manager is, by definition, someone who directs work he does not do with his own hands. He delegates. That is the whole job. And the parable’s hinge is that delegation does not dissolve the account. The manager cannot summon his under-servants and say “they handled it — ask them.” The books are demanded of him. The account follows the one who was entrusted, not the ones he handed the tasks to.

This is the exact thing an AI agent tempts you to forget. The agent is the most delegable delegate ever invented — fast, tireless, willing to take any task off your hands. And the whisper that comes with it is: if the agent did it, the agent answers for it. But a tool cannot be summoned to turn in an account. You cannot put an agent in front of the board, the client, the patient, the auditor. The account has no meaning applied to a machine — only a person can be called to answer, because only a person was entrusted. When the work went out under your name, the books are yours. Turn in the account of your management. Not the agent’s. Yours.

Notice, too, that the parable does not condemn delegation or shrewdness. The master actually commends the manager’s prudence in the end (Luke 16:8), and Jesus draws the lesson upward: “One who is faithful in a very little is also faithful in much” (Luke 16:10, ESV). Faithfulness is not refusing to use powerful tools — the servant who buried his talent out of fear was the one condemned in the parable of the talents (Matthew 25). Faithfulness is using them and answering for the use. The agent is a very great “little” placed in your hands. To wield it well — to gate it, verify it, correct it, and own what it produces — is faithful management. To let it run unwatched and then hide behind it when it fails is to be the manager who cannot turn in his books.

The LCMS confession names your daily work a vocation — a calling through which God serves your neighbor through you. The client whose report you signed, the patient whose record you touched, the student whose recommendation you sent — they do not receive the agent. They receive your work, and they are owed a faithful account of it. The agent serves you; you serve them. That order does not reverse because the tool got clever. So the spine rule and the Scripture land on the same spot from two directions: you choose the tool, you own the verdict, because the account was entrusted to you. Delegate the labor freely. You may never delegate the account you will give.

13.10 — Common Pitfalls

Pitfall: Treating an agent like a chatbot and forgetting it has hands. Example: You tell an assistant “reply to Karen about the invoice,” assuming it will draft — and it sends, in your name, a reply built on a number it misread. Fix: Before you use any agent, find out what it can do, not just say. Know where the “act” happens and keep a gate in front of every consequential one. If a mistake could land in someone else’s inbox or account, you are supervising an actor, not reading an answer.

Pitfall: Removing the approval gate because it is annoying. Example: You set your outreach agent to full autonomy to save clicks; a wrong turn early sends forty personalized emails to the wrong contact list. Fix: Reserve gate-off autonomy for tasks that are reversible, bounded, and low-stakes. Anything irreversible or outward-facing — send, spend, delete, share, commit — keeps a human gate. The two seconds you spend approving is cheaper than the afternoon you spend apologizing.

Pitfall: Trusting a research agent’s confident, cited report without opening the citations. Example: A deep-research brief cites a “2025 industry survey” for a headline number; the linked page says nothing of the kind — or does not exist. Fix: Verify citations the way you learned in Chapter 7. Open the links. An agent that browsed forty sources can still misread, misattribute, or invent — and it delivers all three in the same fluent voice.

Pitfall: Feeding confidential or personal data to a personal agent as if it were the enterprise one. Example: You point your consumer assistant at a folder of client files to “summarize the account,” pasting private data into a tool with no data agreement. Fix: Know which agent you are in (13.6). Confidential, client, patient, or student data belongs behind enterprise guardrails — see Chapter 14 and Appendix C. “It was just being helpful” is not a compliance defense.

Pitfall: Letting long-term memory quietly hoard your secrets. Example: Weeks ago you told the tool a client’s private number “so it could help,” and it has faithfully remembered it in a profile you have never reviewed. Fix: Memory is for preferences, not secrets. Learn where each tool stores what it knows about you, review it, and clear what should not persist. Teach it your writing style; never teach it a password.

Pitfall: Laundering accountability through the agent. Example: The board deck has a fabricated statistic. Asked about it, you say “the agent generated that section.” Fix: The account never transfers with the delegation (13.9). Keep an agent-log — code/agent-log-template.txt — that records what you delegated, what it did, where it was wrong, and where you signed off. When your name is on the work, the agent’s confidence is not a defense; your verification is.

Pitfall: Believing the “digital coworker” marketing and over-delegating an unproven multi-agent workflow. Example: You hand an ambitious agent “team” your whole month-end close on the promise that it “works autonomously,” and the compounding errors surface only after the numbers went out. Fix: Treat “digital coworker” as metaphor plus hype flag. Start small, gate heavily, verify the output, and scale autonomy only as the agent earns it on reversible tasks. New delegate, new probation.

13.11 — Reps

The work is in the exercises, and this is where Week 13 gets into your hands. The keyboard is the gym; delegation is a skill you build by actually delegating and then catching the machine, not by reading about it. A preview of what is waiting:

• Name the difference between three real tools — which are chatbots and which are agents — by asking one question: can it act?
• Decompose a real goal with code/task-breakdown.txt, marking each step green / yellow / red before an agent ever runs.
• Run a research agent on a question you care about and fact-check its citations line by line.
• Watch the loop in the Agent Step-Tracer, gate on and gate off, and predict which tasks you would let run unattended.
• Design the approval gates for a task you actually do — and write your own never-delegate list.

This week’s AI policy for reps (Phase 2 — agentic): you will use agents; that is the point. Every rep that uses one ends with an honest one-line AI usage note — what you delegated, where it was wrong, and what you verified — and, where it fits, a line in your agent-log. You are learning to supervise, and supervision that leaves no record is not supervision.

A short Check Your Reps quiz is embedded on this page, right under the chapter. Five questions, straight from what you just read. Take it before you move on.

13.12 — This Week’s Project

Your project is P13 — “Delegate to an Agent,” specified in Project 13. You will take a real, multi-step task from your own work, hand it to an AI agent, and — this is the graded part — supervise the delegation like a manager who will have to give an account of it. You will fill in the task-breakdown worksheet first, run the agent, keep an agent-log of what it did and where it went wrong, verify the output against reality, and produce a final deliverable you are willing to sign.

At a high level: Normal tier delegates one task, logs it honestly, catches the errors, and owns the result. Medium tier compares a gated run to an autonomous one (or two agents head-to-head) and measures what you actually saved. Hard tier is a one-page Delegation Policy — a written judgment about which parts of your recurring work you would ever let an agent do unattended and which must always keep a human gate, defended with the failure mode and the name of who answers. That memo is the part no agent can write for you, and it is where this week’s thesis gets graded.

13.13 — Coach’s Final Word

Here is what I want you to carry out of Week 13. The tool grew hands this year. That is the whole story. For twelve weeks AI could only talk, and the worst it could do was waste your time. This week it can act — search, draft, schedule, send, spend, delete — and in growing hands it did not take your job. It handed you a harder and better one: you are no longer the person doing every task. You are the manager of a fast, tireless, capable, and occasionally confidently-wrong worker who will do exactly what you delegate and answer for none of it.

That promotion is not optional and it is not free. A manager’s mistakes are bigger than a worker’s, and a manager cannot say “my team did it.” Everything durable in this chapter is a manager’s discipline: decompose the goal before you delegate it, draw the autonomy line on purpose, keep the gate in front of anything you cannot undo, verify the output against the real world, and keep the log that lets you give an account. The tools will turn over — half the agent features named here will have new names by the time you read this twice. The discipline will not. Plan, gate, verify, sign. That outlasts every product in the fact brief.

And the steward’s question runs underneath all of it. You will spend the rest of your career directing work you do not do with your own hands, more of it every year, more of it done by machines. Faithfulness is not refusing the tool out of fear — the servant who buried his talent was the one rebuked. Faithfulness is wielding the tool and answering for the wielding. Delegate the labor. Never delegate the account. Turn in the account of your management — and let it be a faithful one.

Now go do the reps. The Step-Tracer is waiting right below this page, the templates are in code/, and Project 13 is where you finally manage a machine and sign the result.

See you on Monday.

Up next: Read the exercises and do all of Week 13’s reps, then build Project 13 — Project P13: Delegate to an Agent. Set up your toolkit from Appendix A, reach for agent modes in the tool directory at Appendix B, keep the guardrails in Appendix C close, and check any unfamiliar term against the Appendix D glossary. Then Chapter 14 — Privacy, Ethics, and Organizational Policy.