All articles
    open-source
    ai-runtime
    mission-runtime
    context-runtime
    execution
    governance
    langchain
    langgraph
    amd
    reference-systems
    aiengineering
    llmops
    aiinfrastructure
    genai

    Open-sourcing rAIls: A Different Layer of the AI Stack

    August 5, 2026redevops.io
    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

    A different layer of the AI stack: applications declare a goal to a shared runtime that plans, executes and governs, above a complementary deployment layer. LangChain and LangGraph sit inside applications as an alternative orchestration approach.
    Scroll the diagram sideways to read itFull size
    • 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.

    Execution moves out of the application and into the runtime. The imperative path wires Application to Framework to Model to Retrieval per app; the declarative path turns a Goal into a Mission, Planner, Execution Graph and finally Models, Retrieval and Tools, planned before any model is called.
    Scroll the diagram sideways to read itFull size

    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 / LangGraphrAIls
    ShapeLibrary embedded into each applicationStandalone runtime shared by many applications
    OwnershipEach app owns its orchestrationOne reusable execution model across projects
    LanguagePrimarily the Python ecosystemCross-language semantics (Python · Go · Kotlin)
    SurfaceBroad framework, many optional integrationsIntentionally lightweight core, minimal dependencies
    FocusOrchestrationPlanning, 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.

    The public repository map: runtimes and core (agentic-os, context-runtime, redevops-rag, agent-harness) under AGPL-3.0; the mission-sdk and sidekick as SDK and tooling; DataOpsBench and multiagent-orchestration-benchmark as benchmarks; redevops-demo and RAAAL as runnable demos. The enterprise layer ships separately.
    Scroll the diagram sideways to read itFull size
    RepositoryRoleLangLicenseReleaseWhat it does
    agentic-osRuntime · corePythonAGPL-3.0v0.3.1Mission Runtime kernel + control plane: cost-aware LLM router, permissions plane, reference apps.
    context-runtimeRuntime · retrievalPythonAGPL-3.0v0.3.0A query planner for LLM context: decides what a model sees before it answers, across six orthogonal axes.
    redevops-ragRuntime · substratePythonAGPL-3.0v0.3.0Hybrid RAG library: DuckDB vector + BM25 fused via RRF, recency/keyword priors, optional cross-encoder rerank.
    agent-harnessRuntime · stepPythonAGPL-3.0v0.1.0How a single model/tool step runs safely: clients, tools, sandbox, approvals, guardrails, evaluation.
    mission-sdkDeveloper surfacePythonApache-2.0v0.3.0The developer boundary + compatibility target: author, validate, explain, run a governed MissionProgram (rdo CLI).
    sidekickToolingPythonAGPL-3.0v0.1.0Local coding-agent orchestrator: a DAG of auto-approved, git-worktree-isolated sub-sessions across LLM providers.
    DataOpsBenchBenchmarkPythonApache-2.0-Model- and framework-agnostic DataOps benchmark (the DataOps TPC-C): diagnose, repair, reconcile and verify beyond a context window.
    multiagent-orchestration-benchmarkBenchmarkPythonMIT-Controlled, reproducible test: does formal multi-agent orchestration beat a strong supervisor? Harness, specs, results.
    redevops-demoDemoPython--Self-demonstrating deploy-and-operate: one prompt provisions, secures, monitors and self-heals a real cloud stack.
    RAAALDemoHTML--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

    ComponentAvailability
    ✅Python runtimeOpen source · AGPL-3.0
    ✅Helm-based Reference SystemsOpen source
    🔒Go runtimeEnterprise · on request
    🔒Kotlin runtime (Spark / Databricks)Enterprise · on request
    🔒Discovery RuntimeEnterprise
    🔒Self-learning RuntimeEnterprise
    🔒Context FabricEnterprise
    🔒Identity & Policy PlaneEnterprise
    🔒Multi-tenancyEnterprise

    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

    Want ReDevOps in your Google Top Stories & AI results?Follow ReDevOps on Google