Claude Code Plugin - CloudShip AI

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:

Plugin	Best For	What’s Included
`station`	Users who want lightweight guidance	Skills + Slash Commands + MCP Server
`station-agent`	Power users who want autonomous operations	Pre-configured Subagent + MCP Server

station (Skills-based)
station-agent (Subagent-based)

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.

Full integration - A dedicated Station expert subagent that Claude can delegate to.

Subagent: station-operator - autonomous Station operations
MCP Server: 55+ tools pre-configured for the subagent
Tracing: Reminds you to start Jaeger for observability

Best when you want Claude to handle Station tasks autonomously with cleaner context separation.

Quick Start

Option 1: Install from Marketplace (Recommended)

# 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:

Station CLI installed: See Installation
Station initialized: Run stn init to set up your workspace
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

Skill	Command	Description
station	`/skill station`	Core CLI reference - commands, agent format, workflows
station-config	`/skill station-config`	Configuration 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

station
station-config

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

The configuration skill covers:

Global config (~/.config/station/config.yaml)
AI provider setup (OpenAI, Anthropic, etc.)
Coding backend configuration
CloudShip platform integration
Environment variables
OAuth authentication

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:

Capability	Description
Create & Manage Agents	Uses `create_agent`, `update_agent`, `delete_agent`, `list_agents`
Execute Agents	Uses `call_agent`, `list_runs`, `inspect_run`
Configure MCP Servers	Uses `add_mcp_server_to_environment`, `discover_tools`
Handle Workflows	Uses `execute_workflow`, `list_approvals`, `approve_step`
Debug Runs	Analyzes 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

Scenario	Recommended
Learning Station commands	`station` plugin (skills)
Step-by-step guidance	`station` plugin (skills)
Quick autonomous tasks	`station-agent` plugin (subagent)
Complex multi-step operations	`station-agent` plugin (subagent)
Keeping main context clean	`station-agent` plugin (subagent)
Direct control over operations	`station` plugin (skills)

Available Slash Commands

The plugin provides four slash commands that teach Claude Code how to work with Station:

Command	Purpose
`/station`	Core Station concepts and MCP tools overview
`/station-agent`	Create and manage AI agents
`/station-workflow`	Build multi-step workflows with state machines
`/station-bundle`	Package 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

Tool	Description
`station_create_agent`	Create a new agent with prompt and model
`station_list_agents`	List all agents in an environment
`station_call_agent`	Execute an agent with a task
`station_update_agent`	Modify agent configuration
`station_delete_agent`	Remove an agent

Execution & Monitoring

Tool	Description
`station_list_runs`	View execution history
`station_inspect_run`	Get detailed run information
`station_get_run_logs`	Retrieve execution logs

Environment & Configuration

Tool	Description
`station_list_environments`	List available environments
`station_create_environment`	Create a new environment
`station_get_config`	View Station configuration

Workflows

Tool	Description
`station_create_workflow`	Create a state machine workflow
`station_run_workflow`	Execute a workflow
`station_list_workflows`	List 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:
Triages incoming alerts by severity
Investigates high-severity issues automatically
Requires human approval before remediation
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

Verify Station is installed:

stn --version

Test MCP manually:

echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | stn stdio

Reinstall the plugin:

/plugin uninstall station
/plugin install cloudshipai/station

MCP Tools Not Available

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

Agent Creation Failing

Check environment exists:

stn env list

Verify AI provider is configured:

stn provider status

Check MCP tools are available:

stn mcp tools

Best Practices

1. Choose the Right Plugin

If you want…	Use
Lightweight guidance in your conversation	`station` plugin
Autonomous Station operations	`station-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

Agent Development

Create custom AI agents

MCP Tools

Full MCP tools reference

Workflows

Multi-step orchestration

Bundles

Package and distribute agents

Get Started

Station CLI

Building Agents

Station Lattice

Deployment

Advanced

​Choose Your Plugin

​Quick Start

​Option 1: Install from Marketplace (Recommended)

​Option 2: Direct GitHub Install

​Option 3: Local Installation

​Option 4: Manual MCP Configuration

​Prerequisites

​Skills

​Available Skills

​Using Skills

​Skill Contents

​Station Operator Subagent

​Capabilities

​How It Works

​Tracing Setup

​Skills vs Subagent: When to Use Each

​Available Slash Commands

​Using Commands

​MCP Tools

​Agent Management

​Execution & Monitoring

​Environment & Configuration

​Workflows

​Usage Examples

​Creating an Agent

​Running an Agent

​Building Multi-Agent Teams

​Creating Workflows

​Agent Format (Dotprompt)

​MCP Configuration Options

​Basic stdio Mode

​With Custom Config

​HTTP Mode (Remote Station)

​Multiple Environments

​With Telemetry

​Troubleshooting

​Plugin Not Working

​MCP Tools Not Available

​Agent Creation Failing

​Best Practices

​1. Choose the Right Plugin

​2. Enable Tracing

​3. Use MCP Over CLI

​4. Use Slash Commands for Context (Skills Plugin)

​5. Organize by Environment

​Next Steps

Agent Development

MCP Tools

Workflows

Bundles

Choose Your Plugin

Quick Start

Option 1: Install from Marketplace (Recommended)

Option 2: Direct GitHub Install

Option 3: Local Installation

Option 4: Manual MCP Configuration

Prerequisites

Skills

Available Skills

Using Skills

Skill Contents

Station Operator Subagent

Capabilities

How It Works

Tracing Setup

Skills vs Subagent: When to Use Each

Available Slash Commands

Using Commands

MCP Tools

Agent Management

Execution & Monitoring

Environment & Configuration

Workflows

Usage Examples

Creating an Agent

Running an Agent

Building Multi-Agent Teams

Creating Workflows

Agent Format (Dotprompt)

MCP Configuration Options

Basic stdio Mode

With Custom Config

HTTP Mode (Remote Station)

Multiple Environments

With Telemetry

Troubleshooting

Plugin Not Working

MCP Tools Not Available

Agent Creation Failing

Best Practices

1. Choose the Right Plugin

2. Enable Tracing

3. Use MCP Over CLI

4. Use Slash Commands for Context (Skills Plugin)

5. Organize by Environment

Next Steps