Add Memory to a Chatbot That Remembers Users Between Sessions (and Win Up to $2500)"

#ai #opensource #agents #web3

LLMs are stateless, so most chatbots forget you when the chat ends. Here is how persistent memory fixes that, and a $2,500 open challenge to build one with Walrus Memory."

You tell a support bot your order number. A week later it asks for it again. An internal helpdesk bot walks the same employee through the same fix every month. A companion app has no idea what you said yesterday.

This is the most common complaint about chatbots, and it has a simple cause.

Why chatbots forget

A language model is stateless. Every request starts from a blank slate, and the only "memory" is whatever text you put in the prompt. Most bots handle this by replaying the current conversation. That works inside one session. When the session ends, everything is gone.

To remember someone across sessions, across users, and across devices, memory has to live outside the model and outside any single chat window.

The pattern that works

Whatever tool you use, persistent memory comes down to four steps:

# pseudocode, not a real SDK
on each user message:
    memories = recall(user_id, query=message)    # 1. fetch what matters
    reply    = llm(system_prompt + memories + message)  # 2. answer with context
    facts    = extract_facts(message, reply)     # 3. pull out durable facts
    store(user_id, facts)                        # 4. save them for next time

A few principles make the difference between memory that helps and memory that is decorative:

Store facts, not transcripts. Preferences, constraints, past problems and goals are useful. Raw chat logs are noisy and expensive to recall.
Recall before responding. The bot should use memory on the turn where it matters, not after.
Scope memory per user. One person's context must never leak into another's.
Make recall visible. The best moment in any memory demo is the bot saying something that only makes sense because of a previous session.

The challenge: Walrus Session 8

Walrus is running Chatbots That Remember from Sep 18 to Oct 9 with a $2,500 prize pool paid in stablecoin. The task is to build a chatbot that uses Walrus Memory (an open-source memory layer for AI agents) to persist and recall context across sessions, users and devices, and then to write honestly about what changed.

Any chatbot qualifies if it talks to people and should remember them:

Customer support and website widgets
Internal IT or HR helpdesks
Onboarding assistants
Tutoring and language-learning bots
Sales and lead-qualification bots
Community moderators
Coaching or companion bots
Game NPCs

What you need to do

Build a bot with Walrus Memory integrated (new, or retrofit an existing one).
Deploy it somewhere real: Telegram, Discord, Slack, WhatsApp, a web widget or a CLI.
Run it for a few days with at least 3 users, each with 10 or more stored memories.
Publish a 500 to 800 word article on Medium or Inkray covering what it does, how memory is wired in, a before/after comparison, and evidence of real use.
Submit a public GitHub repo with setup instructions.

Prizes

Category	Prize
Best Chatbot	$500 / $250 / $150
Open and alternative models (non-Anthropic, non-OpenAI, such as Gemini, Llama, Qwen or DeepSeek)	2 x $150
Best Article	3 x $100
Bug Bounty (reproducible issues on the MemWal repo)	5 x $100
Promo posts (sharing in communities outside Walrus and Sui)	5 x $100

Prizes can stack, so one project can compete in several categories. If you don't want to build, the bug bounty and promo prize each have their own form.

A tip if you're building

If you use a non-OpenAI, non-Anthropic model, the challenge specifically wants to hear about integration friction. Local models through Ollama or LM Studio, and hosted providers like Gemini or DeepSeek, are where unusual bugs show up. Reproducible reports on the MemWal issue tracker are eligible for the bug bounty.