The argument in one line.
AI agents do not fail because the AI is bad -- they fail because most people give the AI a task without a job description, no context about who they are, and no instructions for what to do when things go wrong.
Read if. Skip if.
- You have set up at least one Claude CoWork agent and found that it works inconsistently or stopped using it after a few runs.
- You write prompts but have not written a standing job description with quality standards, edge-case rules, and fallback behavior.
- You want your agents to sound like you and reflect your voice, audience, and non-negotiables without re-explaining every session.
- You are a solo creator, educator, or professional using CoWork for recurring tasks like research briefs, content drafts, or morning summaries.
- You are building multi-agent pipelines or API-integrated systems -- this video targets the CoWork project-based interface, not code-level agent orchestration.
- You are brand new to CoWork and have not yet built your first agent -- there is a beginner video linked at the end that covers that ground first.
The full version, fast.
When an AI agent produces inconsistent or useless output, the root cause is almost never the model -- it is underspecified instructions. This video names three fixes: replace thin prompts with a proper job description that defines what good looks like and what to avoid; add a context anchor file that loads your voice, audience, and non-negotiables into every session automatically; and write a failure protocol that tells the agent exactly what to do when it cannot complete the task as specified. All three can be drafted with Claude's help in about ten minutes.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · Hook -- the quiet quitter agent
Addresses CoWork users directly: you built agents that kind of work but stopped using at least one of them. Frames this as a setup problem, not a CoWork problem.

02 · Origin story -- the broken grading system
University instructor built an AI grading assistant that hallucinated features that no longer existed. Root cause: gave the AI a job without a job description.

03 · Preview -- three missing components
Sets up the three-part structure. Frames the vending machine vs. real agent contrast.

04 · #1 Job Clarity
Distinguishes prompt (do this this time) from job description (responsibility, quality standard, edge cases). Shows a real morning brief agent instruction set with source list, format rules, topic thresholds, and null-state behavior.

05 · #2 Context Anchor
Every session starts knowing agent instructions but not who the user is. A claude.md file loaded automatically carries voice, audience, frameworks, and non-negotiables into every session.

06 · #3 Failure Protocol
Agents built only to succeed will guess when they hit edge cases -- confidently and wrongly. A failure protocol is fallback instructions built into the job description itself.

07 · Action step -- build all three with Claude
Shows the exact prompt template to ask Claude to write a job description including failure protocol. Workspace overview: several agents, each with job description plus claude.md plus fallbacks.

08 · CTA -- Portable AI Working Identity guide
Free guide for building the context anchor file. Final watch-next card.
Lines worth screenshotting.
- The agent that stopped working after two runs was not broken -- it was under-instructed, and it was guessing.
- A prompt tells the AI what to do this time. A job description tells it what it is responsible for, what good looks like, and how to handle the exceptions.
- Confident wrong answers are worse than honest admissions of uncertainty -- build the failure protocol before the agent ships.
- Every CoWork session starts knowing the agent instructions but not knowing who you are -- your voice, your audience, your non-negotiables are invisible unless you file them.
- A context anchor loaded automatically into every project session is the single highest-leverage thing a CoWork user can build.
- Agent inconsistency does not come from the agent failing -- it comes from the agent succeeding at the wrong thing because no one defined the wrong thing.
- Adding a null-state instruction is one extra line and prevents the agent from fabricating content to fill a gap.
- Briefing an AI agent is identical to briefing a new hire for a recurring weekly job they will do without supervision -- same mental model, same information required.
- A failure protocol does not make an agent smarter -- it makes it honest, which is more useful than confident-sounding garbage.
- The job description and the failure protocol are not separate documents -- the failure conditions are clauses inside the job itself.
Three things every recurring agent needs.
An AI agent that guesses is not failing -- it is succeeding at something you never defined, which is why the fix is never about the model and always about the instructions.
- A prompt and a job description are not the same thing: a prompt covers one session, a job description covers every session, including the edge cases you have not thought of yet.
- Specificity in agent instructions is not pedantry -- it is the only way to close the gap between what the AI thinks you want and what you actually need.
- A context anchor file is not a memory hack; it is the answer to why your agent sounds generic even when the output is technically correct.
- Failure conditions should be defined before the agent runs, not discovered after it hallucinates three weeks in a row.
- The right prompt template for building a job description with failure protocol built in: say the agent is supposed to do X for you every week, then ask Claude to help write a job description that includes what good output looks like, what to avoid, and what to do if it cannot complete the task.
Terms worth knowing.
- CoWork
- Anthropic's Claude.ai Projects interface, which allows users to configure persistent AI agents with standing instructions that activate on every new session within a project.
- Job description (agent)
- A standing instruction set that defines what an agent is responsible for, what good output looks like, what mistakes to avoid, and how to handle edge cases -- distinct from a one-off prompt.
- Context anchor
- A persistent file loaded automatically into every project session, containing the user's voice, audience, frameworks, and non-negotiables so the agent does not start from zero each time.
- Failure protocol
- Explicit fallback instructions embedded in an agent's job description that specify what to do when the task cannot be completed as specified -- flag it, ask for clarification, or produce a partial output with a label.
- Null-state instruction
- A clause that tells the agent what to do when the expected input or output does not exist -- for example, if nothing is worth reporting today, say so instead of fabricating content.
Lines you could clip.
“I was giving it a job without a real job description.”
“The guesses were confident and wrong.”
“Write your agent instructions the way you'd brief a new hire on a job they're going to do every week without you watching.”
“The failure protocol didn't make the agent smarter, it made it honest.”
“Not from the agent failing, from the agent succeeding in the wrong thing.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
You built the agent. You ran it twice. Then you quietly stopped. The video opens by naming that specific embarrassment -- not as a criticism, but as a diagnosis -- before a university instructor who once had the same problem explains the three-part fix he found.
Named ideas worth stealing.
The Three Missing Components
- Job Clarity
- Context Anchor
- Failure Protocol
Three structural elements that distinguish a reliable recurring agent from a vending machine that produces inconsistent output.
Job Description vs. Prompt
A prompt is a one-time instruction. A job description is standing guidance: what the agent is responsible for, what good looks like, what to avoid, and how to handle exceptions. Same mental model as briefing a new hire.
Failure Protocol
Embedded fallback instructions that define what the agent does when it cannot complete the task as specified. Prevents confident fabrication. Three options shown: flag and stop, ask for clarification, produce partial output with a label.
How they asked for the click.
“I've put together a free guide that walks you through exactly how to do that. It's called the Portable AI Working Identity. Link is in the description.”
Clean soft sell after the content is fully delivered. No urgency language. The guide name (Portable AI Working Identity) is specific enough to feel like a real product.








































































