Mastering OpenClaw on Mac: Using Folders as Infinite Agent Memory

Running OpenClaw locally on a Mac feels like the future. You have a powerful AI agent right in your terminal, capable of executing commands, reading files, and helping you build.

But while OpenClaw has its own internal memory (short-term context and long-term storage), it often feels like a black box.

You know the agent "remembers" things, but you can't see what it's thinking. Its plans, rules, and tracking data are hidden away in internal databases or JSON files. You can't easily glance at a folder and see "What does the agent think is important here?" or "What is the status of this file?"

In this tutorial, I'll show you how to use Tokie to add a visible, collaborative memory layer for OpenClaw. We'll teach OpenClaw to externalize its state directly into your folders, turning them into a shared workspace where both you and the agent can track progress visually.

The Setup: OpenClaw on Mac

First, let's get OpenClaw running locally. If you haven't set it up yet, the Mac experience is surprisingly smooth.

1. Installation

The easiest way to get OpenClaw running on macOS is via their installer script (or Docker if you prefer isolation).

# Standard installation
curl -sL https://install.openclaw.ai | bash

Once installed, you'll need to configure your model provider. For a purely local Mac experience, you might point it to a local Ollama instance, but for best performance, using an API key (Anthropic/OpenAI) is usually recommended for the "brain" while the execution happens locally.

2. Connect the Filesystem

OpenClaw needs access to your files. On macOS, this means granting the necessary permissions.

openclaw config set sandbox_mode disabled

Note: Only disable sandbox mode if you trust the agent and are watching what it does. For this tutorial, we want OpenClaw to freely manage our project folders.

The Problem: "Hidden State"

Imagine you ask OpenClaw to "organize my downloads folder based on my project priorities."

It scans the files, decides that invoice_2025.pdf belongs in Finance and logo_v2.png goes to Design. It might even store this preference in its internal long-term memory.

But you can't see that.

To you, the user, the logic is invisible. You don't know why it made those choices, and if you want to correct it, you have to argue with the agent in chat. If you want to change the status of a file manually, you can't just click a dropdown—you have to tell the agent to update its internal database.

We need a way to make the agent's memory visible and editable by you.

The Solution: Tokie as a "Shared Whiteboard"

This is where Tokie Skills comes in.

Tokie allows folders to have Custom Fields (labels, status, tags) and Inline Markdown. We can use these features to create a "Shared Memory" between you and the Agent.

Instead of keeping the project state hidden in the agent's brain, we force the agent to write it to the folder metadata. This turns your file system into a two-way interface:

1. Agent -> User: The agent tags files and writes status updates so you can see what's happening.
2. User -> Agent: You can change a tag or edit a markdown note, and the agent reads that as new instructions.

Step 1: Install the Tokie Skill

First, we need to give OpenClaw the ability to manipulate Tokie folders.

1. Download the Tokie Folder Management skill (export it from the Tokie app or grab the .md skill file).
2. Add it to your OpenClaw skills directory or point the agent to it.

# Example: Adding the skill (conceptually)
openclaw skill add ./tokie-folder-manager.md

You can find and download tokie skills on the tokie skills page.

Step 2: Defining the "Memory Structure"

Now, let's tell OpenClaw to set up its memory. We don't just want it to move files; we want it to tag them.

Run this prompt in OpenClaw:

"I want you to manage this folder: /Users/me/Downloads/Inbox. First, use the Tokie skill to create a custom Select field called 'Status' with options: 'New', 'Processing', 'Done', 'Review'. Create a second Select field called 'Category' with options: 'Finance', 'Personal', 'Work', 'Junk'. Finally, create a RULES.md file and expand it inline. In this file, write down the logic you use to decide which category a file belongs to."

Why this works:

• Persistent State: The 'Status' of a file is now saved in the filesystem (in Tokie's hidden .folderinfo). If you restart OpenClaw, it can just read the file list and see which ones are 'New'.
• Explicit Logic: The RULES.md becomes the agent's long-term memory of how to do the job. Next time, you just say "Follow the instructions in RULES.md".

Step 3: The "Memory Dump" Workflow

When your session gets long or you want to switch tasks, you can ask OpenClaw to "dump" its current context into the folder structure. This ensures that nothing is lost in the black box of the chat history.

The Prompt:

"I'm ending this session. Please update the CURRENT_STATE.md file:

Now, that memory is durable. You can close the terminal, restart your computer, or even switch to a different AI agent (like Claude Code or Cursor), and the context is right there in the folder.

Real-World Example: The Collaborative Blog Folder

Let's look at a concrete example. I use this for my "Blog Posts" folder where OpenClaw acts as my editor.

I have OpenClaw managing /Documents/Blog.

1. Shared Context: We keep a KANBAN.md inside the folder (rendered inline by Tokie).
2. Visual Status: Every subfolder has a Stage field: 'Idea', 'Drafting', 'Polishing', 'Published'.
3. The Loop:
   • Me: I drop a rough voice note into a new folder and set the tag to 'Idea'.
   • OpenClaw: Scans for 'Idea' tags, reads the note, creates a structured outline, and updates the tag to 'Drafting'.
   • Me: I review the outline. If I don't like a section, I just leave a comment in the file.
   • OpenClaw: Reads my edit, updates the draft, and marks it 'Polishing'.

Instead of a long, messy chat thread, we have a clean folder where the state of the work is always visible. Tokie provides the interface, and OpenClaw provides the labor.

Conclusion

Local AI agents on Mac are powerful, but working with them can feel like shouting into a void. By using Tokie to visualize the agent's memory, you turn that void into a structured, collaborative workspace.

You stop wondering "What does the agent know?" and start seeing exactly what it's doing—right in your folder.