Station AI Agent Orchestration Platform

Station is an open-source runtime designed for infrastructure management agents. It provides a platform to develop, orchestrate, and deploy agents that can manage complex infrastructure tasks. Key capabilities include:

• Agent Development: Creating agents using the .dotprompt format.
• Multi-Agent Orchestration: Building hierarchies where coordinator agents manage specialist agents.
• Workflows: Orchestrating multi-step tasks that include human-in-the-loop approval steps.
• Tool Integration: Using Model Context Protocol (MCP) to give agents access to APIs, databases, and services, as well as using Station's own 41 built-in MCP tools for programmatic agent management.
• Evaluation: Utilizing LLM-as-judge testing to generate performance reports.
• Deployment: Supporting multiple modes including Server, stdio, standalone binary, and Docker.

Station supports four primary deployment modes depending on your workflow:

• stn up (Server Mode): Best for local development. Provides a Web UI, API, and MCP server integration.
• stn stdio (Stdio Mode): Best for direct integration with Claude Desktop or Cursor IDE via the stdio protocol.
• stn serve (Production API Mode): Best for production environments. Provides an HTTP API and optional Web UI.
• Standalone Binary: Best for scripts, CI/CD, and scheduled jobs where no persistent server is required.
• Docker: Containerized deployment supporting all the above modes.

Station is an AI Agent Orchestration Platform with several key functional areas:

• UI System: An embedded React web interface for real-time agent management and execution monitoring.
• Agent Execution Engine: Provides comprehensive token usage monitoring, cost tracking, and detailed execution step logging (including tool call parameters).
• Bundle Management: A system for creating, installing, and managing shareable agent configurations and MCP server setups.
• Template System: A dynamic configuration system using interactive variable prompting and validation.
• Build System: A production pipeline that produces multi-platform binaries with embedded UI assets.

Station is an AI agent orchestration runtime designed for local infrastructure control. It operates using four primary deployment modes:

• Server Mode (stn up): Provides a full-featured environment including a web UI, API, and MCP servers.
• Stdio Mode (stn stdio): Enables integration with IDEs or desktop clients like Claude Desktop and Cursor via the stdio protocol.
• Standalone Binary: A single executable with no external dependencies.
• Docker/Kubernetes: Containerized deployments that support zero-config credential discovery (e.g., IAM roles).

Station uses the Model Context Protocol (MCP) to connect agents to tools and Go templates to manage environment-specific configurations safely.

As of version v0.16.1, the Station platform includes the following core capabilities:

• Configuration: File-based, GitOps-ready configuration system with multi-environment support (dev, staging, prod) and Go template variable resolution.
• Agent Engine: Execution engine with GenKit integration and detailed run tracking/metadata capture.
• MCP Management: Discovery and configuration of MCP servers.
• Bundle System: Ability to create, install, and share bundles.
• Sync Flow: Interactive synchronization with variable prompting.
• UI: ReactFlow-based agent canvas, MCP server management, environment management, and agent run history/inspection.

For deep technical understanding and production operations:

• System Architecture: Explore the layered architecture, agent execution flows, MCP server pool management, and the GitOps-style file configuration system in the ARCHITECTURE section.
• Operations: Monitor performance, troubleshoot common issues, and implement production deployment patterns using the guides in the Development & Operations section.

The Station Workflow Engine is designed for durable, multi-step DevOps workflows. It supports advanced execution patterns including:

• Branching: Conditional execution paths.
• Parallelism: Running multiple steps simultaneously.
• Human Approval Gates: Pausing workflows for manual intervention.

Detailed feature specifications can be found in docs/features/workflow-engine-v1.md.

The Model Context Protocol (MCP) is an open standard that acts as a universal adapter between AI agents and external systems (APIs, databases, filesystems).

In Station, the architecture follows this flow:

1. Station Agent requests a tool (e.g., __get_cost_and_usage).
2. Station MCP Client validates permissions and routes the request.
3. MCP Server (a separate process) executes the request using its own credentials.
4. Agent receives only the structured results, never seeing the underlying credentials.

Key Benefits:

• Security: Fine-grained permissions (read vs. write) and credential isolation.
• Standardization: The same MCP servers work across Claude Desktop, Cursor, and Station.
• Ecosystem: Access to 100+ community servers for AWS, GCP, databases, etc.

Station Faker is a universal MCP tool wrapper that acts as an intelligent proxy between Station agents and real MCP servers. Instead of interacting directly with a real server, the agent interacts with Faker, which intercepts tool calls and generates realistic, AI-simulated responses based on custom instructions.

The Proxy Flow: Agent → Station → Faker Proxy → AI Model → Simulated Response

Faker can optionally consult a real MCP server for schema validation or to ground the simulation, but its primary purpose is to simulate diverse scenarios (like high traffic, cost spikes, or security incidents) that would be difficult or dangerous to trigger in real production environments.

Agent → Station → Faker Proxy → AI Model → Simulated Response
                      ↓
                 (Optional) Real MCP Server (for schema/validation)

Station Lattice is a distributed agent mesh network. It uses a NATS Message Bus (with JetStream for KV storage and pub/sub) to allow multiple Station instances to communicate. A central stn lattice CLI can query and execute agents across the entire mesh, regardless of which specific Station process is hosting them.

Key components include:

• Orchestrator Station: Manages the mesh and hosts core agents.
• Compute Station: Hosts agents for heavy lifting (e.g., mathematical calculations).
• Utility Station: Hosts helper agents (e.g., time, jokes).
• NATS Cluster: The communication backbone providing connectivity and state via KV stores.