Most people use AI like a vending machine.
You walk up, insert a prompt, get something back, walk away. Tomorrow, you do the same thing. The AI has no memory of yesterday. It doesn't know your name, your business, your goals, or your tone. Every session starts from zero.
That's not an employee. That's a calculator with a personality.
I've been running a team of AI agents for 2 months out of a $600 Mac mini. They handle my content strategy, trade Polymarket markets 24/7, send me a morning brief before I wake up, and monitor my bots while I sleep. Total operating cost: $200/month.
The thing that makes this work isn't the AI model. It's 5 files.
These files are the difference between an AI that waits for you and one that works without you.
Why Most AI Setups Stay Dumb
When you open ChatGPT or Claude and start a new conversation, the AI knows nothing about you. It can barely remember what you built yesterday. It doesn't know what you're trying to accomplish. You have to explain yourself every single time.
This is the "chatbot trap." People get frustrated because their AI gives generic advice, forgets context, and never gets better at understanding them. They blame the model. The model isn't the problem.
The problem is there's no persistent identity, no memory, and no autonomous behavior.
The 5 files below solve all three.
I use OpenClaw, which is built around this file-based memory system. But the same principle applies to any AI setup where you can inject context at the start of a session. The files are the architecture. The AI is just the engine.
File 1: SOUL.md (Who Your Agent Is)
This is the most underrated file in the stack.
SOUL.md defines your agent's personality, working style, and hard rules. Without it, every AI session defaults to generic corporate assistant mode: hedging every answer, over-explaining everything, and never taking a real position.
With it, your agent has an actual character.
Here's a slice of mine:
That's not a prompt. That's a hire spec.
When you define who your agent is, you stop getting generic output. You get output that sounds like it came from someone with taste and judgment.
What to put in SOUL.md:
Tone and communication style (concise vs. detailed, formal vs. casual)
Core working principles (ask first vs. figure it out, bold takes vs. hedge everything)
Non-negotiable rules (what it should never do, what requires approval)
How it should push back when you're wrong
Resources:
OpenClaw Workspace Docs: docs.openclaw.ai/concepts/agent-workspace
Anthropic's guide on effective system prompts: docs.anthropic.com/claude/docs/system-prompts
OpenClaw SOUL.md template: included in every new workspace setup
File 2: USER.md (Who You Are)
This one sounds obvious. It isn't.
USER.md is where you document everything your agent needs to know about you so it never has to ask. Your name, your work, your timezone, your communication style, your goals, your context.
Every time you start a session, this file gets loaded. Your agent already knows who it's talking to.
Here's the kind of stuff that goes in mine:
The result: my agent never asks me to explain what I do. It never asks for my email when it needs to draft something. It never recommends I post at times that are wrong for my timezone. It already knows.
USER.md also prevents the most annoying AI behavior: asking you questions you've already answered. When an agent says "could you tell me more about your business?" three sessions in a row, it's because it has no memory of what you told it. USER.md fixes this at the root.
What to put in USER.md:
Name, role, and what you actually do
Timezone and working hours
Communication preferences (formal vs. casual, voice vs. text)
Key accounts, contacts, and platforms
Current goals and priorities
Things your agent should never assume or ask about
Resources:
OpenClaw User Context Docs: docs.openclaw.ai/concepts/agent-workspace
Think of it like onboarding a new hire. What would you put in their first-week brief?
File 3: MEMORY.md (What It Remembers)
This is where things get interesting.
AI models have no memory between sessions by default. When a conversation ends, everything resets. MEMORY.md is how you break that.
It's a plain Markdown file that stores the things that matter long-term: decisions you've made, lessons learned, preferences your agent has figured out, context it should always carry.
Every time a session starts, your agent reads this file. It already knows what happened last week. It already knows which strategies worked and which didn't. It already knows the context it needs to do good work.
Here are some real examples from mine:
These aren't things I told the AI once. These are things it learned over time and stored so it never makes the same mistake twice.
OpenClaw also supports daily memory files (memory/YYYY-MM-DD.md) for running context, so your agent knows what happened today and yesterday. The two layers work together: MEMORY.md for durable long-term knowledge, daily files for recent context.
The system also uses semantic search (vector embeddings) so your agent can find relevant memories even when it doesn't know exactly what to look for.
What to put in MEMORY.md:
Hard rules and non-negotiables (things it's gotten wrong before)
Decisions you've made that affect future work
Preferences it should always apply
API keys, IDs, and reference data it needs regularly
Lessons from experiments and outcomes
Resources:
OpenClaw Memory Docs: docs.openclaw.ai/concepts/memory
The system supports hybrid search (BM25 + vector), temporal decay for recent context, and automatic memory flush before sessions end
Gigabrain (open source long-term memory layer): github.com/Legendaryy/gigabrain
Anthropic research on persistent AI context: anthropic.com/research
File 4: TOOLS.md (How to Reach Your Stuff)
Your agent can only do autonomous work if it knows how to access your infrastructure.
TOOLS.md is where you document the practical details: which tools you use, how to connect to them, what credentials live where, what shortcuts and conventions your agent should know.
Think of it like the toolbox briefing you'd give a new contractor on their first day. They're skilled. They just need to know where everything is.
Here's a sample of what mine covers:
Without this file, your agent has to ask where things are or guess. With it, it can reach your calendar, your Notion, your databases, and your messaging channels without interrupting you.
TOOLS.md doesn't control what your agent can do (that's handled by the actual tool configuration). It's guidance. The equivalent of a cheat sheet your agent can reference when it needs to find something.
What to put in TOOLS.md:
Your key apps and platforms with IDs, URLs, and shortcuts
Which channels route to which topics (Telegram, Discord, Slack)
Where important files and databases live
SSH hosts, device nicknames, and environment-specific details
Any automation infrastructure your agent needs to interact with
Resources:
OpenClaw Tools Docs: docs.openclaw.ai/concepts/agent-workspace
OpenClaw Skills (add actual tool capabilities): docs.openclaw.ai/concepts/features
OpenClaw skill library: https://clawhub.ai/
File 5: HEARTBEAT.md (What It Does Without You)
This is the file that makes your agent truly autonomous.
Heartbeat is a scheduled pulse. Every 30 minutes (or whatever interval you set), your agent wakes up, reads HEARTBEAT.md, and works through the checklist. If something needs attention, it tells you. If everything is quiet, it replies internally and stays silent.
You don't ask. It just checks.
Here's a slice of what mine does on every heartbeat:
Some of these take seconds. Some of them involve actually going and doing work, like reopening a browser tab that closed, restarting a crashed process, or fulfilling a content request someone submitted through my dashboard.
The key thing: I didn't ask for any of this. The heartbeat is running in the background. My agent is checking on my infrastructure, my content pipeline, and my trading bots whether I'm awake or asleep.
This is what "runs without you" actually looks like.
The heartbeat system also integrates with cron jobs for tasks that need exact timing. Heartbeats handle routine monitoring. Cron handles precise schedules, like a 6 AM daily audit or a weekly content review.
What to put in HEARTBEAT.md:
Recurring checks that matter (bots running, tabs open, dashboards live)
Conditions that should trigger an alert vs. stay silent
Background work your agent can do proactively
Rules for when to reach out vs. stay quiet (don't message at 2 AM)
Resources:
OpenClaw Heartbeat Docs: docs.openclaw.ai/gateway/heartbeat
OpenClaw Cron vs Heartbeat Guide: docs.openclaw.ai/automation/cron-vs-heartbeat
The decision framework: use heartbeat for batched periodic checks, cron for exact timing and isolated tasks
What a Week Looks Like When All 5 Are Running
Monday morning. I wake up to a Telegram message from my agent. It arrived at 6 AM, before I was awake.
It has:
A summary of what happened overnight in crypto markets
3 tweet drafts waiting for my approval, scored by bookmark potential
A status update on my trading bot (93% win rate, up $140 on the week)
A note that one of my Polymarket tabs closed and it already reopened it
Two calendar events to prep for today
I didn't ask for any of that.
By the time I finish my coffee, I've approved one tweet and responded to one urgent email that my agent flagged. Everything else is already handled.
That's what these 5 files actually do. They don't make the AI smarter. They give it the context to be useful without constant hand-holding.
If you'd rather have this built for your business instead of setting it up yourself, that's what we do at founderfunnel.com. We install content systems for founders who want the output without the setup.
How to Set This Up
If you're on OpenClaw, these files live in your workspace directory (default: `~/.openclaw/workspace`). You can create them manually or run `openclaw setup` to get starter templates.
Start simple. One file at a time.
Write SOUL.md first. Give your agent a personality and clear rules. This has the highest return for the least effort.
Add USER.md with your basic context. Name, work, timezone, current goals.
Start MEMORY.md small. Add things as your agent makes mistakes or learns something worth keeping.
Build TOOLS.md incrementally. Add entries as you actually need them.
Start HEARTBEAT.md with 2-3 checks. Add more as you figure out what you actually want it to monitor.
Don't try to write all 5 perfectly on day one. The files get better as you work with your agent. MEMORY.md especially. Half of mine was written after my agent did something wrong and I realized it needed a rule.
The point isn't perfect setup. The point is continuity. Every session, your agent loads these files and knows who it is, who you are, what it remembers, how to reach your tools, and what to check without being asked.
That's the whole architecture. 5 plain Markdown files and a model that runs on a $600 Mac mini.
Resources
OpenClaw:
Workspace file layout: docs.openclaw.ai/concepts/agent-workspace
Memory system: docs.openclaw.ai/concepts/memory
Heartbeat setup: docs.openclaw.ai/gateway/heartbeat
Cron vs heartbeat: docs.openclaw.ai/automation/cron-vs-heartbeat
Skills marketplace: https://clawhub.ai/
Building agent identity:
Anthropic's system prompt guide: docs.anthropic.com/claude/docs/system-prompts
Anthropic's guide on building effective agents: anthropic.com/research/building-effective-agents
Memory and persistence:
Gigabrain (long-term memory for OpenClaw agents): github.com/Legendaryy/gigabrain
OpenClaw memory search (vector + hybrid): docs.openclaw.ai/concepts/memory
My setup in practice:
Everyone's Using OpenClaw Wrong (Here's How I Make $31K/Month): x.com/sharbel/status/2032114510626967697
How to Build Your First AI Employee with OpenClaw in 25 Minutes: x.com/sharbel/status/2026662838022832472
How I Run My Entire Business With AI Agents (Full OpenClaw Setup): x.com/sharbel/status/2025944354070659094
If you found this useful, I post this kind of stuff regularly. Follow me on X: @sharbel
