How we build, run, and self-host Context Runtime and the applications on top of it — and what we learn doing it.
Signed, multi-architecture container images for the rAIls runtime, plus two applications you can now run on their own: redevops-qa for evidence you can re-verify offline, and edge-sentinel for security responses a human approved. What shipped, how to verify it, and what is still missing.

Confirmatory feedback made adults remember things they had knowingly invented. Children take years to learn to say 'I don't know'. Put those two findings next to each other and the usual advice for teaching agents honesty inverts: consequences are necessary, but a reward channel selects for what got endorsed, not for what is true. 75 registry-verified papers, and what they do and do not license an architect to build.
Keep specialized test frameworks. Standardize the execution contract, the evidence and the independent verification step. What the rAIls layer adds to the engines, how to install the pre-release today, and what has and has not been validated.
Why we deliberately stress-test agent infrastructure with smaller models, and what a constrained JobBench experiment revealed about harness and context management.
Chain-aware filtering retains a fraction of log data—but detecting unfamiliar failures remains the hard part.

What if the next frontier in AI is not getting models to produce more acceptable answers, but recovering their ability to produce ideas nobody expected? Human preference signals can reward the familiar over the original. Here is what the research shows, what it does not, and the experiment to run next.
We tested a week's worth of recent arXiv allocation papers against our own published strategy. Almost every headline result failed to replicate. Combining the pieces that failed in the same way did little. Combining the pieces that failed in different ways nearly halved the worst drawdown, from −19.4% to −10.6%, at the same return. It did not beat the original on risk-adjusted return since 2013, and we say so.
We spent weeks ranking asset-allocation models by twenty basis points. Then we measured what our data could resolve (169 bp) and found eleven implementation bugs each moving the numbers by hundreds. The signal was below the noise floor. The bugs were above it.

We gave an agentic research loop one question: can market state improve portfolio allocation? Most early hypotheses did not survive. One did (dynamic equity sizing), and the failures are now evidence for what the system explores next. On a 345-month window through August 2026 the dynamic strategy returned 7.62%/yr at 0.91 Sharpe, beating the best fixed allocation by +2.56%/yr (t=2.24). This is how the loop works, what survived, and what stays open.

We made two business questions ('where is recoverable revenue stuck?' and 'can we fulfil this quote?') into first-class Runtime capabilities that resolve across Twenty, ERPNext, Chatwoot and Lago through one receipted, replayable path, and stop at a human approval gate. Against a live demo the leakage question returned 131 signals (129 stalled opportunities, one unanswered quote request, one account nearing its plan ceiling), resolved the entities behind them, ranked them, and parked every one on approval. 131 things to look at. Zero autonomous actions. This is how it's wired, and why the boring parts are the point.
SPLADE + dense fusion is the retrieval upgrade everyone recommends this year, and the case for it is real: learned-sparse recovers exact identifiers dense embeddings drop. Before adding a transformer dependency to our stack we measured it against the hybrid we already run. On the cases it should win, SPLADE⊕dense beat our hybrid by +0.005 (inside the noise) and as a graph-completion signal it tied plain tf-idf at AP 0.01. So we didn't ship it; we kept it as a benchmark arm for the corpus where it actually wins. The post is about measuring the upgrade, on your corpus, before you take the dependency.
We froze one base model and added the decision Runtime one layer at a time (verification, context, planning, bounded tools, discovery, persistent lessons) and scored every decision with a frozen Stockfish depth-16 oracle on 726 held-out chess positions. The full stack cuts the blunder rate 0.408 → 0.197, and with the weights held fixed the held-out blunder rate falls as the Runtime learns.
A seeded, end-to-end benchmark of a real pure-Python geometry engine ported to Mojo 1.1: native kernels ran 5.7×–42× faster with zero correctness mismatches, yet the Python↔Mojo boundary turned a 7 ms point-in-polygon into 195 ms. Why the microbenchmark isn't enough, and how we choose an execution backend by measured crossover.
Most AI applications still wait to be told what to do. The rAIlsApps release makes each app observe its domain, decide what deserves attention, and let a shared runtime plan, govern, execute, and learn, with 'do nothing' as a first-class action.
We showed that a code change is a closure (the edit plus every caller whose contract breaks) and that graph traversal recovers what similarity cannot. Does that generalize past code? We ran the same experiment on real statutes, regulations and SEC contracts: the citation graph wins or ties on every single case, similarity trails 4-12x, and a HippoRAG-style associative graph never helps. The invariant is the change closure. And we found exactly one lever that lifts it.
An asset-management workflow is a changing execution plan over data, evidence, models, tools, policy and actions, and its real job is to turn a research signal into a portfolio-specific, tax-aware, compliant, authorized and explainable action before anything consequential happens. That is a database-query-planner problem, and the contract that fixes the meaning of a Mission while its machinery varies is what makes the planner possible at all.

AI infrastructure doesn't need another rip-and-replace migration. If your application already uses LlamaIndex for retrieval, keep it; if LangChain or LangGraph owns your workflows, keep those too. ReDevOps sits at a different boundary. It manages context and production execution across the components you already use: LlamaIndex becomes one retrieval capability, LangGraph an application workflow, and the Runtime decides what to use, verifies it, and governs the whole Mission.
We didn't want to argue that ReDevOps is a better agent framework than the one you use. We wanted to show it's the production runtime that goes around whichever one you picked. So we built eight reference implementations: NVIDIA NeMo, PydanticAI, LlamaIndex, CrewAI, plus Azure, Google, AWS and DigitalOcean. Real agents, running locally, on one provider-neutral contract, each testing a different boundary, and every result classified as conformance.
Relevant is not the same as complete. Across five domains we show the unit of relevance is the dependency closure, composed in a capability-specific way; and end to end on ContractNLI, dependency-complete context raises task accuracy where a dependency decides the answer (Contradiction 0.800 to 0.933) while the Runtime abstains (0.817 autonomous at 67% coverage) when completeness can't be established. Three different accuracy numbers, kept carefully apart.
Open-core has an uncomfortable question: what exactly changes when you move to Enterprise? A measurable rule replaces a feature checklist. The open and enterprise runtimes execute the same workload the same way; Enterprise adds enforceable guarantees around that execution.
A retriever that finds the most relevant snippet still fails at code, because a code change is a closure: the definition plus every caller whose contract breaks. We built a benchmark that measures whether the change actually lands, and found that structural graph traversal and content retrieval fail differently. Their union recovers the closure, and (the result that matters) that lift converts into successfully completed edits.
A 12-family benchmark of ReDevOps against LangChain, LangGraph, and a hand-rolled baseline, plus cross-language runtime conformance across Python, Go, and Kotlin, measuring correctness beside efficiency on real corpora with a local 27B model.

A real-model long-horizon test: past a model's context window, dumping the whole corpus in collapses to zero while managed context holds full accuracy at ~27× fewer tokens, reproduced on an independent corpus, with a 30B model on a single 32GB GPU.
Ask an LLM “can I build a warehouse on this parcel?” and it will answer confidently, and sometimes fabricate a permit that doesn't exist. We added geospatial as a Runtime capability instead: geometry is typed evidence, spatial relations are computed by an engine (never guessed), and land-use is decided by a deterministic-first, fail-safe resolver that returns PERMITTED, PROHIBITED, or an honest UNKNOWN: never a made-up yes. Measured on real parcels (a cross-country sample drawn from a nationwide harvest of 149,624 districts across 4,562 official ArcGIS services), it holds a false-permitted rate of zero, and the runtime learns the cheapest sufficient evidence bundle: +0.894 reward at 1.4× lower cost than always-fetching-everything, with zero SLO violations. It's live at geo.redevops.io.
Bolt-on security and bolt-on telemetry share a hidden failure: each subsystem invents its own event semantics, and agent-reported telemetry can be lied about by the very agent it is watching. For v0.3.0 we made both properties of the runtime instead. One canonical event, emitted at the capability boundary (hashes of payloads, runtime-emitted) feeds security, governance and OpenTelemetry alike. The Mission is the root of one causal trace, and a deployment substrate like Argo nests only underneath it. The shapes are open; the enforcement is a private plugin. And we measured the epistemic gate honestly on a public prompt-injection dataset: a deterministic, zero-inference first gate that lifts recall 5× over the baseline at zero false positives on held-out benign text, as a first gate before a classifier that still runs.

Enterprises spent decades making infrastructure reusable (shared databases, APIs, compute, data platforms), yet every new application still rebuilds the logic that decides how those systems compose into a business workflow. Agentic systems give us a reason to move the boundary: business systems express intent; data, compute and applications expose capabilities; the runtime compiles one into the other and governs the trajectory. The catch data teams will look for first: this only works if the runtime reads served evidence, never fires ad-hoc queries at production. Done right, it's the enterprise version of treating the app as an execution node, and it strengthens the separation of concerns.

The honest way to add a GPU to a runtime is to treat the accelerator as a costed capability the runtime can select, and to measure, on real data, where it actually pays. We built three accelerated backends for our evidence-native runtime (cuVS for retrieval, cuDF for evidence processing, cuOpt for planning) and ran them on real Wikimedia history against a strong CPU baseline on the same machine. The results split cleanly: retrieval is a 36× GPU win, evidence processing wins only above a million rows, and planning is a win the GPU never gets. Same runtime, three different right answers, which is exactly the point.
You want an AI workflow to touch your CRM, and first you must build an integration: API type, OAuth, scopes, credentials, field mapping, webhooks. None of it is the goal. That's an architectural assumption: the app is treated as both the capability and the boundary you have to walk through. Agentic systems let us separate those. The app becomes an execution node the runtime calls, and the runtime owns the relationship: intent, context, scoped authority, execution, verification and governance across the whole mission. The rule that removes most of the friction: ask the user only for what the runtime doesn't already have and can't safely derive.
Couldn't a Random Forest predict drive failures better than your runtime? Probably, and that's exactly the point. On real failure ground truth (Backblaze Drive Stats, 5,061 drives, 1,061 real failures) the trained models cluster with a simple inspectable rule, so prediction is an interchangeable input to the runtime. Discovery's real job is routing: run the cheap device-local capability first, escalate only the ambiguous cases to a learned specialist, and adaptive routing matches an always-on model's precision and recall while running it on just 7% of drives. That's the decision-quality/resource frontier, plus reference-first context (−95% bytes), fleet governance (96 quarantines → one review), and one honest physical ceiling (19% of drives fail with no warning at all).
We argued that sanctions screening is a graph traversal, then measured it: 100% vs a naive screen's 36.7%. Now it's live: at grc.redevops.io you type a company and watch it walk ultimate ownership and catch the sanction sitting on an owner upstream, over 182,445 real GLEIF entities.

Multi-agent systems introduce a failure that ordinary safety controls can't see: every individual action can look acceptable while the behavior of the agent population becomes unsafe. For ReDevOps v0.2.0 we're introducing a Governance / Trajectory Plane: governing what agents collectively do across missions and over time.

Generated video is usually all-or-nothing: regenerate and everything drifts. vibexgen makes every scene addressable: Mission Runtime holds the scene graph, Context Runtime keeps the shared details consistent, so a plain-English note changes only the scenes you name and leaves the rest byte-identical. Watch a 3:20 film go v1 → v2.

AlphaGo's 2016 supercomputer cost ~$35M; by 2022 a single H100 matched it; by 2026 an NVL72 rack delivers 20–30× an H100 for ~$6.5M. When compute-per-dollar moves more than two orders of magnitude in a decade, buying too early can destroy capital even when you're right about demand, so rent while the curve is steep and let the big dogs fight.
The AI-accounting gold rush is on, and the hard part is correctness: no public dataset pairs a document with its correct bookkeeping entry or its correct tax return, because real ledgers and returns are private. So we didn't fabricate the numbers. We generated them from real open-source accounting and tax engines and cross-validated across a second, independent engine. Two working example apps, business bookkeeping and personal (1040) tax, built in an afternoon by composing open source. Both are public. Here's how they work, how to run them, and the exact datasets and licenses involved.
Chasing idempotency through an AI stack quietly rebuilt half of a database: normalization, a write-ahead log, query planning, CHECK constraints. So a fair question followed: should the deterministic core ship as a PostgreSQL extension? The pure kernels (merge, BM25, temporal, PPR, verify) are exactly the shape of a stored function. We built the prototype path and then chose not to make it the product. Here's which half of the runtime belongs in the database, which half never will, and why an extension is deployable almost nowhere that actually matters.
A vendor blueprint makes an AI system easy to stand up. A runtime makes its decisions easy to trust, and to make twice. AMD's Enterprise AI Agentic RAG blueprint is genuinely good at the first; ReDevOps is built for the second. They're different axes, and they run on the same eight MI350X GPUs. Here's why you want both, and where each one earns its keep.
Cloudflare announced Cloudflare OS: a platform for running AI agents at scale. At first glance it looks like what we build at ReDevOps; in reality the two start from different questions. Cloudflare asks how to run millions of agents reliably: infrastructure-first. ReDevOps asks how to make AI execute the right decision, every time: execution-first. Those questions lead to complementary layers, and to the same conclusion: shared AI runtime infrastructure is becoming as fundamental to AI systems as databases were to traditional software.
Today we're open-sourcing the Python implementation of rAIls, the reference behind ten whitepapers. The first question everyone asks is how it differs from LangChain, LangGraph, or vendor blueprints like AMD's. The honest answer: it's a different problem. Frameworks orchestrate inside each app; deployment stacks standardize infrastructure; the runtime standardizes planning, execution and governance: one shared, replayable, auditable execution model many applications ride on. Deployment reuse and execution reuse are different problems, and the next-generation stack needs both.
The project began with one small question (an AI operating system still ahead): can an AI system make the same decision twice? Traditional RAG can't. Chasing that single property, idempotency, through retrieval, then context, then execution, then discovery, kept surfacing problems that already had names in database systems: normalization, query planning, write-ahead logs, sagas, constraints, one write path. This is the honest story of how a stack of runtimes emerged, one source of nondeterminism at a time, and why the destination was database discipline all along.
Before adding a formal multi-agent framework to our roadmap, we ran a controlled test: does runtime-managed orchestration (isolation contracts and a formal integration mission) beat a strong supervisor decomposing work and merging it directly? At small scale it tied on every axis. Then we scaled the input past a single model's context window, and the tie became a wall. Here is the harness, the honest result, and how it led to the merge() operator in the v9 runtime.
A single model can write SQL. But operating a data platform means diagnosing failures, tracing lineage, reconciling totals, detecting cross-source conflicts, and repairing pipelines across a codebase far larger than any context window. We built DataOpsBench to test whether a governed AI runtime can do that where a direct model can't. Two failure modes recur: a direct approach either overflows the window, or it fits but is silently wrong, reconciling away the very conflicts that make a merge risky. The runtime is the only thing right on both axes, holding to 28× the window, at zero model calls. Here's the honest breakdown, including where the model isn't even in the loop.
Insurance distribution is a delayed-reward decision problem, so we built it as a self-learning control loop that prunes unsafe actions before learning and proves its value off-policy before it ever acts live.
A restocking decision needs three views of the same shelf (camera, inventory system, and sales history) and on 204 real M5 scenarios only the composed decider that reconciles all three reaches 96.1% with a reported blind spot.
Google DeepMind evaluated hundreds of multi-agent configurations and found the coordination strategy matters more than the number of agents. In Context Runtime, execution topology becomes another measurable optimization dimension (single agent, coordinator and workers, voting, or pipeline) chosen to fit the task.
KYC, sanctions and ownership analysis are graph traversals. We made a deterministic property graph a first-class knowledge representation the planner can choose, then measured it on 182,445 real GLEIF entities: the planner routes across five engines at 91.5%, and the ownership traversal itself runs in 0.53 ms.
Most analytics systems wait for someone to ask the right question. Discovery Runtime watches the world state, identifies what changed, forms evidence-backed hypotheses, and proposes the missions worth executing.

Long-form AI video is serial by construction: every second waits for the one before it. But if the context for second forty doesn't depend on rendering second thirty-nine, you can render them at the same time. Here's how an event-sourced world model (Context Runtime's idea applied to narrative) makes text-to-video an embarrassingly parallel problem, and where interpolation heals the seams.

Google's Gemini Enterprise Agent Platform now ships a full production stack: Agent Engine, the ADK, Vertex AI Search, Model Armor and the open A2A protocol. Context Runtime complements it as the optimization layer that learns which combination of those building blocks produces the best outcome per mission, with Sidekick bridging local IaC into the Google Cloud project.

DigitalOcean's Gradient AI Platform ships a refreshingly simple agent stack: managed agents, knowledge bases, guardrails and agent routing. Context Runtime complements it as the optimization and governance layer that learns which building blocks produce the best outcome per mission, with Sidekick bridging local IaC into your DigitalOcean project.

Microsoft Foundry now ships a full production stack for agents: Foundry Agent Service, the unified Agent Framework, Entra Agent ID and MCP-native knowledge bases. Context Runtime complements it as the optimization layer that learns which combination of those building blocks produces the best outcome per mission, with Sidekick bridging local IaC into the Azure tenant.

Every hyperscaler now ships a production agent stack, and they look more alike than different: a managed runtime, a framework, managed retrieval, guardrails and identity. So the interesting question in 2026 is where the optimization layer belongs, and that answer is the same on all four.

AWS now ships a full production stack for agentic systems: AgentCore, AWS Context, Knowledge Bases and more. Context Runtime is the optimization layer that continuously learns which combination of those building blocks produces the best outcome for each class of mission, with Sidekick bridging local IaC into the VPC.

NVIDIA alone could ship enough hardware for ~99 GW of AI data center capacity by 2030; with AMD and custom ASICs the number tops 150 GW. But global data centers run at roughly 68–73 GW today. The bottleneck has moved from chips to power, transmission, permits, and politics.

Many developers start in the language they intend to deploy, asking the LLM for Go or Rust from the beginning. After building and porting Context Runtime from Python to Go, I think the better workflow is the opposite: treat Python as an executable specification, then translate a working, tested spec instead of re-inventing it in prompts.

Three lessons from stress-testing retrieval architectures against 24B–284B models: heavy infrastructure has to earn its cost, quality beats quantity, and context orchestration and model progress are complementary.

For fifty years, software was organized around applications and users were the orchestrators. AI breaks that assumption. Applications are becoming capability providers, operating systems are becoming orchestration layers, and users are becoming supervisors.

We benchmarked routing each query to the right knowledge representation (document, graph, or temporal) with real HippoRAG and Graphiti engines. Better context matched brute-force context at a third of the cost. And we publish the one result that didn't go our way.

Citations aren't enough; we must expose the hidden logic behind AI document selection to build true trust.

Stop debugging modern AI like static software; understand why non-determinism breaks reproducibility and how to fix it.

Stop confusing chat history with true memory; here is how to build AI that actually remembers what matters.

Stop blaming retrieval. Your RAG fails because context pollution drowns the signal in noise, causing confident hallucinations.

Bigger context windows don't fix irrelevant data; stop paying for noise and start optimizing for signal.

RAG, DeepSeek, Anthropic and OpenAI look like competing answers to long-context AI. Each optimizes a different bottleneck of the same problem: context. Part III maps the engineering trade-offs that point toward an AI operating system.

Everyone assumed Retrieval-Augmented Generation was the future. It was the cheapest workaround we had. DeepSeek asks a different question: what if the model didn't need retrieval to be nearly as precise? Part II on compressing context inside the model.

Everyone is obsessed with context window size. Nobody asks what it costs. Attention scales quadratically, which is why RAG became the industry's default, and why production retrieval pipelines keep getting more sophisticated. Part I of how the AI industry is splitting into two architectural camps.

Purpose-built inference chips like OpenAI's Jalapeño and Qualcomm's HBC will make AI inference cheap. That's exactly when the real problem shows up. When hardware stops being the bottleneck, reliability does, and AI engineering starts to look a lot like systems engineering.

From answering questions to owning production systems: the six-generation arc of agentic AI (AI Assistant → Executor → Learner → Organization → Systems Engineer → System Owner) and what it will take to cross from AI-assisted development into autonomous software engineering.

The demand is for inference. The supply is for training rigs. That gap is a business model. Here's how the inference drought is engineered, and how to route around it today.

Everyone talks about training. Nobody talks about inference. That's backwards. The next decade will belong to whoever makes intelligence cheap, ahead of whoever trains the biggest model, and that changes how all software is built.