Your Tools & Data

goClaw is designed to work with the tools and data you already have. The sixth pillar — "Your Tools & Data" — means you can extend the agent with custom MCP tools, external APIs, and proprietary datasources without modifying the core platform.

MCP (Model Context Protocol)

All agent capabilities in goClaw are exposed through MCP — the same protocol used by Claude Code, Cursor, and other AI-native development tools. This means:

• Any MCP server you've built works with goClaw out of the box
• goClaw's built-in tools (CRM, knowledge, channels) use the same interface as your custom tools
• The agent can discover and use new tools from its context

What MCP provides

MCP is a standard interface for LLMs to call external functions. In goClaw, the agent uses MCP tools to:

• Query your CRM
• Search knowledge
• Send messages
• Look up data in your systems
• Call external APIs

From the agent's perspective, all tools look the same — it just calls them by name with typed inputs.

Adding a custom MCP tool

Custom tools are defined in a tool manifest file. Each tool has a name, description, input schema, and a handler function.

Tool manifest

// tools/my-tools.ts
import { ToolManifest } from "@clawrm/core";

export const tools: ToolManifest = {
  crm_get_deal: {
    description: "Look up an active deal by contact ID in Salesforce",
    input_schema: {
      type: "object",
      properties: {
        contact_id: { type: "string", description: "goClaw contact ID" },
      },
      required: ["contact_id"],
    },
    handler: async (input) => {
      const email = await crm.getContactEmail(input.contact_id);
      const deals = await salesforce.query(
        `SELECT Id, Name, Amount, StageName FROM Opportunity WHERE Contact.Email = '${email}'`
      );
      return { deals };
    },
  },

  get_account_health: {
    description: "Get account health score and recent activity from your analytics system",
    input_schema: {
      type: "object",
      properties: {
        company: { type: "string" },
        metric: {
          type: "string",
          enum: ["health_score", "active_users", "last_login", "revenue"],
        },
      },
      required: ["company", "metric"],
    },
    handler: async (input) => {
      return await analyticsApi.getAccountMetric(input.company, input.metric);
    },
  },
};

Register tools

// In your agent entry point
import { registerTools } from "@clawrm/core";
import { tools } from "./tools/my-tools";

registerTools(tools);

Once registered, tools are available to the agent based on the group's tool_allowlist configuration.

Connecting external data sources

Database queries

For simple database lookups, you can expose a query tool directly:

get_customer_data: {
  description: "Query customer data from your Postgres database",
  input_schema: {
    type: "object",
    properties: {
      email: { type: "string" },
      fields: {
        type: "array",
        items: { type: "string" },
        description: "Fields to return: subscription_status, plan, mrr, signup_date"
      },
    },
    required: ["email"],
  },
  handler: async (input) => {
    const fields = input.fields?.join(", ") ?? "*";
    const row = await db.query(
      `SELECT ${fields} FROM customers WHERE email = $1`,
      [input.email]
    );
    return row;
  },
},

REST API wrappers

Wrap any REST API as an MCP tool:

get_github_activity: {
  description: "Get recent GitHub activity for a developer",
  input_schema: {
    type: "object",
    properties: { username: { type: "string" } },
    required: ["username"],
  },
  handler: async ({ username }) => {
    const res = await fetch(`https://api.github.com/users/${username}/events`, {
      headers: { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` },
    });
    const events = await res.json();
    return events.slice(0, 10).map(e => ({
      type: e.type,
      repo: e.repo.name,
      date: e.created_at,
    }));
  },
},

Existing MCP servers

If you already have MCP servers (Claude Code configs, Cursor integrations, etc.), they can be mounted directly:

# config/agent.yaml
mcp_servers:
  - name: "my-internal-tools"
    command: "node"
    args: ["./mcp-servers/internal-tools.js"]
    env:
      API_KEY: "${INTERNAL_API_KEY}"

The agent can use tools from mounted MCP servers alongside goClaw's built-in tools.

Data access patterns

Pattern 1 — Query on demand

The agent queries your system during execution when it needs a specific piece of data.

Best for: Contact-level data lookups (deal status, account health, subscription tier).

// Agent calls during execution:
// "Let me check this prospect's account status before responding."
await mcp.tool("get_account_health", { company: "Acme Corp", metric: "health_score" });

Pattern 2 — Knowledge enrichment

Batch data is loaded into the knowledge base as Markdown files, where it's available for full-text retrieval.

Best for: Bulk reference data (product catalog, pricing, company descriptions, competitor info).

# Export data to Markdown and import into knowledge
node scripts/export-products-to-markdown.js > knowledge/products/catalog.md
npx @clawrm/cli knowledge reindex

Pattern 3 — Webhook-triggered execution

Your system sends a webhook to goClaw when an event occurs (new signup, trial expiry, support ticket opened). The agent responds to the event.

// Register a webhook handler
import { webhooks } from "@clawrm/core";

webhooks.on("trial_expiring", async (payload) => {
  const contact = await crm.findByEmail(payload.email);
  await agent.run({
    group: "sales",
    task: "trial_expiry_outreach",
    context: { contact, days_remaining: payload.days_remaining },
  });
});

Skills and learned procedures

The agent doesn't just consume static data — it writes procedures back to the skills system.

When the agent successfully completes a complex multi-step task, it can create a skill file:

---
skill: salesforce_opportunity_lookup
version: 1
created: 2026-03-01
tags: [crm, salesforce, deals]
---

# Salesforce Opportunity Lookup

## Steps
1. Use `crm_get_contact` to retrieve the contact's email
2. Call `crm_get_deal` with the contact ID
3. If multiple deals exist, select the most recent active opportunity
4. Summarize deal stage, amount, and last activity date for context

On subsequent executions, the agent references this skill instead of re-discovering the procedure. Skills improve over time as the agent encounters edge cases and updates the procedure.