Tools, MCP Servers & Skills

Tools and skills are what make your AI employee truly powerful. This guide covers built-in tools, MCP (Model Context Protocol) servers, marketplace integrations, and custom skills.

The Tools section in employee configuration

Understanding the Components

Built-in Tools

These tools are available to all employees without additional configuration:

Web Search

Enable your employee to search the internet for current information.

Configuring web search providers

To enable:

1. Go to employee configuration → Tools
2. Find the Web Search section
3. Toggle your preferred provider
4. Add API key if required (Settings → Tool Secrets)

Exec (Command Execution)

Allows your employee to run terminal commands in their isolated workspace.

Capabilities:

• File operations (create, read, modify files)
• Run scripts (Python, Node.js, etc.)
• Data processing and transformation
• System automation tasks

Example use cases:

User: "Create a CSV file summarizing our sales data"
Employee: *Uses exec to create and populate the file*

User: "Run my Python script to analyze the data"
Employee: *Executes the script and returns results*

Security Note: Commands run in an isolated container. Employees cannot access your local system or other employees' workspaces.

Cron (Scheduled Tasks)

Enable scheduled, recurring tasks for your employee.

Example schedules:

• Daily morning reports at 9 AM
• Weekly data backups every Sunday
• Hourly monitoring checks
• Monthly summary generation

MCP Servers (Model Context Protocol)

MCP is an open protocol that allows AI employees to securely connect to external data sources and tools. MakersFuel fully supports MCP, letting your employees integrate with virtually any service.

MCP Tools section showing installed tools

What Are MCP Servers?

MCP servers are bridges between your AI employee and external services:

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  AI Employee    │────▶│   MCP Server    │────▶│ External Service│
│  (MakerClaw)    │◀────│   (Bridge)      │◀────│ (GitHub, etc.)  │
└─────────────────┘     └─────────────────┘     └─────────────────┘

Why Use MCP?

Transport Types

MCP servers communicate via three transport methods:

Marketplace Tools

The easiest way to add capabilities—pre-configured MCP servers ready to install with one click.

Browse and install tools from the marketplace

Browsing the Marketplace

1. Go to employee configuration → MCP Tools
2. Click Browse Marketplace
3. Search or filter by category
4. View tool details and requirements

Marketplace Categories

Installing a Marketplace Tool

Tool installation with API key configuration

1. Find the tool — Browse or search the marketplace
2. Click Install — Opens configuration modal
3. Configure secrets — Enter required API keys:
   • Use Saved: Select from your Security Vault
   • Enter New: Paste a new key (optionally save to vault)
4. Complete installation — Tool appears in your tools list
5. Enable the tool — Toggle it on in your configuration

Managing Installed Tools

Managing your installed MCP tools

Each installed tool shows:

• Name and icon — Easy identification
• Status badge — "Configured" or "Needs Config"
• Source badge — "Marketplace" or "Custom"
• Enable toggle — Turn on/off without removing
• Action buttons — Configure, Edit, Remove

Custom MCP Tools

Create your own MCP server connections for internal tools, self-hosted services, or any MCP-compatible server.

Creating a custom MCP tool

When to Use Custom Tools

• Self-hosted services
• Internal company APIs
• Beta/unreleased MCP servers
• Custom-built integrations

Two Ways to Add Custom Tools

You can add custom tools using either JSON Mode (paste configuration) or Form Mode (guided input).

JSON Mode (Recommended for Developers)

Paste MCP server configuration JSON directly. This is ideal when you have a configuration from documentation or another source.

Example - stdio server:

{
  "command": "npx",
  "args": ["-y", "@anthropic/mcp-server-github"],
  "env": {
    "GITHUB_TOKEN": "{{GITHUB_TOKEN}}"
  }
}

Example - HTTP/SSE server:

{
  "url": "https://api.example.com/mcp",
  "headers": {
    "Authorization": "Bearer {{API_KEY}}"
  }
}

Note: The type field is optional. If omitted, the system auto-detects based on the presence of command (stdio) or url (http/sse).

Form Mode

Use the guided form to configure your tool step-by-step:

1. Enter basic information:
   • Server Name: Lowercase identifier (e.g., my-internal-api)
   • Display Name: Human-readable name (e.g., Internal API)
2. Select transport type and configure:For stdio (command-line):

  Command: npx
   Arguments: -y @myorg/mcp-server-internal

1. For HTTP/SSE (web endpoint):

URL: https://api.mycompany.com/mcp
   Headers: Authorization, X-API-Key, etc.

Using Variable Placeholders

You can use {{VARIABLE_NAME}} placeholders in your configuration to securely inject secrets. This works in both JSON and Form modes.

How it works:

1. Add placeholders in your configuration:

   {
     "command": "npx",
     "args": ["-y", "@anthropic/mcp-server-github"],
     "env": {
       "GITHUB_TOKEN": "{{GITHUB_TOKEN}}"
     }
   }

1. System detects variables — When you paste JSON or enter args with {{VARIABLE}} patterns, the system automatically detects them.
2. Configure each variable:
   • Use from Vault: Select an existing secret from your Security Vault
   • Enter Value: Paste a new value (optionally save to vault for future use)
3. Secure storage — Values are stored securely and injected at runtime. The actual secrets are never exposed in the configuration.

Configuring detected variables from JSON

Supported placeholder formats:

• {{VARIABLE_NAME}} — MakersFuel format (recommended)
• ${VARIABLE_NAME} — Shell/env var format (also supported)

Where placeholders work:

• Environment variables (env)
• Command arguments (args)
• URLs (url)
• Headers (headers)

Example Custom Configurations

GitHub Integration with Token:

{
  "command": "npx",
  "args": ["-y", "@anthropic/mcp-server-github"],
  "env": {
    "GITHUB_TOKEN": "{{GITHUB_TOKEN}}"
  }
}

Self-hosted Database:

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres"],
  "env": {
    "POSTGRES_URL": "{{POSTGRES_CONNECTION_STRING}}"
  }
}

Internal REST API:

{
  "url": "https://internal.mycompany.com/ai-gateway",
  "headers": {
    "Authorization": "Bearer {{API_TOKEN}}",
    "X-Service": "makerclaw"
  }
}

Security Vault

All API keys and secrets are managed through the Security Vault—encrypted storage for your sensitive credentials.

Managing secrets in Security Vault

Accessing the Vault

1. Go to Settings → Tool Secrets
2. View all your saved secrets
3. Add, edit, or delete secrets

Adding Secrets

From Settings:

1. Click Add Secret
2. Enter secret name (e.g., "Brave API Key")
3. Select secret type (helps with matching)
4. Paste the secret value
5. Save

During Tool Configuration:

1. When configuring variables, check "Save to Security Vault"
2. Enter a name for the secret
3. Secret is saved and referenced automatically

Security Features

Best Practices

• Use descriptive names: "Brave Search - Production" not "API Key 1"
• Rotate regularly: Update secrets periodically
• Delete unused: Remove secrets for discontinued services
• Prefer vault: Always save to vault rather than inline
• Use variables: Leverage {{VARIABLE}} placeholders for secure injection

Skills

Skills are modular capabilities that extend your AI employee's functionality. Each skill packages instructions, metadata, and optional resources that the employee uses automatically when relevant.

Managing employee skills

Why Use Skills?

Skills provide domain-specific expertise that transforms a general-purpose AI employee into a specialist:

• Specialize: Tailor capabilities for domain-specific tasks
• Reduce Repetition: Create once, use automatically
• Compose Capabilities: Combine skills to build complex workflows

Skill Structure (SKILL.md Format)

Every skill requires a SKILL.md file with YAML frontmatter:

---
name: customer-support
description: Handle customer inquiries, process refunds, and escalate issues. Use when users ask about orders, billing, or account problems.
---

# Customer Support

## Quick Start

Greet customers warmly and identify their issue before providing solutions.

## Guidelines

- Acknowledge the customer's issue before providing solutions
- Use simple language, avoid technical jargon
- End conversations with "Is there anything else I can help with?"

## Escalation Rules

Escalate to human agent when:
- Customer requests human assistance
- Billing disputes over $100
- Technical issues unresolved after 3 attempts

Required Metadata Fields

Important: Write descriptions in third person. The description is used by the AI to determine when to activate the skill.

Writing Effective Descriptions

The description field is critical for skill discovery. Include both what the skill does and when to use it:

Good examples:

description: Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.

description: Generate descriptive commit messages by analyzing git diffs. Use when the user asks for help writing commit messages or reviewing staged changes.

Bad examples (too vague):

description: Helps with documents
description: Processes data

Skill Content Best Practices

Be Concise:
Claude is already smart—only add context it doesn't have. Challenge each piece of information: "Does Claude really need this explanation?"

Use Progressive Disclosure:
Keep the main SKILL.md under 500 lines. Split detailed content into separate files that are loaded only when needed:

customer-support/
├── SKILL.md           # Main instructions (loaded when triggered)
├── REFUNDS.md         # Refund procedures (loaded as needed)
├── ESCALATION.md      # Escalation rules (loaded as needed)
└── scripts/
    └── validate.py    # Utility script (executed, not loaded)

Reference additional files in your main SKILL.md:

## Advanced Topics

**Refund Processing**: See [REFUNDS.md](REFUNDS.md) for complete guide
**Escalation Procedures**: See [ESCALATION.md](ESCALATION.md) for when to escalate

Provide Concrete Examples:

## Example Interactions

### Handling a Refund Request

**Customer:** "I want a refund for order #12345"

**Response:** "I understand you'd like a refund for order #12345.
Let me look that up for you.

[Checks order details]

I can see this order was placed 5 days ago and is eligible for
a full refund. Would you like me to process that now?"

Define Clear Boundaries:

## What NOT to Do
- Never share customer data with other customers
- Don't make promises about unreleased features
- Always escalate legal questions to the legal team
- Don't process refunds over $500 without manager approval

Multi-File Skills

For complex skills, organize content by domain:

research-skill/
├── SKILL.md              # Overview and navigation
├── sources/
│   ├── academic.md       # Academic research methods
│   ├── market.md         # Market research methods
│   └── competitor.md     # Competitor analysis
├── templates/
│   ├── report.md         # Report template
│   └── summary.md        # Executive summary template
└── scripts/
    └── cite.py           # Citation formatting script

Types of Skills

Creating a Custom Skill

1. Go to employee configuration → Skills
2. Click Add Skill
3. Choose Custom Skill
4. Enter a category/folder name (e.g., "customer-support")
5. Write your SKILL.md content with YAML frontmatter
6. Save

Workflow Patterns for Skills

For complex tasks, provide step-by-step workflows:

## Research Workflow

1. **Understand the question**
   - Clarify scope and objectives
   - Identify key terms and topics

2. **Gather information**
   - Search multiple sources
   - Cross-reference findings

3. **Analyze and synthesize**
   - Identify patterns and themes
   - Note conflicting information

4. **Present findings**
   - Executive summary (3-5 sentences)
   - Key findings (bullet points)
   - Detailed analysis
   - Sources with links

Feedback Loops

Include validation steps for quality-critical tasks:

## Content Review Process

1. Draft your content following the guidelines
2. Review against the checklist:
   - Check terminology consistency
   - Verify examples follow the standard format
   - Confirm all required sections are present
3. If issues found:
   - Note each issue with specific section reference
   - Revise the content
   - Review the checklist again
4. Only proceed when all requirements are met

Combining Tools and Skills

The most powerful employees combine tools with skills effectively.

Example: Research Assistant

Tools Enabled:

• Web Search (Brave)
• Exec (for saving files)

MCP Tools:

• Notion (for storing research)
• GitHub (for code examples)

Skill (SKILL.md):

---
name: research-assistant
description: Conducts market research and competitor analysis. Use when users ask for research, analysis, or competitive intelligence.
---

# Research Assistant

## Quick Start

Use web search to gather information, cross-reference findings, and store structured notes in Notion.

## Research Process

1. Understand the research question
2. Search multiple sources using web search
3. Cross-reference findings
4. Store structured notes in Notion
5. Save detailed reports to workspace
6. Provide executive summary

## Output Format

Always structure research as:
- Executive Summary (3-5 sentences)
- Key Findings (bullet points)
- Detailed Analysis
- Data Sources (with links)
- Recommendations
- Confidence Level (High/Medium/Low)

Example: DevOps Assistant

Tools Enabled:

• Exec (command execution)
• Cron (scheduled tasks)

MCP Tools:

• GitHub (code management)
• Slack (notifications)
• PostgreSQL (database access)

Skill (SKILL.md):

---
name: devops-assistant
description: Helps with deployment, monitoring, and infrastructure tasks. Use when users ask about deployments, CI/CD, monitoring, or server operations.
---

# DevOps Assistant

## Quick Start

Use GitHub for code management, monitor database health, and send alerts to Slack.

## Capabilities

- Deploy code via GitHub actions
- Monitor database health
- Send alerts to Slack
- Run scheduled maintenance tasks

## Safety Rules

- Always confirm destructive actions
- Never modify production without explicit approval
- Log all operations for audit trail
- Alert humans for critical issues

## Deployment Checklist

Before any deployment:
1. [ ] Verify all tests pass
2. [ ] Check for breaking changes
3. [ ] Confirm rollback plan exists
4. [ ] Notify team via Slack

Troubleshooting

Tool Not Working

1. Check configuration — Is the tool enabled?
2. Verify secrets — Are API keys correct and active?
3. Test the service — Is the external service up?
4. Check limits — Have you hit API rate limits?

MCP Server Connection Failed

1. Verify transport type — Correct type selected?
2. Check URL/command — Correct endpoint or command?
3. Test credentials — Are secrets properly configured?
4. Check variable placeholders — Are all {{VARIABLES}} configured?
5. Review logs — Check for error messages

Skill Not Being Applied

1. Check skill is enabled — Toggle should be on
2. Verify YAML frontmatter — Must have name and description
3. Check description — Should clearly indicate when to use the skill
4. Test with simple prompt — Verify basic behavior
5. Check for conflicts — Multiple skills may contradict

Variables Not Being Replaced

1. Check placeholder format — Use {{VARIABLE_NAME}} format
2. Verify variable is configured — Check the variable configuration panel
3. Check Security Vault — Ensure selected secret exists and has a value

Best Practices Summary

Next Steps

• Managing Employees — Day-to-day operations
• Employee Channels — Communication setup
• Configuring Your Employee — Full configuration guide