Build a Custom OpenClaw Skill with MCP: A Trello Integration Walkthrough

OpenClaw went from zero to 190,000+ GitHub stars in under two months. If you haven't seen it yet, it's an open-source AI agent that runs locally and connects to any LLM such as Claude, GPT, DeepSeek, and others, using messaging platforms like Signal, Telegram, and Discord as its interface.

What makes OpenClaw interesting for developers is its skill system. A skill is just a folder with a SKILL.md file. No SDK, no compilation, no special runtime. You write Markdown instructions that teach the agent how to do something, and optionally bundle scripts, MCP servers, or config files alongside them.

I recently built a Trello MCP server for managing my blog editorial calendar through Claude Cowork. In this post, I'll show you how to take that same MCP server and package it as a local OpenClaw skill, so you can manage your Trello boards through your OpenClaw agent. We'll cover:

• How OpenClaw skills work (the SKILL.md format)
• Connecting an MCP server to OpenClaw
• Writing effective agent instructions
• Using your skill locally

If you've already built an MCP server for any API, you're most of the way to having an OpenClaw skill. Let's close the gap!

How OpenClaw Skills Work

At its core, a skill is a folder in ~/.openclaw/workspace/skills/ containing a SKILL.md file. That's the only hard requirement. The file has two parts:

1. YAML frontmatter: metadata about the skill (name, description, dependencies)
2. Markdown body: instructions that load into the agent's context when the skill is active

Here's the simplest possible skill:

1---
2name: hello-world
3description: A simple greeting skill.
4---
5
6# Hello World
7
8When the user asks for a greeting, respond with "Hello from your custom skill!"
Copy to clipboard

No code. No build step. The Markdown body is literally the prompt that gets injected into the agent's context. This is why skill design is really prompt engineering: the better your instructions, the more reliably the agent uses your tools.

Frontmatter Fields

The frontmatter tells OpenClaw what your skill needs to run:

1---
2name: trello-mcp
3description: Manage Trello boards, lists, and cards through natural language.
4version: 1.0.0
5metadata:
6  openclaw:
7    requires:
8      env:
9        - TRELLO_API_KEY
10        - TRELLO_TOKEN
11      bins:
12        - node
13    primaryEnv: TRELLO_API_KEY
14    emoji: "📋"
15    homepage: https://github.com/rdeprey/trello-mcp-server
16---
Copy to clipboard

The key fields under metadata.openclaw are listed below.

Getting these declarations right matters. If your code references TRELLO_API_KEY but your frontmatter doesn't list it under requires.env, OpenClaw won't prompt the user to set it and the skill will fail silently at runtime.

Connecting Your MCP Server

OpenClaw can spawn MCP servers as child processes. When the agent starts, it discovers the tools your server exposes through the MCP protocol, and routes tool calls to your server over stdio. Claude Desktop handles local MCP servers the same way.

If you already have an MCP server (like the Trello connector I built previously), you have two options for integrating it:

Option A: Reference an Existing MCP Server

If your MCP server is published as an npm package or lives in a known path, your SKILL.md instructions can tell OpenClaw how to launch it:

1---
2name: trello-mcp
3description: Manage Trello boards, lists, and cards through natural language.
4version: 1.0.0
5metadata:
6  openclaw:
7    requires:
8      env:
9        - TRELLO_API_KEY
10        - TRELLO_TOKEN
11      bins:
12        - node
13    primaryEnv: TRELLO_API_KEY
14    emoji: "📋"
15---
16
17# Trello Skill
18
19This skill connects to Trello via MCP. Make sure the Trello MCP server
20is configured in your OpenClaw MCP settings:
21
22## Setup
23
24Add this to your OpenClaw MCP configuration (`~/.openclaw/config.json`):
25
26\```json
27{
28  "mcpServers": {
29    "trello": {
30      "command": "npx",
31      "args": ["-y", "trello-mcp-server"],
32      "env": {
33        "TRELLO_API_KEY": "${TRELLO_API_KEY}",
34        "TRELLO_TOKEN": "${TRELLO_TOKEN}"
35      }
36    }
37  }
38}
39\```
40
41## Available Tools
42
43Once connected, you have access to these Trello tools:
44
45### Board Management
46- **trello_list_boards** — List all boards the user has access to
47- **trello_get_board** — Get board details including lists and labels
48- **trello_list_lists** — List all lists on a board
49- **trello_create_list** — Create a new list
50
51### Card Operations
52- **trello_list_cards** — List cards on a board or in a specific list
53- **trello_create_card** — Create a new card with title, description, due date, labels
54- **trello_update_card** — Update card fields or move to a different list
55- **trello_delete_card** — Permanently delete a card (prefer archiving with update)
56- **trello_search_cards** — Search across all boards with Trello search operators
57
58### Collaboration
59- **trello_list_members** — List board members
60- **trello_add_comment** — Add a comment to a card
61- **trello_get_comments** — Read comments on a card
62- **trello_add_checklist** — Create a checklist with items
63- **trello_create_label** — Create a new label on a board
64
65## Usage Guidelines
66
67When the user asks to interact with Trello:
68
691. **Always start by listing boards** if you don't know the board ID yet.
70   Call `trello_list_boards` first to discover available boards.
71
722. **Get the board details** to learn its lists and labels before creating
73   or moving cards. Call `trello_get_board` with the board ID.
74
753. **Use markdown format by default** for responses shown to the user.
76   Switch to JSON format when you need to parse the response for a follow-up action.
77
784. **When creating cards**, ask for the list if the user doesn't specify one.
79   If they say something like "add it to the todo column," match that against
80   the list names you got from `trello_get_board`.
81
825. **Prefer archiving over deleting.** Use `trello_update_card` with
83   `closed: true` instead of `trello_delete_card` unless the user
84   explicitly asks to permanently delete.
85
866. **For search**, remember that Trello supports operators like `@member`,
87   `#label`, `board:name`, `list:name`, `is:open`, `has:attachments`, and `due:week`.
Copy to clipboard

Option B: Bundle the Server Inside the Skill

For a self-contained skill, you can include the MCP server source directly in the skill folder:

trello-mcp/
├── SKILL.md
├── package.json
├── src/
│   ├── index.ts
│   ├── constants.ts
│   ├── types.ts
│   ├── schemas/
│   │   └── common.ts
│   ├── services/
│   │   └── trello-client.ts
│   └── tools/
│       ├── boards.ts
│       ├── cards.ts
│       └── members.ts
└── tsconfig.json

The SKILL.md instructions would then reference the local server path. This approach is simpler since everything lives together, but the skill folder is larger.

Writing Effective Agent Instructions

The Markdown body of your SKILL.md is where skill design gets interesting. These instructions become part of the agent's prompt, so they directly affect how reliably it uses your tools. Here's what I've learned:

Be Specific About Workflow Order

Agents make fewer mistakes when you tell them the sequence of operations:

1## Workflow
2
31. Always call `trello_list_boards` first to discover board IDs
42. Then call `trello_get_board` to learn the lists and labels
53. Only then create, update, or move cards
Copy to clipboard

Without this, the agent might try to create a card without knowing the list ID, fail, and confuse or frustrate the user.

Describe When NOT to Use a Tool

Negative instructions are surprisingly effective:

1- Do NOT call `trello_delete_card` unless the user explicitly says "permanently delete."
2  Use `trello_update_card` with `closed: true` to archive instead.
3- Do NOT create duplicate cards. Search first if the user says "add" something
4  that might already exist.
Copy to clipboard

Map Natural Language to Tool Parameters

Users won't say "set idList to abc123." They'll say "move it to Done." Your instructions should bridge that gap:

1When the user refers to lists by name (e.g., "move it to Done" or "add to In Progress"),
2match their words against the list names returned by `trello_get_board`. List names are
3case-insensitive for matching purposes.
Copy to clipboard

Keep It Concise

Every token in your SKILL.md body costs context window space. The agent has to hold these instructions alongside the conversation, tool schemas, and other active skills. Aim for clear, actionable instructions, not documentation. If you need detailed docs, link to an external page.

Testing Your Skill Locally

Install your skill by placing it in the skills directory:

1cp -r ./trello-mcp ~/.openclaw/workspace/skills/trello-mcp
Copy to clipboard

Then either restart your OpenClaw agent or ask it to refresh skills. Test with progressively complex requests:

1. Basic discovery: "What Trello boards do I have?"
2. Read operations: "Show me the cards in the To Do list on my Blog board"
3. Write operations: "Create a card called 'Write OpenClaw post' in the Doing column"
4. Multi-step: "Move all cards labeled 'done' from In Progress to the Done list"
5. Search: "Find any cards about React across all my boards"

If the agent makes mistakes, the fix is almost always in your SKILL.md instructions and not in the MCP server code. The server does what it's told. The skill instructions determine whether the agent tells it the right thing.

From One MCP Server to Two Ecosystems

Here's what I find compelling about this approach: the same MCP server works in both Claude Cowork and OpenClaw. I built the Trello connector once, and now it powers:

• A custom connector in Claude Cowork via Claude Desktop's MCP configuration
• An OpenClaw skill via the SKILL.md wrapper that teaches the agent how to use the tools

The MCP server code didn't change at all between the two. The only difference is the instruction layer. Claude gets its instructions through the tool descriptions baked into the MCP schema, while OpenClaw gets additional context from the SKILL.md body.

This is the real value of building on MCP: write your integration once, and it works across any agent that speaks the protocol. As more AI products adopt MCP, that investment keeps paying off.

Wrapping Up

Building an OpenClaw skill is mostly about writing good instructions. If you already have an MCP server, you're 90% done. The remaining work is:

1. Create a SKILL.md with proper frontmatter declaring your dependencies
2. Write clear agent instructions that map natural language to tool calls
3. Test locally until the agent reliably handles your target workflows

If you've built an MCP server for any API, wrapping it as an OpenClaw skill takes a few minutes. And since skills are just folders, you can share them with others through Git or any file transfer method.