Building AI Agents With a Soul

I run an AI assistant called OpenClaw as my daily productivity system. It handles scheduling, research, content creation, social media posting, software engineering, and the rest of the stack. It works well, but I kept hitting the same limit: one agent, one personality, doing everything.

Ask a generalist AI to write code and it will do it the same way it drafts a social media post. That works, sort of, but it is not optimal. A software engineer thinks differently than a copywriter. A database analyst thinks differently than a social media manager.

So I built specialized agents, each with their own workspace, their own model preference, and their own identity.

The Architecture

I run a main orchestrator agent, which I call DATA, that handles triage, delegation, and synthesis. It decides which task goes to which specialist. The specialists live under ~/clawd/agents/<id>/, and each one gets two files that define who they are:

SOUL.md
This is the agent's operating manual: what it is good at, how it approaches problems, what it cares about, and what boundaries it respects. It is not a prompt hack. It is more like a constitution. The coder agent, for example, opens with "I build things that work, and I build them well" and emphasizes structured thinking, edge-case awareness, and clean architecture. The social amplifier opens with "Make noise that matters" and focuses on engagement strategy and platform-specific nuance.

IDENTITY.md
If SOUL.md is the constitution, IDENTITY.md is the badge. It gives the agent a name, a persona, a communication style, and a default response structure. The researcher agent, for instance, defaults to evidence-driven investigation with clear source attribution. The SQL agent treats every data question as uncovering a story, because that is what it is designed to do.

Why It Matters

Before this change, every task came to the same agent with the same context. The difference between writing a blog post and debugging a database query was handled entirely by the prompt I happened to write in that moment. That meant inconsistent output quality and a lot of context-switching overhead on my end.

Now, when I need research done, it goes to an agent whose identity file says "I find what others miss" and who defaults to deep-dive investigation with multiple source verification. When I need code written, it goes to an agent whose soul file emphasizes architecture-first thinking and test coverage. I do not have to re-explain the approach every time. The agent already knows what kind of work it does.

The difference is tangible. Blog posts come back with better structure. Code comes back with better error handling. Research comes back with source citations built in. Each agent plays to its strengths because its identity tells it what those strengths are.

The Practical Setup

Each agent directory looks like this:

~/clawd/agents/
├── coder/                    # Software engineering
│   ├── SOUL.md
│   └── IDENTITY.md
├── researcher/               # Deep research & analysis
│   ├── SOUL.md
│   └── IDENTITY.md
├── sql/                      # Databases & data analysis
│   ├── SOUL.md
│   └── IDENTITY.md
├── motrix-blog-creator/      # Content writing
│   ├── SOUL.md
│   └── IDENTITY.md
└── motrix-social-amplifier/  # Social media
    ├── SOUL.md
    └── IDENTITY.md

Each agent also gets a separate model assignment. The software engineer runs on Claude Opus 4.7 for complex code reasoning. The researcher runs on DeepSeek Reasoner for analytical work. The social amplifier runs on Gemini Flash, which is fast enough for short-form work and cheap enough to run constantly. Right model for the shape of the work.

The Result So Far

After a week running this, the difference is real. The orchestrator handles the routing, the specialists handle the execution, and I just say what I need. It is closer to managing a team than typing prompts into a chatbot.

The next layer I am working on is self-improvement tracking: error logs, learning files, and feature requests that each agent maintains to get better over time. If an agent makes a mistake or discovers a better approach, it logs it and adapts. The system improves without me having to remember what went wrong last time.

If you are running OpenClaw or any other multi-agent system, give your agents an identity. Pick your two most frequent task types, write a SOUL.md for each, and route manually for a week before automating. It reads like fluff. It is not. It is the single highest-leverage change I have made to my setup.