Key takeaways
SOPs fail because they're written once from memory and go stale in months. That's a systems problem, not a discipline one.
Start with the few high-cost processes, onboarding first, not everything at once.
Pull SOPs from the meetings where the work happens, so the doc matches reality and people trust it.
Give each one an owner, update it on the event not the calendar, and let decisions flow from the call into the doc so they reach the team undistorted.
The endgame: one place where context comes together, docs stay current on their own, and an agent flags conflicts before they hit the client.
Most agencies have SOPs. Most of them are out of date.
An agency SOP is just a standard operating procedure: the documented steps for how you run a repeatable job, from onboarding a client to sending a weekly report, so it comes out the same way whoever picks it up. That's the promise, anyway.
The reality is often a little more like this: someone senior loses a week to writing up how onboarding, reporting, and delivery are meant to run, drops it all in a shared drive, and presents the new system at an all-hands. It holds for about a month. Then a client asks for something the doc doesn't cover, someone finds a quicker way, a tool changes, and the process on the ground drifts off from the written one. A quarter later the SOP describes an agency that doesn't exist, and everyone's running on memory again.
The doc's still sitting there. It's just fiction now, and everyone knows it, which is why nobody opens it.
The deeper problem is that the context never stops moving. It moves from the bottom up, when your ICs find a better way and quietly change what they do. And it moves from the top down, when leadership makes a call that has to reach the people doing the work. That call gets passed from manager to lead to IC, and it loses a little something at every step, like a game of telephone. By the time it reaches the person who needs it, it's fuzzy. The SOP that should've caught it? Never touched. Nobody owns that gap, so it just sits there and grows.
So the usual advice, write better SOPs and be more disciplined, misses the point. That's not on your team. You've asked them to keep a second, hand-written copy of their own job up to date forever, on top of doing the job. Of course it rots. If you want SOPs people use, stop writing them from memory and start pulling them from where the work already happens.
The winners scale on systems, not people
This isn't only our take. When we asked agency leaders what separates the agencies pulling ahead in the AI shakeout, the answer kept coming back to one word: systems. Peter Emad of SalesCaptain said he'd "build systems from day one. Repeatable workflows for research, data, content, outreach, reporting, and client delivery," so the agency "isn't dependent on doing everything manually." Hannah Swinkin of Saint Boswell named the payoff: productizing your processes makes "output more predictable and standardized across teammates," which "gives teams more space for the real heavy lifting: strategy and creative thinking."
SOPs are how you build those systems. Which is what makes the state of most agency SOPs a problem: a system you can't keep current isn't a system. It's a document.
SOPs don't rot because your team is lazy
SOPs start out with such enthusiasm: "We're going to note down our process and lock it in so it'll be so much easier going forward." The intention is always good, and for a while they're checked and followed.
But, SOP rot is inevitable. It's too long to read in the moment, so it gets skimmed. It lives in a drive nobody opens, miles from the tools where the work happens. The people following it didn't write it, so they've no stake in it. And nothing keeps it fresh, so every little change stretches the gap until the whole thing's make-believe.
Not one of those is a discipline problem. They all come back to the same thing: an SOP is a one-time snapshot of something that never stops moving. The snapshot ages. The work carries on.
Start with the processes that hurt when they break
You don't need to document everything, and trying to is half the reason these projects die in a spreadsheet. Start where not having a system costs you the most.
For most agencies that's the short list where a missed detail turns into a client problem: onboarding, weekly reporting and status, campaign or project delivery, and the handoffs in between. Onboarding is usually the one to start with. It sets the tone for the whole relationship, and it's where new-client chaos does the most visible damage. Nail that SOP and you've covered the moment clients are watching hardest.
The once-a-year, low-stakes stuff can wait. A living SOP for the ten things you do every week beats a dead binder covering a hundred you barely touch.
Write the SOP from captured context, not from memory
The best record of how you run a process already exists, in the transcript of the meeting where you run it.
Your kickoffs, delivery reviews, and handovers already hold the process, in plain language, with the exceptions and judgment calls that a from-memory doc always omits. So take it from there. With Supernormal taking notes in the background of those calls, no bot on the invite, its AI agent can turn that onboarding call into a first-draft onboarding SOP, one prompt away and ready for you to shape. You're editing something grounded in what happened, not sweating a blank template trying to remember step seven.
One version describes the ideal. The other describes the job. People follow the one they recognize.
Keep it short enough to use mid-task
If it's too long to read while you work, it won't get read. Aim for the least you need to let a capable colleague run the process without pinging you.
Give it a title that names the process, a one-line note on when to use it, an owner, and the date it was last updated. Then the steps in order, with the decision points and handoffs flagged, since that's where things go wrong. Link out to the templates, folders, and tools instead of pasting them in. Cut the padding. If a step needs a paragraph of why, that's a training note, not a step.
Don't underrate the last-updated date. It's the quickest read on whether an SOP can be trusted, and the first thing anyone checks before they'll follow it.
Who owns updates, and how do they reach the team?
This is where most SOP systems fall over, so say it out loud instead of hoping. Four questions decide whether an SOP stays true.
Who owns it
Every SOP gets a named owner, usually whoever runs the process. But owning isn't writing. Their job is to review and sign off a change, not to remember to write it up from scratch, because that's the bit that never happens.
How often
On the event, not the calendar. It should change the moment the process changes, which is nearly always a specific conversation: the leadership call where a decision lands, the retro where you agree a new step, the client call where scope moves. A quarterly review is a safety net, not the plan.
How changes reach people
This is the Telephone problem, and it's the one that matters. Instead of a decision getting watered down as it's passed along from memory, catch it at the source. If the leadership call where it's decided is already being turned into notes, one prompt turns that decision into an updated draft of the SOP, in the words it was said, ready for the owner to approve. The doc becomes the channel, so the message stops getting mangled on the way down.
How it's enforced
You can't enforce your way to people following an SOP, which is why "be more disciplined" never works. What you can do is kill every excuse to ignore it: keep it up to date, keep it short, keep it where people already work. They'll follow it once it's worth following. Accuracy is the enforcement.
When someone leaves, the process shouldn't go with them
Every agency runs on knowledge that lives in people's heads and never lands in a doc. Shared knowledge, institutional knowledge, the how-we-do-it-here a new hire soaks up over months and a leaver takes with them. And it doesn't only leak when someone resigns. A client pauses and comes back to a different team. An account moves from one consultant to the next. Someone writes a process up the week before they go, in a hurry, badly. Each of those is a moment the agency loses a piece of what it knows, and it shows up in revenue: AgencyAnalytics' 2026 benchmark ties 24% of client churn to misaligned expectations at onboarding, the kind of gap that opens when the knowledge didn't carry over.
The classic fix, a panicked documentation sprint in someone's last two weeks, produces exactly the rushed, idealized SOPs that rot fastest. Better to capture as you go, so it's written down long before anyone hands in their notice. When the meetings where work happens are already becoming living docs, an exit is a handover of context you already have, not a dig through someone's inbox. The knowledge stays with the agency instead of walking out with the person.
Beyond fresh SOPs: a system that catches conflicts
Fresh SOPs are table stakes, and a better template won't get you there. A template still leaves the updating to you, and updating by hand is the part that breaks. What holds up is documentation that stays current from the work: one place where context from every stream lands together, client calls, internal decisions, project updates, the threads where decisions get made. Once it's in one place, updating the docs that depend on it is a prompt, not a project: you refresh the SOP from the meeting where the change happened, instead of waiting on someone to remember to reconcile it. That's a single source of truth in the plainest sense: the agency's shared knowledge, its IP, held in one place instead of scattered across inboxes, drives, and people's memory, building up over time instead of leaking away every time someone leaves.
The bigger prize is where this is heading. With the context in one place, an agent can watch for conflict: a decision in this morning's leadership call that cuts against a documented process, a new client promise that collides with a timeline you already agreed, two workstreams heading for the same person in the same week. It flags the clash while it's still cheap to fix, so you deal with it before the client ever feels it. That's the jump from documentation that records what happened to a system that guards the work while it's happening.
There's a bigger shift forming behind that. As agents get more capable, the goal moves from a doc a person can follow to an instruction an agent can run the same way every time: no lost links, no skipped steps, no retraining a new hire, no one leaving with the process in their head. That's still the direction, not where the product is today, but the groundwork is identical: get the process out of people's heads and into one place that stays current.
From conversation to SOP
Writing up how your agency works shouldn't mean losing a week to write fiction. Supernormal takes notes in the background of the calls where your processes run, then its AI agent turns them into drafts you review and send, from onboarding SOPs to status updates to project docs. You keep the judgment. You skip the blank page. Start with the Supernormal notetaker, and have a look at how agencies manage projects with an AI agent and what a strong client kickoff looks like.
