Orion
The governed services platform for teams building software with AI.
Its runtime acts as the production nervous system, coordinating, observing and controlling how services behave, so engineers and AI assistants can build, change and ship faster. The lifecycle is fixed: draft, dry-run, canary, one-call rollback.
AI writes the change in minutes. The pipeline still ships it in days.
Every business runs on two clocks. The business clock moves at the speed of opportunity; the engineering clock moves at the speed of the release cycle. AI hasn't changed that, because the pipeline doesn't care who wrote the code.
The bottleneck moved from writing software to shipping and governing it. That is the part Orion takes over.
The review is the whole job. The build, packaging, and rollout machinery is gone.
The logic is yours. The architecture is the runtime's.
A service is one JSON document: logic, connectors, endpoint. Post it and it's live a second later, with the guards you declared enforced before any logic runs. A review only has to catch logic errors, never architecture errors.
Microservice APIs
Order triage: flag orders over $10,000, add a risk_level field, answer on POST /orders.
One JSON document, drafted by an engineer or an AI assistant.
The endpoint, validation, rate limiting, metrics, and versions.
Decision APIs
Pricing tiers and eligibility as JSONLogic conditions. The decision is the response.
The condition tree, as data.
Validation that fails at save, and a trace of every decision.
Event pipelines
A Kafka topic in, transform and enrich, publish onward.
The transform pipeline.
Retries, duplicate suppression, and a dead-letter queue for failed messages.
Webhook & data ingestion
Normalize Stripe, GitHub, or Shopify payloads, then write to your databases.
The mapping.
Pooled connections, retries, circuit breakers, and credentials held outside the logic.
AI agent tools
An agent calls your channels as tools, and through the CLI and its skills it drafts the workflows behind them.
The tools themselves.
Lifecycle rules the agent operates inside: draft, dry-run, then explicit activation.
Design the architecture. Defer the topology.
Orion runs as a modular monolith: one runtime holding many small services, each with its own endpoint, versions, and rollout, composed in-process with no network hop. Your architects draw the boundaries the domain wants, not the ones the deployment diagram forces. And when the estate grows, the topology changes while the architecture doesn't.
Decide the microservices question when production answers it, not on day one.
Boundaries without sprawl
Each service ships on its own schedule without becoming its own deployment, pipeline, or on-call surface.
Composition without the network
In-process calls between services, with the callee's guards still applied and cycles refused.
Scale as a topology decision
SQLite to start; PostgreSQL, Redis, and replicas when you need them. A configuration change, not a rewrite.
The AI writes one document. You review one document.
Spend your tokens on business logic, not on rewriting the same guardrails for every service.
Ask an AI for a conventional service and most of what it generates is infrastructure, every line yours to review, every copy slightly different. On Orion the entire output is the service definition; the guardrails are declared in configuration and enforced by the runtime. The same arithmetic holds for a pipeline, a webhook handler, or an agent tool.
order-service/
main.py
middleware/
auth.py
rate_limit.py
retry.py
metrics.py
logic.py
Dockerfile
ci.yaml
k8s.yamlThe business logic is the smallest file in the tree.
{
"workflow": "order-triage",
"tasks": [
{ "function": "parse_json" },
{ "function": "map",
"condition": { ">": [
{ "var": "amount" }, 10000 ] },
"set": { "risk_level": "review" }
}
],
"channel": { "route": "POST /orders" }
}One document: logic, endpoint, connections. Reviewed as a diff.
AI proposes. You approve. The runtime enforces.
Every change follows the same path, whoever or whatever wrote it.
AI builds
With the CLI and a set of skills, an assistant works through the same admin API engineers use:
One paragraph of English becomes a drafted workflow with a real execution trace
Reviewed as a diff, not as generated code
Nothing it creates serves traffic until it is activated
You approve the exact bytes
Versions are immutable, so approving the diff is approving the exact bytes that will run:
Canary to 10% of traffic; each caller consistently sees one version
Roll back with one call to the previous immutable version
Every change lands in the audit log: who, what, when
The AI follows the same safe path your engineers would, because no other path exists.
Every change moves through the same gate.
An assistant drafts, you approve, Orion executes. Every step below is a real product mechanic.
AI builds
An assistant drafts and dry-runs the workflow through the same admin API engineers use. Nothing serves traffic until it is activated.
You approve
Approving the diff approves the exact bytes that will run. Versions are immutable.
The runtime governs
Canary by percentage, one-call rollback, and every change in the audit log.
payment-fraud-check v7, from active v6. Lowers the threshold that flags an order for review.Written in minutes. Live in seconds. Reversible in one call.
Business logic becomes a governed, living artifact. Engineers and AI assistants write it; the runtime versions, traces and guards every execution.
Orion.
The nervous system for modern software.
Authoring and shipping on the same clock
An assistant drafts the change in minutes; activation makes it live with no restart.
One runtime, five kinds of service
APIs, decisions, pipelines, ingestion and agent tools, with the same guards and lifecycle.
Governance on every change
Versioned, audited, reversible. What ran yesterday is still there to return to.
Compared honestly: Durable execution · API gateways · Automation platforms · Rule engines · Is Orion right for you?
The docs name where each neighbour wins; Orion is for request-shaped work in milliseconds.
What people ask before they start.
What is a governed services platform?
A runtime that carries the parts of a service that are not your business logic: the endpoint, validation, retries, rate limiting, credentials, metrics and versioning. You write the logic as a JSON definition; the platform coordinates, observes and controls how it behaves in production.
What is Plasmatic Orion?
Orion is Plasmatic's governed services platform for teams building software with AI. A JSON definition becomes a live, governed REST or Kafka service, so a change written in minutes can be reviewed as one document, activated in seconds and reversed with one call.
Is Orion open source?
Yes. Orion is released under the Apache License 2.0 and developed in the open at github.com/GoPlasmatic. Plasmatic sells delivery, support and enterprise engagements around it, not a licence to the runtime.
How is Orion different from Temporal, Kong or Drools?
Those tools each carry one layer: Temporal handles durable orchestration, Kong handles the API edge, Drools handles rules evaluation. Orion carries the whole service definition, so the endpoint, the transformation, the decision logic and the operational guarantees live in one governed document rather than three systems you integrate yourself.
What kinds of services can Orion run?
Microservice APIs, decision APIs expressed as JSONLogic condition trees, Kafka event pipelines, webhook and data ingestion that normalizes payloads from providers such as Stripe, GitHub or Shopify, and tools that AI agents call directly.
How does Orion govern what AI changes?
Every change moves through the same gate regardless of who wrote it. The AI proposes a definition, a person approves it, and the runtime enforces the lifecycle: draft, dry-run, then explicit activation, with a trace of every decision and a one-call path back to the previous version.
Who builds Orion?
Plasmatic Solutions Pte. Ltd., a company registered in Singapore. The team that wrote the runtime is the team that deploys it.
Put a governed runtime under your business logic.
Thirty minutes with a founding engineer. We'll scope a pilot on one of your real services.
Organisations
Run a pilot with the team behind Orion, from first service to production checklist.
Talk to an engineer →Developers
One binary, installed in about a minute; a live service in four API calls.
github.com/GoPlasmatic/Orion →