The Blog

    Field notes from an agentic company

    How we build, run, and self-host Context Runtime and the applications on top of it — and what we learn doing it.

    From AI Runtime to Standalone Applications: The ReDevOps v0.6.1 Release
    November 13, 2026

    From AI Runtime to Standalone Applications: The ReDevOps v0.6.1 Release

    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.

    release
    rails
    runtime
    qa
    security
    oci
    cosign
    multi-architecture
    edge-sentinel
    redevops-qa
    Read article
    Being wrong has to cost something — but the wrong bill teaches the wrong lesson
    November 12, 2026

    Being wrong has to cost something — but the wrong bill teaches the wrong lesson

    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.

    agentic-ai
    hallucination
    confabulation
    metacognition
    epistemic-vigilance
    reinforcement-learning
    embodied-cognition
    uncertainty-calibration
    abstention
    governance
    evidence
    Read article
    Why We Built One QA Runtime for Multiple Test Engines
    November 1, 2026

    Why We Built One QA Runtime for Multiple Test Engines

    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.

    qa
    testing
    playwright
    selenium
    robot-framework
    appium
    verification
    evidence
    rails
    Read article
    Stress-Testing Agent Harnesses Where Models Cannot Hide Their Weaknesses
    October 31, 2026

    Stress-Testing Agent Harnesses Where Models Cannot Hide Their Weaknesses

    Why we deliberately stress-test agent infrastructure with smaller models, and what a constrained JobBench experiment revealed about harness and context management.

    agents
    agent-harness
    context-runtime
    benchmarks
    context-management
    evidence
    Read article
    Can We Drop 97% of Logs Without Missing the Next Failure?
    October 31, 2026

    Can We Drop 97% of Logs Without Missing the Next Failure?

    Chain-aware filtering retains a fraction of log data—but detecting unfamiliar failures remains the hard part.

    logs
    observability
    anomaly-detection
    retrieval
    benchmarks
    evidence
    Read article
    The Price of Being Agreeable: Are We Training Originality Out of AI?
    October 26, 2026

    The Price of Being Agreeable: Are We Training Originality Out of AI?

    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.

    ai
    creativity
    rlhf
    preference-optimization
    model-training
    inference
    research
    Read article
    Combine the Ideas That Fail Differently
    October 5, 2026

    Combine the Ideas That Fail Differently

    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.

    quantitative-investing
    asset-allocation
    portfolio-construction
    drawdown
    pre-registration
    replication
    agentic-research
    quantify
    market-regimes
    backtesting
    Read article
    The Bugs Were Bigger Than the Signal
    October 1, 2026

    The Bugs Were Bigger Than the Signal

    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.

    measurement
    statistical-power
    evidence
    research-integrity
    quant
    reproducibility
    Read article
    Nine Experiments, One Result
    September 29, 2026

    Nine Experiments, One Result

    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.

    quantitative-investing
    regime-aware-allocation
    self-learning
    agentic-research
    backtesting
    portfolio-allocation
    asset-allocation
    quantify
    market-regimes
    survivorship-bias
    Read article
    A Governed Revenue Loop Across Four Business Systems
    September 29, 2026

    A Governed Revenue Loop Across Four Business Systems

    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.

    revenue-intelligence
    decision-intelligence
    governance
    entity-resolution
    systems-of-record
    approval-gated
    agentic-os
    twenty
    erpnext
    chatwoot
    lago
    Read article
    Measure the Retriever Before You Add It
    September 25, 2026

    Measure the Retriever Before You Add It

    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.

    retrieval
    splade
    hybrid-search
    dense-retrieval
    learned-sparse
    benchmarks
    evaluation
    redevops-rag
    information-retrieval
    lessons
    Read article
    Same Model, ~52% Fewer Blunders: Measuring What the Runtime Adds on Chess
    September 19, 2026

    Same Model, ~52% Fewer Blunders: Measuring What the Runtime Adds on Chess

    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.

    benchmarks
    decision-runtime
    self-learning
    chess
    ablation
    context-runtime
    mission-runtime
    lessons
    agents
    Read article
    We Made a Python Hot Path 42× Faster With Mojo. We're Not Integrating It Yet.
    September 17, 2026

    We Made a Python Hot Path 42× Faster With Mojo. We're Not Integrating It Yet.

    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.

    mojo
    performance
    geospatial
    benchmarks
    runtime
    python
    gpu-acceleration
    cross-language
    architecture
    Read article
    rAIlsApps Should Decide What Happens Next
    September 11, 2026

    rAIlsApps Should Decide What Happens Next

    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.

    agentic-apps
    proactive-intelligence
    ai-runtime
    governance
    priority-engine
    discovery-runtime
    Read article
    Retrieving the Change, Across Documents
    September 8, 2026

    Retrieving the Change, Across Documents

    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.

    context-runtime
    retrieval
    graph
    legal-ai
    benchmarks
    redevops-rag
    citation-graph
    Read article
    Why Agentic Asset-Management Workflows Need a Query-Planner Architecture
    September 3, 2026

    Why Agentic Asset-Management Workflows Need a Query-Planner Architecture

    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.

    asset-management
    query-planner
    runtime-contracts
    mission-runtime
    context-runtime
    governance
    tax-aware
    compliance
    physical-data-independence
    agentic-workflows
    quantify
    reference-implementation
    Read article
    Keep Your RAG and Agent Stack. Let the Runtime Decide What to Use.
    September 1, 2026

    Keep Your RAG and Agent Stack. Let the Runtime Decide What to Use.

    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.

    llamaindex
    langchain
    langgraph
    rag
    agent-frameworks
    context-runtime
    mission-runtime
    closure-resolution
    integrations
    no-rip-and-replace
    governance
    Read article
    Keep Your Framework. Add the Runtime. Eight Times Over.
    September 1, 2026

    Keep Your Framework. Add the Runtime. Eight Times Over.

    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.

    integrations
    agent-frameworks
    nvidia
    pydanticai
    llamaindex
    crewai
    azure
    google
    aws
    digitalocean
    mission-runtime
    governance
    reference-implementation
    benchmarks
    Read article
    Closure Resolution: Retrieval Isn't Finished Until You Know the Context Is Complete
    August 31, 2026

    Closure Resolution: Retrieval Isn't Finished Until You Know the Context Is Complete

    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.

    closure-resolution
    context-runtime
    retrieval
    rag
    verification
    governance
    selective-prediction
    benchmarks
    legal-ai
    scientific-claims
    code-retrieval
    composition
    Read article
    What Does the Enterprise Runtime Actually Add?
    August 30, 2026

    What Does the Enterprise Runtime Actually Add?

    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.

    open-core
    enterprise
    mission-runtime
    governance
    security
    audit
    benchmarks
    agpl
    Read article
    Retrieving the Change, Not Just the Code
    August 30, 2026

    Retrieving the Change, Not Just the Code

    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.

    context-runtime
    code-retrieval
    graph
    benchmarks
    redevops-rag
    agents
    mission-runtime
    Read article
    What a Runtime Buys You That LangChain and LangGraph Don't, and What It Doesn't
    August 29, 2026

    What a Runtime Buys You That LangChain and LangGraph Don't, and What It Doesn't

    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.

    benchmarks
    langchain
    langgraph
    mission-runtime
    context-runtime
    safe-concurrency
    replay
    cross-language
    go
    kotlin
    agents
    Read article
    Answers From Less Context
    August 27, 2026

    Answers From Less Context

    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.

    context-engineering
    long-context
    benchmarks
    llm-optimization
    context-runtime
    self-hosted
    rag
    Read article
    What Can I Build Here? Zoning Intelligence Without the Guessing
    August 24, 2026

    What Can I Build Here? Zoning Intelligence Without the Guessing

    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.

    ai-runtime
    geospatial
    zoning
    context-runtime
    evidence-native
    deterministic
    gis
    real-estate
    benchmark
    capabilities
    Read article
    Security and Telemetry Belong to the Runtime, Not the Plugin
    August 24, 2026

    Security and Telemetry Belong to the Runtime, Not the Plugin

    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.

    ai-runtime
    ai-security
    telemetry
    opentelemetry
    observability
    mission-runtime
    prompt-injection
    governance
    argo
    benchmark
    evidence-native
    Read article
    Enterprise Infrastructure Should Be Capabilities, Not Application Plumbing
    August 23, 2026

    Enterprise Infrastructure Should Be Capabilities, Not Application Plumbing

    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.

    ai-runtime
    enterprise-ai
    capabilities
    execution-planner
    mission-runtime
    context-runtime
    governance
    data-infrastructure
    agentic-architecture
    evidence-native
    Read article
    When the GPU Wins, and When It Doesn't
    August 22, 2026

    When the GPU Wins, and When It Doesn't

    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.

    ai-runtime
    gpu-acceleration
    rapids
    cuvs
    cudf
    cuopt
    benchmark
    context-runtime
    evidence-native
    nvidia
    Read article
    The App Should Be an Execution Node, Not a Destination
    August 22, 2026

    The App Should Be an Execution Node, Not a Destination

    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.

    ai-runtime
    agentic-apps
    execution-node
    mission-runtime
    authority
    governance
    discovery-runtime
    context-runtime
    agentic-ux
    llmops
    Read article
    The Runtime, on a Real Fleet: Testing Fleet-Scale AI on 1,061 Real Drive Failures
    August 19, 2026

    The Runtime, on a Real Fleet: Testing Fleet-Scale AI on 1,061 Real Drive Failures

    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).

    ai-runtime
    edge
    fleet
    discovery-runtime
    context-runtime
    governance
    backblaze
    smart
    predictive-maintenance
    benchmark
    llmops
    Read article
    Screen a Vendor Against a Real Ownership Graph: Live
    August 17, 2026

    Screen a Vendor Against a Real Ownership Graph: Live

    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.

    kyc
    kyb
    sanctions
    ownership
    property-graphs
    gleif
    opensanctions
    grc
    context-runtime
    demo
    Read article
    AI Agents Can All Follow the Rules and Still Cause a Disaster
    August 17, 2026

    AI Agents Can All Follow the Rules and Still Cause a Disaster

    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.

    multi-agent
    ai-safety
    governance
    trajectory
    agentic-ai
    mission-runtime
    context-runtime
    ai-runtime
    Read article
    Edit Your Video in Plain English
    August 12, 2026

    Edit Your Video in Plain English

    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.

    generative-video
    ai-video
    vibexgen
    mission-runtime
    context-runtime
    ai-runtime
    video-editing
    agentic-ai
    Read article
    Rent Today's Compute. Buy Tomorrow's.
    August 11, 2026

    Rent Today's Compute. Buy Tomorrow's.

    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.

    ai-infrastructure
    gpu
    nvidia
    ai-economics
    compute
    capex
    cloud
    rent-vs-buy
    Read article
    Two Agentic Accounting Apps, Built in an Afternoon on Open Source
    August 7, 2026

    Two Agentic Accounting Apps, Built in an Afternoon on Open Source

    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.

    agentic-accounting
    ai-tax
    open-source
    erpnext
    odoo
    tax-calculator
    policyengine
    ground-truth
    ai-runtime
    aiengineering
    llmops
    genai
    fintech
    Read article
    What Belongs in the Database, and Why We Didn't Ship a Postgres Extension
    August 6, 2026

    What Belongs in the Database, and Why We Didn't Ship a Postgres Extension

    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.

    architecture
    database-systems
    postgresql
    ai-runtime
    determinism
    extensions
    pg_tle
    kubernetes
    mission-runtime
    context-runtime
    reproducibility
    aiengineering
    llmops
    genai
    Read article
    The Box and the Decision: ReDevOps vs. AMD's Enterprise AI Blueprints
    August 6, 2026

    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. 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.

    architecture
    amd
    rocm
    enterprise-ai
    ai-runtime
    rag
    kubernetes
    helm
    reproducibility
    mission-runtime
    context-runtime
    gpu
    aiengineering
    llmops
    genai
    Read article
    Cloudflare OS and the Rise of AI Runtime Infrastructure
    August 6, 2026

    Cloudflare OS and the Rise of AI Runtime Infrastructure

    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.

    architecture
    ai-runtime
    cloudflare
    agent-infrastructure
    ai-agents
    execution
    governance
    kubernetes
    mission-runtime
    context-runtime
    aiengineering
    llmops
    genai
    Read article
    Open-sourcing rAIls: A Different Layer of the AI Stack
    August 5, 2026

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

    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.

    open-source
    ai-runtime
    mission-runtime
    context-runtime
    execution
    governance
    langchain
    langgraph
    amd
    reference-systems
    aiengineering
    llmops
    aiinfrastructure
    genai
    Read article
    The Evolution of a Runtime Stack: How Idempotency Rebuilt Database Systems for AI
    August 5, 2026

    The Evolution of a Runtime Stack: How Idempotency Rebuilt Database Systems for AI

    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.

    architecture
    idempotency
    determinism
    context-runtime
    mission-runtime
    discovery-runtime
    database-systems
    event-sourcing
    replay
    verification
    governance
    provenance
    aiengineering
    llmops
    genai
    Read article
    We Benchmarked Formal Multi-Agent Orchestration Against a Good Supervisor. It Tied. Until It Couldn't Run.
    July 30, 2026

    We Benchmarked Formal Multi-Agent Orchestration Against a Good Supervisor. It Tied. Until It Couldn't Run.

    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.

    multi-agent
    agent-orchestration
    benchmark
    llm
    software-engineering
    mission-runtime
    context-runtime
    agents
    reproducibility
    genai
    aiengineering
    llmops
    Read article
    DataOpsBench: Can an AI System Operate a Production Data Platform It Can't Fit in a Prompt?
    July 30, 2026

    DataOpsBench: Can an AI System Operate a Production Data Platform It Can't Fit in a Prompt?

    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.

    dataops
    data-engineering
    ai-agents
    context-runtime
    mission-runtime
    benchmark
    lineage
    data-quality
    reconciliation
    governance
    llmops
    aiengineering
    genai
    Read article
    Self-Learning Insurance Distribution: A Governed Control Loop, Not a Pitch Generator
    July 27, 2026

    Self-Learning Insurance Distribution: A Governed Control Loop, Not a Pitch Generator

    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.

    insurance
    contextual-bandit
    discovery-runtime
    mission-runtime
    context-runtime
    off-policy-evaluation
    benchmarks
    Read article
    Should We Reorder This SKU? A Retail Restocking Benchmark on Real Walmart M5 Data
    July 27, 2026

    Should We Reorder This SKU? A Retail Restocking Benchmark on Real Walmart M5 Data

    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.

    retail
    inventory
    mission-runtime
    context-runtime
    benchmarks
    m5
    walmart
    composition
    Read article
    The Best AI Swarm Is Usually Smaller Than You Think
    July 27, 2026

    The Best AI Swarm Is Usually Smaller Than You Think

    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.

    execution-topology
    multi-agent
    coordination
    context-runtime
    mission-runtime
    ai-infrastructure
    Read article
    Documents, SQL, Graphs and Time: AI Needs More Than One Way to Think
    July 26, 2026

    Documents, SQL, Graphs and Time: AI Needs More Than One Way to Think

    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.

    rag
    knowledge-graphs
    property-graphs
    kyc
    neo4j
    entity-resolution
    benchmarks
    context-engineering
    Read article
    From Dashboards to Missions: Why AI Analytics Needs a Discovery Runtime
    July 26, 2026

    From Dashboards to Missions: Why AI Analytics Needs a Discovery Runtime

    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.

    discovery-runtime
    context-runtime
    mission-runtime
    agentic-analytics
    ai-infrastructure
    proactive-intelligence
    Read article
    Rendering Video Out of Order: Parallelizing Text-to-Video With a World Model
    July 24, 2026

    Rendering Video Out of Order: Parallelizing Text-to-Video With a World Model

    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.

    context-runtime
    text-to-video
    story-runtime
    video-generation
    parallelism
    interpolation
    diffusion
    world-model
    Read article
    The Context Runtime Meets the Google Agent Stack
    July 23, 2026

    The Context Runtime Meets the Google Agent Stack

    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.

    context-runtime
    gcp
    gemini-enterprise
    vertex-ai
    agent-engine
    adk
    a2a
    sidekick
    agentic-ai
    mission-runtime
    governance
    Read article
    The Context Runtime Meets the DigitalOcean Agent Stack
    July 23, 2026

    The Context Runtime Meets the DigitalOcean Agent Stack

    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.

    context-runtime
    digitalocean
    gradient-ai
    agents
    knowledge-base
    sidekick
    agentic-ai
    mission-runtime
    governance
    cost
    Read article
    The Context Runtime Meets the Azure Agent Stack
    July 23, 2026

    The Context Runtime Meets the Azure Agent Stack

    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.

    context-runtime
    azure
    microsoft-foundry
    agent-framework
    semantic-kernel
    autogen
    sidekick
    agentic-ai
    mission-runtime
    governance
    Read article
    Choosing an Agent Stack in 2026: AWS vs Azure vs Google vs DigitalOcean
    July 23, 2026

    Choosing an Agent Stack in 2026: AWS vs Azure vs Google vs DigitalOcean

    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.

    agentic-ai
    aws
    azure
    gcp
    digitalocean
    context-runtime
    mission-runtime
    sidekick
    agent-platforms
    llmops
    Read article
    The Context Runtime Meets the AWS Agent Stack
    July 22, 2026

    The Context Runtime Meets the AWS Agent Stack

    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.

    context-runtime
    aws
    strands
    bedrock-agentcore
    crewai
    sidekick
    agentic-ai
    mission-runtime
    iac
    governance
    Read article
    The AI Chip Boom Has a Deployment Problem
    July 16, 2026

    The AI Chip Boom Has a Deployment Problem

    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.

    ai-infrastructure
    data-centers
    gpu
    nvidia
    colocation
    power-grid
    sovereign-ai
    deployment
    Read article
    Python Isn't the Product. It's the Specification.
    July 16, 2026

    Python Isn't the Product. It's the Specification.

    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.

    python
    golang
    rust
    context-runtime
    llm
    code-generation
    software-engineering
    porting
    Read article
    Better Context Beats More Context
    July 12, 2026

    Better Context Beats More Context

    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.

    context-engineering
    rag
    knowledge-graphs
    llm
    benchmarks
    llm-optimization
    hipporag
    Read article
    rAIlsApps Are Just the Beginning
    July 12, 2026

    rAIlsApps Are Just the Beginning

    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.

    agentic-ai
    mission-runtime
    context-runtime
    ai-agents
    agentic-os
    mcp
    orchestration
    llm
    Read article
    Why Context Runtime Started Routing Knowledge Instead of Retrieving It
    July 11, 2026

    Why Context Runtime Started Routing Knowledge Instead of Retrieving It

    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.

    rag
    knowledge-graphs
    context-engineering
    hipporag
    graphiti
    benchmarks
    llm-optimization
    Read article
    Can You Explain Why Your AI Read That Document?
    July 10, 2026

    Can You Explain Why Your AI Read That Document?

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

    ai-explainability
    retrieval-augmented-generation
    llm-interpretability
    trustworthy-ai
    Read article
    Why Yesterday's AI Answer Cannot Be Reproduced.
    July 9, 2026

    Why Yesterday's AI Answer Cannot Be Reproduced.

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

    ai-reproducibility
    non-deterministic-systems
    llm-debugging
    rag-architecture
    Read article
    Your AI Does Not Have Memory. You Are the Memory.
    July 8, 2026

    Your AI Does Not Have Memory. You Are the Memory.

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

    ai-memory
    llm-architecture
    context-management
    ai-design
    Read article
    Your RAG Is Not Failing. It Is Reading Too Much.
    July 6, 2026

    Your RAG Is Not Failing. It Is Reading Too Much.

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

    rag
    context-window
    llm-optimization
    retrieval-augmented-generation
    Read article
    Bigger Context Windows Won't Save You Money.
    July 6, 2026

    Bigger Context Windows Won't Save You Money.

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

    llm-cost-optimization
    context-window
    token-efficiency
    ai-infrastructure
    Read article
    The Context Wars, Part III: The AI Operating System
    June 29, 2026

    The Context Wars, Part III: The AI Operating System

    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.

    rag
    deepseek
    anthropic
    openai
    context-engineering
    attention
    ai-architecture
    ai-engineering
    agentic-ai
    context-runtime
    Read article
    The Context Wars, Part II: The End of RAG?
    June 29, 2026

    The Context Wars, Part II: The End of RAG?

    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.

    rag
    deepseek
    attention
    sparse-attention
    context-windows
    llm-inference
    retrieval
    ai-engineering
    Read article
    The Context Wars, Part I: The Hidden Cost of Context
    June 29, 2026

    The Context Wars, Part I: The Hidden Cost of Context

    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.

    rag
    context-windows
    llm-inference
    attention
    retrieval
    graphrag
    deepseek
    openai
    ai-engineering
    Read article
    Cheap Inference Won't Solve AI
    June 27, 2026

    Cheap Inference Won't Solve AI

    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.

    inference
    ai-reliability
    agentic-ai
    distributed-systems
    ai-economics
    systems-engineering
    future-of-ai
    Read article
    From AI Assistants to AI System Owners: Where Agentic AI Is Heading
    June 24, 2026

    From AI Assistants to AI System Owners: Where Agentic AI Is Heading

    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.

    ai-agents
    autonomous-engineering
    devops
    systems-design
    future-of-ai
    Read article
    The Engineered Drought: Why Cheap AI Inference Is Being Kept Out of Your Reach
    June 20, 2026

    The Engineered Drought: Why Cheap AI Inference Is Being Kept Out of Your Reach

    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.

    inference
    hardware
    hbm
    economics
    local-llm
    Read article
    Jalapeño: The Beginning of Cheap AI
    June 20, 2026

    Jalapeño: The Beginning of Cheap AI

    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.

    inference
    ai-economics
    cheap-ai
    hardware
    compute
    future-of-ai
    Read article