I built Pickup, a chatbot that remembers users across browsers and devices using Walrus mainnet.
I thought the hard part would be storing and retrieving memories.
It wasn't.
The real challenge was making decentralized storage work smoothly behind a chatbot. These were the six things I learned.
If memory retrieval is slow, the whole chat shouldn't have to wait. I added an 8-second timeout. If memory doesn't come back in time, the chatbot answers normally and tells the user that it answered without the latest memory.
The chatbot should still work when memory doesn't.
One Walrus mainnet write took 36 seconds in my testing.
Waiting 36 seconds after every message obviously isn't acceptable.
So I changed the flow:
Reply first → save memory afterward.
The user gets the response immediately while the memory is saved in the background.
Saving every message creates a lot of useless memory.
I added a simple filter that skips short conversations and messages that don't contain useful information about the user.
For example: "Why does it 429?" → skip
"I'm running v0.1.8 and getting 429 errors." → save
The goal isn't to remember everything.
It's to remember the right things.
I ran into an interesting consistency issue.
A memory could be successfully saved, but the next recall wouldn't find it because the index hadn't caught up yet.
So I temporarily keep recently saved memories on the client and include them in recall results until the server catches up.
In other words:
Written ≠ immediately readable.
That's something I had to design around.
Sending several writes at once caused rate-limit failures.
The fix was simple:
One namespace, one write at a time.
Instead of firing every write immediately, I queue them.
Pickup shows the memories used for each response and how old they are.
This turned memory from a black box into something I could actually inspect.
When the chatbot gives an unexpected answer, I can see whether it used the wrong memory, an old memory, or no memory at all.
One limitation
The SDK I'm using currently doesn't provide a delete method.
So I didn't add a fake delete button.
Instead, the UI warns users not to store secrets or sensitive information in persistent memory.
I'd rather be honest about the limitation than pretend deletion is guaranteed.
The main lesson
Building persistent AI memory taught me that storage is only part of the problem.
Once storage sits behind a real-time chatbot, you also have to think about:
Latency. Consistency. Rate limits. Memory quality. Observability.
That's where most of the interesting engineering happened.
Pickup was built for Walrus Sessions 8.