AI speeds up development. Orion keeps production under control.
Orion is the governed services platform for teams building software with AI. Its runtime coordinates, observes and controls how services behave, so engineers and AI assistants can build, change and ship faster.
The architecture is the runtime's job.
Every service needs the same architecture: rate limiting, retries, metrics, versioning, rollout. Orion's runtime enforces all of it at execution time, so the only thing your teams write and review is the logic that makes your business different.
Business logic becomes a governed artifact: versioned like code, changed in seconds by engineers or AI assistants, reversible in one call.
AI made writing software fast. Shipping it stayed slow.
The pipeline doesn't care who wrote the change. It reviews, builds and rolls out at the pace it always did, so work an assistant finishes in minutes still waits days to reach production.
AI writes faster than review keeps up
Each generated service is new infrastructure to read, and every copy is slightly different
The release cycle didn't move
An assistant drafts the change in minutes; the pipeline still ships it in days
Review became the bottleneck
The logic that matters is a fraction of what you have to approve
The speed is real. The path it ships through has to change.
Build, deploy and govern on one path.
Logic as a governed artifact. Guardrails as configuration. One safe path for every change.
Declare the logic
Written by engineers or AI
Business logic is a JSON document: versioned like code, reviewed as a diff, writable by an engineer or an AI assistant.
The runtime carries the rest
Configured, not coded
Rate limiting, validation, caching, and backpressure enforced before any logic runs; circuit breakers and traces around every backend call.
Every change is governed
Enforced, not promised
Draft, dry-run, canary, active. The same path for an urgent fix and an assistant's proposal.
One platform.
One safe path for every change.
Orion turns a JSON definition into a live REST or Kafka service: APIs, decision endpoints, event pipelines, webhook ingestion, agent tools. Many services, one runtime, as a modular monolith; scaling out later is a topology change, not a rewrite.
Built for AI authorship
An assistant drafts, dry-runs and rolls back services through the CLI and admin API, inside the same lifecycle rules engineers follow.
Guardrails as configuration
Rate limiting, circuit breakers, validation and observability: declared once per channel, not rewritten per service.
Production-grade, measured
Performance that's published, not promised. One Rust binary; clustered replicas when you grow.
Built for modern architectures.
Open, measured and built for how distributed systems are actually run today.
Open source foundation
Apache-2.0
Developed in the open at GoPlasmatic/Orion; v1.0 shipped in August 2026.
Rust-speed performance
Measured, not claimed
5.1K–5.7K workflow requests/sec per instance at single-digit milliseconds, on the published v1.0 benchmark.
Connect to anything
Built for the real world
REST, HTTP, and Kafka in; PostgreSQL, MySQL, MongoDB, Elasticsearch, Redis, and any HTTP API out. Credentials stay on the connector.
API-first & developer-friendly
Admin API, CLI, skills
Admin API, CLI, CI/CD packages and skills for AI assistants, so an assistant operates the runtime the same governed way engineers do.
Two ways in. Both take minutes.
Evaluating for your team? Talk to an engineer. Want proof first? It installs in about a minute.
View documentation
Concepts, guides, honest comparisons, API reference
GitHub
Explore the source and contribute
Quickstart
A server in about a minute; a live service in four API calls
Built in the open. Apache-2.0, v1.0 shipped August 2026, benchmark published. One binary, your data in your own databases: nothing to migrate off.