All articles
    ai-runtime
    enterprise-ai
    capabilities
    execution-planner
    mission-runtime
    context-runtime
    governance
    data-infrastructure
    agentic-architecture
    evidence-native

    Enterprise Infrastructure Should Be Capabilities, Not Application Plumbing

    August 23, 2026redevops.io
    Enterprise Infrastructure Should Be Capabilities, Not Application Plumbing

    Part of the agentic-apps thread, the enterprise companion to The App Should Be an Execution Node, Not a Destination. That piece was about consumer friction; this one is about the enterprise execution layer.

    Enterprise software spent decades decomposing monoliths into services, APIs, data platforms and specialized compute. Yet one coupling remains: every new application still rebuilds the logic that connects those systems into a business workflow. The infrastructure is shared; the execution logic is rebuilt, application by application. Agentic systems give us a reason to move that boundary.

    Enterprise systems should expose capabilities and state. The runtime should decide how those capabilities compose into a business outcome.

    It's the enterprise version of treating an application as an execution node, extended past applications to models, APIs, compute backends, deterministic algorithms and human approvals. The application no longer owns the whole path from intent to infrastructure.

    Business systems express intent

    Behind one business operation, an application may authenticate the user, pull data, run a calculation, retrieve documents, invoke a model, call an API, apply rules, request approval, write a result and record an audit trail. That orchestration lives inside the application, and the next application rebuilds its own version. Instead, an application can submit a goal and its constraints:

    Rebalance this portfolio while keeping estimated taxes below $5,000 and do not sell restricted positions.

    That's an objective. The systems it needs (portfolio state, market data, tax calculations, policy checks, an optimizer, order generation, approval) expose capabilities, and the runtime decides which are required, plans them, executes, and governs the trajectory:

    Business Goal → Discovery / World State → Execution Planner → Governed Execution Graph → Capabilities → Verified Outcome

    A capability carries what a planner needs to choose it: inputs and outputs, authority, expected quality, cost, latency, freshness, locality, privacy, and historical outcomes. The application describes what must happen; the runtime decides how: the way a database optimizer turns a query into a plan from statistics and cost, except the operators are enterprise capabilities.

    Data: served evidence

    Data infrastructure is where this most needs care, and where a naive version gets it wrong.

    The wrong version lets an agent fire ad-hoc SQL at a production database. That is exactly what data engineering has spent years preventing: poorly-written queries, unpredictable load, and read traffic contending with live writes are how you take down an OLTP system. Making "run SQL against the source" a user-driven capability would be a step backward.

    The right version keeps the separation data teams already enforce. Raw sources and the write path stay behind the boundary; capabilities expose served evidence from a read layer the data team controls: materialized and curated views, a warehouse or lakehouse, read replicas, a feature or evidence store, a governed snapshot. When a mission needs "current customer risk," it requests that evidence; the data platform answers from its serving layer, or refreshes a materialized view on its own schedule and governance, never by reaching into the live database.

    So the pipeline doesn't disappear, and it doesn't get bypassed. It becomes one evidence-producing capability the data team publishes, with the freshness, isolation and query-safety guarantees they decide. The capability boundary is the contract that protects production: the same separation of concerns, made explicit and enforceable. And because evidence carries provenance and identity, when it changes the runtime recomputes only what depended on it (the evidence-native principle ReDevOps applies in Discovery and Context Runtime, carried into enterprise data).

    Compute becomes a planning decision

    The same holds one layer down. An application shouldn't have to say run model X on GPU cluster Y. It can state the requirement (classify within 100 ms, process without leaving the local environment, maximize quality within this latency budget) and let the runtime pick the implementation: a local function, a CPU service, a GPU workload, an edge device, an internal or external model, a cached result. The right choice moves as prices, models and measured outcomes change, so hardcoding it into every application makes every change expensive. As a capability, the runtime weighs it across quality × latency × cost × privacy × locality × authority × availability. That is the line between a framework and a runtime: a framework helps you implement a workflow; a runtime decides which workflow should run.

    Three planes, one execution problem

    Three luminous strata over a dark landscape (a data plane of stores and streams, a compute plane of models and jobs, an application plane of surfaces) with one beam of light threading up through all three into a single governed outcome. The runtime is the layer that composes them.
    Scroll the diagram sideways to read itFull size
    • Data plane: what do we know? Databases, warehouses, documents, streams, vector stores, event histories: exposed as served capabilities, with no direct access to the sources.
    • Compute plane: what can we do? Deterministic algorithms, query engines, CPU/GPU, models, optimizers, pipelines, edge compute. Executable capabilities.
    • Application plane: what does the business want? Users, agents, processes, domain apps expressing goals, constraints and outcomes.

    Most applications bridge all three themselves. A runtime stack provides the shared layer instead, in ReDevOps: Discovery (what's relevant), Execution Planner (what plan runs), Mission Runtime (execute + govern), Context Runtime (evidence, method, model and budget per step), and Governance (whether the trajectory stays in policy). The infrastructure underneath can evolve without rewriting every application around it. The UI changes too: it moves from UI + business logic + workflow + integration to UI + domain capabilities, becoming a view into a mission (a wealth interface initiates and inspects a portfolio mission, an operations interface a remediation mission).

    Cross-system execution needs cross-system governance

    Dynamic composition raises the stakes. If a mission spans data systems, models, applications and compute, governance can't stop at a single API call: a sequence of individually-acceptable actions can add up to an unacceptable trajectory. The system has to preserve and replay what goal authorized the run, which evidence (and which version) supported the plan, which capabilities participated and with what authority, what changed, and whether the trajectory stayed in policy. Once infrastructure becomes composable, the execution graph itself becomes an object that must be governed.

    None of this replaces the specialized systems. The warehouse, the pipeline, Kubernetes, the GPU cluster, the CRM keep solving what they solve well; they just stop needing to know the entire workflow. The runtime sits above them, closer to the query planner than the storage engine.

    Turning the pieces into a system

    Most enterprises already have the pieces: APIs, data platforms, containerized compute, event streams, models, SaaS integrations, policy and identity. The missing layer is usually a way to compile business intent into a governed execution plan over the capabilities that already exist:

    Business systems express intent. Data, compute and applications expose capabilities. The runtime compiles one into the other.

    The payoff is less orchestration code and adaptability. A better model replaces an older one, a cheaper backend appears, fresh evidence invalidates only what depended on it, a policy change alters what's permitted, and the applications above don't have to be redesigned around each change. The consumer version of the idea is simple: the app should be an execution node. The enterprise version goes further: data, compute and applications should expose capabilities, so no application has to rebuild the execution path.


    rAIls, from ReDevOps, is a source-available Runtime Agentic Intelligence Stack for planning, context, execution and governance across production AI systems.

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