From Seed to Garden

Before we do anything new, let's see where you actually stand. Send this to your agent:

Give me a full workspace audit. List every file and folder in our workspace, show the line count for each .md file, and tell me which files haven't been updated in over a week. Show the results as a tree with file sizes.

Your agent will crawl through your workspace and give you a snapshot. If you followed Molt 1, you'll see something like this:

workspace/
├── SOUL.md              (42 lines)
├── IDENTITY.md          (28 lines)
├── USER.md              (35 lines)
├── TOOLS.md             (19 lines)
├── MEMORY.md            (87 lines)   ← growing
├── memory/
│   ├── 2026-02-17.md    (23 lines)
│   ├── 2026-02-18.md    (31 lines)
│   └── 2026-02-19.md    (18 lines)
└── agents/
    └── argus/
        ├── SOUL.md      (36 lines)
        └── HEARTBEAT.md (24 lines)

Maybe yours is messier. Maybe there are daily logs stacking up and stray files from experimenting. Maybe MEMORY.md is already 200+ lines and getting unwieldy.

Here's the thing: this is exactly what growth looks like.

Your workspace didn't start this way. When you first installed OpenClaw, you had two files. Then TOOLS.md for credentials. Then MEMORY.md for saving things. Then Argus showed up with his own folder. Each file exists because you needed it.

That's not clutter. That's evolution. And in this chapter, you're going to understand the pattern behind that evolution — and give your agent the tools to help you manage it as it grows.

The Evolution Arc

Every OpenClaw user follows roughly the same growth pattern. Not because someone designed it that way, but because the same needs surface in the same order.

Week 1: The Essentials

You set up identity and personality. Just enough for your agent to function:

workspace/
├── SOUL.md          ← Who your agent is
├── IDENTITY.md      ← Contact info and boundaries
├── USER.md          ← Who you are and your preferences
└── TOOLS.md         ← Available tools and API keys

Four files. Simple. Your agent can hold a conversation, knows your name, has the right API keys. This is the foundation you laid in Molt 1, Chapters 1-4.

Weeks 2-3: Memory Kicks In

You start saving things. Daily logs accumulate. MEMORY.md grows from a few lines to a page:

workspace/
├── SOUL.md
├── IDENTITY.md
├── USER.md
├── TOOLS.md
├── MEMORY.md               ← Getting longer now
└── memory/
    ├── 2026-02-17.md       ← Daily logs appearing
    ├── 2026-02-18.md
    ├── 2026-02-19.md
    └── health/
        └── 2026-02-19.md   ← Argus health reports

This is when most people first think "is this getting messy?" No — it's working as intended. The memory system you set up in Chapters 7-8 is doing its job.

Month 1: Agents and Automation

Argus is running security patrols every 6 hours. Maybe you created a second agent for a different purpose. Heartbeats and cron jobs are part of your daily life:

workspace/
├── SOUL.md
├── IDENTITY.md
├── USER.md
├── TOOLS.md
├── MEMORY.md
├── PROJECTS.md             ← New: tracking active work
├── memory/
│   ├── 2026-02-17.md
│   ├── ... (growing)
│   └── weekly/
│       └── 2026-02-16.md   ← Weekly summaries
└── agents/
    ├── argus/
    │   ├── SOUL.md
    │   └── HEARTBEAT.md
    └── hermes/              ← New agent for messages
        ├── SOUL.md
        └── HEARTBEAT.md

Two agents, each with their own soul and heartbeat. A projects file to track what you're working on. The weekly summary folder your cleanup cron writes to. It's a real system now.

Month 2+: The Full Garden

Multiple projects, external integrations, maybe team coordination. Your workspace reflects a productive setup:

workspace/
├── SOUL.md                     ← Core identity (never changes much)
├── IDENTITY.md
├── USER.md
├── TOOLS.md
├── MEMORY.md                   ← Curated, pruned, tight
├── BRAIN.md                    ← New: live working memory
├── PROJECTS.md                 ← Index of active work
├── AGENTS.md                   ← New: multi-agent directory
├── CLI.md                      ← New: custom commands
├── memory/
│   ├── 2026-02-21.md
│   ├── areas/
│   │   ├── job-hunt.md
│   │   └── side-projects.md
│   ├── weekly/
│   └── archive/                ← Old logs moved here
├── agents/
│   ├── argus/
│   ├── hermes/
│   └── athena/                 ← Research agent
└── projects/
    ├── zero2claw/
    └── consulting/

This might look like a lot compared to your four files from Week 1. But every single file exists because something needed a home. Nobody sat down and designed this structure on day one — it grew.

The Core Files (Your Foundation)

Let's quickly recap what you built in Molt 1. These files are your foundation — they never go away, and everything else builds around them.

SOUL.md — Who your agent is. Personality traits, values, communication style. You wrote this in Chapter 3 when you connected Telegram, and your agent's personality comes from here. This is the file that makes your agent yours instead of a generic chatbot.

IDENTITY.md — The practical stuff. Your agent's name, its purpose, what it should and shouldn't do. Contact information, boundaries, scope. Think of SOUL.md as the heart and IDENTITY.md as the business card.

USER.md — Who you are and how you make decisions. Your preferences, your communication style, the decision frameworks you want your agent to use. When your agent says "based on your preference for X, I'd recommend..." — that recommendation is grounded in USER.md.

TOOLS.md — What your agent can access. API keys, credentials, which tools are enabled and how to use them. You set this up during installation and updated it as you added capabilities.

MEMORY.md — The curated long-term memory. The most important file after SOUL.md. Your agent loads this into context frequently, so it should stay tight — your key preferences, standing instructions, project essentials. You set up the memory system in Chapters 7-8, including the flush mechanism that keeps important information from being lost.

These five files are non-negotiable. Whether your workspace has 5 files or 50, these five are always there, always loaded, always the foundation.

The Growth Files (What Gets Added)

Now for the new stuff. These are files that show up as your usage matures. You don't need all of them — some you might never create. The key: add them when the need arises, not before.

For each file below, we'll explain what it does, show you what good content looks like, and give you a prompt to have your agent create it when the time is right.

BRAIN.md — Live Working Memory

Think of MEMORY.md as your journal and BRAIN.md as your whiteboard.

BRAIN.md holds what's on your agent's mind right now. Current context, active thoughts, working hypotheses, things it's tracking in the short term. While MEMORY.md is curated and permanent, BRAIN.md is messy and temporary.

Here's what a good BRAIN.md looks like:

# BRAIN.md — Current Working State
 
## Active Context
- User is job hunting, focusing on backend roles
- Resume was updated yesterday, needs cover letter for Acme Corp
- Waiting on response from interview last Tuesday
 
## Working Hypotheses
- The Acme Corp role is strongest match based on USER.md preferences
- Should prioritize portfolio project over more applications
 
## Open Questions
- What salary range for the Acme Corp role?
- Should we follow up on the silent application from last week?

Your agent updates this as context shifts. When it wakes up from a heartbeat or starts a new session, it reads BRAIN.md to pick up where it left off. The difference from MEMORY.md is lifespan — BRAIN.md content is relevant for days or weeks, not months.

When to add this file: When your agent starts losing track of ongoing work between sessions. If you find yourself re-explaining "remember, we were working on X" — that's the signal. When that happens, send this:

Create a BRAIN.md file in our workspace for live working memory.

Look through our recent conversations and memory files to understand
what I'm currently working on, what decisions are pending, and what
context you keep losing between sessions.

Structure it with these sections:
- Active Context (what's going on right now)
- Working Hypotheses (your current best guesses about my priorities)
- Open Questions (things you'd need to ask me about)
- Short-term Tasks (things due in the next few days)

Fill it with REAL content from our actual conversations — not
placeholder text. If you're not sure about something, put it in
Open Questions.

From now on, read BRAIN.md at the start of each session and update
it when context changes. Add this to MEMORY.md as a standing
instruction.

HEARTBEAT.md — Autonomous Thinking Loop

You already met heartbeats in Chapter 6 with Argus. A HEARTBEAT.md file tells your agent what to do when it wakes up on schedule — what to check, what to monitor, what to maintain.

But Argus's HEARTBEAT was specific to security. Your main agent can have one too:

# HEARTBEAT.md — What to Do When You Wake Up
 
## Morning Check (8:00 AM)
1. Read BRAIN.md for current context
2. Check calendar for today's events
3. Review memory/today.md for overnight notes
4. Prepare morning briefing
 
## Periodic (Every 4 Hours)
1. Check for unread messages
2. Update BRAIN.md with any new context
3. Review PROJECTS.md for overdue items
 
## Evening Wrap (10:00 PM)
1. Flush important context to memory
2. Update BRAIN.md with tomorrow's priorities
3. Clear completed items from PROJECTS.md

The heartbeat makes your agent proactive, not just reactive. Instead of waiting for you to type something, it wakes up, checks what needs attention, and either handles it or flags it for you.

When to add this file: When you want your agent to do things without being asked. If you're always saying "check my calendar" or "remind me about X" — automate it with a heartbeat. When you're ready:

Create a HEARTBEAT.md for our main agent (not Argus — he has his own).

This should define what you do when you wake up on schedule.
Include three routines:

1. Morning (8 AM): Read BRAIN.md, check what's happening today,
   prepare a short briefing and send it to me on Telegram.

2. Periodic (every 4 hours): Check for anything that needs
   attention, update BRAIN.md with any new context, flag overdue
   items from PROJECTS.md if it exists.

3. Evening (10 PM): Flush important context to memory, update
   BRAIN.md with tomorrow's priorities, send me a short end-of-day
   summary on Telegram.

Set up cron jobs for the morning and evening routines. The periodic
check should run every 4 hours between 10 AM and 8 PM.

Start with just the morning routine enabled — I want to see how it
works before turning on all three.

PROJECTS.md — Active Work Tracking

As you start using OpenClaw for real projects, you need a place to track what's active, what's blocked, and what's next:

# PROJECTS.md — Active Work
 
## Job Hunt [ACTIVE]
- Status: 3 applications out, 1 interview scheduled
- Next: Write cover letter for Acme Corp
- Blockers: None
- Memory: memory/areas/job-hunt.md
 
## Side Project: Recipe App [PAUSED]
- Status: Backend API done, frontend 60%
- Next: User authentication flow
- Blockers: Waiting on design mockups
- Memory: projects/recipe-app/README.md
 
## Home Automation [ACTIVE]
- Status: 2 smart plugs configured, thermostat pending
- Next: Set up thermostat schedule
- Memory: memory/areas/home-automation.md

Your agent reads this to understand what you're working on and what matters right now. It also helps when BRAIN.md gets refreshed — PROJECTS.md provides the stable context that persists across brain resets.

When to add this file: When you're juggling more than two things and your agent keeps losing track of which project you're talking about. When that happens:

Create a PROJECTS.md file in our workspace.

Search through our memory files and recent conversations to find
everything I'm actively working on or have mentioned working on.

For each project, include:
- A name and status tag: [ACTIVE], [PAUSED], or [WAITING]
- Current status (one line)
- Next step (one line)
- Blockers if any
- Link to the relevant memory file if one exists

Sort active projects first, then paused, then waiting.

Add a standing instruction to MEMORY.md: review and update
PROJECTS.md at the end of each session where we worked on
any project.

AGENTS.md — Multi-Agent Directory

Once you have more than Argus, you need a phone book:

# AGENTS.md — The Pantheon
 
## Argus (Security)
- Role: Security monitoring and threat detection
- Schedule: Every 6 hours
- Workspace: agents/argus/
- Reports to: Main agent
 
## Hermes (Communications)
- Role: Message routing and notifications
- Schedule: Every 2 hours
- Workspace: agents/hermes/
- Reports to: Main agent
 
## Athena (Research)
- Role: Deep research and analysis
- Schedule: On-demand
- Workspace: agents/athena/
- Reports to: Main agent

This file answers questions like "which agent handles this?" and "what's Hermes doing again?" As your team grows (we'll build multi-agent teams later in Molt 2), this becomes your organizational chart.

When to add this file: When you create your second agent. One agent doesn't need a directory. Two agents absolutely do. Tell your agent:

Create an AGENTS.md file that catalogs all agents in our workspace.

Scan the agents/ directory and for each agent, document:
- Name and role (what it does)
- Schedule (how often it runs, or "on-demand")
- Workspace path
- Who it reports to
- Key files in its workspace

Also include our main agent (you) at the top with the same format.

Keep this file updated whenever we create or modify an agent.
Add that as a standing instruction in MEMORY.md.

CLI.md — Custom Commands

Shortcuts you use frequently, complex commands you don't want to forget, agent-specific tool configurations:

# CLI.md — Quick Commands
 
## Daily Use
- `openclaw gateway status` — Check if everything's running
- `openclaw cron list` — See all scheduled jobs
- `qmd ls memory` — Check QMD index status
 
## Debugging
- `tail -f /tmp/openclaw/openclaw-$(date +%Y-%m-%d).log` — Live log
- `python3 -m json.tool ~/.openclaw/openclaw.json` — Validate config
- `openclaw sessions spawn --agent argus` — Manual Argus trigger
 
## Maintenance
- `openclaw cache clear` — Free disk space
- `qmd reindex memory` — Rebuild search index

You're not writing documentation here. You're saving yourself from Googling "what was that log command again" for the third time this week.

When to add this file: When you've looked up the same command three times. Just tell your agent:

Create a CLI.md file with all the OpenClaw commands we've used so far, organized by category — daily use, debugging, and maintenance. Include a one-line description for each command.

Your agent knows which commands you've run together. It'll build a useful cheat sheet from your actual history.

Organization Patterns

Your files will grow. Here's how to keep them manageable — and how to let your agent do the heavy lifting.

When to Split Files

The rule is simple: when a file hurts to use, split it.

Specific signals:

• File > 200 lines — Getting hard to navigate. Time to break it into focused pieces.
• One file covers multiple unrelated topics — Memory about job hunting mixed with smart home notes? They need separate homes.
• Different agents need different info — Move agent-specific knowledge into agent folders.

Don't split preemptively. A 150-line MEMORY.md that covers three topics is fine — you can find things. A 400-line MEMORY.md that covers twelve topics? That needs surgery. And your agent can do the surgery:

My MEMORY.md has gotten too long. Reorganize it:

1. Audit MEMORY.md — identify every distinct topic it covers
2. Keep only the most essential, cross-cutting information in
   MEMORY.md (target: under 100 lines)
3. Move topic-specific content into memory/areas/ files:
   - One file per major topic (job-hunt.md, home-automation.md, etc.)
   - Use lowercase-with-dashes naming
4. In MEMORY.md, add a "Topic Files" section that links to each
   area file so you know where to look
5. Show me what you moved and where before and after

Don't delete anything — just reorganize.

Naming Conventions

OpenClaw users have settled on a convention that works well:

| Pattern | Use For | Example | |---------|---------|---------| | UPPERCASE.md | Core system files | SOUL.md, MEMORY.md, BRAIN.md | | YYYY-MM-DD.md | Daily logs | 2026-02-21.md | | lowercase-with-dashes.md | Everything else | job-hunt.md, recipe-app.md | | folder/name.md | Grouped by category | agents/argus/SOUL.md |

The UPPERCASE convention is particularly useful — it makes system files visually distinct when you list a directory. You can spot them instantly:

$ ls workspace/
AGENTS.md    BRAIN.md     CLI.md       IDENTITY.md
MEMORY.md    PROJECTS.md  SOUL.md      TOOLS.md
USER.md      agents/      memory/      projects/

System files in caps, everything else lowercase. Clean and scannable.

Asking Your Agent to Reorganize

When your workspace feels chaotic, don't reorganize by hand. Your agent knows the conventions and can do it for you:

Audit and reorganize our workspace:

1. List every file and folder, with line counts
2. Flag any files that don't follow our naming conventions
   (UPPERCASE.md for system files, YYYY-MM-DD.md for daily logs,
    lowercase-with-dashes.md for everything else)
3. Flag any files over 200 lines that should be split
4. Flag any daily logs older than 30 days that should be archived
5. Suggest specific changes but DON'T make them yet — show me
   the plan first

Follow these conventions:
- System files (SOUL, MEMORY, BRAIN, etc.) stay in the root
- Daily logs go in memory/
- Topic notes go in memory/areas/
- Agent files go in agents/<name>/
- Project files go in projects/<name>/

This is the "garden tending" approach. Let your agent survey the landscape and propose changes. You approve, it executes. No manual file shuffling required.

The Advanced Folder Structure

If your workspace has grown to the Month 2+ level, here's a battle-tested structure that scales:

workspace/
├── SOUL.md                        ← Core identity
├── IDENTITY.md                    ← Purpose and boundaries
├── USER.md                        ← Your preferences
├── TOOLS.md                       ← Credentials and tools
├── MEMORY.md                      ← Curated long-term memory
├── BRAIN.md                       ← Live working state
├── PROJECTS.md                    ← Active work index
├── AGENTS.md                      ← Multi-agent directory
├── CLI.md                         ← Command shortcuts
│
├── memory/
│   ├── 2026-02-21.md              ← Today's log
│   ├── 2026-02-20.md              ← Yesterday's log
│   ├── areas/                     ← Long-running life areas
│   │   ├── job-hunt.md
│   │   ├── side-projects.md
│   │   └── home-automation.md
│   ├── weekly/                    ← Weekly summaries
│   │   └── 2026-02-16.md
│   └── archive/                   ← Old logs (still searchable)
│       └── 2026-02-10.md
│
├── agents/
│   ├── argus/                     ← Security agent
│   │   ├── SOUL.md
│   │   ├── HEARTBEAT.md
│   │   └── memory/
│   │       └── 2026-02-21.md
│   ├── hermes/                    ← Communications agent
│   │   ├── SOUL.md
│   │   ├── HEARTBEAT.md
│   │   └── WORKING.md
│   └── athena/                    ← Research agent
│       ├── SOUL.md
│       └── WORKING.md
│
└── projects/
    ├── recipe-app/                ← Project workspace
    │   ├── README.md
    │   └── docs/
    └── consulting/
        └── client-name.md

Notice the pattern: every agent gets its own folder with its own SOUL.md and optionally its own memory. Projects get their own folders too. The root level stays clean because detailed notes live in subdirectories.

The Growth Mindset

There's a famous quote in programming: "Premature optimization is the root of all evil." It applies perfectly to agent workspaces.

The temptation when you see a nice folder structure like the one above is to immediately reorganize everything to match. Don't. That structure works for someone who's been using OpenClaw for two months and has real content to organize. It doesn't work for someone who just finished Molt 1.

Instead, follow these principles:

Add structure when it hurts, not when it might. If you can find what you need in your current setup, the current setup is fine. When you can't find last week's note, that's the signal to create a better system — not before.

One new file at a time. Feel like you need BRAIN.md? Send the prompt. Don't also create PROJECTS.md, CLI.md, and AGENTS.md "while you're at it." Each file only earns its place when you're actually using it.

Let your agent do the work. Every prompt in this chapter is designed for your agent to execute. You decide what to add, your agent figures out how and fills it with real content from your actual usage. No empty templates.

Empty files are worse than no files. An empty PROJECTS.md that your agent loads into context wastes precious tokens and teaches it nothing. Better to have no file than a placeholder. That's why every prompt above tells your agent to fill files with real content, not placeholders.

Signs You're Ready for More Structure

Not sure when to level up your organization? Here's a checklist. If you're hitting three or more of these, it's time to send one of the prompts above:

• Can't find that note from last week. You know you told your agent something important, but searching MEMORY.md comes up empty. Stuff is falling through the cracks. → Time for the memory split prompt.

• One file is 500+ lines. MEMORY.md has become a novel. Scrolling through it takes forever. → Time for the reorganize prompt.

• Multiple projects getting mixed up. Your agent confuses your job hunt with your side project because both are jumbled in the same memory. → Time for PROJECTS.md.

• Want different agents for different domains. You're tired of your main agent handling everything. Security needs a specialist. Research needs a specialist. → Time for AGENTS.md (and Molt 2's multi-agent chapters).

• Need to share some files but not others. You want your research agent to see your preferences but not your security reports. → Time for folder-level separation using the reorganize prompt.

• Repeating yourself every session. Your agent keeps losing context overnight. → Time for BRAIN.md.

If none of these describe you, keep your simple setup. It's working. Don't fix what isn't broken.

Your New Files: A Quick Reference

Here's everything in one place — what each file does and when to create it:

| File | Purpose | Create When... | |------|---------|----------------| | BRAIN.md | Live working context and active thoughts | Agent forgets what you were working on between sessions | | HEARTBEAT.md | Autonomous wake-up routine | You want proactive behavior without asking | | PROJECTS.md | Active work tracking and status | Juggling more than two projects | | AGENTS.md | Multi-agent directory | You have two or more agents | | CLI.md | Command shortcuts and references | You've looked up the same command three times |

And the folders:

| Folder | Purpose | Create When... | |--------|---------|----------------| | memory/areas/ | Long-running topic notes | MEMORY.md is getting too long | | memory/archive/ | Old logs you might need | Daily logs are piling up | | agents/<name>/ | Per-agent workspace | You create a new agent | | projects/<name>/ | Per-project workspace | A project needs its own notes |

A Note About Mess

Your workspace will get messy. Files will accumulate. Daily logs will stack up. You'll create a file, use it for a week, and forget about it.

This is normal. This is fine.

The best workspaces aren't the tidiest ones — they're the ones where the owner can find what they need. If your messy desk has everything within arm's reach, it's a better workspace than a clean desk where everything is filed in labeled drawers you never open.

The same is true for your agent workspace. A "messy" memory folder with 30 daily logs and a few stray files is perfectly functional if QMD can search it and your agent can find what it needs. The day it can't find things — that's cleanup day. And when that day comes, you have a prompt for it.

Until then, let it grow.

Credits & Shoutouts

This chapter was inspired by the OpenClaw community's sharing of their workspace growth:

Johann Sathianathen — The "default OpenClaw vs. my OpenClaw after 3 weeks" tweet that visualized the evolution from simple beginnings to complex, living systems. That side-by-side comparison is what made us realize this chapter needed to exist — your workspace should look different after three weeks, and that's worth celebrating.

What's Coming in Molt 2

Your workspace started as a seed — a few files in a folder. It's growing into a garden. Some parts are tidy, some are wild, and that's exactly right.

But gardens need tending. In the rest of Molt 2, you'll learn to cultivate yours intentionally:

• The PARA Method — Organize everything into Projects, Areas, Resources, and Archives. A proven system adapted for agent workspaces.
• Multi-Agent Teams — One bot per agent, routing messages to the right specialist. Your Pantheon grows.
• External Integrations — Connect your workspace to Obsidian, Notion, GitHub, and more. Your agent reaches beyond its folder.
• Shared Memory — Agents reading each other's files. Coordinated knowledge across your team.
• The Roundtable — A synthesis agent that watches all the others and gives you the big picture.

Your workspace is about to become an ecosystem. But first — that one file from the challenge. Start there.