Walrus 🦭/acc Re-poster

We would like to extend our warmest congratulations to @RaphElevator for securing the 3rd place position within the App track of Walrus Session 8. This impressive rank was achieved through the creation of Anchor. Operating as a dedicated accountability bot on @telegram, this helpful tool memorizes your personal commitments, takes the initiative to message you as soon as your deadline arrives, and carefully monitors whether you actually completed your stated goals.

To learn more about this project, you can read the complete details on @Medium at https://bit.ly/4yOzVY5

Congratulations are in order for @UyLeQuoc, who secured 2nd place during Walrus Session 8 with the project hippo.

This application operates seamlessly through the Web, @telegram, @discord, and the terminal. Its standout feature is how it handles data, as hippo saves its memory directly to a personal Walrus account that you fully own. This guarantees that you remain in complete control, giving you the ability to withdraw system access at any point in time.

To explore a detailed breakdown of the project, be sure to read the complete article on @Medium right here: https://medium.com/@lequocuyit/i-gave-my-chatbot-memory-then-gave-the-memory-back-to-the-users-eaba16bb6b86

Congratulations to @UyLeQuoc for taking 2nd place in the App Track of Walrus Session 8 with the project hippo. This versatile application is built to run smoothly across the Web, @telegram, @discord, and the terminal. Its most defining feature is how it handles data: all memory is kept directly in your personal Walrus account. Because you maintain complete ownership of this account, you hold the power to revoke the application's access at any time. For a closer look at how this system was built, you can read the dedicated @Medium article here: https://medium.com/@lequocuyit/i-gave-my-chatbot-memory-then-gave-the-memory-back-to-the-users-eaba16bb6b86

Congratulations to @UyLeQuoc for securing 2nd place in the App Track during Walrus Session 8 with the project hippo.

This versatile tool is designed to operate smoothly across the Web, your terminal, @telegram, and @discord. What truly sets hippo apart is its approach to user data. The application saves its memory entirely within a Walrus account that you personally own, ensuring you retain the power to revoke access at any time.

To learn more about the development process and how user control was prioritized, check out the @Medium article here: https://medium.com/@lequocuyit/i-gave-my-chatbot-memory-then-gave-the-memory-back-to-the-users-eaba16bb6b86

We are delighted to announce that the project hippo, developed by @UyLeQuoc, secured 2nd place in the App Track during Walrus Session 8.

Here is a closer look at how the application functions. The system is built to operate smoothly across the Web, @telegram, @discord, and the terminal. However, its most notable feature is how it handles user data. The application stores its memory directly in your personal Walrus account, ensuring you have total ownership and the ability to revoke access whenever you wish.

For a deeper dive into the development process, you can read the complete @Medium publication at this link: https://medium.com/@lequocuyit/i-gave-my-chatbot-memory-then-gave-the-memory-back-to-the-users-eaba16bb6b86

Did you happen to catch the recent update from @github regarding Copilot? The platform now has the ability to retain your personalized preferences across different sessions, and it seamlessly maintains this context even if it transitions between different AI models in the middle of a task.

This is a wonderful enhancement for those working strictly within Copilot. However, a widespread issue remains because numerous teams deploy various agents across multiple environments. As it stands today, each of those separate agents must learn your specific workflow preferences completely from the beginning.

Bridging this exact divide is the focus of our current development efforts. We are creating a continuous memory solution designed to travel alongside you, ensuring your preferences remain intact regardless of the diverse models and tools you choose to incorporate into your daily workflow.

https://github.blog/changelog/2026-10-28-github-intelligence-puts-your-code-context-and-history-to-work/

Initially, the objective was to enter the word login, yet the network broke down right after the letters lo were sent.

We face a completely different obstacle in the present day. Your agent context is currently isolated in a separate utility, while your essential files are stored in another application entirely. Walrus Console bridges this gap by gathering everything into a unified location.

The platform successfully pairs your files with your agent context. It also delivers native MCP support for Cursor and Claude Code. Furthermore, every piece of data is fully encrypted by default.

#InternationalInternetDay

Taking the top position in Walrus Session 8: Chatbots That Remember is Playbook, an innovative project developed by @inspikalu. This unique chatbot features an integrated simulation workbench designed to handle bridges, queues, solar, and more.

The standout capability of Playbook is its persistent memory. Every time you return, the system resumes your work exactly where you stopped. It successfully keeps track of your specific limits, your optimal settings, and any approaches that have already failed.

The creator captures the core value of this tool perfectly with the following thought: “The useful part of engineering help is not the textbook answer. It is remembering your limits, your best result, and your failures.”

To learn more about the details behind this use case, you can read the full article on @Medium at https://medium.com/@inspikalu/playbook-my-use-case-62e1009e9d37

You can also experience the project firsthand through the live demo hosted on @vercel by visiting http://playbook-nine-tau.vercel.app

Model lifecycles naturally come to an end, but the memory of your agent does not need to expire alongside them. On October 23, @OpenAI phased out several of its legacy API models, specifically GPT-4, GPT-4 Turbo, o1, o3-mini, and o4-mini. Looking ahead, both GPT-4o and GPT-4.1 are scheduled to follow suit on January 14, 2027.

While these retirements are a routine part of the industry, they highlight the value of maintaining memory independently from the model layer. Storing context externally gives development teams the freedom to switch between models at will. This approach prevents vendor lock-in and ensures you never have to reconstruct your accumulated data from scratch. You can simply upgrade your models while seamlessly retaining your memory.

Walrus Memory provides exactly this kind of stability, keeping your interface completely consistent regardless of the runtime or model you decide to implement next. The process remains straightforward and familiar, requiring only remember() for writing data and recall() for reading it.

You can review the official deprecation schedule here:
https://developers.openai.com/api/docs/deprecations

On October 23, @OpenAI discontinued a batch of its older API models, specifically o1, o3-mini, o4-mini, GPT-4, and GPT-4 Turbo. Furthermore, they plan to phase out GPT-4.1 and GPT-4o on January 14, 2027. Additional details regarding these updates can be found at https://developers.openai.com/api/docs/deprecations

Although it is completely natural for artificial intelligence models to go through lifecycles, your agent should never lose its memory just because a platform evolves. Separating your memory storage from the underlying model layer gives your team the freedom to switch between different AI providers seamlessly. You will never have to rebuild your accumulated context from the ground up or remain tethered to a single vendor.

You can comfortably transition to new models while retaining all your historical data. Walrus Memory makes this effortless by providing an unchanging interface regardless of the runtime or model you choose in the future. The process remains as simple as using remember() for a write operation and recall() for a read operation.

If you are ready to incorporate Walrus Memory into your workflow, there are three distinct methods available to help you get started.

One excellent approach involves using the Vercel AI SDK. By leveraging middleware, you can seamlessly introduce persistent memory capabilities directly into your streamText and generateText processes. To achieve this, simply include the following import statement in your code:
import { withMemWal } from "@mysten-incubation/memwal/ai";

Alternatively, you might prefer utilizing the OpenClaw plugin. This method empowers your OpenClaw agents with automatic memory retrieval and capture features, which ensures that all information remains completely accessible across various sessions. You can easily install this plugin by running the following command:
openclaw plugins install @mysten-incubation/oc-memwal

Finally, you can choose the Core SDK route. This option provides a comprehensive way to recall and store memory, featuring Walrus storage, SEAL encryption, and automatic embedding. To add this package to your project, execute:
pnpm add @mysten-incubation/memwal

For the complete installation guide and full source code, please check out @github at this address:
https://github.com/MystenLabs/MemWal

Losing your artificial intelligence context just because you moved to a different tab is an experience that needs to be left in the past. Information generated within a single application ought to be easily accessible for use in another. In a recent video and interview produced by @AltCryptoGems, @Kenton explores exactly how Walrus Memory provides a reliable solution for portable agent context. He details the way this technology guarantees that your information remains entirely under your ownership, regardless of the various AI platforms you choose to utilize.

Walrus Memory has recently captured the spotlight in a new feature by @Forbes.

Reflecting on a critical challenge, @kostascrypto shared the following thought: "There was a point in time that we were stopped from accessing Fable and Mythos. And imagine at that time, what do I have to do?"

This exact dilemma explains why builders are eagerly transitioning to user-keyed, portable memory systems. Following a milestone of over 5,000+ agents and more than 4.5M+ retrievals, the motivation is abundantly clear. By adopting this technology, developers ensure that migrating between different LLMs never requires them to start completely from zero.

You can dive into the comprehensive article authored by @guneyyildiz right here: https://www.forbes.com/sites/guneyyildiz/2026/10/21/ai-startups-are-betting-on-what-the-big-platforms-cannot-credibly-sell/

To introduce verifiability into its enterprise data suite, @PerceptronNTWK is currently moving the data that powers its 800,000-node network over to Walrus. This transition directly addresses a critical requirement for hedge funds and enterprise buyers who depend heavily on real-time data, as it is absolutely crucial to confirm that this information remains completely unaltered.

Discover all the details by reading the complete announcement at the following link: https://walrus.xyz/blog/perceptron-walrus-verifiable-data-provenance/

It is certainly a positive development to see the largest data platforms shifting towards model-flexible and framework-agnostic memory solutions. For instance, @databricks launched agent memory into beta on Oct 12, just after @MongoDB introduced the capability to Atlas last month.

Nevertheless, a significant issue persists. While this memory might function across different models and agents, it frequently stays anchored to a single data platform. As a result, the valuable customer insights acquired by your agents transform into yet another trapped asset that you cannot relocate.

Walrus Memory ensures that your data remains completely yours. It acts as an independent memory layer that accompanies your agent everywhere. Because it is not restricted to any specific platform, it can be accessed from any runtime or model. Storing a fact is as simple as using remember(), and bringing it back just takes recall().

https://docs.databricks.com/aws/en/release-notes/product/2026/october

We warmly invite you to a special builder AMA on @discord where we will discuss how to eliminate the guesswork involved in locating information across decentralized sites and blobs. On October 21, 2026 at 12:00 p.m. UTC, @OmuraHQ co-founders Aditya Berry and Sourabh Chawla will be joining us to provide a comprehensive overview of the search infrastructure and real-time indexing developed for Walrus. We look forward to seeing you there, so please come prepared with your inquiries and access the event using the following link: https://discord.com/invite/walrusprotocol

In a fascinating conversation about maximizing GPU performance, @AMD representative @AnushElangovan recently sat down with @ConorBronsdon. Together, they delve into the capabilities of ROCm 10 and discuss the innovative application of agent swarms. These agents are deployed to successfully navigate search spaces, resulting in the automated optimization of thousands of models. You can catch this insightful discussion on Season 4 of the @chain_ofthought podcast, which is proudly sponsored by Walrus Memory. Listen to the complete episode at the following link: https://chainofthought.show/podcast/72-tuning-gpu-performance-with-ai-agents-amds-anush-elangovan-on-rocm-10/?utm_source=sponsor-share&utm_medium=referral&utm_campaign=ep72