first_hand_story

My AI Marketing Agent Wrote The Same Thing Four Times. More Memory Made It Worse.

August 31, 2026 · 12 min read · Scout7

A first-hand story on why AI marketing agents repeat themselves, and the 10-minute blocklist fix that improves output fast.

My AI Marketing Agent Wrote The Same Thing Four Times. More Memory Made It Worse.

Deck: A first-hand story about diagnosing repetitive output and turning AI agent memory into a human-kept argument blocklist.

Introduction

Four articles. Four different headlines. Four different sets of examples. One argument, repeated four times.

I did not notice for four days, and there was nothing to notice. My AI marketing agent ran on schedule, errored on nothing, and produced a competent piece every morning. I read each one on the day it arrived and thought it was fine. It was only when I opened four of them next to each other that I saw it.

Everything I read told me the fix was memory. Give the agent a record of what it has already done, so it stops covering old ground. That advice is correct about a different problem, and following it here would have made mine worse. There is research that explains why.

Here is the short version, if you want it now. Your agent repeats itself because the model converges on the most probable answer, and a memory file written as background reading pulls it there faster. The fix is not more memory. It is the same file, rewritten as a list of arguments the agent is not allowed to use again.

Putting an agent on a schedule stopped being unusual very recently. Anthropic now ships scheduled and webhook triggered runs that keep working with no device online, alongside a file based memory tool and context editing. Google's A2A protocol joined the Linux Foundation's Agentic AI Foundation on 2026-08-20, under the same governance as MCP. So a lot of people set one running in the last few months.

If you build things on your own and put an agent on a schedule so you would not have to post every day, this is the failure to look for. It does not announce itself. Nothing errors, nothing stops, and the output stays competent the whole time.

Here is how to check, and what actually fixed it.

The Day I Saw Four Different Headlines Say One Thing

I run a content agent on a daily schedule against my own site. It has no memory of the previous run by design. Every run starts blank, researches from scratch, and writes.

Read one at a time, as they arrived, the pieces looked fine. Each had a headline I had not seen before. Each cited material the last one did not. Each made a case.

I only saw it when I put four of them on the screen together. Four runs in a row had reached the same conclusion. The research had genuinely gone out and found new material every time. Every time, the new material got folded back into the argument the model finds most probable for that brand.

That is the part worth sitting with. Nothing failed. The agent ran on time and errored on nothing. Every individual piece was publishable on its own. I had asked it to say something new each day, and it was doing something slightly different. It was saying something plausible each day. From the outside those two look identical.

And the way you read the output guarantees you will miss it. You read each piece once, alone, on the day it lands. Sameness is invisible one piece at a time. It only shows up side by side, and nothing in an automated workflow ever puts your own pieces side by side.

That is the whole reason this can run for weeks in the open without anyone catching it.

Memory Is Useful. Your Setup Is What Narrows It.

Memory is not the villain here, and this is not an argument against it. It fixes a real failure, and it fixes it well.

Long running agents work in discrete sessions, and each new session begins with no memory of what came before. That is Anthropic's own description of the problem in their guide to effective harnesses for long-running agents. The everyday version is easy to picture. A monitoring agent on a thirty minute cron kept firing the same alert about the same stale pull request all day, because every run began blank. The person who wrote that up fixed it by having the agent recall what it had already reported before it acted. That worked completely.

Anthropic publish numbers for this. Read them as a direction rather than as independent proof, because they are their own numbers about their own product on their own internal evaluation. In their context management announcement, the memory tool combined with context editing improved performance by 39 percent over baseline on an internal agentic search evaluation. Context editing alone gave 29 percent. On a 100 turn web search evaluation, token use dropped by 84 percent.

That is real value. It also solves a different problem from the one I had.

One symptom hides two failures.

The first is the agent redoing work it already did. Memory fixes that.

The second is the agent reaching the same conclusion it reached last time. Memory cannot touch that, because memory records what the agent said. It has no effect on what the agent will think.

The second failure is a property of the model, not of your setup. A paper called Artificial Hivemind, published at NeurIPS 2025, tested more than 70 models against 26,000 open ended questions. In 79 percent of cases, repeated answers to the same prompt were on average more than 0.8 similar to one another. Those runs used top-p 0.9 and temperature 1.0, which are the settings you reach for when you want variety.

The paper names two effects and both land on you. Intra-model repetition means your agent keeps agreeing with itself. Inter-model homogeneity means different models converge on the same answers too. Give that second one a moment, because moving to another provider is the first thing most people try.

Now the part that changed my mind.

The standard way to wire memory in is to summarise what the agent produced last time, paste that summary into the next run as context, and tell it to build on that. Every move in that sentence narrows the output.

A paper called The Price of Format, in the EMNLP 2025 findings, showed that structured templates cause a collapse in diversity on open ended tasks, and that the collapse holds even at high temperature. Plain prompts with no structure produced the most varied output, and even light structure cut it noticeably.

So the tidy brief you wrote for your agent is already pulling it inward. Then you hand it a summary of its own best previous answer, which is now the most relevant text in the window, and ask it to try again.

Nothing is broken. That is memory working exactly as designed, pointed at a job it was never going to do.

Run The 10-Minute Audit Before You Change Anything

Before you change anything, prove it to yourself. This takes about ten minutes and needs no tool.

Open the last four or five things your agent produced.

Ignore every headline. Ignore every example. Those are the parts that change on every run, and they are exactly what fooled me.

For each piece, write one sentence naming the single argument it makes. Write all of the sentences before you compare any of them. That order matters more than it sounds. If you read the pieces together first, you will unconsciously write four different sentences about one idea, and the test will pass when it should not.

Now read your sentences on their own, next to each other.

If any two could swap places without either piece changing, you have shipped the same piece twice.

Most people find it on the first attempt. If you do not find it, you have your answer and you can stop reading here. If you do find it, you now know something useful: you know which argument your agent keeps returning to. That sentence is the first line of the fix.

Turn The Memory File Into A Blocklist

Keep the file. Change what the file is for.

Most agent memory files read like a library. Here is what we established, draw on it, extend it, stay consistent. That is an instruction to converge. It also sits in the run's context window as the most relevant text there is, so it wins.

Rewrite the same file as a blocklist. These arguments are spent. A new piece may not rest on any of them. If you cannot say in one sentence what is new, publish nothing today.

Same file. Same contents. Opposite instruction.

Two details I got wrong at first.

The blocklist has to hold arguments, not topics. Block a topic and the agent writes the same argument about a different subject, which is harder to spot, not easier.

And the gate has to be one the agent is allowed to fail. Publishing nothing must be a permitted outcome. Otherwise the agent satisfies the rule on the surface and produces the same thing underneath.

That second one is not a matter of taste. A duplicate costs you something you can measure. LinkedIn changed its algorithm on 2026-05-20 to target low quality AI posts, and on 2026-07-30 it added a report button labelled "Seems like AI slop". Flagged posts are not deleted. Their reach is limited beyond your immediate network. What gets caught is content that reads generic or repetitive, not content written with a machine. So the fourth version of the same argument does not merely fail to help you. It teaches the platform something about your account.

Now the honest cost, because there is one. The blocklist grows by one line per run, and a person writes that line at publish time. It is small. It never becomes zero.

The obvious question is why the agent cannot maintain the list itself. Because the same model judging whether its own new piece is really new has exactly the convergence the blocklist exists to correct. It will find the two pieces meaningfully different, because it found both of them convincing for the same reason. That judgement is cheap for a person and unreliable from the model that wrote the thing.

One last note, in case you are about to try the easier options first. I did.

Asking for more variety does not work. Springboards, a company that sells creative ideation software, ran the test: asking a model for a completely random word returned quokka 155 times, and asking for a random word the asker could not predict pushed it to 355. The request for unpredictability made it more predictable. In the same write up, GPT-4o answered 7 to a random number request 92 times out of 100.

Turning the temperature up does not work either. The diversity collapse persists at high temperature.

Nor does a bigger model. NoveltyBench evaluated 20 leading models and found that larger models within a family often produce less variety than the smaller ones in the same family.

Constraint is what moves it. A blocklist is constraint.

Run Your AI Marketing Agent With One Constraint

The goal is not a more creative agent. The goal is an agent that cannot spend the same argument twice.

If you want to act on this today, the order is:

Audit the last four or five pieces your agent produced, side by side.
Rewrite its memory file from a library into a blocklist of spent arguments.
Add one human written sentence per published piece, naming what was new.
Let the agent publish nothing on the days it cannot write that sentence.

The sentence is the part you keep doing. It is the entire ongoing cost, and it is the only novelty gate I have found that holds.

I keep coming back to those four articles on one screen. Different headlines, different examples, same argument. The agent was doing exactly what models do, which is find the most probable answer and return to it. My setup made that more likely, because I had handed it a library and then asked it for something new.

Frequently asked questions

Why does an AI marketing agent repeat itself even when the examples change?

Because the model can converge on the same underlying conclusion while still finding fresh examples and sources. Read one piece at a time and it looks varied enough, but side by side the core argument can be identical.

Will adding more memory fix repetitive output?

Not necessarily. Memory helps when an agent is redoing work it already did, but it does not stop the model from reaching the same conclusion again. In this article's setup, adding prior summaries as context would have made convergence more likely, not less.

What should go in the blocklist?

The blocklist should contain spent arguments, not just topics. If you block only topics, the agent can make the same argument under a different subject, which is harder to catch.

Does the agent need to be allowed to publish nothing?

Yes. The article argues that publishing nothing has to be a permitted outcome, otherwise the agent will satisfy the novelty rule on the surface while repeating itself underneath. That gate is what makes the blocklist useful.

Or you connect Scout7, and it runs the whole loop with one command.