Before the National Day holiday, I said I would share two major developments. We can now talk about them together: Sparse Agent Memory, our cloud memory service, and the Sparse Agent personal assistant, built on the way of working we have already put into practice.
Both come from experience working with Agents over time. The longer we work together, the more we need an Agent to remember requirements we have already agreed on and to remain responsible for a task. The background a user has spent time explaining should remain useful in later work. A goal that has been handed over should have someone responsible for following it through.
My view of these two products is clear: for collaboration across devices, memory must be offered as SaaS. For a Personal Agent to become a productivity tool, it must be able to take responsibility for following through on work. The first carries experience forward; the second carries the work forward.
Memory is essential to ongoing collaboration
In my own work, Sparse Agent Memory is the most effective Agent memory system I have used so far. That is a judgment based on practical use. Its value shows up in later tasks: can the Agent find requirements we have already confirmed, refer to ways we solved problems before, and use new corrections in the next round of work?
Working with an Agent produces a great deal of information like this: how an article should be written, the conventions for a project, what a daily report should include, which approaches have already been tried, and the conditions under which a decision was made. These details often influence the work for much longer than a single answer does.
For example, I have told an Agent that a daily report should begin with completed work, then cover unfinished items and the next steps. That convention should become a requirement it can look up when writing future reports. If the reporting schedule changes, or an approach turns out to need adjustment, the change should be recorded and the current version used in later tasks.
If the user has to explain everything again whenever work begins, they keep paying the cost of organizing the background. The longer the project runs and the more Agents participate, the more noticeable that cost becomes. Memory needs to provide a foundation for collaboration that can keep accumulating, being queried, and being updated.
Our memory service focuses on how saved information remains useful. An Agent looks up relevant conventions when starting a task, records new decisions and reusable methods during the work, and uses that information in later tasks while taking current circumstances into account. Experience gained in one task can then help with the next.
Work across devices needs memory beyond one machine
Agents run on different devices and in different environments. A project handled on one computer today may move to another computer later, or continue with an Agent in the cloud. The same user's working experience needs to remain available through those changes.
If every device has its own independent local memory, with no shared access or synchronization, earlier requirements stay on the original machine. When the environment changes, the user has to find files, move materials, and explain things again. Different Agents may also save different versions of a requirement, leaving someone to reconcile them later.
This is why I consider SaaS memory so important. SaaS has a straightforward meaning here: the memory service runs in the cloud and provides a common place to save, query, and manage information. Agents connect through accounts and within their authorized scope. The working environment can change while useful information remains in an accessible place.
For the ongoing collaboration across devices that we want to support, this capability is essential. We made Sparse Agent Memory an independent service so that memory can remain in the user's accounts and projects, available for later work to query and update.
Users also need to manage this information themselves. On the Memory website, they can select their projects, query existing memory, check project status, run validation, and export backups. When an old requirement no longer applies, they can update the relevant information and query it again to confirm the change. Providing memory as a service also gives users a lasting place to manage their working experience.
The Sparse Agent Memory project query interface includes query, status, export, import, and validation tools.
Shared experience needs a clearly defined scope
To reuse the same experience, Agents on different devices need access to the appropriate authorized memory project. For example, product wording agreed on during social media operations can later be used by an Agent responsible for writing, provided it has the appropriate access. What the user wants to reuse is the material and methods already accumulated.
The scope of sharing needs to be clear. Memory is managed by account and project, with separate accounts isolated from one another. The current Sparse workbench also keeps each Agent's memory separate. Connecting to the same service does not automatically let every Agent read the others' private information. When reusing memory across devices or Agents, users should confirm which authorized project they are accessing.
Whether memory makes a difference also depends on whether an Agent queries and updates it during tasks. When we say it becomes “smarter with use,” we mean a concrete process of collaboration: useful experience is saved, outdated requirements are corrected, and later work can find and use that information. A user can start with one work preference or a problem that has already been solved, then check whether it actually helps with the next task.
In the Sparse workbench, users can open Settings → Cloud Memory to connect their Chat account and check the connection status. Existing local memory can also be migrated by following the instructions on the page, while retaining the original records. See the cloud memory guide for details.
Personal Agents should take responsibility for the follow-up
Our other development is Sparse Agent. It continues a way of working we have already put into practice: the user supplies a goal, and the Agent saves progress, arranges subsequent work, and proactively contacts the user when their help is needed.
I think one of the hardest parts of ongoing work is keeping track of it. Someone has to remember where things stood last time, decide whether anything has changed, determine when to check again, follow up with people whose help is needed, and connect one round of work to the next. A specific operation may be quick, while remaining responsible for all these arrangements consumes a great deal of time.
Take website performance improvement as an example. If I want to focus on performance this month but still have to send dozens or even hundreds of prompts every day, telling an Agent which pages to inspect, which problems to analyze, and what to change next, I am still responsible for the daily follow-up. The Agent performs some operations, while I have to keep remembering the progress and pushing the next step forward.
We want Sparse Agent to take on that responsibility. Once the user defines the goal, how results will be checked, and the scope of the work, it schedules work based on current progress, reports regularly, and accepts feedback. A goal can span several months, a year, or longer. A specific task can be closed when it meets the agreed acceptance criteria.
Dots and Muse have brought more attention to Personal Agents. Their official introductions also describe ongoing task progress and proactive contact with users. When judging whether products in this category can become productivity tools, we focus particularly on what happens during an extended collaboration: after a user hands over a responsibility, can the Agent connect the subsequent work on its own, allowing the user to participate through reports and necessary assistance? Dots official introduction and Muse official introduction
Define the work through goals, KPIs, and constraints
Sparse Agent defines a responsibility through Goal, KPI, and Constraints. Goal explains whom it works for, what result it should achieve, and how long the responsibility lasts. KPI explains how progress and results will be checked. Constraints specify which operations it may handle independently and which require human review or assistance.
For example, a responsibility could be defined as continually improving a website's performance over the next month. Start by selecting key pages and APIs and establishing the current baseline. Then agree on targets and measurement methods for indicators such as loading time, response time, and error rate. The scope of work should also be explicit: code changes are submitted for human review, and a release decision follows that review.
Within that responsibility, the Agent can inspect the site's running state, identify problems affecting the indicators, reproduce them, prepare changes, and compare results before and after optimization. After a release, it continues observing the actual effects and arranges the next round of work. Progress reports should show the user the current indicators, changes already made, remaining problems, and subsequent plans.
Scheduled tasks and event triggers can determine when a round of execution begins. Ongoing work also needs subsequent arrangements based on the goal, progress, and results. After an inspection, what should be handled next? If external conditions are not yet in place, when should the Agent check again? If the user supplies a new judgment, which plans need to change? These are all part of following through on the work.
The Sparse Agent task form. The social media operations goal shown is a form example; the Agent has not yet been created.
At the end of each round, Sparse Agent saves the current progress and schedules the time and task for the next round. It keeps the records while waiting and resumes work when further judgment and execution are needed. When the user provides feedback, it incorporates the new requirements into subsequent arrangements and continues working within the same responsibility.
Work we have done, and work an Agent can take on
Previously, I handed an Agent the work of handling an Apple developer account and signing the PythonMiao desktop application. The task began on July 16, 2026, and was completed on July 29, spanning about 13 days. It involved registration and renewal, account activation, support tickets, payment confirmation, and the subsequent certificates, Developer ID signing, and Apple notarization.
Much of the time went into waiting and communication. The Agent recorded the current status, followed up with Apple support, and sent daily progress reports. When I needed to sign in, confirm my identity, or authorize payment, it explained what was missing and asked for my help. Once the necessary operation was complete, it continued until the account and software distribution checks met the agreed standard.
This way of working can also be used to run a social media account over time or keep improving a website against a set of performance indicators. The period of responsibility can be set as needed: social media operations might be a role lasting a year, while performance improvement might be concentrated into one or three months. Progress is checked through continued work; these are periods that can be assigned.
The user retains responsibility for judgments and necessary personal actions. When the Agent needs help, it should explain the issue clearly and proactively follow up. People learn about progress through reports and participate when decisions or authorization are needed, while the Agent continues handling the daily coordination.
Memory and follow-through belong in the same work
The value of putting these two products together becomes clearer. Memory saves user preferences, project conventions, and experience handling problems, so that later work can find existing information. Sparse Agent takes on an ongoing responsibility, applies those requirements to the current task, and arranges what happens next.
If the user changes the daily report format, later reports should use the new requirements. If a performance problem has already been handled, the Agent can first look up the earlier method when it encounters something similar. If a judgment is corrected, subsequent work should use that experience too. Continued follow-up produces new information, and memory helps later work keep using it.
A goal spanning an extended period also needs an available working environment. Sparse Agent can use an Omarchy cloud computer in the user's own DigitalOcean account. Models, cloud machines, and account authorization also need to be arranged for the period of responsibility so that the Agent can continue its work later. Users can start with one task whose scope is clear and whose results are easy to check, agree on the goal, KPIs, work scope, and reporting method, then observe whether the collaboration works.
Both services are currently open for invited users to try. To try memory, leave “记忆” (memory) in the WeChat Official Account's messages. To ask an Agent to keep advancing a task, leave “助手” (assistant) and describe the responsibility you would like it to take on. You can also contact me by email at allwefantasy@gmail.com.
Memory service: Sparse Agent Memory. Personal assistant: Sparse Agent. See the Goal, KPI, and work constraints guide for the way it works.
My expectations for these two products are concrete: accumulated working experience should remain useful across sessions and devices, and an Agent should remain responsible for following through on a goal that has been handed over. Users can entrust the daily effort of tracking progress and arranging next steps to a digital worker, while staying in control through reports, feedback, and necessary decisions.