Good Morning Lucy

What working with AI agents in production has taught me about memory.

I've been doing the AI-agent equivalent of 50 First Dates for two years.

If you saw the movie: Adam Sandler is in love with Drew Barrymore. Drew has short-term amnesia. Every morning she wakes up with no memory of him. Every morning he has to make her fall in love with him again. He builds her a videotape. He labels the cassette "Good Morning Lucy." She plays it the moment she wakes up. The tape gently catches her up on her life, shows her their wedding, asks her to come downstairs for breakfast when she's ready.

That is what running AI agents in production actually looks like.

The misconception

Most people's AI experience is a chatbot. ChatGPT, Claude, Gemini. You open it on your phone. It greets you. It knows your name, your projects, the tone you like. It remembers that you're working on a deck, that you have two kids, that you don't want lists of three. After a few months of using it, the relationship feels real. The AI remembers you.

So when someone says "AI agents in production," people who use AI this way assume agents work the same way. They picture the same thing scaled up. A useful assistant that knows them, but doing more things.

That isn't what production AI looks like at all.

Why it's not the same thing

A chatbot you use as a person is a single agent that persists across sessions. The platform stores a memory layer for you. That memory layer is a feature, not a default. It exists because the consumer product team built it, and it's thin. A few hundred facts about you, surfaced when relevant.

Production AI agents are different. They run jobs. They send emails for you, manage your inbox, post to your social, process leads, draft proposals, audit your books, deploy your website. Each agent is a separate process. Each new session is a blank slate. There is no memory layer by default. Every "morning," the agent wakes up with no idea who you are, what you do, or what it's supposed to be doing.

Building memory for those agents is the central engineering problem of running AI in production. Most people who say they "use AI" don't know that problem exists, because their chatbot solved it for them invisibly.

What it actually feels like

Three examples from a recent week.

My email triage agent drafted a reply to a long-time client without realizing they were a long-time client. The voice was fine. The content was fine. The opening line was "Thanks for reaching out." The line you write to a stranger. The agent didn't know we'd been working together for years because nobody told it that morning.

My outbound sales agent sent a follow-up to a prospect we already serve. We were pitching her one of our service lines. She owns the company that buys another one of our service lines. The agent had no memory of the client list because the spawn that morning didn't load it.

My LinkedIn post agent drafted a post that contradicted a positioning decision I locked three days earlier with a different agent. The decision lived in one wiki page. The agent that wrote the post didn't read that page.

In each case the agent did good work. The output was clean. The voice was right. The mechanics were right. The agent just didn't know the one fact that would have made the difference between "useful" and "embarrassing."

The system you build for it

For two years I've been building a Good Morning Lucy tape for each of my agents. Mine looks like this.

Every agent has a memory directory. Its own Good Morning Lucy tape. The agent reads it on every spawn. It contains the user profile, the project state, the active feedback, the rules of the road.

Every agent has a Status file in a shared wiki. Other agents read each other's status files. The fleet has a rough sense of what's happening across the floor.

Every project has a Brand Context document. Voice rules, never-say list, audience archetypes, recent decisions. Every agent that touches public-facing content reads it before writing anything.

Every session starts with a system-prompt load that is essentially a love letter. Who I am, what I'm working on, what I care about, what I just shipped, who I just heard from. That prompt grows. It now runs to several thousand words.

Every cross-agent decision posts to a shared bus. Linear issues. Discord channels. Wiki entries. The fleet learns about itself by reading itself.

When a session approaches its context limit, a compaction runs that distills the conversation into a summary the next session reads. The agent's daily memory rolls forward by hand-off.

The whole stack is the answer to one question. How does an agent that wakes up blank become useful within thirty seconds of waking.

What it costs

A lot of tokens. The system-prompt load alone is meaningful spend at every session. Add the wiki reads, the status checks, the Brand Context, the memory directory, the cross-agent comms, and a typical session burns the price of a sandwich before it does any actual work.

A lot of discipline. Memory files have to be maintained or they go stale. Decisions have to be written down or they evaporate. Voice rules have to be enforced or they drift. The system rewards the operator who treats agent memory as a first-class artifact and punishes the operator who doesn't.

A lot of taste. The wrong context loaded at the wrong moment is worse than no context. An agent that thinks it knows you when it doesn't is more dangerous than an agent that admits it doesn't. The art is figuring out what the agent actually needs to remember this time, versus the noise that just consumes tokens.

When it works

When context loads cleanly, the agent is your trusted colleague.

Last Tuesday my email agent caught a tonal mismatch in a draft I was about to send to a client. Not because the agent is smarter than me. Because the agent had been briefed that morning on a memory note I wrote three weeks ago about that specific client's preference for short replies. I forgot. The agent didn't, because the agent read its memory file before reading the email.

That moment, repeated across a dozen agents and a few hundred decisions a week, is what production AI actually feels like. It isn't magic. It isn't an assistant that knows you. It is a careful, expensive, ongoing act of building memory for systems that can't build it for themselves.

The close

If your AI remembers you, you haven't met the AI that does the work.

The remembering is what we build.