products / Railyard
[ PREVIEW ] v0.1 · orchestration · 200 m

Railyard

Full-stack platform for building and governing multi-agent systems.

Go backend, React dashboard, DSPy reasoning modules, and CLIPS-based policy governors.

// example railyard 
workflow.stage("analyze", {
  module: "chain_of_thought",
  agents: ["analyst"],
  governor: "nist-800-53"
})
workflow.stage("review", {
  require_approval: true,
  on_failure: "escalate"
})
// why Railyard

What Railyard does.

◆
DSPy Reasoning

Six reasoning modules: predict, chain of thought, react, multi-chain comparison, refine, and parallel. Agents use structured reasoning instead of raw prompting, with JSON Schema validation on inputs and outputs.

⧉
Workflow DAGs

Declarative multi-stage pipelines with conditional branching, parallel execution, looping, and human approval gates. Data flows through an execution context with full trace logging at every step.

✦
CLIPS Governors

Policy governors backed by CLIPS expert system instances. Inbound governors pre-process agent inputs, outbound governors post-process outputs. Stateful or stateless, with priority ordering and working memory snapshots.

// where it sits

Railyard owns the orchestration layer.

Each tool in the Kraken stack owns a single concern. Railyard sits at the orchestration tier — adopt it on its own, or descend the whole column.

Railyard orchestration · you are here
Stargraph orchestration
Bosun action governance
Nautilus data governance
Fathom reasoning

Railyard is a production-grade orchestration platform, a running system rather than a framework you wire together yourself. The API server is Go on go-chi, the dashboard is React on Vite with Shadcn components, and state lives in PostgreSQL. You build workflows visually from the dashboard or programmatically through the API, and you monitor execution in real time either way. What sets it apart from other orchestrators is that Railyard owns the full stack, from workflow definition through agent execution to policy enforcement.

The workflow engine executes stages as a DAG. Each stage binds one or more agents to a reasoning module from DSPy-Go, such as chain of thought, react, or multi-chain comparison, with three others available. Conditional branching routes execution based on agent output. Parallel stages run concurrently with configurable concurrency limits. Human approval gates pause the pipeline until an authorized user signs off. When a stage fails, the behavior is declared up front: stop, skip, retry with backoff, or escalate to a human reviewer. Nothing falls back to an implicit default.

CLIPS-based governors enforce policy at the agent boundary. Every input passes through an inbound governor before the agent sees it, and every output passes through an outbound governor before it leaves. Governors are priority-ordered, so a compliance rule always fires before a formatting rule. What separates them from ordinary middleware is that governors maintain working memory across invocations within a session. They can detect patterns across an agent’s entire execution history instead of evaluating individual calls in isolation.

Real-time WebSocket connections stream execution state to the dashboard as workflows run. Concurrency limits prevent runaway agents from saturating resources, so once you exceed the limit you get a 429 until a slot opens. Structured trace logs capture every LLM call, tool invocation, and governor evaluation with timing data, so when something goes wrong you can reconstruct exactly what happened and in what order.

// adjacent layers
← All products