Tencent WorkBuddy Memory System Case Study: Cross-Device Sync, Hidden Rule Files, and Why Ask/Craft/Plan Start to Feel Like Training a Long-Term AI Teammate

Earlier public articles about WorkBuddy mostly focused on questions like these:

• Can it handle factory and supply chain work?
• Can it plug into file-heavy and system-heavy workflows?
• Can it move beyond a simple chat UI?

This article looks at a different question, and it may be the more important one over time:

Why do some people end up using WorkBuddy more smoothly over time, almost like they are training a long-term AI teammate, while others never get beyond "it helps once in a while"?

I went back through several representative public posts from Tencent Cloud Developer Community and rebuilt the story around three threads:

1. Initial setup
2. The memory system
3. Cross-device sync

After reading them together, my conclusion is simple:

What makes WorkBuddy feel closer to a real production environment is not only whether it can complete tasks. It is that it is starting to show a full long-term structure built around a working directory, memory files, behavior rules, and multi-device sync.

The short conclusion first

• As of June 29, 2026, the most interesting public signals around WorkBuddy's advanced workflow path center on five capabilities:

  1. A default working directory and core setup choices
  2. Continuously updated AI memory
  3. Three task modes: Ask, Craft, and Plan
  4. Hidden rule files: IDENTITY.md, SOUL.md, and USER.md
  5. Cross-device memory sync through cloud storage and automation scripts

• The difference between this and ordinary office AI is not just that it can write text better. It is that:

  • it starts remembering who you are
  • it starts understanding how you work
  • it starts carrying context across devices

• If your workload involves:

  • high-frequency desktop workflows
  • long-running agent tasks
  • multi-device coordination
  • local files mixed with automation

  then these cases are more useful than another generic model leaderboard.

Why "it remembers you" matters more than "it answers you"

One of the easiest mistakes people make when they first try WorkBuddy is this:

• install it and immediately start assigning tasks
• jump straight into Craft
• assume the AI will automatically understand everything

But long-term experience usually depends less on whether the first task works and more on things like:

• whether it knows your default working directory
• whether it remembers your preferences
• whether it can understand your usual style
• whether it loses context on another machine

In other words, the real gap is not created by one good conversation. It is created by this:

Have you turned it from a tool into a partner with continuity?

Case 1: The first step is not assigning work. It is setting up the working directory, memory, and modes

The clearest public article on this is:

WorkBuddy - Setup Guide: The First Thing Is Not to Make It Work

It is worth studying because it does not stay abstract. It points directly at the practical setup mistakes new users are most likely to make.

1.1 Set the default working directory early, and do not dump everything onto the system drive

One of the most useful reminders in the article is:

• choose your default workspace location early
• do not leave everything on C: if you are on Windows

That sounds simple, but it is exactly how real desktop agent environments behave. Once tasks pile up, generated artifacts, caches, and project files start accumulating quickly. If you never plan the working directory up front, the environment becomes messy fast.

This is not an advanced trick. It is:

basic operations hygiene for a desktop agent you expect to use for a long time.

1.2 Memory is not decoration. It is meant to keep getting better over time

The same setup article explicitly says the memory feature should be turned on.

The public description is straightforward:

• memory keeps updating through conversations and tasks
• the agent gradually understands you better
• you can periodically review, edit, delete, or add memory items

That tells us something important. Memory in WorkBuddy is not a cosmetic toggle. It is designed as something that is:

persistent, reviewable, and correctable over time.

1.3 Ask / Craft / Plan are not minor UI options. They are risk boundaries

The article's explanation of the three modes is worth preserving almost verbatim:

• Ask: read-only, no file writes
• Craft: directly operates on files
• Plan: outlines a plan first, then executes after confirmation

This matters because many first-time users jump straight into Craft, but the public guidance makes the safer path very clear:

• start with Ask if you are new
• use Plan first for more complex tasks
• move to Craft after you understand the boundaries

That is basically a way to turn AI usage risk into a more manageable desktop workflow.

Case 2: What really feels like "training a teammate" is writing identity, soul, and user files

The most interesting part of the same setup article is the hidden .workbuddy directory.

The public paths given in the article are:

• ~/.workbuddy/ on Mac and Linux
• C:\\Users\\your-name\\.workbuddy\\ on Windows

Inside that directory, the three most important files are:

• IDENTITY.md
• SOUL.md
• USER.md

2.1 IDENTITY.md: who it is

The public article explains this file clearly. It defines things like:

• name
• role
• focus area
• capability boundaries

That means WorkBuddy's AI personality is not shaped only by temporary prompts. It can be defined and persisted.

2.2 SOUL.md: how it speaks and how it works

This is closer to a behavior-rules layer. The examples in the public article include:

• prefer concise answers
• lead with the conclusion
• always confirm before risky operations
• state the problem directly instead of padding with apology language

At that point, this is no longer ordinary chat customization. It is defining:

what kind of coworker your agent should behave like every day.

2.3 USER.md: who you are

This file tells the AI things like:

• your background
• your working style
• your preferences

That is why I think one of the most production-like aspects of the WorkBuddy setup is not the model selector. It is this:

the relationship between the person and the agent gets written into files.

That is much more stable than saying, "Please do it this way from now on," inside a chat thread.

Case 3: After 40 days, the shift from tool to partner comes from memory and rules, not just a better model

Another public piece worth pulling into the same narrative is:

When AI Starts Remembering Who You Are: My Real 40-Day Experience Living With WorkBuddy

The value of that article is that it is not a tutorial. It is long-term usage feedback.

From the public outline and searchable summaries, its core structure includes:

• setting rules first
• building a memory system
• configuring automation tasks
• coordinating across devices
• summarizing what went wrong

I agree with the article's core judgment:

How far AI can go does not depend only on model strength. It depends on how much time you are willing to spend training it.

That is especially true for WorkBuddy. A lot of users treat an agent as a disposable tool, but this write-up argues for a different operating model:

• do not restart from zero every time
• keep calibrating it continuously

That feels much closer to training a long-term collaborator than calling a temporary interface.

Case 4: Cross-device memory sync is where context starts becoming an asset

If the first two articles are mainly about single-machine usage, the third one pushes WorkBuddy toward a real multi-device workflow:

Take WorkBuddy's Memory to Every Device: A Full Cross-Device Sync Tutorial

Several public details from that tutorial stand out:

• the goal is to solve cross-device memory inconsistency
• the method is cloud storage plus automation scripts
• the article explicitly names mainstream cloud drives such as OneDrive
• it claims setup can be finished in 15 minutes
• the main sync targets include:
  • work logs
  • user preferences
  • project background

That means the discussion is no longer just, "How do I make it understand me better on one machine?" It becomes:

When you switch to another computer, can it keep working as if it never left?

4.1 The most production-like part is not the script itself. It is what gets synced

When people hear "sync script," they usually focus on implementation. From an operations point of view, the more important question is what the system chooses to synchronize.

Based on the public tutorial, the synced assets are not trivial settings. They are:

• work logs
• user preferences
• project background

Once those can move with you, several things change immediately:

• the second machine does not need to be retrained from scratch
• task context does not break every time you switch devices
• project switching becomes cheaper

That is why I think cross-device memory sync matters more than it first appears to.

It is really about turning:

experience trapped inside conversations

into:

portable work assets.

Case 5: The biggest risk is not that AI makes a mistake. It is silent failure and memory bloat

The 40-day experience write-up also surfaced several pitfalls that feel very real:

• silent push failures are the most dangerous kind
• memory files cannot grow forever without cleanup
• automation tasks need to account for timing and machine state

These are classic production problems. They are not about the model being "not smart enough." They are about:

• automation not actually running
• memory accumulating noise over time
• device state and schedule conditions being ignored

In other words, once WorkBuddy starts taking on long-running tasks, its operations profile starts looking much more like a real system:

• it has state
• it has scheduling
• it has failure recovery needs
• it has context pollution risk

That is exactly why these case studies are worth reading.

Put together, what does WorkBuddy's advanced workflow actually look like?

If you read the setup guide, the 40-day experience article, and the cross-device sync tutorial together, a fairly clear advanced-workflow shape emerges:

• a default working directory
• three risk boundaries: read only, direct modification, and plan first
• a continuously growing memory system
• rule files that lock in identity, tone, and user preferences
• cross-device sync that moves memory from one machine to many
• automation tasks plus visible failure modes

That is a very different pattern from a typical AI tool.

It is no longer just:

• you ask one question, it answers one question

It is increasingly closer to:

• you have a full working system
• AI is one configurable, portable, maintainable component inside that system

Who should try this first

Good immediate fits

• people with long-running desktop workflows
• users who switch devices often
• people who already use agents as daily tools instead of occasional chat helpers
• users with accumulated file structures, project context, and personal preferences
• people willing to maintain rule files, working directories, and automation scripts

Who can wait and watch

• people who only want to ask occasional questions and do not need persistent memory
• users who almost never switch devices and do not need cross-device context
• anyone who does not want to maintain configuration files or automation at all
• users with little awareness of local directory structure or agent permission boundaries

If you want to connect WorkBuddy-style long-running workflows to custom models, where is the buying value?

From the business side, the real question is usually not "Can it answer?" It is more like:

• should long-term memory use a different model path?
• does the context cost stay manageable after cross-device sync?
• can automation tasks and file flows run through one gateway?
• can multiple agents' state, rules, and billing be managed in one place?

So if you are working on long-running desktop agents, memory systems, or automation workflows, a unified model gateway is often more useful than betting everything on a single model.

You can continue from these entry points:

• Pricing
• Buy API key
• Tutorials

Final take

If I had to summarize my view of the WorkBuddy memory-system, cross-device-sync, and hidden-rule-file direction in one sentence, it would be this:

What matters most is not that it can complete tasks. It is that it is starting to show a structure that can turn AI from a temporary tool into a long-term teammate.

That structure includes at least five parts:

1. a working directory
2. a memory system
3. behavior rule files
4. risk-boundary modes
5. multi-device sync

That also means the part of WorkBuddy that feels closest to a production environment is not one flashy task demo. It is this:

It increasingly behaves like a desktop work system that has to be configured, maintained, migrated, and reused.

Sources

• When AI Starts Remembering Who You Are: My Real 40-Day Experience Living With WorkBuddy
• Take WorkBuddy's Memory to Every Device: A Full Cross-Device Sync Tutorial #WorkBuddy
• WorkBuddy - Setup Guide: The First Thing Is Not to Make It Work