Quick answer (TL;DR): Most marketing-ops and RevOps teams get little value from AI because every conversation starts with no memory of the last one. Someone spends the first ten minutes re-explaining the lifecycle stages, the lead-routing rules, which Salesforce fields sync and which don’t. The fix is to give the team’s AI assistant a persistent, external memory: a small set of files the team owns, which the assistant reads at the start of every session and updates at the end. That one change turns AI from a disposable chat into a colleague that knows your stack, your stakeholders and your past decisions. The conversation is disposable; the shared memory is what compounds.
If your team has concluded that AI is “impressive but not much use for real ops work”, this is almost certainly why. It is fixable in an afternoon.
The vending machine pattern (and why it caps your results)
Here is how most ops teams use ChatGPT, Claude, Gemini or Copilot today:
- Open a new chat.
- Paste in a HubSpot workflow export or a Salesforce error and ask a question.
- Get an answer.
- Close the tab.
- Tomorrow, a teammate opens another blank chat that knows nothing, and asks something that assumes context the machine no longer has.
This is the vending machine pattern: insert query, receive snack. It works for one-off formula help and quick drafts. It is also why so many teams plateau at “AI is a faster search engine” and never get to “AI is the most useful member of the ops team.”
The bottleneck isn’t the model. Modern assistants are extremely capable. The bottleneck is that every session starts from zero context, which means your ops lead is the model’s short-term memory, reloaded by hand every morning. They re-explain that “MQL” means something different in HubSpot and in the board deck. They re-paste the routing logic. They remind it that the Marketo-to-Salesforce sync skips records without a company name. By the time the assistant is useful, the time saving has gone.
Why “AI has memory now” doesn’t solve it
Many tools now offer built-in memory, and it helps a little. But it is usually shallow, hard to inspect, tied to one person’s account and not portable across tools. For a team, that is the wrong shape. You want memory that is external, human-readable and owned by the team: something anyone can open, correct and hand to a new hire or a new assistant.
The shift: treat AI like a colleague who has read the runbook
Think about what makes a strong ops hire valuable after their first month. It isn’t raw intelligence. It’s that they don’t need re-onboarding every morning. They know the stack, the field definitions, the sales leader who hates lead reassignment, and the workflow you agreed never to touch without a backup.
The difference between a tool and a colleague is persistent, structured memory, plus the discipline to keep it current.
Stop treating each conversation as the valuable thing. The conversation is cheap. The shared memory of your stack is what’s valuable. Sessions come and go; the memory is what shapes where they go.
Once the team accepts that, the workflow inverts. Instead of cramming context into each chat, you write it down once, store it where the team can reach it, and have the assistant load it at the start of every session.
What “persistent memory” looks like for an ops team
This is not abstract. It’s a shared folder: a handful of living documents in a drive both the team and the assistant can reach. At minimum:
- A standing handoff: the team’s current state of play. What’s live, what shipped this week, what’s blocked, and how the team works with AI.
- A stack map: every system (HubSpot, Marketo, Salesforce, the enrichment tool, the connectors between them), what each one owns, and which is the system of record for which object.
- A stakeholder file: who in sales, finance and marketing leadership consumes which number, who approves changes, and who needs a heads-up before a routing change.
- A glossary: lifecycle stage definitions, field API names, campaign naming conventions, dashboard links. Everything a new hire would ask twice.
- Internal notes: honest observations the team needs but that don’t belong in a stakeholder deck.
Then a folder per recurring unit of ops work, such as workflows, integrations, tickets and reports, with one file per item.
That’s the whole thing. It isn’t a product you buy. It’s a structure the team creates and the assistant maintains alongside you, and it doubles as the runbook you wish the last admin had left.
The two rituals that make it work
A shared memory is inert without a loop around it. Two rituals close the loop:
1. The opening ritual. At the start of every session, the assistant reads the standing handoff and the relevant files before doing anything else. The ten-minute re-explanation disappears, because the assistant rebuilds context from the files rather than from whoever is at the keyboard.
2. The closing ritual. Before the session ends, the assistant writes back what changed (what shipped, what’s pending, what was decided) and timestamps it. Skip this and the next session, or the next teammate, starts from a stale picture.
Read the memory. Feed the memory. Everything else depends on keeping that loop intact.
A concrete before-and-after
Before (vending machine):
“We’re a B2B SaaS company on HubSpot and Salesforce. Our lifecycle stages are… Our routing works like this… The sales VP wants… Last week we decided… Now, about this dedupe project…” (Repeated every session, by every teammate.)
After (colleague):
“Pick up the contact dedupe where we left off.” The assistant reads the memory. It already knows which merge rules were agreed, which records are excluded because they carry open opportunities, who signed off, and what’s left. Then it starts working.
The second version isn’t science fiction. It’s a folder and two habits.
Common objections (answered)
“Isn’t maintaining these files just more work for an already stretched team?” It’s front-loaded work that pays back quickly. The stack map and glossary get written once. After that, the assistant maintains most of the memory as part of the closing ritual. The time saved by never re-explaining your lifecycle model soon outweighs the upkeep.
“Can’t we just keep one very long chat?” It’s better than nothing, but it breaks down fast. Long chats slow down, lose the thread, are hard to search, and can’t be seen by a teammate’s new session. Files are durable, structured and readable by everyone.
“Which AI tool do we need?” Any capable assistant that can read and write files, or that you can paste context into. The method is tool-agnostic. What matters is the structure and the rituals, not the brand.
The payoff
When a team makes this shift, three things happen quickly. Sessions become much more useful. Nobody dreads the setup tax. And the team builds something that outlasts any single person, tool or vendor: a written, current description of how your GTM stack actually works. That turns out to matter a great deal, and it’s where this series ends.
Frequently asked questions
What does it mean to give an ops team’s AI a “memory”? It means keeping a shared set of files that describe your stack, definitions, stakeholders and decisions. The assistant reads them at the start of each session and updates them at the end, so it knows your HubSpot and Salesforce setup instead of starting from zero every time.
Why does AI feel useless for real marketing-ops work? Because each conversation starts with no knowledge of your stack, so someone has to re-explain lifecycle stages, routing and sync rules every session. The capability is there. What’s missing is persistent, structured context plus the habits to maintain it.
Do we need a special tool to do this? No. Any capable AI assistant plus a shared folder of plain documents works. The value is in the file structure and the opening and closing rituals, not in a specific product.
How long does it take to set up? The first files take an afternoon for someone who knows the stack. After that, the assistant maintains most of the memory as part of each session’s closing ritual.
This is Part 1 of The Ops Operating System. Next: the exact file architecture that gives an ops team’s AI a working memory of your stack.
If nobody on your team can write the stack map today, that’s the first thing our GTM Systems Audit produces: a documented picture of what your HubSpot, Marketo and Salesforce setup actually does.