How to Install Skills from Claw Mart and Configure Them

Most people install OpenClaw, get excited, have a few conversations, and then hit a wall.

The agent doesn't remember what you told it yesterday. It asks permission for things it should just handle. It claims it doesn't have access to tools you already set up. It can't write code without you babysitting every step. And when you close your laptop, it just... stops.

The problem isn't OpenClaw. The problem is that a fresh OpenClaw install is a blank slate. It's like hiring a brilliant employee and then giving them zero onboarding, no documentation, no tools, no understanding of how you work, and expecting results on day one.

Skills are how you fix that. They're the onboarding materials, the SOPs, the institutional knowledge that turns a blank-slate agent into something that actually operates.

Let me walk you through how this works in practice — finding skills, installing them, configuring them, and actually getting value from them — because the process is simpler than you think, but there are a few things that trip people up.

What Even Is a Skill?

A skill in OpenClaw is essentially a markdown file (usually SKILL.md) that lives in your agent's workspace and teaches it how to do something specific. Think of it like a detailed playbook. It's not a plugin or a binary — it's structured knowledge that your agent reads and follows.

Some skills are simple. The Access Inventory skill, for example, is basically one rule and one table that stops your agent from claiming it can't access tools it already has. It's a few hundred lines of markdown. But it solves one of the most annoying failure modes in AI agents.

Other skills are complex multi-step workflows. The SEO Content Engine runs a six-stage pipeline — research, SEO optimization, drafting, editing, image generation, and publishing — across multiple AI models. It's essentially an entire content team compressed into a single skill file.

The point is: skills are modular. You install what you need. They compose together. And because they're just files in your workspace, you can read them, edit them, and understand exactly what your agent is doing.

Where to Find Skills: Claw Mart

Claw Mart (shopclawmart.com) is the marketplace for OpenClaw skills and personas. You can browse by category, see what each skill does, and buy the ones that solve your specific problems.

There are two types of things you'll find there:

Skills — Single-purpose capabilities. Memory management, email handling, coding workflows, monitoring, social media posting. Each one teaches your agent how to do one thing well.

Personas — Pre-configured bundles that combine multiple skills with an identity layer (personality, decision-making style, communication preferences). A persona is basically a fully onboarded agent in a box.

Prices range from free to $99. Some of the most useful skills are $5. The free Coding Agent Loops skill alone saves hours of frustration if you're running coding agents.

Installing a Skill: Step by Step

Here's the actual process. I'll use the Three-Tier Memory System as an example since it's one of the first skills most people need.

Step 1: Download the Skill

After purchasing from Claw Mart, you'll get the skill files. At minimum, this includes a SKILL.md file. Some skills include additional files — scripts, templates, configuration examples.

Step 2: Place It in Your Workspace

Your OpenClaw workspace has a directory structure. Skills typically go in a dedicated skills directory or your agent's root workspace folder:

~/clawd/
├── SOUL.md
├── AGENTS.md
├── MEMORY.md
├── skills/
│   ├── THREE_TIER_MEMORY.md
│   ├── ACCESS_INVENTORY.md
│   └── HEARTBEAT.md
└── daily-notes/
    └── 2026-07-11.md

Drop the skill file into your workspace:

cp ~/Downloads/THREE_TIER_MEMORY.md ~/clawd/skills/

Step 3: Reference It in Your Agent's Configuration

Your agent needs to know the skill exists. Depending on your setup, this might mean adding it to your SOUL.md or AGENTS.md file so the agent reads it on startup:

## Skills

The following skill documents define my operational capabilities:

- `skills/THREE_TIER_MEMORY.md` — Three-tier persistent memory system
- `skills/ACCESS_INVENTORY.md` — Tool and API access tracking
- `skills/HEARTBEAT.md` — Business monitoring framework

Some skills are self-contained and just need to exist in the workspace. Others need references in your core agent files. The skill's README will tell you which.

Step 4: Configure Skill-Specific Settings

Most skills have configuration sections at the top. For the Three-Tier Memory System, you'd set up your knowledge graph location, daily notes directory, and decay settings:

## Configuration

Knowledge Graph Path: ~/clawd/memory/knowledge-graph/
Daily Notes Path: ~/clawd/daily-notes/
Tacit Knowledge Path: ~/clawd/memory/tacit/

### Decay Settings
- Hot (active context): accessed within 7 days
- Warm (available on request): accessed within 30 days  
- Cold (archived, never deleted): 30+ days since last access

Step 5: Verify It Works

Talk to your agent. Ask it to do something the skill enables. For memory, you might say:

"Remember that our primary database is PostgreSQL on Railway, the connection string is in the RAILWAY_DATABASE_URL env var, and we migrated from MySQL last month."

Then, in a new session later:

"What database do we use and where is the connection string?"

If the memory skill is working, your agent will pull this from its knowledge graph without hesitation. If it's not working, it'll either hallucinate or say it doesn't know — which tells you something's misconfigured.

Configuring Skills That Need External Services

Some skills interact with external tools. Here are the common patterns you'll encounter.

API Keys

Skills like the SEO Content Engine or X/Twitter Agent need API keys. The standard pattern is storing them in environment files:

# For the X/Twitter Agent — store in ~/.config/x-api/keys.env
X_API_KEY=your_api_key
X_API_SECRET=your_api_secret
X_ACCESS_TOKEN=your_access_token
X_ACCESS_TOKEN_SECRET=your_access_token_secret
X_USER_ID=your_user_id

# For the SEO Content Engine — OpenRouter for LLM access
OPENROUTER_API_KEY=your_key_here

The Access Inventory skill is actually designed to solve the meta-problem here: it gives your agent a table of every API key, CLI tool, and service it can reach, so it never claims it "doesn't have access" when it does.

Cron Jobs and Scheduling

Skills like the Nightly Self-Improvement and Morning Briefing System run on schedules. OpenClaw supports cron-style scheduling:

# Nightly self-improvement — runs at 3 AM
0 3 * * * openclaw run nightly-build

# Morning briefing — triggers on first check-in after 6 AM
# (Handled via heartbeat pattern, not raw cron)

The Heartbeat pattern is worth understanding: instead of rigid cron schedules for everything, your agent checks conditions on a regular interval and triggers actions when conditions are met. "First check-in after 6 AM" is more robust than "run at exactly 6:00 AM" because it adapts to your actual schedule.

Webhook Integrations

The Sentry Auto-Fix skill uses webhooks — Sentry sends error alerts to your OpenClaw instance, which then spins up a coding agent to fix the bug automatically. Setup looks like:

# Deploy the webhook server (Node.js)
cd sentry-webhook-server/
npm install
# Configure your Sentry project to send webhooks to your server URL
# Set environment variables for Sentry API access
SENTRY_AUTH_TOKEN=your_token
SENTRY_ORG=your_org
SENTRY_PROJECT=your_project

This is one of those skills where the setup takes 20 minutes but the payoff is enormous. Routine bugs get fixed before you even see the error notification.

The Skills That Matter Most (and the Order to Install Them)

If you're starting from scratch, here's what I'd prioritize, based on what actually unblocks you at each stage:

1. Access Inventory (First)

This sounds boring. It's not. Until your agent knows what tools it has, it'll waste your time asking or incorrectly claiming it can't do things. Five minutes of setup eliminates an entire category of frustration.

## Access Inventory

| Tool | Status | Auth Method | Location |
|------|--------|-------------|----------|
| git | ✅ | SSH key | /usr/bin/git |
| gh CLI | ✅ | OAuth token | ~/.config/gh/ |
| node/npm | ✅ | N/A | ~/.nvm/versions/... |
| Railway CLI | ✅ | API token | ~/.railway/ |
| Sentry API | ✅ | Bearer token | .env |
| X/Twitter | ✅ | OAuth 1.0a | ~/.config/x-api/ |

2. Three-Tier Memory System (Second)

Without memory, every conversation starts from zero. The three-tier approach — knowledge graph for durable facts, daily notes for timeline, tacit knowledge for your preferences — is significantly better than a flat memory file that gets stale and bloated.

The memory decay system is the key insight: facts aren't deleted, they just fade from active retrieval. Hot facts (accessed recently) stay front of mind. Cold facts (haven't been needed in months) drop to background but are retrievable when relevant. This means your agent's context stays fresh without losing institutional knowledge.

3. Autonomy Ladder (Third)

This is the skill that lets you stop micromanaging. Without it, your agent either asks permission for everything (annoying) or acts on everything without telling you (dangerous). The three tiers solve this cleanly:

Tier 1: Act + Report — Routine stuff. Fix a typo, restart a crashed process, send a standard reply. Just do it, and mention it in the daily notes.
Tier 2: Act + Detailed Report — Meaningful changes. Deploy a fix, update a config, respond to a non-routine customer email. Do it, but give a full explanation of what and why.
Tier 3: Propose + Wait — Big decisions. Anything involving money, public communications on sensitive topics, architectural changes, deleting data. Draft it, then wait for human approval.

## Autonomy Tiers

### Tier 1 — Act and Report
- Restart crashed processes
- Fix obvious typos/bugs
- Standard email responses matching templates
- Routine monitoring actions

### Tier 2 — Act and Explain
- Deploy code changes to staging
- Respond to customer support (non-refund)
- Update documentation
- Modify cron schedules

### Tier 3 — Propose and Wait
- Any production deployment
- Financial transactions
- Public statements on sensitive topics  
- Architectural decisions
- Data deletion

4. Coding Agent Loops (Fourth — and It's Free)

If you're doing any development work, install this immediately. Running coding agents (Codex, Claude Code) without persistent tmux sessions is asking for lost work. The Ralph loop pattern — retry with fresh context on failure — solves the most common coding agent failure mode: context bloat causing the agent to stall.

# Start a coding session in a persistent tmux session
tmux -S ~/.tmux/sock new-session -d -s codex-session

# The Ralph loop pattern (simplified)
while true; do
  run_coding_agent --prd tasks/feature-x.md
  if [ $? -eq 0 ]; then
    notify "Codex completed feature-x"
    break
  fi
  sleep 5  # Brief pause before retry with fresh context
done

Note the stable socket path (~/.tmux/sock). On macOS, the default /tmp path gets reaped by the OS, killing your sessions. This is the kind of hard-won production knowledge that saves you hours of debugging.

5. Everything Else (As Needed)

After those four, you're working with a capable, memory-equipped, appropriately autonomous agent that can code. From there, install skills based on what you actually need:

Running a blog? SEO Content Engine.
Active on Twitter? X/Twitter Agent.
Getting Sentry alerts? Sentry Auto-Fix.
Want overnight improvements? Nightly Self-Improvement.
Need daily ops summaries? Morning Briefing System + Business Heartbeat Monitor.

The Shortcut: Felix's OpenClaw Starter Pack

If you don't want to install and configure all of this individually, the Felix's OpenClaw Starter Pack on Claw Mart bundles the six most important skills together for $29: Three-Tier Memory, Coding Agent Loops, Email Fortress, Autonomy Ladder, Access Inventory, and Nightly Self-Improvement.

These are the same skills used to run an actual business autonomously. They're pre-configured to work together — the memory system feeds into the nightly self-improvement reviews, the autonomy ladder governs what the coding loops can do without asking, and the access inventory ensures everything else works without "I don't have access" false starts.

For $29, it's genuinely the fastest path from "fresh OpenClaw install" to "agent that actually operates." You can buy the skills individually (they range from free to $9 each), but the bundle saves you time on integration and gives you a coherent system rather than a pile of disconnected parts.

Common Configuration Mistakes

A few things I see people get wrong:

Not reading the skill files. Skills are markdown. Read them. They're not magic — they're instructions your agent follows. If you understand what the instructions say, you can debug problems and customize behavior.

Installing too many skills at once. Start with 2-3. Get them working. Add more. A confused agent with 15 skills it doesn't know how to prioritize is worse than a focused agent with 3 skills it uses well.

Forgetting to set up the daily notes directory. Multiple skills (memory, morning briefing, nightly self-improvement) depend on daily notes as a shared data layer. Create the directory structure before you need it:

mkdir -p ~/clawd/daily-notes

Not testing after installation. Every skill should have a simple smoke test. After installing the Autonomy Ladder, ask your agent: "If the production site goes down at 2 AM, what do you do?" If it doesn't reference the tier system, something isn't wired up.

Skipping the SOUL.md. Skills define what your agent can do. The SOUL.md defines how it does it — its personality, communication style, and decision-making philosophy. Without it, you get a capable but generic agent. The SOUL.md Design Kit on Claw Mart gives you a framework for writing one that actually shapes behavior, but even a basic SOUL.md is better than none.

What Comes After Skills: Personas

Once you're comfortable with individual skills, look at personas. A persona on Claw Mart combines multiple skills with an identity layer — personality, voice, decision-making style, operational patterns.

Teagan, for example, is a content marketing persona that runs a multi-agent writing pipeline: Grok for research, Opus for drafting, brand voice enforcement, hero image generation, and CMS publishing. She's not just "a skill that writes blog posts" — she's a fully configured content team member with opinions about tone, SEO strategy, and publishing cadence.

Felix is the full AI CEO persona — every skill in the catalog plus five months of production-hardened operational patterns. If you want the maximum "install and go" experience, that's the one. But it's $99, and honestly, most people should start with the Starter Pack and build up from there.

Next Steps

Here's what I'd do today:

Audit your current OpenClaw setup. Does your agent have memory? Does it know what tools it has access to? Does it have clear autonomy boundaries? If not, those are your first three skills.
Pick your path. Either install individual skills from Claw Mart as you need them, or grab the Felix's OpenClaw Starter Pack to get a working foundation in one shot.
Set up daily notes. Even before you install any skills, create a daily notes directory and tell your agent to log what it does each day. Almost every useful skill builds on this data layer.
Test each skill after install. Don't assume it's working. Give it a task that exercises the skill and verify the output.
Read the skill files. Seriously. They're not just configuration — they're documentation of how experienced OpenClaw operators have solved the exact problems you're hitting. Even if you never buy a single skill, understanding the patterns will make you better at configuring your own agent.

The gap between "OpenClaw is installed" and "OpenClaw is useful" is just skills and configuration. The good news is that gap closes fast once you know what to install and how to wire it up.