Your Automation Skills, Everywhere —
VS Code, Mobile, and Beyond

When we first built Automation Skill Builder, the vision was simple: let developers and power users compose, store, and deploy automation skills — repeatable, AI-driven task sequences that handle the tedious parts of digital work, running entirely on your own machine. Local-first is not a constraint; it is a deliberate design choice. Your skills, your data, your compute — no cloud dependency, no remote execution, no third-party handling of your workflows.

What we didn't fully anticipate was how rapidly the ecosystem around Model Context Protocol (MCP) would mature, and how that maturity would turn our platform into something far bigger: a fully open AI agent surface, accessible from virtually any AI client, on virtually any device — while keeping every skill execution firmly local on your machine.

This post is the story of that journey. We'll walk through what MCP support means for Automation Skill Builder, which clients we've tested and verified, and — the part that genuinely surprised us — how a combination of ChatMCP and Tailscale lets you manage automations from an Android phone while sitting on a park bench, with every skill still running on your own hardware.

What MCP Actually Changes

Before MCP, every AI integration was a custom affair. You'd write a plugin, a webhook, a purpose-built API connector — and then repeat the process for every new client or model provider. The Model Context Protocol flips this. It defines a standard wire protocol — think USB-C, but for AI tools — so that any MCP-capable client can discover and invoke tools exposed by any MCP-capable server, with no per-client integration work on either side.

For Automation Skill Builder, this meant a single MCP server implementation unlocks compatibility with every client that speaks the protocol — today's and tomorrow's. We expose skill management operations (list, run, create, edit, delete) as MCP tool definitions, and any agent can call them as naturally as it calls a web search or a file reader. Crucially, this all happens through a locally-running server on your machine — no skill data leaves your environment.

The protocol runs over SSE (Server-Sent Events) for network-accessible connections or stdio for local process-based integrations. Automation Skill Builder runs its MCP server locally — binding to localhost:8800 on your machine by default. Desktop clients connect directly over the loopback interface. Mobile access, as we'll see, uses Tailscale to bridge your phone into the same local network.

The Verified Client Lineup

We didn't just ship the MCP server and call it done. We systematically tested every major AI client we could get our hands on, running the same battery of skill operations — list, trigger, inspect results — on each. Here's what we found.

VS Code: The Developer's Home Ground

For most developers, VS Code is already the hub of their workflow. With GitHub Copilot's Agent mode and its built-in MCP support, connecting to Automation Skill Builder takes about two minutes. Open your Copilot settings, add the local server configuration, and the next time you chat with the agent it will have access to all your defined automation skills.

The integration shines when you're deep in a coding task and realize you need to trigger a supporting automation — say, a skill that fetches API docs, reformats a configuration file, or runs a pre-defined test sequence. Rather than context-switching to a browser, you simply tell Copilot to run the skill, and it does.

mcp config — VS Code settings.json{
  "mcp": {
    "servers": {
      "automation-skill-builder": {
        "type": "sse",
        "url": "http://127.0.0.1:8800/mcp/sse"
      }
    }
  }
}

Cherry Studio: The Visual Way

Cherry Studio is the client we recommend to users who prefer a visual interface over config files. Its MCP server management panel lets you add, enable, and disable servers through a clean GUI, and it shows you a live list of discovered tools the moment a connection is established. There's something genuinely satisfying about seeing your custom automation skills appear as first-class tools in a chat interface — it makes the platform feel alive.

Cherry Studio also handles the nuance of tool calling well: it shows the tool name, the arguments passed, and the raw result inline in the conversation thread, which makes debugging a malfunctioning skill much more ergonomic than staring at server logs.

Cline: For Autonomous Task Agents

Cline is not a chat assistant — it's an autonomous agent that takes multi-step tasks and executes them with minimal hand-holding. It can read files, write code, run terminals, and, via MCP, invoke external tools. Pairing Cline with Automation Skill Builder creates a particularly powerful loop: Cline can decide autonomously which of your skills to invoke as part of a larger task, without you needing to specify it upfront.

For example, tell Cline to "set up the project, run the data normalization skill, and then generate the report." It will orchestrate the steps, delegating the normalization work to the appropriate Automation Skill Builder skill through MCP, without any manual intervention. This is autonomous agent behavior in practice, not just in marketing copy.

ChatMCP: The Bridge to Mobile

Here's where things get genuinely exciting. The clients we've discussed so far are all desktop-first. But ChatMCP — an open-source, cross-platform MCP client — ships both a desktop application and an Android app. That single fact opens a door that previously required either a full mobile API integration project or a purpose-built app.

ChatMCP's design philosophy mirrors the protocol it's built on: it's a thin, capable client that does one thing well. You add an MCP server, you chat with it, and the tool-calling mechanism handles the rest. On Android, the experience is remarkably polished — conversation threading, tool invocation logs, and server status indicators all behave as you'd expect from a well-maintained mobile app.

Why Tailscale?

Automation Skill Builder runs locally on your machine — that's the whole point. The MCP server listens on localhost:8800, which is only reachable by processes on the same machine. Your Android phone on a mobile network is a completely separate device, so there's no path to localhost from it. Tailscale solves this elegantly.

Tailscale creates a private mesh network between your enrolled devices — your development machine, your phone, and any other devices you add — giving each a stable, private 100.x.x.x IP address that works regardless of which physical network each device is on. Once both your machine and your phone are on the same Tailscale tailnet, your phone can reach your machine's Tailscale IP on port 8800, just as if it were on your local WiFi. There is no exposure to the public internet — only devices in your tailnet can connect.

This also means any local tools that need filesystem access, local credentials, or other sensitive resources remain safely isolated. The Tailscale tunnel is authenticated and encrypted end-to-end.

Setting It All Up: A Practical Guide

The conceptual picture is satisfying, but let's get practical. Here's how to go from zero to managing Automation Skill Builder from your Android phone.

Step 1 — Generate Your Service Secret Token

Open Automation Skill Builder on your machine and navigate to the settings panel. Create a service secret token — this token secures your local MCP endpoint when it's accessed over the Tailscale network. Copy it somewhere safe; you'll reference it in your mobile client config.

Step 2 — Set Up Tailscale

Step 3 — Install and Configure ChatMCP on Android

ChatMCP is available through its official GitHub releases page. Install it on your Android device, launch the app, and navigate to the server settings panel. Add a new MCP server pointing to your machine's Tailscale IP:

ChatMCP server config — AndroidName:    Automation Skill Builder
Type:    SSE
URL:     http://100.x.x.1:8800/mcp/sse
         ↑ replace with your machine's Tailscale IP
Headers:
  Authorization: Bearer <your-service-secret-token>

Once saved, tap "Connect." Within a few seconds you should see the tool list populate — tools like list_skills, run_skill, create_skill, and get_skill_result. You're connected, and every tool call runs on your local machine.

What You Can Actually Do From Your Phone

It's one thing to say "you can connect from Android." It's another to understand what that actually enables in practice. Here are the workflows we've found most valuable.

Monitoring and Triggering Running Automations

The most common mobile use case is checking in on automation workflows that were set up on desktop. Using ChatMCP, you can ask the AI to list your active skills, check the status of recent runs, and view execution logs — all in natural language. "Show me the last five runs of the data-sync skill and tell me if any failed" is a valid prompt, and ChatMCP will call the right MCP tools to answer it, with the actual execution happening on your machine.

You can also trigger skills on demand. If a stakeholder messages you while you're away from your desk asking for a fresh report, you can open ChatMCP, ask it to run your report-generation skill, and share the result — without ever touching a laptop.

Creating and Editing Skills on the Go

The create_skill and update_skill MCP tools expose the full skill authoring API. Through natural language, you can describe a new automation to ChatMCP, and it will scaffold the skill definition and call the creation tool. For quick adjustments — changing a parameter, updating a schedule, fixing a prompt — this mobile editing flow is genuinely faster than opening a laptop.

Debugging With AI Assistance

This is perhaps the most underappreciated use case. When a skill fails, you typically need to look at the execution log, understand what went wrong, and decide how to fix it. ChatMCP lets you bring the AI model into that debugging loop directly: "Fetch the last failed run of skill X, read the error log, and suggest a fix." The model reads the MCP tool results and reasons about them — your debugging assistant is always in your pocket, and it's working against your live local environment.

Under the Hood: How the MCP Server Is Built

For the technically curious, here's a brief look at how the Automation Skill Builder MCP server is structured. The server runs as a local process on your machine, binding to localhost:8800 (configurable). The MCP layer is a thin translation layer — it maps MCP tool definitions to the internal skill execution engine, and returns results in MCP-compliant response envelopes.

MCP tool definition — simplified{
  "name": "run_skill",
  "description": "Execute an automation skill by ID",
  "inputSchema": {
    "type": "object",
    "properties": {
      "skill_id": {
        "type": "string",
        "description": "The unique identifier of the skill"
      },
      "params": {
        "type": "object",
        "description": "Optional runtime parameters"
      }
    },
    "required": ["skill_id"]
  }
}

The SSE transport keeps an HTTP connection open and streams newline-delimited JSON events as the server sends them. For long-running skills, this means clients receive status updates in real time rather than waiting for a single blocking response. ChatMCP on Android handles the streaming connection gracefully, reconnecting automatically if the connection drops on a flaky mobile network.

Authentication — when configured — is handled via a bearer token in the HTTP Authorization header. This is the service secret token you generated in Automation Skill Builder settings. Because the token is managed locally by you, there's no central authority that can grant or revoke access to your skills; you are fully in control.

The Bigger Picture: Why Cross-Platform Agent Access Matters

There's a tendency in developer tooling to think of "the platform" as the web dashboard. You build things in the dashboard, monitor them in the dashboard, fix them in the dashboard. The dashboard is the center of gravity.

MCP changes that center of gravity. When your automations are accessible as tools through a standard protocol, the platform becomes ambient — it goes where you go, fits into the clients you already use, and gets invoked by agents that you didn't build yourself. Your skills are no longer features of an application. They're capabilities that any sufficiently smart agent can discover and use.

We see this playing out in how our users actually work. Developers who use Cline find themselves delegating to Automation Skill Builder naturally, without thinking about it — the tool call is just another step in a task. Teams that adopted Cherry Studio use it as their daily work interface, with Automation Skill Builder handling the repetitive parts in the background. And now, the ability to trigger and monitor from mobile means the platform is genuinely always-on — not just "reachable from a browser," but integrated into the chat interface that's already in your pocket.

The clients we've verified today — VS Code, Cherry Studio, Cline, ChatMCP — represent the current wave. The MCP ecosystem is growing quickly. Claude Desktop, other AI coding assistants, and purpose-built enterprise clients are all adding MCP support. Every new MCP-capable client in the ecosystem is a new way to reach your local skills, without any additional work on your end.

Getting Started

If you're already using Automation Skill Builder, MCP access is available now. Open the app, generate your service secret token in settings, and pick a client from the verified list above.

Cherry Studio is the easiest entry point if you want a GUI. Cline is the right choice if you're deep in VS Code and want autonomous task execution. ChatMCP on Android is the path if you want your automation layer accessible from anywhere — with Tailscale as the secure bridge to your local machine.

The setup time is measured in minutes. The change in how you work with automations tends to be lasting.

Questions or feedback? Reach us at info@visualbuild.me or dev@visualbuild.me — we read everything.