All articles
    architecture
    amd
    rocm
    enterprise-ai
    ai-runtime
    rag
    kubernetes
    helm
    reproducibility
    mission-runtime
    context-runtime
    gpu
    aiengineering
    llmops
    genai

    The Box and the Decision: ReDevOps vs. AMD's Enterprise AI Blueprints

    August 6, 2026redevops.io
    The Box and the Decision: ReDevOps vs. AMD's Enterprise AI Blueprints

    A vendor blueprint makes an AI system easy to stand up. A runtime makes its decisions easy to trust, and to make twice. Here's why you want both, and why they run on the same eight GPUs.

    There's a slide at the end of a lot of enterprise-AI demos right now. "Resources & Next Steps." It points you at the AMD Enterprise AI Agentic RAG blueprint on GitHub, the docs, and a Supermicro MI350X 8-GPU node to run it on. Follow the links and you get something genuinely good: a modular RAG system (an MCP server managing embeddings and a ChromaDB vector store, a reasoning agent on top) packaged as a Helm chart, deployable on Kubernetes in about one command, tuned for AMD Instinct and ROCm, with a web UI waiting at localhost:7860.

    That is real, hard, unglamorous engineering, and AMD did it well. Making an AI system deployable (one command, reproducible infrastructure, sensible defaults, a UI you can show someone on Friday) is most of what stops good ideas from reaching production. If your problem is "I have eight MI350X GPUs and I want a RAG chatbot serving traffic by next week," a blueprint is exactly the right tool, and this is a good one.

    But it answers a specific question (how do I deploy an AI system?) and it's worth noticing the question it doesn't ask.

    Two different questions

    Watch the blueprint actually run and the shape is familiar. ReDevOps starts from a different question (how does an AI system make a decision I can trust, and reproduce?) and pulls planning out of the application, which produces a different shape:

    Two questions, two shapes. Left, the deployment question: Application → Agent → Model/MCP/Retrieval → Infrastructure. Ask twice and you may get different answers. Right, the execution question: Goal → Mission → Planner → Execution graph → Retriever/Models/Tools. Ask twice and you get the same evidence, provably.
    Scroll the diagram sideways to read itFull size

    The blueprint's application holds a prompt. The agent calls some tools. A retriever returns some chunks. A model writes an answer. It works, and if you ask it the same question twice, you may get two different answers, from two different sets of chunks, for reasons nothing in the system can reconstruct. That's the ambient design of almost everything built this way, AMD's blueprint included. Retrieval is "whatever the vector database returned today." Planning (which retriever, how much context, which model, in what order, under what budget) is smeared across the application, solved a little differently every time.

    On the runtime side, the planner decides representation, retrieval, reasoning effort, model, topology, budget, and verification before the model runs, and emits one explainable plan. The mission runtime compiles that plan into a governed execution graph: event-sourced, replayable, gated where it touches the outside world, rolled back by a saga when a step fails. Retrieval stops being "whatever came back" and becomes a deterministic artifact: stable chunk identifiers, provenance, ranking evidence, a context view materialized from references. Ask the same question twice and you get the same evidence, provably.

    Two different questions. Deployment reuse versus execution reuse. They're different axes.

    What "execution reuse" actually buys you

    Abstract until it isn't, so here's the concrete version (things we can point at):

    • The same retrieval, in three languages. The redevops.io/benchmarks retrieval suite (document, graph, temporal, routing) runs identically across the Python spec, the Go systems port, and now the Kotlin/JVM runtime. On the deterministic arms the numbers match cell for cell (popqa document recall 1.000, musique 0.613, the native router 0.992/0.00/0.00, the same in every implementation). A decision the runtime makes is a decision any conforming implementation makes the same way.
    • Cost-based planning before the model runs. Routing each question to the method proven to answer that kind beats any single fixed method (0.883 vs. every fixed baseline). The system estimates cost, latency and quality across candidate plans and picks, paying the context window cost of the chosen plan.
    • Reconciliation you can't fake. A governed, metric-keyed merge surfaces every cross-source conflict and invents none (recall 1.0, precision 1.0); the naive value-keyed union surfaces none (0.0). We ran that as a distributed Spark job on a Kubernetes cluster and it reproduced bit-for-bit: 263 executor tasks, zero model calls, deterministic. It's the same result in Python, in Go, and on Spark, because it's a property of the operator.
    • Provenance, replay, verification, deny-by-default. Every mission is an append-only event log that replays to the same terminal state; every capability is denied unless explicitly granted; every stored claim is re-verified from an independent source, then trusted.

    A deployment blueprint is for the deploy. A runtime is for all of that. And it's the half a chatbot-on-a-vector-store leaves on the floor.

    Where AMD is genuinely stronger, and what we did about it

    Here's the honest part. For a long time the thing ReDevOps didn't have was exactly the thing AMD is great at: packaging. Helm charts. One-command installs. Reference deployments with tuned hardware paths and a UI. We had execution reuse largely solved and deployment reuse barely standardized, which is a strange way to lose, because the runtime's whole pitch is reproducibility, and "clone these fourteen repos and wire them up by hand" is the opposite of reproducible.

    So we took the blueprint idea seriously and built the missing layer, Reference Systems: complete, production-shaped deployments built on the runtime. The Kubernetes face of that is now a single Helm chart, redevops-runtime, that stands up Context Runtime + Mission Runtime + ReDevOps RAG in one command, points at a managed Postgres + pgvector (RDS, Aurora, Cloud SQL, Azure) or bundles one, and (this is the part a vendor blueprint doesn't do) installs itself as a governed deployment mission. A post-install hook runs the acceptance checks as a gate and fails the release if they don't pass. The deployment is a mission with an Outcome, the same way every other mission in the system is, retiring "kubectl apply and hope". We built our own. We adopted the blueprint's best idea and kept ours.

    They run on the same eight GPUs

    The punchline the "vs." framing hides: this is complementary.

    Complementary: the AMD blueprint owns model serving (ROCm / vLLM); rAIls owns the decisions (plan, govern, verify), and both schedule onto the same Supermicro MI350X node, eight AMD Instinct GPUs on ROCm.
    Scroll the diagram sideways to read itFull size

    The Reference System runs on the exact Supermicro AMD Instinct MI350X nodes from that closing slide. Flip one value and it schedules a ROCm/vLLM model server onto amd.com/gpu, self-contained on Instinct. Or point it at an AMD blueprint's model endpoint and let the blueprint own the serving while the runtime owns the decisions. AMD's ROCm ecosystem is maturing fast; the runtime is deliberately hardware-neutral and happy to ride it.

    AMD standardizes deployment reuse. ReDevOps standardizes execution reuse. The blueprint makes the system easy to stand up. The runtime makes its decisions easy to trust, to explain, and to make twice. Those are different problems, and the interesting move is to ship both, on the same box.

    A blueprint gets you to a running system by Friday. A runtime is what lets you still trust that system's answers six months later, reproduce any decision it made, prove the deterministic ones, and roll back the deploy that broke it. Stand up the box with the blueprint. Govern the decision with the runtime. The next slide after "Resources & Next Steps" is the one where those two stop being separate talks.

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