rAIls in very plain English
A primer on what each part does, and the specific tricks it uses to do it well — each trick explained with a basic example.
The one idea everything hangs on
Ask an ordinary AI the same question twice and you can get two different answers, with no way to explain why. ReDevOps is built to fix that: make the same decision twice, and be able to prove it. Everything below is a piece of machinery that removes one more source of "it changed and nobody knows why."
The pieces, and how they fit in one sentence:
Discovery notices work worth doing → Mission runs that work safely and provably → Context decides what information each step needs → ReDevOps RAG fetches the actual sources → agent-harness keeps each individual step safe → the Governance Plane watches the whole team's trajectory across agents → and Sidekick / Projects are where a person actually uses it.
None of these pieces replace your agent framework — they run around it. Bring LangGraph, CrewAI, PydanticAI, LlamaIndex, NVIDIA NeMo or a custom stack; ReDevOps adds the machinery below and governs the whole thing. We've built and measured the same integration on eight of them — see the integrations.
The parts, in plain words
ReDevOps RAG — the librarian
What it does: finds the passages that actually answer a question and hands back pointers to the sources (with where each came from and why it ranked), instead of pasting in a blob of text. Why it matters: a pointer to one source of truth can't quietly go stale the way a pasted copy does. Tricks it uses: keyword search (BM25), connect-the-dots search (Personalized PageRank / HippoRAG), time-aware search (temporal), and references instead of copies.
Context Runtime — the prep chef / planner
What it does: given a question and some limits (time, cost, quality), it decides what evidence is needed and how to assemble it into a plan the model can act on — then writes that plan down so it can be explained and reused. Why it matters: every app used to reinvent this badly; now it's one planner that can show its work. Tricks it uses: routing, knapsack (context budgeting), the six-axis plan, recompile-on-change-only, and (optionally) a contextual bandit that learns which choice works best.
Mission Runtime — the project manager with a safety net
What it does: turns a goal into steps, runs them, pauses for human sign-off where needed, records everything, and can replay the whole thing and prove the record wasn't altered. Why it matters: this is where real work with real consequences happens, so it borrows every safety trick databases already figured out. Tricks it uses: write-ahead log + replay, saga / compensation, two-phase approval gate, leases (locking), safe concurrency (parallelize what's safe, serialize what conflicts), a hash-chained ledger, and verification (independent re-checking).
Discovery Runtime — the scout
What it does: notices "this investigation or fix should probably happen" and proposes it — but never runs it itself. Proposals go through the exact same Mission pipeline as human-requested work. Why it matters: there's no privileged back door; a machine-proposed job is validated, simulated, run, replayed, and verified identically to a human one. Trick it uses: it keeps two things separate — what triggered the idea (origin) and how sure it is about each input (stated / inferred / unconfirmed…), so a guess never quietly becomes a "fact."
agent-harness — the safety cage for a single step
What it does: governs how one model or tool call runs — approvals, sandboxing, guardrails, evaluation. It's the smallest safe unit; the runtimes above compose many of these.
Governance Plane — the referee watching the whole game
What it does: the safety cage guards one step; the Governance Plane watches the whole team — the sequence of moves across agents. A fleet where every agent follows the rules can still cause a disaster: one agent undoes another's fix, several pile onto the same resource, or a sensitive record is reassembled from reads that each looked harmless. Why it matters: once agents coordinate on their own (see Sidekick, below), the danger isn't one bad call — it's the pattern across many good-looking ones. And it's honest about its reach: it says what it can actually stop versus only flag and escalate. Trick it uses: it evaluates the trajectory — the correlated sequence — not each action in isolation, so it catches an escalation no single-step check can see. A new rule can be switched on in shadow first: it records what it would have done without acting, so you can confirm it's right before it's ever allowed to stop anything — and it can flag when a risky sequence follows right after a change in the underlying facts.
Sidekick — the assistant app
What it does: the hands-on assistant where several agents coordinate to help you get something done. Coordination is emergent (agents figure out the teamwork) rather than a rigid pre-drawn org chart.
Projects — the workspace
What it does: the human workspace over the whole stack — where a person launches, watches, and approves missions, and where the workflows, discoveries, and anything that needs a person all surface in one place. Missions are the core of it; the rest of the machinery shows up here too, and Sidekick is the conversational way to work across all of it.
Agentic Apps — the ready-made stack you can run today
What it does: a suite of six domain agents (open-source apps, AGPL-3.0, on the source-available ReDevOps Runtime) — Revenue, Intelligence, Finance, Customer Success, Content, and Security & Compliance — each acting through a real open-source business app (a CRM, an analytics tool, a support desk, a publishing tool). It's the whole machinery above, pre-wired into software you'd actually use, so you can stand it up and watch it work instead of building from scratch. Why it matters: the design target is that every one of those agents is runtime-native — it doesn't freelance. It 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. Today, approvals gate actions and read-back verification is live for a few capabilities; the rest is rolling out. A signal in one app becomes one governed Mission that borrows authorized capability and context from the others — one identity, one approval trail, one auditable history — instead of a person ferrying context between six separate copilots. The honest part: it's yours to run. Public images, no login; self-host on your own hardware or deploy on your own cloud (on-prem, AWS, Google Cloud, Azure, DigitalOcean), pointed at your own model. See the Agentic Apps →
The tricks, explained with basic examples
These are the specific optimizations named above. Each is a small, well-known idea; the value is in applying the right one in the right place.
| Trick | In one line | Basic example |
|---|---|---|
| Routing | Send each question to the tool best at that kind of question, instead of one tool for all. | "How many orders yesterday?" → ask the database. "Summarize this contract" → read the document. Like a receptionist sending each caller to the right department. (Measured: picking per-question beats every single fixed method — ~0.883 accuracy.) |
| Knapsack | You have limited space and many useful items; pick the combination worth the most that still fits. | Packing a carry-on with a weight limit: take the highest-value items that fit, not just the first ones you grab. Here the "bag" is the model's context window and the "weight limit" is the token budget. |
| Contextual bandit | Mostly use the choice that's been working, but now and then try an alternative to keep learning — and let the situation decide which is best. | A vending-route driver who mostly restocks the top seller but occasionally tries a new snack to see if it does better at that location. Used sparingly and opt-in, only for a single leaf decision — never to reshuffle a whole plan. |
| Recompile-on-change-only | Only redo the planning work when the inputs actually changed; otherwise reuse the last plan. | A spreadsheet recalculates only the cells affected by your edit, not the entire sheet. Same inputs → same plan, every time (that's idempotency). |
| Saga / compensation | If a multi-step job fails partway, undo the steps that already happened with matching "undo" actions. | Booking a trip: flight ✓, hotel ✓, car ✗ → cancel the hotel and the flight. You can't just "roll back" like one database write, so each step carries its own undo. It only fires when something actually ran and then failed — a plan that was declined never ran, so there's nothing to undo. |
| Write-ahead log + replay | Write down what you're about to do before doing it; if you crash, re-read the log to rebuild the exact state. | A chess diary recording every move: lose the board and you can reconstruct the game move-for-move. The rule here: replaying the log must reach the same ending every time — and it replays against exactly what was known at the time (pinned to that moment's evidence), which is kept separate from deliberately re-checking the decision against today's facts. |
| Two-phase approval gate | Prepare an action but don't actually commit it until a human says "go." | The "review and confirm" screen before a payment actually sends. Nothing with real-world side effects happens on the strength of a guess. |
| Leases (locking) | Give one worker a time-limited exclusive claim on a resource so two don't collide. | A library book checked out for two weeks — nobody else can take it until it's returned or the loan expires. The time limit means a crashed worker doesn't block the resource forever. |
| Safe concurrency | Run independent steps at the same time, but automatically hold back the ones that touch the same thing — and say why each was held. | Two deploys to different clusters go at once; two deploys to the same cluster take turns, and the log records "held: same resource." You get the speed of parallelism without two changes racing the same target — and the same rules hold identically in the Python, Go and Kotlin versions of the runtime. |
| Hash-chained ledger | Each record carries a fingerprint of the one before it, so history can't be edited secretly. | A tamper-evident seal on a run of records: change any earlier entry and every fingerprint after it stops matching. (The core idea behind a blockchain, minus the coins.) |
| Least authority + just-in-time keys | A step can only ever do what it was specifically handed — never more — and secrets are lent for one job, then taken back. | A hotel keycard: it opens your room for your stay, not the whole building, and it stops working at checkout. Each step gets a narrow, time-limited permission and a borrowed key, so a compromised step can't reach past its job. |
| Written at the door, not by the worker | The runtime records what each step actually did, as it happens — the agent doesn't get to narrate its own history. | A shop's own camera versus asking the shoplifter to describe their visit. Because the record is captured at the boundary (as fingerprints, not the sensitive contents), a misbehaving step can't quietly leave its bad move out. |
| Containment | If a run of individually-fine moves adds up to something dangerous, box the whole thing — and some boxes can't be quietly reopened. | Read one private record (fine), then another (fine), then email them out (fine on its own) — together that's a leak. The runtime spots the shape, stops it, and a "no-override" stop can't be lifted by the very thing that triggered it. |
| Use a real engine, not a guess (geospatial) | For anything a precise tool can compute, use the tool — never ask the AI to eyeball it. | "Is this address inside the downtown zoning district?" is a geometry calculation, not a vibe. Hand the boundary and the point to a geometry engine for an exact yes/no — and where the ordinance is genuinely unclear, an honest "needs review" instead of a made-up "yes." |
| References instead of copies (normalization) | Store a fact once and point to it, rather than pasting it everywhere. | A shared document link vs emailing the file to ten people — edit one emailed copy and the other nine silently go stale. Retrieval hands back a pointer to the one source, not a pasted copy. |
| Verification (CHECK constraints) | Independently re-check the answer against the rules before accepting it. | A second person re-adds the invoice total. It only works if the checker is built from an independent source — otherwise it just repeats the same mistake. |
| Six-axis plan | Write the whole plan down as six independent choices, so any one can be explained or changed alone. | A recipe card that lists ingredients, method, and oven temperature separately — you can change the temperature without rewriting the recipe. The six: what to represent, what to retrieve, how to reason, which model, what shape (topology), and how to verify. |
| Connect-the-dots search (Personalized PageRank / HippoRAG) | For questions that need several linked facts, walk the web of connections starting from the facts you already know are relevant. | "Who is my manager's manager?" — follow the links from the people already in play, rather than hoping one search returns the whole chain. |
| Keyword search (BM25) | Classic relevance: reward rare matching words, don't over-reward repetition. | A search that knows "reconciliation" is a more meaningful match than "the," and that a word appearing 50 times isn't 50× more relevant. |
| Time-aware search (temporal) | Prefer the version of a fact that was true at the relevant moment. | "What was the price in March?" returns March's price, not today's. |
If you remember only three things
- References, not copies. One source of truth you point at — so nothing silently drifts.
- Write it down before you do it, and be able to replay it. That's what makes work auditable, resumable, and provable.
- Pick the right method per question, not one method for everything. Routing (and its friends) is why the system is both cheaper and more accurate than a fixed pipeline.
Want the "where does everything live?" picture? The very first idea above — references, not copies — is really a rule about what gets written down and kept versus what the system just works out again each time. The architecture page draws that line for the whole platform, in one diagram: what persists, and what recomputes →.