You've been using CoWork.
You've built at least one agent,
maybe a few, and they kind of work. But if you're honest,
they all don't work the way you thought they would when you first set them up. And there's at least one agent you built, ran twice,
and quietly stopped using.
That's not a co work problem,
that's a setup problem.
And it's the same setup problem I had in my own workspace
when I first started.
I'm a university instructor.
One of my courses is writing,
and a couple of semesters ago, I built an AI grading system to handle part of the routine grading. I do the teaching, it lends a hand grading.
But it was a mess at first.
The AI kept hallucinating
features
that no longer existed on the platform.
I had to screenshot my own screen to prove I was correct.
And I almost quit several times.
But at one point,
I realized the problem wasn't the AI.
It was me. I was giving it a job without a real job description.
I was asking it to work right without telling it what looked right
and I hadn't told it what to do when it wasn't sure,
So it guessed.
The guesses were confident
and wrong. Once I fixed three things,
it worked.
Not perfectly,
about 85 to 90%
of the time.
But it's been solidly running
ever since
with little intervention
from me.
The same three things that were missing from the grading system are missing from most co work agents I've seen. And in this video,
I'm going to show you exactly what they are. And by the end of this video,
you'll know exactly what to do about it. Let me start with what a well built agent actually looks like versus
what most people actually have
because the gap is actually
more specific than you think.
Most agents are built the same way. Someone opened co work, created a new project, wrote a few lines of instructions at the top, and then started using it. Co What they ended up with is a vending machine.
You put something in, you get something back. Here's what each of the three things actually look like.
The first one is job clarity,
not prompt clarity,
job clarity,
and they're really quite different.
A prompt tells the AI what to do this time. A job description
tells the AI what it's actually responsible
for, what good looks like,
what mistakes to avoid,
and how to handle the edge cases you haven't thought to prompt it on yet. Your co work agents need the same thing. Here's an example of my morning brief agent.
I wrote, pull news from these five sources,
summarize each item in exactly two sentences.
The first sentence states what happened. The second states why it matters to a nontechnical
professional.
Flag anything relevant to AI workflow,
productivity tools,
or education technology.
Do not flag product launches
unless they're from a company with more than 10,000,000 users.
If there's nothing worth reporting on a given day, say so.
That level of specificity
separates an agent
that gives you information
that it thinks you want
versus what you really need. And here's the thing, you already know how to do this. You've been delegating work to people for years.
You tell them what good looks like, what to watch out for, and how to handle the exceptions.
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.
That's job clarity.
The second thing most people never build is a context anchor.
The context here
is that every session you use in co work starts with co work knowing your instructions,
but not really knowing who you are.
It doesn't know your voice unless you've told it your voice.
It doesn't know your audience
unless you've described your audience.
It doesn't know what you've already covered,
what you're looking toward,
what you care about,
or what your non negotiables are.
Here's what this looks like in practice.
Before building this,
my LinkedIn agent
created content that was technically fine,
but it really didn't sound like me
as of course you would expect.
A context anchor fixes that. It's a file. I call mine claud dot m d that loads automatically
in the background
every time I open any session within this project.
It contains everything any AI needs to do my specific work.
If you don't have a file like this in your workspace,
that's the single highest leverage thing you can build today.
The third thing,
and this is really the one most people are surprised about,
is a failure protocol.
Most agents are built to succeed.
Almost zero are built to fail gracefully.
When your morning brief agent, for example, can't find anything worth reporting, what does it do? When your research agent hits a paywall and can't pull a source.
When your LinkedIn agent gets content that's too vague to work with, if you haven't told it what to do in those situations,
it will do something.
It will guess.
That's where the inconsistency
comes from.
Not from the agent failing,
from the agent succeeding
in the wrong thing. A failure protocol
is just a set of instructions
for what to do when the job can't be done as specified.
I'll give you a concrete example.
My weekly research brief has a fallback instruction
that says,
if fewer than three credible sources are found on a given topic, do not synthesize
from weak sources.
Instead,
flag that topic as low coverage for this week and move on.
The failure protocol
didn't make the agent smarter,
it made it honest.
And that is infinitely more useful
than one that produces
confident sounding garbage.
Now, before we continue,
if you found this video useful so far, please give it a like or comment.
It really helps the channel. Also, subscribe
if you would like to see more content like this.
Here's what my workspace looks like now.
Several agents.
Each one has a real job description, draws from my Claude dot m d file, and has fallback instructions.
That's the setup.
So here's what to do next.
Open whatever agent you want to improve,
tell Claude what it's supposed to do, and ask it to help you write a proper job description.
Something like this. This agent is supposed to do x for me every week, help me write a job description
that includes what good output looks like, what to avoid, and what to do if it can't complete the task.
That last part, what to do if it can't complete the task,
is your failure protocol.
You're not building it separately,
you're building it into the job itself.
You'll have a real instruction set including the fallbacks
in about ten minutes
and you can paste it straight back into the agent.
If you want to build the context anchor I mentioned, the file that loads every time and makes every agent in your workspace
smarter by default,
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.
And if you're still in the early stages of co work and not sure exactly what you should build first,
I've got a video that covers exactly that.
Click this video here to see what it is.