rAIls in plain English
A non-technical walkthrough of the AI Runtime Stack: one worked example, the layers behind it, and why the approach should be better than how AI systems are usually built.
The one-sentence version
Most AI products bolt a chatbot onto a search box. We built something closer to an operating system for getting real work done with AI: it decides what's worth doing, plans it, executes the plan safely under human approval, and gives each step only the intelligence it needs — every decision explainable, every outcome fed back so it improves.
The problem with how it's usually done
"AI that answers questions about your documents" almost always means three things:
- Search the same way every time. Turn documents into math fingerprints, grab the closest few. Fine for "what's our refund policy?"; it fails on questions that connect facts across documents, reason about when something was true, or query a real database.
- Dump everything on the AI. The fashionable fix — "bigger memory, more text" — is expensive, slow, and often worse: the more you pile in, the more the one fact that mattered gets buried.
- Glue it together and hope. No sense of which approach fits which question, no learning, no checking, and no safe way to let it actually do anything.
The result is confidently wrong on hard questions, costs too much, can't explain itself, and can't be trusted with actions. The platform attacks all four.
How it works — one example
A customer's support volume spikes the day after a deployment.
- Discovery Runtime notices — nobody filed a ticket. It watches support volume, deploy history and error rates, sees the spike line up with the release, and proposes a mission with the evidence attached.
- The Execution Planner designs the plan — combine four kinds of evidence (support tickets, deployment history, telemetry, docs) into one plan that says how to investigate, how hard to reason, and what "done" means.
- Mission Runtime compiles it into a governed step-by-step graph — correlate tickets, diff the deploy, check telemetry, propose a fix — and owns the order, state, approvals, and undo.
- Context Runtime gives each node only what it needs — the right evidence and the right model per step, not everything, not the same thing every time.
- Sidekick asks for approval in plain language: "the spike traces to yesterday's checkout release; here's the likely fix; approve the rollback?"
- Mission Runtime executes on approval — and if a step fails, it rolls back the ones already taken, so a half-finished repair never leaves a mess.
- The outcome updates world state and the learning policy — next post-deploy spike, it's faster and smarter about which play to run.
No one scripted "post-deploy support spike." The platform discovered the work, planned it, governed it, and learned from it.
The layers
- Discovery Runtime — finds the work. Proposes the missions worth running before anyone asks. It proposes; it never acts alone.
- Execution Planner — designs the work. Turns a proposal into one explainable plan across six choices: which representations, which retrieval, how hard to reason, which model, what shape the work takes, and how it's verified.
- Mission Runtime — governs the work. Compiles the plan into an execution graph and runs it — simulation, approval gates, a replayable event log, saga rollback, and safe concurrency (independent steps run at once; steps that touch the same resource serialize, with a stated reason). The execution kernel: it owns the workflow, side effects and state.
- Context Runtime — supplies the intelligence. Inside each node, decides what to retrieve, which representation, how hard to think, which model — then verifies and learns. Crucially it works by reference: the AI is handed pointers to governed data and materializes only what a decision needs, instead of copying the whole world into its context — cheaper, private data stays governed, and every step is replayable. It optimizes context inside nodes; it doesn't run the workflow.
- Capabilities — do the work. Models, retrievers (ReDevOps RAG is one, alongside SQL, property graphs, tools, APIs and humans), each behind one contract the runtime can call safely. Every single model-or-tool step runs inside a safety cage — the agent-harness: approvals, a sandbox, guardrails, evaluation — so one call can't go rogue.
- Intrinsic security — the door check and the flight recorder. Beneath the safety cage, the runtime enforces who may do what: a step can only exercise the authority it was specifically granted — never more — secrets are lent just-in-time and taken back, and the runtime (not the agent) writes down what every step did as it happens, as tamper-evident fingerprints rather than the sensitive contents. If a series of individually-allowed moves adds up to an exfiltration shape, it's contained. It's all opt-in — but once a step declares a boundary (an isolation level, a required permission, a pinned version), it can't be silently bypassed. The meaning lives in the open runtime; the production enforcement is the Enterprise Edition. And we measured that split: run the same work through the open and enterprise runtimes and they execute it the same way, same decisions — Enterprise only adds the enforcement, the tamper-evident audit trail, and the verification around it. The hardening is additive, not a fork of how the work runs.
- Governance Plane — watches across agents. The safety cage stops one call going rogue; it can't see a whole team of agents each following the rules and still causing a disaster — one undoing another's fix, many piling onto the same resource, a private record reassembled from reads that each looked harmless. The Governance Plane evaluates the trajectory across agents and missions, catches the escalation no single-call check can see, and — honestly — reports what it can actually block versus only flag and escalate. A new rule can run in shadow first — recording what it would do without acting — until it's proven and promoted to actually block, and it can flag when a risky sequence of actions follows a change in the underlying evidence.
- Projects + Sidekick — let humans operate it. Projects is the durable control plane (manifest, desired vs observed state, history, approvals, audit); Sidekick is the conversational Mission Supervisor — every change still goes through Mission Runtime.
What you get out of the box — the Agentic Apps
The runtime above is the engine. You don't have to build on it from scratch to see it work: it ships with Agentic Apps — open-source (AGPL-3.0) business apps that serve as a reference implementation of the whole thing, running real business software on the ReDevOps Runtime (which is source-available under AGPL-3.0-or-later with the Commons Clause, not OSI open source).
It's six governed domain agents, each acting through a real open-source application, composed as suites on the one runtime:
- Revenue — prospecting and next-best-action, through a real CRM (Twenty).
- Intelligence — growth, BI and market radar, through a real analytics tool (Metabase).
- Finance — billing and books operations.
- Customer Success — support, onboarding guides and lifecycle, through a support desk.
- Content — the content engine, through a real publishing tool (Postiz).
- Security & Compliance — KYC and controls, with an evidence trail.
The point isn't "six more chatbots." The design target is that each agent is runtime-native: it doesn't act on its own, but decides through the same priority engine, acts as a governed Mission step, stops at an approval gate for anything consequential, verifies the result, and learns from the real outcome — the machinery in the worked example above. Today approvals execute and gate actions; read-back verification is live for a few capabilities and being extended; the priority engine is implemented and tested but not yet driven by live app state in every app; and most apps' learning feeds are labelled sample/demo. A signal in one app (a support spike, a late invoice, a stalled deal) becomes one governed Mission that uses authorized capability and context from the others — one identity, one approval trail, one auditable history — instead of a person copying context between six separate copilots.
And it's yours to run. The app images are public, no login; you self-host on hardware you control or deploy on your own cloud — on-prem, AWS, Google Cloud, Azure or DigitalOcean — pointed at your own model. It's the same runtime that runs in the enterprise; these apps are the honest, inspectable reference you can stand up yourself. See the Agentic Apps →
Why this is better — or should be
| Common approach | What it does | Where it falls short | What the platform does instead |
|---|---|---|---|
| Basic RAG (search → stuff → prompt) | One fixed search, one prompt | Fails on multi-step, time-based, or structured questions; can't explain itself | Route each question to the method proven to answer that kind; separate finding from reasoning; show the work |
| "Bigger context window" | Dump everything into the model | Expensive, slow, often less accurate (the answer gets buried) | Give each node the right evidence, not the most — cheaper and more accurate |
| Agent frameworks alone (LangGraph, NeMo, CrewAI…) | Build the agent workflow — chains, graphs, tool calls | On their own: no measured routing, no cost-awareness, no governance, no undo | Keep the framework; add the runtime around it — measured routing, cost-awareness, approval gates, replayable history, rollback |
| Fixed pipelines | Hand-tune one setup | Breaks when the data, language, or model changes | Learns and re-routes per corpus and question class; stays current with live updates |
The through-line: most systems assume; this one decides, measures and routes — and can act safely. What deserves attention, which representation, which model, how hard to think, whether to act — all learned from evidence, not guessed once, over a governed, reversible execution layer.
And you keep the framework you already use. None of this replaces your agents — it runs around them. LangGraph, CrewAI, PydanticAI, LlamaIndex, NVIDIA NeMo or a custom stack builds the workflow; ReDevOps adds the runtime guarantees on top. We've built and measured the same integration on eight frameworks and clouds — see the reference implementations.
An honest note on "better" vs "theoretically better"
- Proven in our tests: matching the search method and encoder to the data genuinely helps — a domain corpus that scored near zero was rescued to strong accuracy by routing to the right encoder and fixing how much context it reads. Routing beats any single fixed method across a suite of question types. The system falls back to a safe default rather than guessing when it lacks confidence.
- Still being measured: learning the best choice for each individual question (vs each question type) needs more usage to converge — at small scale it over-fits. And the value of "reasoning harder" depends on the model and, we learned the hard way, on the evaluation being correct — a couple of apparent "the AI can't do this" walls turned out to be scoring bugs, not limits of the AI.
That last point is culture as much as architecture: audit the evidence before declaring a wall, measure before promoting, show the work. So we built the measuring into the platform: a benchmark runs through the same governed machinery as everything else — a versioned program whose results are reproducible, trace back to their evidence, and only get published when they verify. (When a couple of "the AI can't do this" walls turned out to be scoring bugs, that's exactly the kind of thing a governed evaluation catches.)
Where things live — the precise version
One design rule underlies a lot of the above: what has to be stored, versus what is only recomputed. Durable, shared truth — the append-only history, the world model, the retrieval indexes, the outcomes — lives in a store; the decisions, the routing and the governance are behavior the runtime recomputes and can replay. Getting that line right is what keeps a mission replayable and a result auditable. The exact boundary, mapped to each contract, is on the architecture page: the state boundary — what persists, what recomputes →.