Give your AI assistant memory, skills, and autonomy.
A shareable config that turns Claude Code into an AI that remembers you,
connects to your tools, and runs workflows while you sleep.

OpenClaw Config

Most AI assistants forget you the moment the conversation ends. OpenClaw doesn't.

This repo is the shared configuration layer for OpenClaw — a personal AI built on
Claude Code that maintains persistent
memory, integrates with real-world tools, and runs autonomous workflows on a schedule.
Everything is markdown and Python scripts. No frameworks, no databases, no lock-in.

What You Get

• Memory that persists — Three-tier architecture: always-loaded essentials, daily
  context files, and deep knowledge with semantic search
• 14 skills — Web research, meeting transcripts, CRM, phone system, voice calling,
  task management, and more — each a standalone Python script with zero setup
• 6 autonomous workflows — Agents that triage your inbox, manage tasks, prep your
  calendar, organize contacts, monitor security threats, and keep cron jobs healthy —
  learning your preferences over time
• Templates for identity — Define your AI's personality, your profile, and how it
  should operate
• DevOps included — Hourly health checks, fleet management across machines,
  automated backups

Getting Started

Prerequisites: Claude Code running
on your machine. That's it — no other dependencies.

Install: Open Claude Code and tell it:

Set up openclaw-config from https://github.com/TechNickAI/openclaw-config

The openclaw skill walks you through setup — cloning the repo, copying templates,
creating memory folders, and configuring optional features like semantic search.

Update later:

Update my openclaw config

How It's Organized

openclaw-config/
├── templates/          # Identity & operating instructions
│   ├── AGENTS.md       # How the AI should think and act
│   ├── SOUL.md         # Personality definition (templated)
│   ├── USER.md         # Your profile — who you are, how you work
│   ├── MEMORY.md       # Curated essentials, always in context
│   ├── BOOT.md         # Startup routine — what to check on launch
│   ├── HEARTBEAT.md    # Periodic checks (inbox, tasks, health)
│   ├── TOOLS.md        # Machine-specific environment config
│   └── IDENTITY.md     # Quick reference card
│
├── skills/             # Standalone UV scripts — no install needed
│   ├── parallel/       # Web research & content extraction
│   ├── quo/            # Business phone — calls, texts, contacts
│   ├── fathom/         # Meeting recording & transcript search
│   ├── fireflies/      # Meeting transcript search
│   ├── limitless/      # Pendant lifelog search
│   ├── asana/          # Task & project management
│   ├── followupboss/   # Real estate CRM
│   ├── librarian/      # Knowledge base maintenance
│   ├── create-great-prompts/  # Prompt engineering guide
│   ├── smart-delegation/     # Route work to the right model
│   ├── vapi-calls/          # Voice calls via Vapi AI
│   ├── workflow-builder/     # Design new autonomous workflows
│   └── openclaw/       # Self-management & updates
│
├── workflows/          # Autonomous agents with state & learning
│   ├── email-steward/  # Inbox triage — archive noise, surface what matters
│   ├── task-steward/   # Classify, create, execute, and QA tasks
│   ├── calendar-steward/    # Daily briefing with travel & meeting prep
│   ├── contact-steward/    # Detect and organize unknown contacts
│   ├── security-sentinel/  # Threat intelligence & exposure mapping
│   └── cron-healthcheck/   # Broken cron detection & auto-remediation
│
├── memory/             # Example memory directory structure
│   ├── people/         # One file per person
│   ├── projects/       # One file per project
│   ├── topics/         # Domain expertise & preferences
│   └── decisions/      # Important decisions with reasoning
│
└── devops/             # Health checks & fleet management

Skills

Each skill is a standalone UV script —
Python with inline dependencies, no project-level setup. Run directly, version
independently.

Workflows

Workflows are autonomous agents that run on a schedule. Unlike skills (tools you
invoke), workflows maintain state, learn your preferences, and manage themselves.

Each workflow maintains its own state:

• AGENT.md — The algorithm (updates when you update openclaw-config)
• rules.md — Your preferences (never overwritten)
• agent_notes.md — Patterns it learns over time
• logs/ — Execution history

Memory Architecture

Most AI memory is "dump everything into a vector database." OpenClaw uses deliberate,
structured memory with clear tiers:

Tier 1 — Always loaded. MEMORY.md stays in context every conversation. Curated to
~100 lines of what matters most.

Tier 2 — Daily context. memory/YYYY-MM-DD.md files. Today and yesterday load
automatically. Raw observations, not curated.

Tier 3 — Deep knowledge. memory/people/, projects/, topics/, decisions/.
Searched via vector embeddings (LM Studio local or OpenAI). Retrieved when relevant, not
loaded by default.

The librarian skill promotes durable knowledge upward — daily observations become
structured knowledge, structured knowledge gets summarized into MEMORY.md.

What gets remembered is filtered through four criteria:

Design Principles

• Files over databases — Markdown in git beats any proprietary store. Readable,
  diffable, portable.
• Self-contained skills — No shared dependencies, no coordination overhead. Each
  skill carries its own pip install inline.
• Workflows that learn — Agents should get better at their job over time, not just
  repeat the same script.
• Two-way door decisions — Act freely on reversible decisions. Pause and confirm on
  irreversible ones.
• Prose over config — Language models reason better in natural language than in JSON
  schemas.

DevOps

Infrastructure-as-code for running OpenClaw in production. Supports macOS (launchd) and
Linux (systemd) with the same operational model.

Health Monitoring

devops/health-check.md is an autonomous agent that runs every 30 minutes via cron. It
checks gateway liveness, model catalog health, cron job status, channel connectivity,
disk/memory, and log health. It can fix routine issues (restart services, kill hung
processes, clean old logs) and escalates to the fleet owner when things break that were
working.

Health checks follow a silent success model — the admin only gets notified when
something is wrong or was fixed, never for routine health.

Machine Setup

Desired-state specifications that define what a healthy OpenClaw machine looks like:

Each section follows the pattern: desired state → verify command → fix
command. The health check agent uses these specs for drift detection.

Security Hardening

devops/machine-security-review.md is a security-focused agent that runs daily (drift
detection) and weekly (full audit + red team). It checks firewall config, open ports,
file permissions, SSH hardening, credential exposure, prompt injection in memory/agent
files, skill script integrity, and MCP tool poisoning. It can auto-fix safe issues
(permission tightening) and escalates everything else to the fleet admin.

The companion workflows/security-sentinel/ researches emerging AI security threats
weekly and maps them against the fleet's exposure.

Notification Routing

devops/notification-routing.md defines a two-lane model:

• Admin lane — System health alerts go to the fleet owner (e.g., "gateway down on
  Ali's machine")
• User lane — Cron outputs go to the host person (e.g., EOD briefing, email alerts)

Lanes never mix. Health check agents use delivery.mode: "none" and self-notify the
admin directly.

Automation Services

Three services run on every OpenClaw machine, defined as launchd plists (devops/mac/)
or systemd units (devops/linux/):

Fleet Management

For multi-machine deployments, the /fleet command manages remote OpenClaw instances
from a master machine. Fleet state lives in ~/openclaw-fleet/ (one markdown file per
server). The gateway-restart skill ensures graceful restarts that don't interrupt
active conversations.

Documentation

Deep-dive guides for advanced setups and multi-agent coordination:

Multi-Agent Coordination

If you're running multiple OpenClaw instances that need to coordinate:

• Single-gateway multi-agent: Fast in-process communication via sessions_send()
• Multi-gateway fleet: Isolated agents across machines/VPS, coordinating via Slack

Both patterns are documented with working configs, troubleshooting guides, and boot
runbooks.

Development

uv run --with pytest pytest tests/ -v

Integration tests auto-skip when API keys aren't set.

Contributing

PRs welcome. Keep templates generic (no personal content). Each skill should remain
self-contained with its own inline dependencies.

License

MIT

Built by TechNickAI
_{Your AI deserves to remember you.}