Skip to main content
Station provides two Claude Code plugins that give Claude Code access to 55+ MCP tools for agent orchestration. Choose the integration style that fits your workflow.

Choose Your Plugin

Station offers two plugin options:
PluginBest ForWhat’s Included
stationUsers who want lightweight guidanceSkills + Slash Commands + MCP Server
station-agentPower users who want autonomous operationsPre-configured Subagent + MCP Server
Lightweight integration - Claude learns Station via skills that inject knowledge into your conversation.
  • Skills: station, station-agents, station-mcp, station-deploy, station-benchmark, station-workflows
  • Slash Commands: /station, /station-agent, /station-workflow, /station-bundle
  • MCP Server: 55+ tools for agent management, execution, and workflows
Best when you want direct control over Station operations in your main conversation.

Quick Start

# Add the Station marketplace
/plugin marketplace add cloudshipai/station

# Choose ONE of these plugins:
/plugin install station@cloudshipai-station        # Skills-based (lightweight)
/plugin install station-agent@cloudshipai-station  # Subagent-based (full integration)

Option 2: Direct GitHub Install

# Skills-based plugin
/plugin install cloudshipai/station/claude-code-plugin

# Subagent-based plugin
/plugin install cloudshipai/station/claude-code-plugin-agent

Option 3: Local Installation

If you’ve cloned the Station repository locally:
# Skills-based plugin
/plugin install ./station/claude-code-plugin

# Subagent-based plugin
/plugin install ./station/claude-code-plugin-agent

Option 4: Manual MCP Configuration

Add Station directly to your .mcp.json (MCP tools only, no skills or subagent):
{
  "mcpServers": {
    "station": {
      "command": "stn",
      "args": ["stdio"],
      "env": {
        "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:4318"
      }
    }
  }
}
The OTEL_EXPORTER_OTLP_ENDPOINT enables distributed tracing. Start Jaeger with stn jaeger up to view traces at http://localhost:16686.

Prerequisites

Before using the plugin:
  1. Station CLI installed: See Installation
  2. Station initialized: Run stn init to set up your workspace
  3. At least one agent: Create an agent or install a bundle
# Verify installation
stn --version

# Initialize Station
stn init

# Create a simple agent
stn agent create --name "Hello Agent" --model gpt-4o-mini

Skills

Skills are comprehensive guides that teach Claude Code how to use Station. Load them with /skill <name>:

Available Skills

SkillCommandDescription
station/skill stationCore CLI reference - commands, agent format, workflows
station-config/skill station-configConfiguration deep-dive - all config options explained

Using Skills

# Load the core Station skill before working with agents
/skill station

# Now ask questions or give commands
Create an agent that monitors Kubernetes pods and alerts on failures
Skills provide Claude with:
  • Complete command reference with examples
  • Agent format (Dotprompt) specification
  • Workflow state machine patterns
  • MCP tool usage patterns
  • Best practices and common patterns
Load /skill station at the start of a session when doing significant Station work. It gives Claude comprehensive context to help you more effectively.
Skills are only available in the station plugin. The station-agent plugin uses a dedicated subagent instead.

Skill Contents

The core Station skill covers:
  • Agent lifecycle (create, run, list, update, delete)
  • Dotprompt format with YAML frontmatter
  • MCP server tools and configuration
  • Workflow state machines
  • Environment management
  • Bundle creation and installation

Station Operator Subagent

The station-operator subagent is only available in the station-agent plugin.
When you install the station-agent plugin, you get a dedicated Station Operator subagent that Claude can delegate to for autonomous Station operations.

Capabilities

The station-operator subagent can:
CapabilityDescription
Create & Manage AgentsUses create_agent, update_agent, delete_agent, list_agents
Execute AgentsUses call_agent, list_runs, inspect_run
Configure MCP ServersUses add_mcp_server_to_environment, discover_tools
Handle WorkflowsUses execute_workflow, list_approvals, approve_step
Debug RunsAnalyzes execution history, tool calls, and costs

How It Works

Claude automatically delegates Station tasks to the subagent when appropriate:
User: Create a Station agent that monitors Kubernetes pods

Claude: [Invokes station-operator subagent]
[Subagent creates agent using create_agent tool]
[Subagent returns result with agent details]

Claude: I've created your Kubernetes pod monitor agent...
You can also invoke it explicitly:
Use the station-operator subagent to debug my last failed agent run

Tracing Setup

The subagent reminds you to set up Jaeger for observability on first interaction:
# Start Jaeger for distributed tracing
stn jaeger up

# View traces at http://localhost:16686

Skills vs Subagent: When to Use Each

ScenarioRecommended
Learning Station commandsstation plugin (skills)
Step-by-step guidancestation plugin (skills)
Quick autonomous tasksstation-agent plugin (subagent)
Complex multi-step operationsstation-agent plugin (subagent)
Keeping main context cleanstation-agent plugin (subagent)
Direct control over operationsstation plugin (skills)

Available Slash Commands

The plugin provides four slash commands that teach Claude Code how to work with Station:
CommandPurpose
/stationCore Station concepts and MCP tools overview
/station-agentCreate and manage AI agents
/station-workflowBuild multi-step workflows with state machines
/station-bundlePackage and distribute agent bundles

Using Commands

# Get Station overview
/station

# Create an agent
/station-agent

# Build a workflow
/station-workflow

# Package agents
/station-bundle

MCP Tools

After installation, Claude Code has access to Station’s MCP tools:

Agent Management

ToolDescription
station_create_agentCreate a new agent with prompt and model
station_list_agentsList all agents in an environment
station_call_agentExecute an agent with a task
station_update_agentModify agent configuration
station_delete_agentRemove an agent

Execution & Monitoring

ToolDescription
station_list_runsView execution history
station_inspect_runGet detailed run information
station_get_run_logsRetrieve execution logs

Environment & Configuration

ToolDescription
station_list_environmentsList available environments
station_create_environmentCreate a new environment
station_get_configView Station configuration

Workflows

ToolDescription
station_create_workflowCreate a state machine workflow
station_run_workflowExecute a workflow
station_list_workflowsList available workflows
Use /station to see the full list of 55+ available MCP tools.

Usage Examples

Creating an Agent

Ask Claude Code directly:
Create a Station agent that monitors Kubernetes pod health 
and alerts on failures. Use gpt-4o-mini model.
Claude will use station_create_agent with the appropriate configuration.

Running an Agent

Run my "Pod Monitor" agent with the task "Check all pods in production namespace"

Building Multi-Agent Teams

Create an incident response team with:
1. An "Incident Coordinator" that delegates to specialists
2. A "Kubernetes Expert" for K8s troubleshooting  
3. A "Log Analyzer" for log pattern analysis

Set up the coordinator to call the specialists as tools.

Creating Workflows

Create a workflow that:
1. Triages incoming alerts by severity
2. Investigates high-severity issues automatically
3. Requires human approval before remediation
4. Documents the resolution

Agent Format (Dotprompt)

Station agents use the Dotprompt format - YAML frontmatter with Handlebars templates:
---
metadata:
  name: "My Agent"
  description: "What this agent does"
model: gpt-4o-mini
max_steps: 8
tools:
  - "__tool_name"
---
{{role "system"}}
You are an expert assistant that...

{{role "user"}}
{{userInput}}
The {{userInput}} variable is populated with the task when running the agent. Always include it in your prompt.

MCP Configuration Options

Basic stdio Mode

{
  "mcpServers": {
    "station": {
      "command": "stn",
      "args": ["stdio"]
    }
  }
}

With Custom Config

{
  "mcpServers": {
    "station": {
      "command": "stn",
      "args": ["--config", "/path/to/config.yaml", "stdio"]
    }
  }
}

HTTP Mode (Remote Station)

Connect to a running Station server:
{
  "mcpServers": {
    "station": {
      "type": "http",
      "url": "http://localhost:8586/mcp"
    }
  }
}

Multiple Environments

{
  "mcpServers": {
    "station-dev": {
      "command": "stn",
      "args": ["--config", "~/.station/dev.yaml", "stdio"]
    },
    "station-prod": {
      "command": "stn",
      "args": ["--config", "~/.station/prod.yaml", "stdio"]
    }
  }
}

With Telemetry

{
  "mcpServers": {
    "station": {
      "command": "stn",
      "args": ["stdio"],
      "env": {
        "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:4318"
      }
    }
  }
}

Troubleshooting

Plugin Not Working

  1. Verify Station is installed:
stn --version
  1. Test MCP manually:
echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | stn stdio
  1. Reinstall the plugin:
/plugin uninstall station
/plugin install cloudshipai/station

MCP Tools Not Available

  1. Check .mcp.json exists in your project root
  2. Restart Claude Code after configuration changes
  3. Ask Claude: “List available Station MCP tools”

Agent Creation Failing

  1. Check environment exists:
stn env list
  1. Verify AI provider is configured:
stn provider status
  1. Check MCP tools are available:
stn mcp tools

Best Practices

1. Choose the Right Plugin

If you want…Use
Lightweight guidance in your conversationstation plugin
Autonomous Station operationsstation-agent plugin
Both (learning + automation)Install both, use as needed

2. Enable Tracing

Always start Jaeger for observability when debugging:
stn jaeger up
# View traces at http://localhost:16686

3. Use MCP Over CLI

Prefer MCP tools for structured responses:
# Good - Claude uses MCP tool with structured response
"Create an agent called 'Cost Analyzer' that..."

# Avoid - asking Claude to run CLI commands
"Run: stn agent create --name 'Cost Analyzer'..."

4. Use Slash Commands for Context (Skills Plugin)

Start complex tasks with the relevant slash command:
/station-workflow

Now create a workflow that handles deployment approvals...

5. Organize by Environment

Use separate MCP entries for different environments to avoid mistakes:
{
  "mcpServers": {
    "station-dev": { "command": "stn", "args": ["--config", "~/.station/dev.yaml", "stdio"] },
    "station-prod": { "command": "stn", "args": ["--config", "~/.station/prod.yaml", "stdio"] }
  }
}

Next Steps