Run agents anywhere
Run agents locally on your machine or remotely in isolated environments. OpenStation provides the execution and security layer around the agent while keeping the underlying agent runtime flexible.
How it runs →Build your own
AI team
Take your Claude, Codex or another agent and run it locally or remotely—with tools, memory, and connections to keep working together.
What OpenStation gives an agent
Run, connect, and manage persistent AI agents.
Connect agents to people
Expose agents through the communication channels your team and users already use — Slack, Telegram, email, and more. A configurable permission layer controls who can interact with each agent and what they are allowed to do, making it possible to safely share agents within a company or expose them to external users.
Channels and permissions →Persistent memory
Agents maintain a persistent, Git-friendly second brain that survives across sessions and environments. Knowledge, decisions, context, and artifacts become part of a transparent workspace that can be inspected, versioned, edited, and shared — instead of disappearing inside individual conversations.
Workspaces and memory →Multi-agent orchestration
Build systems composed of specialized agents that can delegate work, collaborate, validate each other, and share context. OpenStation provides the orchestration layer for running these agents together while keeping their responsibilities, tools, permissions, and context independently configurable.
Orchestrating agents →Automations & triggers
Agents don’t have to wait for someone to start a conversation. They can run on schedules or react to events from connected systems, enabling persistent workflows such as monitoring, research, support, development, and operational automation.
Schedules and triggers →Learning loops
OpenStation enables agents to improve from their own work. Execution history, feedback, evaluations, and accumulated knowledge can feed back into an agent’s instructions, skills, and memory — creating agents that become more effective over time.
Learning loops →How it fits together
People
Ask, approve, review
Channels
Slack, Telegram, email
OpenStation
Routes work through rules
Agents
Execute with memory and tools
Use cases
Build systems of agents.
Software dark factories
Turn queued tasks into implementations, tests, and pull requests. Separate agents build and verify; humans control what merges.
Support investigation pipelines
Collect reports from Slack, deduplicate issues, investigate against docs and code, and independently audit conclusions.
Eval-driven improvement loops
Build blind cases from resolved work, score agent outputs against held-out answers, and turn failures into approved changes.
Persistent repository agents
Give agents a durable workspace to track issues, retain findings, and resume work across sessions—on schedules or artifact changes.
Inside a software dark factory
- Task
- Implement
- Test
- Verify
- Pull request
- Human review
Documentation
Explore the building blocks.
Each primitive stays small enough for humans to inspect and for agents to use directly.
Quick start
Create a station inside a project.
Install Bun and authenticate the Claude Code CLI first. The CLI is not published to npm yet, so run it from the repository.
git clone https://github.com/leonprou/openstation.git
cd openstation
bun install
bun packages/cli/src/index.ts init
bun packages/cli/src/index.ts create my-space
bun packages/cli/src/index.ts my-space devPrinciples
Infrastructure agents and people can understand.
Bring your own intelligence
Models change quickly. The station keeps the environment portable.
Files before databases
Readable files make memory inspectable, versionable, and agent-friendly.
Explicit permissions
Powerful agents need clear access boundaries and auditable grants.
Local first, remote when needed
Run close to your own machine, then move online for persistence.
The idea
OpenStation is a home for your agent.
Most AI agents today start with a prompt and end with a session. OpenStation provides the infrastructure around the model that lets an agent keep working: execution, memory, communication, permissions, orchestration, automation, and learning.