Open-sourcing rAIls: A Different Layer of the AI Stack
Editor's note, October 2026: This article was accurate when it was published on 5 August 2026: the project's code was then licensed under AGPL-3.0-or-later alone, which is open source. On 8 August 2026 the Commons Clause was added, so current versions of the rAIls components are source-available rather than open source as the Open Source Initiative defines it. Versions released before that date remain available under AGPL-3.0-or-later. References to third-party open-source projects are unaffected.
Deployment reuse and execution reuse are different problems. The next-generation AI stack needs both.
Today we're open-sourcing the Python implementation of rAIls, the reference implementation behind the ten whitepapers we've published over the past year. One question keeps coming up, so let's answer it directly:
How is this different from LangChain, LangGraph, or enterprise AI blueprints from vendors like AMD?
The answer is simple: we're solving a different problem.
Three different jobs
- LangChain / LangGraph are application-level orchestration frameworks: a library embedded into each app.
- AMD Enterprise AI Blueprints standardize deployment and infrastructure: Helm, Kubernetes, optimized hardware paths.
- rAIls standardizes planning, execution and governance: one reusable execution model shared across applications.
AMD's deployment stack is complementary to ReDevOps: different layer, no overlap. LangChain and LangGraph are largely an alternative orchestration approach inside each application. Neither framing is a knock; they're just answering different questions than we are.
Execution standardization
Most AI applications decide, inside application code, which retriever to use, which model to call, how much context to send, what reasoning path to follow, what evidence to keep, and how to reproduce the result later. Every application solves this differently, and re-solves it badly.
ReDevOps moves those responsibilities into a reusable runtime. Instead of the application wiring the pipeline by hand, it declares a goal and lets a planner satisfy it.
The runtime plans retrieval, reasoning effort, topology, model selection, budget and verification before any model is called, producing an explainable execution plan that can be replayed and audited. That's the shift SQL made over hand-written record access: from imperative fetching to a declarative statement of intent a planner is free to satisfy optimally.
What actually makes the architecture different
| LangChain / LangGraph | rAIls | |
|---|---|---|
| Shape | Library embedded into each application | Standalone runtime shared by many applications |
| Ownership | Each app owns its orchestration | One reusable execution model across projects |
| Language | Primarily the Python ecosystem | Cross-language semantics (Python · Go · Kotlin) |
| Surface | Broad framework, many optional integrations | Intentionally lightweight core, minimal dependencies |
| Focus | Orchestration | Planning, governance, replay, provenance, verification, execution |
Those differences are architectural. Because execution moves into the runtime:
- Applications stop reinventing orchestration.
- Multiple applications share the same governed execution model.
- Python, Go and Kotlin implementations preserve the same execution semantics: the same golden fixtures round-trip through all three.
- Replay, provenance, verification and policy become first-class runtime concepts, shared across applications from the start.
- The core stays intentionally lightweight, so it's easier to embed, audit, test and evolve.
The minimal dependency footprint is a consequence of the architecture. A shared execution authority can't afford to drag a framework's worth of optional transitive dependencies behind it.
Where AMD fits
AMD's Enterprise AI Blueprints solve deployment extremely well: Helm, Kubernetes and optimized hardware paths. We adopt the same philosophy for deployment through packaged Reference Systems: reproducible Helm deployments that combine Context Runtime, Mission Runtime and ReDevOps RAG with automated acceptance gates.
Deployment reuse (AMD) and execution reuse (ReDevOps) sit in different layers of the same stack. You can, and arguably should, run both.
What about LangChain and LangGraph?
If you're building on rAIls, you generally don't need LangChain or LangGraph: the runtime already owns planning, execution, replay, policy, approvals and verification. Existing LangChain or LangGraph components can still be wrapped as individual capabilities during migration, or when integrating third-party software: they're just no longer the orchestration authority.
Available today
We're releasing the Python Runtime as open source. It implements the architecture described across all ten whitepapers, and it stands up on its own: single-tenant, deterministic, deny-by-default, no hidden calls home. Where to start:
- agentic-os: the Mission Runtime and execution / control plane. Start here.
- context-runtime: the query planner for LLM context.
- redevops-rag: the reference-resolving hybrid-RAG substrate.
- mission-sdk: the developer boundary: author, validate, explain and run a governed
MissionProgram.
Deployment follows the same philosophy through Helm-packaged Reference Systems: reproducible deployments that combine Context Runtime, Mission Runtime and ReDevOps RAG behind automated acceptance gates.
For larger production systems, Go and Kotlin enterprise editions (including Apache Spark and Databricks support), together with enterprise capabilities such as the Discovery Runtime, the Self-learning Runtime, the Identity & Policy Plane, multi-tenancy, Context Fabric, the Evaluation Runtime, and advanced execution topology, are available on request. The public core proves the thesis; the enterprise layer operates, secures, learns and scales it.
The public repository map
Ten repositories under github.com/redevops-io: the open core, its SDK, the benchmarks that hold it to evidence, and demos you can run. Copyleft (AGPL-3.0) on the runtimes and tooling; permissive (Apache-2.0 / MIT) on the SDK and the benchmarks, so you can build against them freely.
| Repository | Role | Lang | License | Release | What it does |
|---|---|---|---|---|---|
| agentic-os | Runtime · core | Python | AGPL-3.0 | v0.3.1 | Mission Runtime kernel + control plane: cost-aware LLM router, permissions plane, reference apps. |
| context-runtime | Runtime · retrieval | Python | AGPL-3.0 | v0.3.0 | A query planner for LLM context: decides what a model sees before it answers, across six orthogonal axes. |
| redevops-rag | Runtime · substrate | Python | AGPL-3.0 | v0.3.0 | Hybrid RAG library: DuckDB vector + BM25 fused via RRF, recency/keyword priors, optional cross-encoder rerank. |
| agent-harness | Runtime · step | Python | AGPL-3.0 | v0.1.0 | How a single model/tool step runs safely: clients, tools, sandbox, approvals, guardrails, evaluation. |
| mission-sdk | Developer surface | Python | Apache-2.0 | v0.3.0 | The developer boundary + compatibility target: author, validate, explain, run a governed MissionProgram (rdo CLI). |
| sidekick | Tooling | Python | AGPL-3.0 | v0.1.0 | Local coding-agent orchestrator: a DAG of auto-approved, git-worktree-isolated sub-sessions across LLM providers. |
| DataOpsBench | Benchmark | Python | Apache-2.0 | - | Model- and framework-agnostic DataOps benchmark (the DataOps TPC-C): diagnose, repair, reconcile and verify beyond a context window. |
| multiagent-orchestration-benchmark | Benchmark | Python | MIT | - | Controlled, reproducible test: does formal multi-agent orchestration beat a strong supervisor? Harness, specs, results. |
| redevops-demo | Demo | Python | - | - | Self-demonstrating deploy-and-operate: one prompt provisions, secures, monitors and self-heals a real cloud stack. |
| RAAAL | Demo | HTML | - | - | A regime-aware asset-allocation research demo. |
The honest read
The runtime sits under an agent framework. It's the layer underneath one: the place where the decision about how to answer, what to spend, what to verify and how to reproduce it lives, once, for every application that rides on it.
We believe AI infrastructure should be reproducible when it's deployed and every time it makes a decision. Deployment reuse and execution reuse are different problems, and the next-generation AI stack needs both.
Open today vs. on request
| Component | Availability | |
|---|---|---|
| ✅ | Python runtime | Open source · AGPL-3.0 |
| ✅ | Helm-based Reference Systems | Open source |
| 🔒 | Go runtime | Enterprise · on request |
| 🔒 | Kotlin runtime (Spark / Databricks) | Enterprise · on request |
| 🔒 | Discovery Runtime | Enterprise |
| 🔒 | Self-learning Runtime | Enterprise |
| 🔒 | Context Fabric | Enterprise |
| 🔒 | Identity & Policy Plane | Enterprise |
| 🔒 | Multi-tenancy | Enterprise |
Start here: github.com/redevops-io/agentic-os · the architecture overview · the ten whitepapers.
#OpenSource #AIEngineering #LLMOps #AIInfrastructure #MissionRuntime #ContextRuntime #LangChain #LangGraph #AMD #Kubernetes #Governance #GenAI #Agents #MLOps