Project P13 — Delegate to an Agent

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

Chapter: 13 — AI Agents and the Future of Work Due: End of Week 13 Submit: A link to a shared folder (Google Drive / OneDrive / Dropbox) or a single combined PDF. Non-technical — no GitHub, no code. See Appendix A. Allowed tools: Any consumer AI agent or “agent mode” you can access — e.g., a general assistant’s agent/tasks mode, a research agent, a scheduling assistant. A plain chatbot doing one step at a time also works if that’s what you have; document what you used. (Tool reference: Appendix B.) AI policy — Phase 2 (agentic AI is ON): This week you delegate multi-step work to an agent. An agent-log is REQUIRED — every task you handed off, what the agent did, where it went wrong, and where you intervened. The agent does the steps; you own the outcome. Keep everything non-confidential — do not let an agent act on real accounts, real money, or real client data. Read Appendix C before you grant any tool access to anything.

The Setup

Meet Sam Whitfield, owner of Trellis & Co., a six-person boutique event-planning firm. Sam just heard the word “agent” and imagined a robot employee who could take a whole project off his plate. That’s half right and half dangerous. An agent can plan and execute a multi-step task — but the moment it acts on Sam’s behalf, Sam still answers for what it does. If the agent books the wrong venue or emails the wrong client, “the AI did it” is not a defense a business owner gets to give.

This week you’ll delegate a real (safe, fictional) multi-step task to an agent, watch it work, and keep the log that makes delegation accountable instead of reckless. The lesson of the week is the oldest one in management: you can delegate the work, but you cannot delegate the account you’ll give for it.

Setup (the starter)

This chapter ships two starter files in code/:

• code/task-breakdown.txt — a worksheet for decomposing a goal into the steps an agent will take, and marking which steps need a human approval gate before the agent acts.
• code/agent-log-template.txt — the log you’ll keep: for each step, what you delegated, what the agent did, whether it was right, and what you did about it.

Copy both into your project folder.

Learning Targets

You will demonstrate that you can:

• Decompose a goal into agent-sized steps and identify which need human approval.
• Delegate to an agent and follow a multi-step task through to completion.
• Keep an honest agent-log — including where the agent failed, which it will.
• Set the approval gates — decide which actions the agent may take freely and which require your sign-off first.
• Own the outcome — review the final result as the accountable human and correct what’s wrong.

Normal Tier

Goal: Delegate one real multi-step task to an agent, keep a complete log, gate the risky steps, and own the final result.

Required features

Produce a folder named p13-delegate containing:

1. task-plan.docx — the decomposition. Pick a safe, multi-step task (e.g., “research and draft a comparison of three fictional caterers for a client event,” “plan a two-day team offsite agenda from a set of constraints,” “compile and summarize public information on a topic into a briefing”). Using code/task-breakdown.txt, break it into steps and mark each: agent-free (safe to do without asking) or gated (needs your approval before acting).
2. agent-log.txt — the required record. Using code/agent-log-template.txt, log the run step by step: what you delegated, what the agent actually did, whether it was correct, and every point where you intervened, corrected, or re-directed it. Be honest about failures — a log with no problems is a log you didn’t really keep.
3. The intervention highlights. Call out at least two specific moments where your judgment changed the outcome — the agent went down a wrong path, misread the goal, invented a “fact,” or was about to take an action it shouldn’t. Explain what you caught and why.
4. result.docx — the owned deliverable. The final output of the task, reviewed and corrected by you, with a one-line statement: “I reviewed this; I am accountable for it.”
5. Agent vs. chatbot reflection. Half a page: how was delegating to an agent different from a normal chat? Where did the multi-step autonomy genuinely help, and where did it add risk?
6. Honest AI usage note.

Normal-tier rubric (out of 100)

Medium Tier (+up to 25% extra credit)

Pick one or more:

1. Gate vs. no-gate. Run a version of the task with a human-approval gate on the risky step, and imagine (or safely test) the ungated version. What could have gone wrong without the gate?
2. Two agents, one task. Try the same task with two different agents/tools and compare how they planned and where each failed.
3. The memory test. Give the agent information early and see whether it remembers and uses it later in the task. Note where its “memory” held and where it dropped the thread.

Hard Tier (+up to 25% additional extra credit)

This is the judgment the machine cannot make for you.

Write delegation-policy.docx — a one-page policy for Trellis & Co. answering: which tasks may Sam’s team delegate to an agent, which actions must always be gated behind a human, and which may never be delegated at all? You must:

• Sort real tasks into three buckets: agent-can-run, agent-proposes-human-approves, and human-only.
• Use the deciding factors you learned: reversibility, blast radius, whether real money/people/data are touched, and how hard the result is to verify.
• Name who’s accountable when an agent acts — a role, by name.
• Ground it in the spine rule and this week’s verse — delegation moves the work, never the account.

A policy that says “let the agent handle everything” fails — you just logged an agent failing. One that says “never use agents” wastes the tool. The grade is in drawing the line where the stakes actually change.

Submission

One shared folder or a combined PDF; submit the link per Appendix A:

p13-delegate/
  task-plan.docx
  agent-log.txt          — REQUIRED
  result.docx            — the owned final deliverable
  reflection.docx        — agent vs. chatbot + intervention highlights
  delegation-policy.docx (Hard tier)

Never point an agent at real email, real calendars with private events, real money, or real client data for this project. Keep the whole task fictional and self-contained. Appendix C covers what you must not expose.

Hints (Read Before You Begin)

• Pick a task with real steps, but no real stakes. You want multi-step complexity you can safely let an agent run — research, drafting, planning — not anything that touches a live account.
• Keep the log as you go, not after. Reconstructed logs are fiction. Write down interventions the moment they happen.
• Expect a failure — welcome it. The agent will misstep somewhere. That moment is the most valuable thing in your submission, not a blemish on it.
• Gate anything irreversible. If an action can’t be easily undone, it needs your approval before the agent takes it. Full stop.

What Mastery Looks Like (Beyond the Rubric)

A mastery submission reads like a manager who knows how to delegate and supervise. Your task plan gates the right steps. Your agent-log is honest about where the agent stumbled and shows exactly where your judgment saved the outcome. Your final deliverable is owned, not just accepted. And your Hard-tier policy draws a line Sam could actually run a business on — bold where it’s safe, firm where the stakes are real. The agent did the steps. You did the managing. That’s the whole point.

Coach’s Note — The fantasy this week is a robot that takes the whole job. The reality is better and harder: an agent is a capable, tireless, sometimes-wrong junior who works at superhuman speed and has zero accountability — because a machine cannot be held to account. That means all of the accountability stays with you. That’s not a burden to resent; it’s the thing that makes you necessary. Delegate freely. Supervise honestly. Sign the result.

When You’re Done (a short checklist)

• Task decomposed; each step marked agent-free or gated.
• Complete, honest agent-log.txt covering the full run, including failures.
• Two+ intervention moments identified and explained.
• Final deliverable reviewed, corrected, and explicitly owned.
• Agent-vs-chatbot reflection is concrete.
• Honest AI usage note; nothing real touched.
• (Hard) delegation-policy.docx sorts tasks and names accountability.

A theological footnote. In Jesus’ parable, the manager is summoned with a line that should sober anyone who delegates: “Turn in the account of your management.” The steward had authority to act on his master’s behalf — real power to transact and decide — but that authority came with a reckoning. He would answer for what was done in his charge. An AI agent is the inverse: it has the capacity to act but bears no reckoning, because it cannot give an account of anything. So the account does not disappear when you delegate — it lands entirely on you, the one who can answer. That is why the agent-log exists, and why the approval gate matters. To delegate the work is wise stewardship; to imagine you have delegated the responsibility is to misunderstand what a steward is. You will be asked to give an account. Keep the log, so you can.

See you next week.